feat(bridge): add wifi/serial bridge runtime and UI

Co-authored-by: Cursor <cursoragent@cursor.com>

bridge-serial/src/main.py

@@ -0,0 +1,166 @@
+"""ESP-NOW bridge: Pi USB-serial downlink, ESP-NOW to drivers (sync loop)."""
+
+import gc, json, struct, time
+import espnow, machine, network
+from machine import Pin, UART
+from settings import Settings
+
+BROADCAST = b"\xff\xff\xff\xff\xff\xff"
+WIRE = 0x4C
+MAX_SERIAL = 4096
+MAX_ESPNOW = 250
+ESPNOW_EXIST = -12395
+ESPNOW_FULL = -12392
+
+
+def add_peer_if_needed(esp, dest, ch):
+    try:
+        esp.add_peer(dest, channel=ch)
+    except TypeError:
+        try:
+            esp.add_peer(dest)
+        except OSError as e:
+            if e.args[0] != ESPNOW_EXIST:
+                raise
+    except OSError as e:
+        if e.args[0] != ESPNOW_EXIST:
+            raise
+
+
+def del_peer_if_present(esp, dest):
+    try:
+        esp.del_peer(dest)
+    except Exception:
+        pass
+
+
+def send_unicast_temp_peer(esp, dest, ch, pkt):
+    try:
+        add_peer_if_needed(esp, dest, ch)
+    except OSError as e:
+        if e.args and e.args[0] == ESPNOW_FULL:
+            del_peer_if_present(esp, dest)
+            add_peer_if_needed(esp, dest, ch)
+        else:
+            raise
+    try:
+        esp.send(dest, pkt, True)
+    finally:
+        del_peer_if_present(esp, dest)
+
+
+def init_radio(ch, name, password):
+    network.WLAN(network.STA_IF).active(False)
+    network.WLAN(network.AP_IF).active(False)
+    time.sleep_ms(100)
+    ap = network.WLAN(network.AP_IF)
+    ap.active(True)
+    time.sleep_ms(50)
+    if password:
+        try:
+            ap.config(essid=name or "bridge", password=password, channel=ch, hidden=True)
+        except TypeError:
+            ap.config(essid=name or "bridge", channel=ch)
+    else:
+        try:
+            ap.config(essid=name or "bridge", channel=ch, hidden=True)
+        except TypeError:
+            ap.config(essid=name or "bridge", channel=ch)
+    sta = network.WLAN(network.STA_IF)
+    sta.active(True)
+    sta.config(pm=network.WLAN.PM_NONE)
+    try:
+        sta.config(channel=ch)
+    except Exception:
+        pass
+
+
+def mac_bytes(addr):
+    h = str(addr).replace(":", "").replace("-", "").strip().lower()
+    return bytes.fromhex(h)
+
+
+def read_serial(uart, buf):
+    if uart.any():
+        buf.extend(uart.read(min(uart.any(), 256)))
+    out = []
+    while len(buf) >= 2:
+        n = (buf[0] << 8) | buf[1]
+        if n > MAX_SERIAL:
+            buf[:] = buf[1:]
+            continue
+        need = 2 + n
+        if len(buf) < need:
+            break
+        out.append(bytes(buf[2:need]))
+        buf[:] = buf[need:]
+    return out
+
+
+def downlink(esp, ch, raw):
+    if not raw:
+        return
+    if raw[0] == WIRE:
+        if len(raw) < 2:
+            return
+        esp.send(BROADCAST, raw, True)
+        return
+    if len(raw) < 8 or raw[0] != ord("{"):
+        return
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        return
+    devs = data.get("dv") or data.get("devices")
+    if data.get("v") != "1" or not isinstance(devs, dict):
+        return
+    for mac_s, body in devs.items():
+        if not isinstance(body, dict):
+            continue
+        try:
+            msg = {"v": "1"}
+            msg.update(body)
+            pkt = json.dumps(msg, separators=(",", ":")).encode()
+            if len(pkt) > MAX_ESPNOW:
+                continue
+            dest = mac_bytes(mac_s)
+        except (ValueError, TypeError):
+            continue
+        if dest == BROADCAST:
+            esp.send(BROADCAST, pkt, True)
+        else:
+            send_unicast_temp_peer(esp, dest, ch, pkt)
+        time.sleep_ms(5)
+
+
+gc.collect()
+s = Settings()
+ch = max(1, min(11, int(s.get("wifi_channel", 5))))
+init_radio(ch, s.get("name"), s.get("ap_password") or "")
+baud = int(s.get("serial_baudrate", 921600))
+uart = UART(
+    int(s.get("serial_uart_id", 1)),
+    baud,
+    tx=Pin(int(s.get("serial_tx_pin", 2))),
+    rx=Pin(int(s.get("serial_rx_pin", 3))),
+)
+esp = espnow.ESPNow()
+esp.active(True)
+add_peer_if_needed(esp, BROADCAST, ch)
+print("bridge ch", ch, "baud", baud, "heap", gc.mem_free())
+
+wdt = machine.WDT(timeout=10000)
+rx_buf = bytearray()
+while True:
+    wdt.feed()
+    for frame in read_serial(uart, rx_buf):
+        try:
+            downlink(esp, ch, frame)
+        except OSError as e:
+            print("dl", e)
+    host, msg = esp.recv(0)
+    if host:
+        up = bytes([0]) + host + msg
+        uart.write(struct.pack(">H", len(up)) + up)
+    else:
+        time.sleep_ms(1)

bridge-serial/src/settings.py

@@ -0,0 +1,62 @@
+import json
+import time
+import ubinascii
+import network
+
+WIFI_CHANNEL_DEFAULT = 5
+
+
+def _sta_mac_hex():
+    sta = network.WLAN(network.STA_IF)
+    was_on = sta.active()
+    if not was_on:
+        sta.active(True)
+        time.sleep_ms(50)
+    try:
+        mac = ubinascii.hexlify(sta.config("mac")).decode().lower()
+    except Exception:
+        mac = "000000000000"
+    if not was_on:
+        sta.active(False)
+    return mac
+
+
+class Settings(dict):
+    SETTINGS_FILE = "/settings.json"
+
+    def __init__(self):
+        super().__init__()
+        self.load()
+
+    def set_defaults(self):
+        self["name"] = "bridge-" + _sta_mac_hex()
+        self["wifi_channel"] = WIFI_CHANNEL_DEFAULT
+        self["ap_password"] = ""
+        self["serial_baudrate"] = 921600
+        self["serial_uart_id"] = 1
+        self["serial_tx_pin"] = 2
+        self["serial_rx_pin"] = 3
+        self["serial_usb"] = False
+
+    def save(self):
+        try:
+            with open(self.SETTINGS_FILE, "w") as f:
+                f.write(json.dumps(self))
+        except Exception as e:
+            print("save settings:", e)
+
+    def load(self):
+        try:
+            with open(self.SETTINGS_FILE, "r") as f:
+                loaded = json.load(f)
+            if not isinstance(loaded, dict):
+                raise ValueError("not object")
+        except Exception:
+            self.clear()
+            self.set_defaults()
+            self.save()
+            return
+        self.clear()
+        self.set_defaults()
+        for k, v in loaded.items():
+            self[k] = v