Pi port: serial transport, addressed ESP-NOW bridge, port 80

- Run app on Raspberry Pi: serial to ESP32 bridge at 912000 baud, /dev/ttyS0
- Remove ESP-NOW/MicroPython-only code from src (espnow, p2p, wifi, machine/Pin)
- Transport: always send 6-byte MAC + payload; optional to/destination_mac in API and WebSocket
- Settings and model DB use project paths (no root); fix sys.print_exception for CPython
- Preset/settings controllers use get_current_sender(); template paths for cwd=src
- Pipfile: run from src, PORT from env; scripts for port 80 (setcap) and test
- ESP32 bridge: receive 6-byte addr + payload, LRU peer management (20 max), handle ESP_ERR_ESPNOW_EXIST
- Add esp32/main.py, esp32/benchmark_peers.py, scripts/setup-port80.sh, scripts/test-port80.sh

Made-with: Cursor

src/models/espnow.py

@@ -1,69 +0,0 @@
-import network
-
-import aioespnow
-
-
-class ESPNow:
-    """
-    Singleton ESPNow helper:
-    - Manages a single AIOESPNow instance
-    - Adds a single broadcast-like peer
-    - Exposes async send(data) to send to that peer.
-    """
-
-    _instance = None
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def __init__(self):
-        if getattr(self, "_initialized", False):
-            return
-
-        # ESP-NOW requires a WiFi interface to be active (STA or AP). Activate STA
-        # so ESP-NOW has an interface to use; we don't need to connect to an AP.
-        try:
-            sta = network.WLAN(network.STA_IF)
-            sta.active(True)
-        except Exception as e:
-            print("ESPNow: STA active failed:", e)
-
-        self._esp = aioespnow.AIOESPNow()
-        self._esp.active(True)
-
-        try:
-            self._esp.add_peer(b"\xff\xff\xff\xff\xff\xff")
-        except Exception:
-            # Ignore add_peer failures (e.g. duplicate)
-            pass
-
-        self._initialized = True
-
-   
-    async def send(self, data):
-        """
-        Async send to the broadcast peer.
-        - data: bytes or str (JSON)
-        """
-        if isinstance(data, str):
-            payload = data.encode()
-        else:
-            payload = data
-
-        # Debug: show what we're sending and its size
-        try:
-            preview = payload.decode('utf-8')
-        except Exception:
-            preview = str(payload)
-        if len(preview) > 200:
-            preview = preview[:200] + "...(truncated)"
-        print("ESPNow.send len=", len(payload), "payload=", preview)
-
-        try:
-            await self._esp.asend(b"\xff\xff\xff\xff\xff\xff", payload)
-        except Exception as e:
-            print("ESPNow.send error:", e)
-            raise
-

src/models/model.py

@@ -1,5 +1,15 @@
 import json
 import os
+import traceback
+
+# DB directory: project root / db (writable without root)
+def _db_dir():
+    try:
+        # src/models/model.py -> project root
+        base = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        return os.path.join(base, "db")
+    except Exception:
+        return "db"
 
 class Model(dict):
     def __new__(cls, *args, **kwargs):
@@ -13,13 +23,13 @@ class Model(dict):
         if hasattr(self, '_initialized'):
             return
         
-        # Create /db directory if it doesn't exist (MicroPython compatible)
+        db_dir = _db_dir()
         try:
-            os.mkdir("/db")
+            os.makedirs(db_dir, exist_ok=True)
         except OSError:
-            pass  # Directory already exists, which is fine
+            pass
         self.class_name = self.__class__.__name__
-        self.file = f"/db/{self.class_name.lower()}.json"
+        self.file = os.path.join(db_dir, f"{self.class_name.lower()}.json")
         super().__init__()
 
         self.load()  # Load settings from file during initialization
@@ -37,11 +47,11 @@ class Model(dict):
 
     def save(self):
         try:
-            # Ensure directory exists
+            db_dir = os.path.dirname(self.file)
             try:
-                os.mkdir("/db")
+                os.makedirs(db_dir, exist_ok=True)
             except OSError:
-                pass  # Directory already exists
+                pass
             j = json.dumps(self)
             with open(self.file, 'w') as file:
                 file.write(j)
@@ -54,8 +64,7 @@ class Model(dict):
             print(f"{self.class_name} saved successfully to {self.file}")
         except Exception as e:
             print(f"Error saving {self.class_name} to {self.file}: {e}")
-            import sys
-            sys.print_exception(e)
+            traceback.print_exception(type(e), e, e.__traceback__)
 
     def load(self):
         try:

src/models/serial.py

@@ -0,0 +1,12 @@
+class Serial:
+    def __init__(self, port, baudrate):
+        self.port = port
+        self.baudrate = baudrate
+        self.uart = UART(1, baudrate, tx=Pin(21), rx=Pin(6))
+
+    def send(self, data):
+        self.uart.write(data)
+
+    def receive(self):
+        return self.uart.read()
+        

src/models/transport.py

@@ -0,0 +1,66 @@
+import asyncio
+import json
+
+
+# Default: broadcast (6 bytes). Pi always sends 6-byte address + payload to ESP32.
+BROADCAST_MAC = bytes.fromhex("ffffffffffff")
+
+
+def _encode_payload(data):
+    if isinstance(data, str):
+        return data.encode()
+    if isinstance(data, dict):
+        return json.dumps(data).encode()
+    return data
+
+
+def _parse_mac(addr):
+    """Convert 12-char hex string or 6-byte bytes to 6-byte MAC."""
+    if addr is None or addr == b"":
+        return BROADCAST_MAC
+    if isinstance(addr, bytes) and len(addr) == 6:
+        return addr
+    if isinstance(addr, str) and len(addr) == 12:
+        return bytes.fromhex(addr)
+    return BROADCAST_MAC
+
+
+async def _to_thread(func, *args):
+    to_thread = getattr(asyncio, "to_thread", None)
+    if to_thread:
+        return await to_thread(func, *args)
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, func, *args)
+
+
+class SerialSender:
+    def __init__(self, port, baudrate, default_addr=None):
+        import serial
+
+        self._serial = serial.Serial(port, baudrate=baudrate, timeout=1)
+        self._default_addr = _parse_mac(default_addr)
+
+    async def send(self, data, addr=None):
+        mac = _parse_mac(addr) if addr is not None else self._default_addr
+        payload = _encode_payload(data)
+        await _to_thread(self._serial.write, mac + payload)
+        return True
+
+
+_current_sender = None
+
+
+def set_sender(sender):
+    global _current_sender
+    _current_sender = sender
+
+
+def get_current_sender():
+    return _current_sender
+
+
+def get_sender(settings):
+    port = settings.get("serial_port", "/dev/ttyS0")
+    baudrate = settings.get("serial_baudrate", 912000)
+    default_addr = settings.get("serial_destination_mac", "ffffffffffff")
+    return SerialSender(port, baudrate, default_addr=default_addr)