UART communication

micro_ondes/esp_lora/main.py

@@ -1,8 +1,6 @@
 import _thread
 from machine import Pin
-from shared import get_lora
-from shared import deviceTypes
-from shared import config
+from shared import get_lora, get_uart, deviceTypes, config
 import time
 
 # --- Configuration Matérielle ---
@@ -48,10 +46,24 @@ def heartbeat_loop():
             print("ESP32 : Pas de réponse de l'orchestrateur (Le RPI est-il éteint ?)")
         
         time.sleep(config.HEARTBEAT_INTERVAL)
+        
+# UART
+uart_device = get_uart(uart_id=1, tx_pin=46, rx_pin=45)
 
 # Lancer la boucle de heartbeat dans un thread séparé
 _thread.start_new_thread(heartbeat_loop, ())
 
+# --- MAIN APPLICATION THREAD ---
+print("[Main] Main execution path active.")
 while True:
-    # Fait rien pour l'instant
-    time.sleep(1)
+    # 1. Listen for incoming UART serial packets from the WROOM board
+    while uart_device.any():
+        command = uart_device.read()
+        print(f"[Main] Received command from WiFi Board: {command}")
+        
+    uart_device.send(f"Hello from esp-32 lora ID {DEVICE_ID}") 
+
+    # 2. Send local metrics over the wire to the WiFi board every few seconds
+    # uart_device.send("Data Pack: LoRa Link RSSI -72dBm")
+
+    time.sleep_ms(200)

micro_ondes/esp_wifi/main.py

@@ -1,16 +1,23 @@
 import _thread
-import select # <--- Built-in module to handle TLS timeouts
+import select
 from machine import Pin
-from shared import get_mqtt_client
-from shared import config
+from shared import get_mqtt_client, get_uart, config
 import time
 
-# --- Hardware Configuration ---
+# Simple thread-safe queue list
+msg_queue = []
+queue_lock = _thread.allocate_lock()
+
+def queue_publish(topic, payload):
+    """Safely queues a message from the main thread."""
+    with queue_lock:
+        msg_queue.append((topic, payload))
+
+# --- Hardware & Client Setup ---
 vext = Pin(19, Pin.OUT)
 vext.value(0)
 time.sleep_ms(100)
 
-# --- Read Unique Device ID ---
 try:
     with open("device_id.txt", "r") as f:
         DEVICE_ID = f.read().strip()
@@ -19,13 +26,12 @@ except Exception:
     
 MQTT_CA_FILE = "/certs/ca.crt"
 
-# --- Setup MQTT Client ---
 mqtt_client = get_mqtt_client(
     host=config.MQTT_BROKER_HOST,
     client_id="smartwave-esp32-" + DEVICE_ID,
     use_tls=config.USE_TLS,
     cafile=MQTT_CA_FILE,
-    keepalive=config.MQTT_KEEPALIVE, # Can safely be 30 now
+    keepalive=config.MQTT_KEEPALIVE,
 )
 
 def on_mqtt_message(message):
@@ -35,7 +41,7 @@ mqtt_client.set_callback(on_mqtt_message)
 
 
 def mqtt_background_thread():
-    """Background MQTT worker using select.poll() for keepalive tracking."""
+    """Background MQTT worker handling ALL socket operations safely."""
     print("[Thread] Background MQTT worker started.")
     
     while True:
@@ -43,37 +49,59 @@ def mqtt_background_thread():
             print("[Thread] Attempting connection to MQTT broker...")
             mqtt_client.connect()
             print("[Thread] Connected! Subscribing to topic...")
-            mqtt_client.subscribe(config.MQTT_TOPIC, qos=config.MQTT_QOS)
+            mqtt_client.subscribe(config.MQTT_TOPIC_COOKING, qos=config.MQTT_QOS)
             print("[Thread] Successfully subscribed. Setting up poller...")
             
-            # --- THE SELECT POLLER SETUP ---
-            # Create a poller and register our active TLS socket to look for incoming data (POLLIN)
             poller = select.poll()
             poller.register(mqtt_client._client.sock, select.POLLIN)
             
-            # Listening loop
+            last_check = time.time()
+            
             while True:
-                # Wait for network events for a maximum of 15000 milliseconds (15 seconds)
-                events = poller.poll(15000)
+                # 1. Process outbound messages queued by the main thread
+                while len(msg_queue) > 0:
+                    with queue_lock:
+                        topic, payload = msg_queue.pop(0)
+                    print(f"[Thread] Safely publishing queued message to {topic}...")
+                    mqtt_client.publish(topic, payload, qos=config.MQTT_QOS)
                 
-                if not events:
-                    # The 15 seconds expired with zero network traffic! 
-                    # Send a keepalive ping to Mosquitto.
-                    print("[Thread] No data for 15s. Sending keepalive ping...")
-                    mqtt_client._client.ping()
-                else:
-                    # Data has physically arrived on the socket!
-                    # Calling wait() now is completely safe and won't block indefinitely.
+                # 2. Check for incoming messages (non-blocking poll)
+                # Shortened timeout to keep the queue responsive
+                events = poller.poll(200) 
+                if events:
                     mqtt_client.wait()
+                
+                # 3. Handle Keepalive tracking manually
+                if time.time() - last_check >= 15:
+                    print("[Thread] Sending keepalive ping...")
+                    mqtt_client._client.ping()
+                    last_check = time.time()
+                    
+                # Small breathe room for the CPU core
+                time.sleep_ms(50)
                         
         except Exception as e:
             print("[Thread] Connection dropped or error encountered:", e)
             print("[Thread] Cleaning up socket context. Retrying in 5 seconds...")
+            
+            # --- FIX FOR ERROR 23 (SOCKET LEAK) ---
+            # Manually force-kill the underlying socket file descriptor if it exists
+            try:
+                if mqtt_client._client and hasattr(mqtt_client._client, "sock"):
+                    if mqtt_client._client.sock is not None:
+                        mqtt_client._client.sock.close()
+            except Exception:
+                pass # Already dead or closed
+
+            # Now we let the wrapper do its normal cleanup safely
             try:
                 mqtt_client.close()
             except Exception:
                 pass
             time.sleep(5)
+            
+# UART
+uart_device = get_uart(uart_id=2, tx_pin=17, rx_pin=16)
 
 # --- Launch background worker ---
 _thread.start_new_thread(mqtt_background_thread, ())
@@ -81,6 +109,19 @@ _thread.start_new_thread(mqtt_background_thread, ())
 
 # --- MAIN APPLICATION THREAD (Core 0) ---
 print("[Main] Main execution path active.")
+time.sleep(2) # Give the thread a moment to initial connect
+
 while True:
-    # Your main physical loop runs completely unhindered here
-    time.sleep(1)
+    print("[Main] Queueing a test message for MQTT...")
+    # Instead of direct publishing, push it to the queue safely
+    queue_publish(config.MQTT_TOPIC_SENSOR, "Hello from ESP32!")
+    
+    # 1. Check if the Heltec V3 sent us something over the wire
+    while uart_device.any():
+        incoming_msg = uart_device.read()
+        print(f"[Main] Received from esp-lora over UART: {incoming_msg}")
+        
+    # 2. Example: Send data to the Heltec board every 5 seconds
+    # uart_device.send("Status Check: WiFi Active")
+    
+    time.sleep_ms(200) # Fast responsive polling loop for local UART