gps related minor fixes

- angular direction (0-359) + 16ths compassrose
- documented in ui README

IDEAS.md

@@ -0,0 +1,5 @@
+Note to keep inspirations lest I forget.  
+
+# Things to do, but not really urgent
+- Fit OpenStreetMap somewhere and have a proper map widget in UI (not really navs, just show where I am)
+- Integrate paho-mqtt into Python backend for some telemetry. Also set up mosquitto or whatnots on vps.

arduino/.gitignore

@@ -1,3 +1,3 @@
-# arduino test files
+# arduino test files
-
+
 test/

extra/themes/rei.json

@@ -1,13 +1,13 @@
 {
   "dark": {
-    "background": "#404040",
+    "background": "#303030",
     "foreground": "#EAEAEA",
     "highlight": "#FA1504",
     "subdued": "#fda052"
   },
   "bright": {
     "background": "#fda052",
-    "foreground": "#202020",
+    "foreground": "#303030",
     "highlight": "#df2100",
     "subdued": "#EAEAEA"
   }

pi/backend/README.md

@@ -178,6 +178,19 @@ The Pi's internal pull-down (~50kΩ) will overpower high-value external resistor
 
 Physical switches/connectors need debouncing. Current implementation requires 15 consecutive identical readings (~750ms at 20Hz) before accepting a state change. Tune `required_consecutive` in `gpio_service.py` as needed.
 
+## Utilities
+
+Standalone tools live in `pi/utils/` (not part of the backend service):
+
+| Tool | Description |
+|------|-------------|
+| `at_terminal.py` | Interactive AT command terminal for SIM7600 (pyserial). Default port: `/dev/ttyUSB2` |
+
+```bash
+python pi/utils/at_terminal.py              # default /dev/ttyUSB2
+python pi/utils/at_terminal.py /dev/ttyUSB3 # specify port
+```
+
 ## Deploy
 
 TODO: Add to `scripts/deploy.py` as second target + systemd service.

pi/backend/arduino_service.py

@@ -1,308 +1,308 @@
-"""Arduino service - connects to Arduino Nano via serial, buffers telemetry."""
+"""Arduino service - connects to Arduino Nano via serial, buffers telemetry."""
-
+
-import json
+import json
-import math
+import math
-import re
+import re
-import threading
+import threading
-import time
+import time
-from collections import deque
+from collections import deque
-from typing import Any
+from typing import Any
-
+
-# pyserial for UART communication
+# pyserial for UART communication
-try:
+try:
-    import serial
+    import serial
-except ImportError:
+except ImportError:
-    serial = None  # Allow import without pyserial for testing structure
+    serial = None  # Allow import without pyserial for testing structure
-
+
-
+
-class ArduinoService:
+class ArduinoService:
-    """Threaded Arduino serial reader with buffering and auto-reconnect."""
+    """Threaded Arduino serial reader with buffering and auto-reconnect."""
-
+
-    # TSV field names (order per PROTOCOL.md)
+    # TSV field names (order per PROTOCOL.md)
-    TSV_FIELDS = ['voltage', 'ax', 'ay', 'az', 'gx', 'gy', 'gz', 'roll', 'pitch', 'yaw', 'rpm', 'gear']
+    TSV_FIELDS = ['voltage', 'ax', 'ay', 'az', 'gx', 'gy', 'gz', 'roll', 'pitch', 'yaw', 'rpm', 'gear']
-
+
-    # Regex patterns for legacy text protocol (backwards compatibility)
+    # Regex patterns for legacy text protocol (backwards compatibility)
-    PATTERNS = {
+    PATTERNS = {
-        "voltage": re.compile(r"V_bat:\s*(\d+\.?\d*)V?", re.IGNORECASE),
+        "voltage": re.compile(r"V_bat:\s*(\d+\.?\d*)V?", re.IGNORECASE),
-        "rpm": re.compile(r"RPM:\s*(\d+)", re.IGNORECASE),
+        "rpm": re.compile(r"RPM:\s*(\d+)", re.IGNORECASE),
-        "eng_temp": re.compile(r"ENG:\s*(\d+)C?", re.IGNORECASE),
+        "eng_temp": re.compile(r"ENG:\s*(\d+)C?", re.IGNORECASE),
-        "gear": re.compile(r"GEAR:\s*(\d+)", re.IGNORECASE),
+        "gear": re.compile(r"GEAR:\s*(\d+)", re.IGNORECASE),
-    }
+    }
-
+
-    # ACK pattern: "ACK:CMD:STATUS" or "ACK:CMD:STATUS:extra"
+    # ACK pattern: "ACK:CMD:STATUS" or "ACK:CMD:STATUS:extra"
-    ACK_PATTERN = re.compile(r"ACK:(\w+):(\w+)(?::(.*))?")
+    ACK_PATTERN = re.compile(r"ACK:(\w+):(\w+)(?::(.*))?")
-
+
-    def __init__(
+    def __init__(
-        self,
+        self,
-        port: str = "/dev/serial0",
+        port: str = "/dev/serial0",
-        baudrate: int = 115200,
+        baudrate: int = 115200,
-        buffer_size: int = 100,
+        buffer_size: int = 100,
-    ):
+    ):
-        self.port = port
+        self.port = port
-        self.baudrate = baudrate
+        self.baudrate = baudrate
-        self.buffer_size = buffer_size
+        self.buffer_size = buffer_size
-
+
-        self._buffer: deque[dict[str, Any]] = deque(maxlen=buffer_size)
+        self._buffer: deque[dict[str, Any]] = deque(maxlen=buffer_size)
-        self._latest: dict[str, Any] = {}
+        self._latest: dict[str, Any] = {}
-        self._connected = False
+        self._connected = False
-        self._running = False
+        self._running = False
-        self._thread: threading.Thread | None = None
+        self._thread: threading.Thread | None = None
-        self._lock = threading.Lock()
+        self._lock = threading.Lock()
-
+
-        # Callbacks for push-based updates
+        # Callbacks for push-based updates
-        self._on_data_callback = None
+        self._on_data_callback = None
-        self._on_ack_callback = None
+        self._on_ack_callback = None
-
+
-        # Serial port handle for sending commands
+        # Serial port handle for sending commands
-        self._serial: Any = None
+        self._serial: Any = None
-        self._serial_lock = threading.Lock()
+        self._serial_lock = threading.Lock()
-
+
-        # Periodic status logging
+        # Periodic status logging
-        self._last_status_log = 0.0
+        self._last_status_log = 0.0
-        self._frame_count = 0
+        self._frame_count = 0
-
+
-    def set_on_data(self, callback):
+    def set_on_data(self, callback):
-        """Set callback for new telemetry data. Called with data dict."""
+        """Set callback for new telemetry data. Called with data dict."""
-        self._on_data_callback = callback
+        self._on_data_callback = callback
-
+
-    def set_on_ack(self, callback):
+    def set_on_ack(self, callback):
-        """Set callback for ACK responses. Called with (cmd, status, extra)."""
+        """Set callback for ACK responses. Called with (cmd, status, extra)."""
-        self._on_ack_callback = callback
+        self._on_ack_callback = callback
-
+
-    def send_command(self, cmd: str, params: dict | None = None) -> bool:
+    def send_command(self, cmd: str, params: dict | None = None) -> bool:
-        """Send a command to Arduino via serial.
+        """Send a command to Arduino via serial.
-
+
-        Format: "CMD:NAME:PARAM1:PARAM2..." followed by newline
+        Format: "CMD:NAME:PARAM1:PARAM2..." followed by newline
-
+
-        Args:
+        Args:
-            cmd: Command name (e.g., "HORN", "LIGHT")
+            cmd: Command name (e.g., "HORN", "LIGHT")
-            params: Optional parameters dict
+            params: Optional parameters dict
-
+
-        Returns:
+        Returns:
-            True if sent successfully, False if serial unavailable
+            True if sent successfully, False if serial unavailable
-        """
+        """
-        with self._serial_lock:
+        with self._serial_lock:
-            if self._serial is None or not self._connected:
+            if self._serial is None or not self._connected:
-                print(f"[Arduino] Cannot send command, not connected")
+                print(f"[Arduino] Cannot send command, not connected")
-                return False
+                return False
-
+
-            try:
+            try:
-                # Build command string
+                # Build command string
-                parts = ["CMD", cmd.upper()]
+                parts = ["CMD", cmd.upper()]
-                if params:
+                if params:
-                    for key, val in params.items():
+                    for key, val in params.items():
-                        parts.append(f"{key}={val}")
+                        parts.append(f"{key}={val}")
-                line = ":".join(parts) + "\n"
+                line = ":".join(parts) + "\n"
-
+
-                self._serial.write(line.encode("utf-8"))
+                self._serial.write(line.encode("utf-8"))
-                self._serial.flush()
+                self._serial.flush()
-                print(f"[Arduino] Sent: {line.strip()}")
+                print(f"[Arduino] Sent: {line.strip()}")
-                return True
+                return True
-            except Exception as e:
+            except Exception as e:
-                print(f"[Arduino] Failed to send command: {e}")
+                print(f"[Arduino] Failed to send command: {e}")
-                return False
+                return False
-
+
-    @property
+    @property
-    def connected(self) -> bool:
+    def connected(self) -> bool:
-        return self._connected
+        return self._connected
-
+
-    def get_latest(self) -> dict[str, Any]:
+    def get_latest(self) -> dict[str, Any]:
-        """Get most recent telemetry values."""
+        """Get most recent telemetry values."""
-        with self._lock:
+        with self._lock:
-            return self._latest.copy() if self._latest else {"error": "no data"}
+            return self._latest.copy() if self._latest else {"error": "no data"}
-
+
-    def get_buffer(self) -> list[dict[str, Any]]:
+    def get_buffer(self) -> list[dict[str, Any]]:
-        """Get buffered telemetry history."""
+        """Get buffered telemetry history."""
-        with self._lock:
+        with self._lock:
-            return list(self._buffer)
+            return list(self._buffer)
-
+
-    def start(self):
+    def start(self):
-        """Start background serial reader thread."""
+        """Start background serial reader thread."""
-        if self._running:
+        if self._running:
-            return
+            return
-        self._running = True
+        self._running = True
-        self._thread = threading.Thread(target=self._reader_loop, daemon=True)
+        self._thread = threading.Thread(target=self._reader_loop, daemon=True)
-        self._thread.start()
+        self._thread.start()
-
+
-    def stop(self):
+    def stop(self):
-        """Stop background reader."""
+        """Stop background reader."""
-        self._running = False
+        self._running = False
-        if self._thread:
+        if self._thread:
-            self._thread.join(timeout=2.0)
+            self._thread.join(timeout=2.0)
-
+
-    def _reader_loop(self):
+    def _reader_loop(self):
-        """Main reader loop with reconnection logic."""
+        """Main reader loop with reconnection logic."""
-        while self._running:
+        while self._running:
-            try:
+            try:
-                self._connect_and_read()
+                self._connect_and_read()
-            except Exception as e:
+            except Exception as e:
-                self._connected = False
+                self._connected = False
-                print(f"[Arduino] Connection error: {e}, retrying in 5s...")
+                print(f"[Arduino] Connection error: {e}, retrying in 5s...")
-                time.sleep(5)
+                time.sleep(5)
-
+
-    def _connect_and_read(self):
+    def _connect_and_read(self):
-        """Connect to Arduino serial and read data."""
+        """Connect to Arduino serial and read data."""
-        if serial is None:
+        if serial is None:
-            print("[Arduino] pyserial not installed, cannot connect")
+            print("[Arduino] pyserial not installed, cannot connect")
-            return  # Will retry via _reader_loop after 5s
+            return  # Will retry via _reader_loop after 5s
-
+
-        try:
+        try:
-            ser = serial.Serial(
+            ser = serial.Serial(
-                port=self.port,
+                port=self.port,
-                baudrate=self.baudrate,
+                baudrate=self.baudrate,
-                timeout=1.0,
+                timeout=1.0,
-            )
+            )
-        except serial.SerialException as e:
+        except serial.SerialException as e:
-            print(f"[Arduino] Cannot open {self.port}: {e}")
+            print(f"[Arduino] Cannot open {self.port}: {e}")
-            return  # Will retry via _reader_loop after 5s
+            return  # Will retry via _reader_loop after 5s
-
+
-        try:
+        try:
-            # Store serial handle for send_command()
+            # Store serial handle for send_command()
-            with self._serial_lock:
+            with self._serial_lock:
-                self._serial = ser
+                self._serial = ser
-            self._connected = True
+            self._connected = True
-            self._last_status_log = time.time()
+            self._last_status_log = time.time()
-            self._frame_count = 0
+            self._frame_count = 0
-            print(f"[Arduino] Connected to {self.port} @ {self.baudrate} baud")
+            print(f"[Arduino] Connected to {self.port} @ {self.baudrate} baud")
-
+
-            while self._running:
+            while self._running:
-                try:
+                try:
-                    # Read null-terminated line (TSV protocol)
+                    # Read null-terminated line (TSV protocol)
-                    line = self._read_null_terminated(ser)
+                    line = self._read_null_terminated(ser)
-                    if not line:
+                    if not line:
-                        continue
+                        continue
-
+
-                    # Check for ACK responses first (legacy newline-terminated)
+                    # Check for ACK responses first (legacy newline-terminated)
-                    ack_match = self.ACK_PATTERN.match(line)
+                    ack_match = self.ACK_PATTERN.match(line)
-                    if ack_match:
+                    if ack_match:
-                        cmd, status, extra = ack_match.groups()
+                        cmd, status, extra = ack_match.groups()
-                        if self._on_ack_callback:
+                        if self._on_ack_callback:
-                            self._on_ack_callback(cmd, status, extra)
+                            self._on_ack_callback(cmd, status, extra)
-                        continue
+                        continue
-
+
-                    data = self._parse_line(line)
+                    data = self._parse_line(line)
-                    if data:
+                    if data:
-                        data["time"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+                        data["time"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-                        with self._lock:
+                        with self._lock:
-                            # Merge new values into latest (preserve old values for partial updates)
+                            # Merge new values into latest (preserve old values for partial updates)
-                            for key, val in data.items():
+                            for key, val in data.items():
-                                if val is not None and not (isinstance(val, float) and math.isnan(val)):
+                                if val is not None and not (isinstance(val, float) and math.isnan(val)):
-                                    self._latest[key] = val
+                                    self._latest[key] = val
-                            self._latest["time"] = data["time"]
+                            self._latest["time"] = data["time"]
-                            self._buffer.append(self._latest.copy())
+                            self._buffer.append(self._latest.copy())
-
+
-                        # Invoke callback with new data
+                        # Invoke callback with new data
-                        if self._on_data_callback:
+                        if self._on_data_callback:
-                            self._on_data_callback(self._latest.copy())
+                            self._on_data_callback(self._latest.copy())
-
+
-                        # Periodic status log (every 5s)
+                        # Periodic status log (every 5s)
-                        self._frame_count += 1
+                        self._frame_count += 1
-                        now = time.time()
+                        now = time.time()
-                        if now - self._last_status_log >= 5.0:
+                        if now - self._last_status_log >= 5.0:
-                            elapsed = now - self._last_status_log
+                            elapsed = now - self._last_status_log
-                            fps = self._frame_count / elapsed
+                            fps = self._frame_count / elapsed
-                            v = self._latest.get('voltage', 0)
+                            v = self._latest.get('voltage', 0)
-                            rpm = self._latest.get('rpm', 0)
+                            rpm = self._latest.get('rpm', 0)
-                            gear = self._latest.get('gear', 0)
+                            gear = self._latest.get('gear', 0)
-                            roll = self._latest.get('roll', 0)
+                            roll = self._latest.get('roll', 0)
-                            print(f"[Arduino] {fps:.1f} fps | V={v:.1f} RPM={int(rpm)} G={int(gear)} roll={roll:.1f}°")
+                            print(f"[Arduino] {fps:.1f} fps | V={v:.1f} RPM={int(rpm)} G={int(gear)} roll={roll:.1f}°")
-                            self._last_status_log = now
+                            self._last_status_log = now
-                            self._frame_count = 0
+                            self._frame_count = 0
-
+
-                except serial.SerialException as e:
+                except serial.SerialException as e:
-                    print(f"[Arduino] Serial error: {e}")
+                    print(f"[Arduino] Serial error: {e}")
-                    break
+                    break
-
+
-        finally:
+        finally:
-            self._connected = False
+            self._connected = False
-            with self._serial_lock:
+            with self._serial_lock:
-                self._serial = None
+                self._serial = None
-            ser.close()
+            ser.close()
-
+
-    def _read_null_terminated(self, ser) -> str:
+    def _read_null_terminated(self, ser) -> str:
-        """Read bytes until null terminator or newline (fallback for legacy)."""
+        """Read bytes until null terminator or newline (fallback for legacy)."""
-        buf = bytearray()
+        buf = bytearray()
-        while self._running:
+        while self._running:
-            byte = ser.read(1)
+            byte = ser.read(1)
-            if not byte:
+            if not byte:
-                # Timeout
+                # Timeout
-                if buf:
+                if buf:
-                    # Return partial buffer if we have data
+                    # Return partial buffer if we have data
-                    return buf.decode("utf-8", errors="ignore").strip()
+                    return buf.decode("utf-8", errors="ignore").strip()
-                return ""
+                return ""
-            if byte == b'\x00' or byte == b'\n' or byte == b'\r':
+            if byte == b'\x00' or byte == b'\n' or byte == b'\r':
-                # End of frame
+                # End of frame
-                if buf:
+                if buf:
-                    return buf.decode("utf-8", errors="ignore").strip()
+                    return buf.decode("utf-8", errors="ignore").strip()
-                # Skip empty lines / consecutive terminators
+                # Skip empty lines / consecutive terminators
-                continue
+                continue
-            buf.append(byte[0])
+            buf.append(byte[0])
-            # Safety limit
+            # Safety limit
-            if len(buf) > 256:
+            if len(buf) > 256:
-                return buf.decode("utf-8", errors="ignore").strip()
+                return buf.decode("utf-8", errors="ignore").strip()
-
+
-    def _parse_line(self, line: str) -> dict[str, Any] | None:
+    def _parse_line(self, line: str) -> dict[str, Any] | None:
-        """Parse a line from Arduino - TSV first, then JSON, fallback to regex.
+        """Parse a line from Arduino - TSV first, then JSON, fallback to regex.
-
+
-        TSV format: 12.45\t0.02\t-0.01\t... (10 fields, per PROTOCOL.md)
+        TSV format: 12.45\t0.02\t-0.01\t... (10 fields, per PROTOCOL.md)
-        JSON format: {"v":12.45,"rpm":4500,"eng":85,"gear":3}
+        JSON format: {"v":12.45,"rpm":4500,"eng":85,"gear":3}
-        Legacy text: V_bat: 12.45V
+        Legacy text: V_bat: 12.45V
-        """
+        """
-        # Try TSV first (new protocol)
+        # Try TSV first (new protocol)
-        if '\t' in line:
+        if '\t' in line:
-            return self._parse_tsv(line)
+            return self._parse_tsv(line)
-
+
-        # Try JSON (may still be used for special messages)
+        # Try JSON (may still be used for special messages)
-        try:
+        try:
-            obj = json.loads(line)
+            obj = json.loads(line)
-            return {
+            return {
-                "voltage": obj.get("v"),
+                "voltage": obj.get("v"),
-                "rpm": obj.get("rpm"),
+                "rpm": obj.get("rpm"),
-                "eng_temp": obj.get("eng"),
+                "eng_temp": obj.get("eng"),
-                "gear": obj.get("gear"),
+                "gear": obj.get("gear"),
-            }
+            }
-        except json.JSONDecodeError:
+        except json.JSONDecodeError:
-            pass
+            pass
-
+
-        # Fallback to regex for legacy text protocol
+        # Fallback to regex for legacy text protocol
-        result = {}
+        result = {}
-        for key, pattern in self.PATTERNS.items():
+        for key, pattern in self.PATTERNS.items():
-            match = pattern.search(line)
+            match = pattern.search(line)
-            if match:
+            if match:
-                val = match.group(1)
+                val = match.group(1)
-                result[key] = float(val) if "." in val else int(val)
+                result[key] = float(val) if "." in val else int(val)
-
+
-        return result if result else None
+        return result if result else None
-
+
-    def _parse_tsv(self, line: str) -> dict[str, Any] | None:
+    def _parse_tsv(self, line: str) -> dict[str, Any] | None:
-        """Parse TSV telemetry frame per PROTOCOL.md.
+        """Parse TSV telemetry frame per PROTOCOL.md.
-
+
-        Fields: voltage, ax, ay, az, gx, gy, gz, roll, pitch, yaw
+        Fields: voltage, ax, ay, az, gx, gy, gz, roll, pitch, yaw
-        Empty fields (stale IMU) become NaN.
+        Empty fields (stale IMU) become NaN.
-        """
+        """
-        fields = line.split('\t')
+        fields = line.split('\t')
-        if len(fields) != len(self.TSV_FIELDS):
+        if len(fields) != len(self.TSV_FIELDS):
-            # Wrong field count - might be debug output or malformed
+            # Wrong field count - might be debug output or malformed
-            return None
+            return None
-
+
-        result = {}
+        result = {}
-        for i, name in enumerate(self.TSV_FIELDS):
+        for i, name in enumerate(self.TSV_FIELDS):
-            val_str = fields[i].strip()
+            val_str = fields[i].strip()
-            if val_str == '':
+            if val_str == '':
-                # Empty field = stale/missing data
+                # Empty field = stale/missing data
-                result[name] = float('nan')
+                result[name] = float('nan')
-            else:
+            else:
-                try:
+                try:
-                    result[name] = float(val_str)
+                    result[name] = float(val_str)
-                except ValueError:
+                except ValueError:
-                    result[name] = float('nan')
+                    result[name] = float('nan')
-
+
-        # IMU axis correction for mounting orientation
+        # IMU axis correction for mounting orientation
-        # Pitch/yaw inverted for motorcycle frame alignment (roll left as-is)
+        # Pitch/yaw inverted for motorcycle frame alignment (roll left as-is)
-        if 'pitch' in result and not math.isnan(result['pitch']):
+        if 'pitch' in result and not math.isnan(result['pitch']):
-            result['pitch'] = -result['pitch']
+            result['pitch'] = -result['pitch']
-        if 'yaw' in result and not math.isnan(result['yaw']):
+        if 'yaw' in result and not math.isnan(result['yaw']):
-            result['yaw'] = -result['yaw']
+            result['yaw'] = -result['yaw']
-
+
-        return result
+        return result
-
+

pi/backend/gps_service.py

@@ -1,143 +1,315 @@
-"""GPS service - connects to gpsd, buffers data, handles reconnection."""
+"""GPS service - connects to gpsd, buffers data, handles reconnection."""
-
+
-import threading
+import random
-import time
+import threading
-from collections import deque
+import time
-from typing import Any
+from collections import deque
-
+from typing import Any
-# gpsdclient is a modern, simple gpsd client
+
-# Install gpsd on Pi: sudo apt install gpsd gpsd-clients
+# ============================================================================
-# Configure: sudo nano /etc/default/gpsd (set DEVICES="/dev/ttyUSB0" or similar)
+# DEBUG MODE - Set True for development without GPS hardware
-try:
+# When True: skips gpsd entirely, generates realistic mock data
-    from gpsdclient import GPSDClient
+# When False: connects to real gpsd (requires GPS device)
-except ImportError:
+# ============================================================================
-    GPSDClient = None  # Allow import without gpsd for testing structure
+_GPS_DEBUG = False
-
+
-
+# gpsdclient is a modern, simple gpsd client
-class GPSService:
+# Install gpsd on Pi: sudo apt install gpsd gpsd-clients
-    """Threaded GPS reader with buffering and auto-reconnect."""
+# Configure: sudo nano /etc/default/gpsd (set DEVICES="/dev/ttyUSB0" or similar)
-
+try:
-    def __init__(self, host: str = "127.0.0.1", port: int = 2947, buffer_size: int = 100):
+    from gpsdclient import GPSDClient
-        self.host = host
+except ImportError:
-        self.port = port
+    GPSDClient = None  # Allow import without gpsd for testing structure
-        self.buffer_size = buffer_size
+
-
+
-        self._buffer: deque[dict[str, Any]] = deque(maxlen=buffer_size)
+class GPSService:
-        self._latest: dict[str, Any] = {}
+    """Threaded GPS reader with buffering and auto-reconnect."""
-        self._connected = False
+
-        self._running = False
+    def __init__(self, host: str = "127.0.0.1", port: int = 2947, buffer_size: int = 100):
-        self._thread: threading.Thread | None = None
+        self.host = host
-        self._lock = threading.Lock()
+        self.port = port
-
+        self.buffer_size = buffer_size
-        # Callback for push-based updates
+
-        self._on_data_callback = None
+        self._buffer: deque[dict[str, Any]] = deque(maxlen=buffer_size)
-
+        self._latest: dict[str, Any] = {}
-    def set_on_data(self, callback):
+        self._connected = False
-        """Set callback for new GPS fix. Called with fix dict."""
+        self._running = False
-        self._on_data_callback = callback
+        self._thread: threading.Thread | None = None
-
+        self._lock = threading.Lock()
-    @property
+
-    def connected(self) -> bool:
+        # Callback for push-based updates
-        return self._connected
+        self._on_data_callback = None
-
+
-    def get_latest(self) -> dict[str, Any]:
+        # GPS state tracking (NMEA can't distinguish "acquiring" from "lost")
-        """Get most recent GPS fix."""
+        self._has_ever_fixed = False  # True after first valid fix this session
-        with self._lock:
+
-            return self._latest.copy() if self._latest else {"error": "no data"}
+        # Periodic status logging
-
+        self._last_status_log = 0.0
-    def get_buffer(self) -> list[dict[str, Any]]:
+        self._last_state_emit = 0.0
-        """Get buffered GPS history."""
+        self._fix_count = 0
-        with self._lock:
+
-            return list(self._buffer)
+    def set_on_data(self, callback):
-
+        """Set callback for new GPS fix. Called with fix dict."""
-    def start(self):
+        self._on_data_callback = callback
-        """Start background GPS reader thread."""
+
-        if self._running:
+    @property
-            return
+    def connected(self) -> bool:
-        self._running = True
+        return self._connected
-        self._thread = threading.Thread(target=self._reader_loop, daemon=True)
+
-        self._thread.start()
+    def get_latest(self) -> dict[str, Any]:
-
+        """Get most recent GPS fix."""
-    def stop(self):
+        with self._lock:
-        """Stop background reader."""
+            return self._latest.copy() if self._latest else {"error": "no data"}
-        self._running = False
+
-        if self._thread:
+    def _gps_state(self, fix: dict) -> str:
-            self._thread.join(timeout=2.0)
+        """Determine GPS state: acquiring, fix, or lost.
-
+
-    def _reader_loop(self):
+        NMEA doesn't distinguish 'never had fix' from 'lost signal' — both
-        """Main reader loop with reconnection logic."""
+        report mode 1 with no position. We track it ourselves.
-        while self._running:
+        """
-            try:
+        has_fix = fix.get("mode") in (2, 3) and fix.get("lat") is not None
-                self._connect_and_read()
+        if has_fix:
-            except Exception as e:
+            return "fix"
-                self._connected = False
+        return "lost" if self._has_ever_fixed else "acquiring"
-                print(f"[GPS] Connection error: {e}, retrying in 5s...")
+
-                time.sleep(5)
+    def get_buffer(self) -> list[dict[str, Any]]:
-
+        """Get buffered GPS history."""
-    def _connect_and_read(self):
+        with self._lock:
-        """Connect to gpsd and read data."""
+            return list(self._buffer)
-        if GPSDClient is None:
+
-            # Stub mode - no gpsd client installed
+    def start(self):
-            print("[GPS] gpsdclient not installed, running in stub mode")
+        """Start background GPS reader thread."""
-            self._stub_mode()
+        if self._running:
-            return
+            return
-
+        self._running = True
-        try:
+        self._thread = threading.Thread(target=self._reader_loop, daemon=True)
-            client = GPSDClient(host=self.host, port=self.port)
+        self._thread.start()
-        except Exception as e:
+        print("[GPS] Service started")
-            print(f"[GPS] Cannot connect to gpsd at {self.host}:{self.port}: {e}, falling back to stub mode")
+
-            self._stub_mode()
+    def stop(self):
-            return
+        """Stop background reader."""
-
+        self._running = False
-        with client:
+        if self._thread:
-            self._connected = True
+            self._thread.join(timeout=2.0)
-            print(f"[GPS] Connected to gpsd at {self.host}:{self.port}")
+
-
+    def _reader_loop(self):
-            for result in client.dict_stream(filter=["TPV"]):
+        """Main reader loop with reconnection logic."""
-                if not self._running:
+        print("[GPS] Reader thread running")
-                    break
+        while self._running:
-
+            try:
-                # TPV = Time-Position-Velocity report
+                self._connect_and_read()
-                fix = {
+            except Exception as e:
-                    "time": result.get("time"),
+                self._connected = False
-                    "lat": result.get("lat"),
+                print(f"[GPS] Connection error: {e}, retrying in 5s...")
-                    "lon": result.get("lon"),
+                time.sleep(5)
-                    "alt": result.get("alt"),
+
-                    "speed": result.get("speed"),  # m/s
+    def _connect_and_read(self):
-                    "track": result.get("track"),  # heading in degrees
+        """Connect to gpsd and read data."""
-                    "mode": result.get("mode"),    # 0=no fix, 2=2D, 3=3D
+        # Debug mode: skip gpsd entirely, use stub data
-                }
+        if _GPS_DEBUG:
-
+            print("[GPS] Debug mode enabled, using stub data")
-                with self._lock:
+            self._stub_mode()
-                    self._latest = fix
+            return
-                    if fix.get("lat") is not None:
+
-                        self._buffer.append(fix)
+        if GPSDClient is None:
-
+            print("[GPS] gpsdclient not installed, running in stub mode")
-                # Invoke callback with new fix
+            self._stub_mode()
-                if self._on_data_callback:
+            return
-                    self._on_data_callback(fix)
+
-
+        # Quick check if gpsd is reachable before attempting connection
-    def _stub_mode(self):
+        import socket
-        """Fake data for testing without gpsd."""
+        try:
-        import random
+            sock = socket.create_connection((self.host, self.port), timeout=2.0)
-
+            sock.close()
-        while self._running:
+        except (socket.timeout, socket.error, OSError) as e:
-            self._connected = True
+            print(f"[GPS] gpsd not reachable at {self.host}:{self.port}: {e}")
-            fix = {
+            raise ConnectionError(f"gpsd not reachable: {e}")
-                "time": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+
-                "lat": 35.6762 + random.uniform(-0.001, 0.001),
+        try:
-                "lon": 139.6503 + random.uniform(-0.001, 0.001),
+            client = GPSDClient(host=self.host, port=self.port)
-                "alt": 40.0 + random.uniform(-5, 5),
+        except Exception as e:
-                "speed": random.uniform(0, 30),
+            print(f"[GPS] Cannot connect to gpsd at {self.host}:{self.port}: {e}")
-                "track": random.uniform(0, 360),
+            raise ConnectionError(f"gpsd connection failed: {e}")
-                "mode": 3,
+
-            }
+        with client:
-            with self._lock:
+            self._connected = True
-                self._latest = fix
+            print(f"[GPS] Connected to gpsd at {self.host}:{self.port}")
-                self._buffer.append(fix)
+
-
+            self._last_status_log = time.time()
-            # Invoke callback with new fix
+            self._fix_count = 0
-            if self._on_data_callback:
+            # 120s for initial cold fix, 10s for signal loss after first fix
-                self._on_data_callback(fix)
+            fix_timeout = time.time() + 120.0
-
+
-            time.sleep(1)
+            for result in client.dict_stream(filter=["TPV"]):
+                if not self._running:
+                    break
+
+                # TPV = Time-Position-Velocity report
+                fix = {
+                    "time": result.get("time"),
+                    "lat": result.get("lat"),
+                    "lon": result.get("lon"),
+                    "alt": result.get("alt"),
+                    "speed": result.get("speed"),  # m/s
+                    "track": result.get("track"),  # heading in degrees
+                    "mode": result.get("mode"),    # 0=no fix, 2=2D, 3=3D
+                    "satellites": result.get("satellites"),  # from SKY messages
+                }
+
+                # Compute state and attach to fix
+                fix["gps_state"] = self._gps_state(fix)
+
+                # Check if this is a real fix (has position) or just empty TPV
+                if fix.get("lat") is None and fix.get("mode") in (None, 0, 1):
+                    # No real data yet, check timeout
+                    if time.time() > fix_timeout:
+                        timeout_s = "120s" if not self._has_ever_fixed else "10s"
+                        print(f"[GPS] No GPS fix after {timeout_s}, will retry connection")
+                        raise ConnectionError("No GPS fix within timeout")
+                    # Emit state periodically so UI knows we're alive
+                    now = time.time()
+                    if now - self._last_state_emit >= 5.0:
+                        self._last_state_emit = now
+                        with self._lock:
+                            self._latest = fix
+                        if self._on_data_callback:
+                            self._on_data_callback(fix)
+                    continue  # Skip empty fixes
+
+                # Got real data — mark first fix, reset timeout to shorter window
+                if not self._has_ever_fixed:
+                    self._has_ever_fixed = True
+                    self._last_state_emit = 0.0  # Force immediate emit on transition
+                    print("[GPS] First fix acquired")
+                fix_timeout = time.time() + 10.0  # 10s timeout for signal loss
+
+                with self._lock:
+                    self._latest = fix
+                    if fix.get("lat") is not None:
+                        self._buffer.append(fix)
+
+                # Invoke callback with new fix
+                if self._on_data_callback:
+                    self._on_data_callback(fix)
+
+                # Periodic status log (every 5s)
+                self._fix_count += 1
+                now = time.time()
+                if now - self._last_status_log >= 5.0:
+                    elapsed = now - self._last_status_log
+                    fps = self._fix_count / elapsed
+                    speed = fix.get('speed', 0) or 0
+                    track = fix.get('track', 0) or 0
+                    mode = fix.get('mode', 0) or 0
+                    sats = fix.get('satellites', '?')
+                    print(f"[GPS] {fps:.1f} fix/s | {speed:.1f}m/s hdg={track:.0f}° mode={mode} sats={sats}")
+                    self._last_status_log = now
+                    self._fix_count = 0
+
+    def _stub_mode(self):
+        """Generate realistic mock GPS data for development/testing.
+
+        Simulates:
+        - Initial acquisition delay (~3s before first fix)
+        - Normal 3D fix with satellites
+        - Occasional signal loss (~30% chance per second, lasts ~2s)
+        - Wandering position near Tokyo
+        """
+        self._last_status_log = time.time()
+        self._fix_count = 0
+
+        # Signal loss state
+        signal_lost = False
+        signal_lost_until = 0.0
+
+        # Simulate cold start acquisition (~30s)
+        acquiring_until = time.time() + 30.0
+
+        # Base position (Tokyo area)
+        base_lat = 35.6762
+        base_lon = 139.6503
+        base_alt = 40.0
+
+        # Smoothly varying heading/speed
+        heading = random.uniform(0, 360)
+        speed = random.uniform(5, 15)
+
+        while self._running:
+            self._connected = True
+            now = time.time()
+
+            # Simulate initial acquisition period
+            if now < acquiring_until:
+                signal_lost = True  # No fix yet
+            elif signal_lost and now >= signal_lost_until:
+                signal_lost = False
+                if self._has_ever_fixed:
+                    print("[GPS] Signal recovered (stub)")
+                else:
+                    print("[GPS] First fix acquired (stub)")
+            elif not signal_lost:
+                # ~30% chance per second to lose signal
+                if random.random() < 0.3:
+                    signal_lost = True
+                    signal_lost_until = now + 2  # fixed 2s loss
+                    print("[GPS] Signal loss simulation (stub)")
+
+            if signal_lost:
+                # No fix - mode 1, no satellites, no track
+                # Note: use None, not float('nan') - NaN doesn't serialize to valid JSON
+                fix = {
+                    "time": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                    "lat": None,
+                    "lon": None,
+                    "alt": None,
+                    "speed": None,
+                    "track": None,
+                    "mode": 1,
+                    "satellites": 0,
+                }
+            else:
+                # Smoothly vary heading and speed
+                heading = (heading + random.uniform(1, 3)) % 360
+                speed = max(0, min(30, speed + random.uniform(-2, 2)))
+
+                if not self._has_ever_fixed:
+                    self._has_ever_fixed = True
+
+                fix = {
+                    "time": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                    "lat": base_lat + random.uniform(-0.001, 0.001),
+                    "lon": base_lon + random.uniform(-0.001, 0.001),
+                    "alt": base_alt + random.uniform(-5, 5),
+                    "speed": speed,
+                    "track": heading,
+                    "mode": 3,
+                    "satellites": random.randint(6, 12),
+                }
+
+            # Attach state — same logic as real GPS path
+            fix["gps_state"] = self._gps_state(fix)
+
+            with self._lock:
+                self._latest = fix
+                if fix.get("lat") is not None:
+                    self._buffer.append(fix)
+
+            # Invoke callback with new fix
+            if self._on_data_callback:
+                self._on_data_callback(fix)
+
+            # Periodic status log (every 5s)
+            self._fix_count += 1
+            if now - self._last_status_log >= 5.0:
+                elapsed = now - self._last_status_log
+                fps = self._fix_count / elapsed
+                speed_val = fix.get('speed') or 0
+                track_val = fix.get('track')
+                track_str = f"{track_val:.0f}" if track_val is not None else "---"
+                mode = fix.get('mode', 0)
+                sats = fix.get('satellites', 0)
+                print(f"[GPS] {fps:.1f} fix/s | {speed_val:.1f}m/s hdg={track_str} mode={mode} sats={sats} (stub)")
+                self._last_status_log = now
+                self._fix_count = 0
+
+            time.sleep(1)

pi/backend/lte_service.py

@@ -0,0 +1,178 @@
+"""LTE service - polls ModemManager for signal quality and connection state."""
+
+import random
+import subprocess
+import re
+import threading
+import time
+from typing import Any
+
+# ============================================================================
+# DEBUG MODE - Set True for development without modem hardware
+# When True: skips mmcli entirely, generates mock LTE data
+# When False: polls real ModemManager via mmcli
+# ============================================================================
+_LTE_DEBUG = True
+
+
+class LteService:
+    """Threaded LTE modem status poller.
+
+    Polls `mmcli -m 0` every 5 seconds, parses signal quality, connection
+    state, operator, and access technology. Emits dict via callback.
+
+    No history buffer — historical signal strength isn't useful.
+    """
+
+    def __init__(self, poll_interval: float = 5.0):
+        self.poll_interval = poll_interval
+
+        self._latest: dict[str, Any] = {}
+        self._connected = False  # True when mmcli responds (modem alive)
+        self._running = False
+        self._thread: threading.Thread | None = None
+        self._lock = threading.Lock()
+
+        # Callback for push-based updates
+        self._on_data_callback = None
+
+    def set_on_data(self, callback):
+        """Set callback for new LTE data. Called with data dict."""
+        self._on_data_callback = callback
+
+    @property
+    def connected(self) -> bool:
+        """Whether the modem is reachable via mmcli."""
+        return self._connected
+
+    def get_latest(self) -> dict[str, Any]:
+        """Get most recent LTE status."""
+        with self._lock:
+            return self._latest.copy() if self._latest else {"error": "no data"}
+
+    def start(self):
+        """Start background LTE poller thread."""
+        if self._running:
+            return
+        self._running = True
+        self._thread = threading.Thread(target=self._poll_loop, daemon=True)
+        self._thread.start()
+        print("[LTE] Service started")
+
+    def stop(self):
+        """Stop background poller."""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=2.0)
+
+    def _poll_loop(self):
+        """Main poll loop."""
+        print("[LTE] Poller thread running")
+        while self._running:
+            try:
+                if _LTE_DEBUG:
+                    data = self._stub_poll()
+                else:
+                    data = self._real_poll()
+
+                with self._lock:
+                    self._latest = data
+
+                if self._on_data_callback:
+                    self._on_data_callback(data)
+
+            except Exception as e:
+                print(f"[LTE] Poll error: {e}")
+                self._connected = False
+
+            time.sleep(self.poll_interval)
+
+    def _real_poll(self) -> dict[str, Any]:
+        """Poll mmcli -m 0 and parse output."""
+        try:
+            result = subprocess.run(
+                ["mmcli", "-m", "0"],
+                capture_output=True,
+                text=True,
+                timeout=5.0,
+            )
+
+            if result.returncode != 0:
+                self._connected = False
+                return {
+                    "connected": False,
+                    "signal": 0,
+                    "operator": None,
+                    "access_tech": None,
+                }
+
+            output = result.stdout
+            self._connected = True
+
+            # Parse signal quality: "signal quality: 68 (recent)"
+            signal = 0
+            m = re.search(r"signal quality:\s*(\d+)", output)
+            if m:
+                signal = int(m.group(1))
+
+            # Parse state: "state: connected" / "registered" / "searching" etc.
+            state = None
+            m = re.search(r"^\s*state:\s*(\S+)", output, re.MULTILINE)
+            if m:
+                state = m.group(1).strip("'\"")
+
+            # Parse operator: "operator name: KDDI KDDI"
+            operator = None
+            m = re.search(r"operator name:\s*(.+)", output)
+            if m:
+                operator = m.group(1).strip()
+
+            # Parse access tech: "access tech: lte"
+            access_tech = None
+            m = re.search(r"access tech:\s*(\S+)", output)
+            if m:
+                access_tech = m.group(1).strip("'\"")
+
+            network_connected = state in ("connected", "registered")
+
+            return {
+                "connected": network_connected,
+                "signal": signal,
+                "operator": operator,
+                "access_tech": access_tech,
+            }
+
+        except subprocess.TimeoutExpired:
+            print("[LTE] mmcli timed out")
+            self._connected = False
+            return {
+                "connected": False,
+                "signal": 0,
+                "operator": None,
+                "access_tech": None,
+            }
+        except FileNotFoundError:
+            print("[LTE] mmcli not found, falling back to stub mode")
+            self._connected = False
+            return self._stub_poll()
+
+    # Stub state lives across polls
+    _stub_signal: float = 70.0
+
+    def _stub_poll(self) -> dict[str, Any]:
+        """Generate mock LTE data for development.
+
+        Simulates connected state with signal wandering 60-80.
+        """
+        self._connected = True
+
+        # Random walk signal, clamped to 60-80
+        self._stub_signal += random.uniform(-3, 3)
+        self._stub_signal = max(60, min(80, self._stub_signal))
+
+        return {
+            "connected": True,
+            "signal": int(self._stub_signal),
+            "operator": "STUB",
+            "access_tech": "lte",
+        }

pi/backend/main.py

@@ -1,245 +1,281 @@
-"""Smart Serow Backend - GPS and Arduino services with HTTP API and WebSocket."""
+"""Smart Serow Backend - GPS and Arduino services with HTTP API and WebSocket."""
-
+
-from gevent import monkey
+from gevent import monkey
-monkey.patch_all()  # Must be at the very top before other imports
+monkey.patch_all()  # Must be at the very top before other imports
-
+
-from flask import Flask, jsonify
+from flask import Flask, jsonify
-from flask_socketio import SocketIO, emit
+from flask_socketio import SocketIO, emit
-
+
-from gps_service import GPSService
+from gps_service import GPSService
-from arduino_service import ArduinoService
+from arduino_service import ArduinoService
-from gpio_service import GPIOService
+from gpio_service import GPIOService
-from throttle import Throttle
+from lte_service import LteService
-
+from throttle import Throttle
-app = Flask(__name__)
+
-app.config["SECRET_KEY"] = "smartserow-secret"  # Not security critical, just for session
+app = Flask(__name__)
-
+app.config["SECRET_KEY"] = "smartserow-secret"  # Not security critical, just for session
-# SocketIO with gevent async mode (eventlet is deprecated)
+
-socketio = SocketIO(app, async_mode="gevent", cors_allowed_origins="*")
+# SocketIO with gevent async mode (eventlet is deprecated)
-
+socketio = SocketIO(app, async_mode="gevent", cors_allowed_origins="*")
-# Services
+
-gps = GPSService()
+# Services
-arduino = ArduinoService()
+gps = GPSService()
-gpio = GPIOService()
+arduino = ArduinoService()
-
+gpio = GPIOService()
-# Throttles for emission rate limiting (20Hz for arduino, 1Hz for GPS)
+lte = LteService()
-arduino_throttle = Throttle(min_interval=0.05)  # 20Hz max
+
-gps_throttle = Throttle(min_interval=1.0)      # 1Hz max
+# Throttles for emission rate limiting (20Hz for arduino, 1Hz for GPS, 5s for LTE)
-
+arduino_throttle = Throttle(min_interval=0.05)  # 20Hz max
-# Track connected clients
+gps_throttle = Throttle(min_interval=1.0)      # 1Hz max
-connected_clients = set()
+lte_throttle = Throttle(min_interval=5.0)      # Every 5s — signal doesn't need real-time
-
+
-
+# Track connected clients
-# -----------------------------------------------------------------------------
+connected_clients = set()
-# WebSocket Event Handlers
+
-# -----------------------------------------------------------------------------
+
-
+# -----------------------------------------------------------------------------
-@socketio.on("connect")
+# WebSocket Event Handlers
-def handle_connect():
+# -----------------------------------------------------------------------------
-    """Client connected."""
+
-    client_id = id(socketio)  # Simple identifier
+@socketio.on("connect")
-    connected_clients.add(client_id)
+def handle_connect():
-    print(f"[WS] Client connected ({len(connected_clients)} total)")
+    """Client connected."""
-
+    client_id = id(socketio)  # Simple identifier
-    # Send current status immediately
+    connected_clients.add(client_id)
-    emit("status", {
+    print(f"[WS] Client connected ({len(connected_clients)} total)")
-        "gps_connected": gps.connected,
+
-        "arduino_connected": arduino.connected,
+    # Send current status immediately
-        "theme_switch": gpio.theme_switch,
+    emit("status", {
-    })
+        "gps_connected": gps.connected,
-
+        "arduino_connected": arduino.connected,
-    # Send latest data if available
+        "theme_switch": gpio.theme_switch,
-    arduino_data = arduino.get_latest()
+    })
-    if "error" not in arduino_data:
+
-        emit("arduino", arduino_data)
+    # Send latest data if available
-
+    arduino_data = arduino.get_latest()
-    gps_data = gps.get_latest()
+    if "error" not in arduino_data:
-    if "error" not in gps_data:
+        emit("arduino", arduino_data)
-        emit("gps", gps_data)
+
-
+    gps_data = gps.get_latest()
-
+    if "error" not in gps_data:
-@socketio.on("disconnect")
+        emit("gps", gps_data)
-def handle_disconnect():
+
-    """Client disconnected."""
+    lte_data = lte.get_latest()
-    client_id = id(socketio)
+    if "error" not in lte_data:
-    connected_clients.discard(client_id)
+        emit("lte", lte_data)
-    print(f"[WS] Client disconnected ({len(connected_clients)} remaining)")
+
-
+
-
+@socketio.on("disconnect")
-@socketio.on("button")
+def handle_disconnect():
-def handle_button(data):
+    """Client disconnected."""
-    """Handle button press from UI.
+    client_id = id(socketio)
-
+    connected_clients.discard(client_id)
-    Expected data: {"id": "horn", "action": "press", ...params}
+    print(f"[WS] Client disconnected ({len(connected_clients)} remaining)")
-    """
+
-    btn_id = data.get("id", "unknown")
+
-    action = data.get("action", "press")
+@socketio.on("button")
-    params = {k: v for k, v in data.items() if k not in ("id", "action")}
+def handle_button(data):
-
+    """Handle button press from UI.
-    print(f"[WS] Button: {btn_id} {action} {params}")
+
-
+    Expected data: {"id": "horn", "action": "press", ...params}
-    # Map button ID to Arduino command
+    """
-    cmd_map = {
+    btn_id = data.get("id", "unknown")
-        "horn": "HORN",
+    action = data.get("action", "press")
-        "light": "LIGHT",
+    params = {k: v for k, v in data.items() if k not in ("id", "action")}
-        "indicator_left": "IND_L",
+
-        "indicator_right": "IND_R",
+    print(f"[WS] Button: {btn_id} {action} {params}")
-        "hazard": "HAZARD",
+
-    }
+    # Map button ID to Arduino command
-
+    cmd_map = {
-    cmd = cmd_map.get(btn_id)
+        "horn": "HORN",
-    if cmd:
+        "light": "LIGHT",
-        # Add action to params (e.g., ON/OFF based on press/release)
+        "indicator_left": "IND_L",
-        params["state"] = "ON" if action == "press" else "OFF"
+        "indicator_right": "IND_R",
-        success = arduino.send_command(cmd, params)
+        "hazard": "HAZARD",
-
+    }
-        # Send immediate ack for the attempt
+
-        emit("ack", {
+    cmd = cmd_map.get(btn_id)
-            "id": btn_id,
+    if cmd:
-            "status": "sent" if success else "failed",
+        # Add action to params (e.g., ON/OFF based on press/release)
-            "error": None if success else "arduino not connected",
+        params["state"] = "ON" if action == "press" else "OFF"
-        })
+        success = arduino.send_command(cmd, params)
-    else:
+
-        emit("ack", {
+        # Send immediate ack for the attempt
-            "id": btn_id,
+        emit("ack", {
-            "status": "error",
+            "id": btn_id,
-            "error": f"unknown button: {btn_id}",
+            "status": "sent" if success else "failed",
-        })
+            "error": None if success else "arduino not connected",
-
+        })
-
+    else:
-@socketio.on("emergency")
+        emit("ack", {
-def handle_emergency(data):
+            "id": btn_id,
-    """Handle emergency signal from UI."""
+            "status": "error",
-    etype = data.get("type", "stop")
+            "error": f"unknown button: {btn_id}",
-    print(f"[WS] EMERGENCY: {etype}")
+        })
-
+
-    # Send emergency command to Arduino
+
-    arduino.send_command("EMERGENCY", {"type": etype})
+@socketio.on("emergency")
-
+def handle_emergency(data):
-    # Broadcast alert to all clients
+    """Handle emergency signal from UI."""
-    socketio.emit("alert", {
+    etype = data.get("type", "stop")
-        "type": "emergency",
+    print(f"[WS] EMERGENCY: {etype}")
-        "message": f"Emergency {etype} triggered",
+
-    })
+    # Send emergency command to Arduino
-
+    arduino.send_command("EMERGENCY", {"type": etype})
-
+
-# -----------------------------------------------------------------------------
+    # Broadcast alert to all clients
-# Service Callbacks (push data to WebSocket)
+    socketio.emit("alert", {
-# -----------------------------------------------------------------------------
+        "type": "emergency",
-
+        "message": f"Emergency {etype} triggered",
-def on_arduino_data(data):
+    })
-    """Called by ArduinoService when new telemetry arrives."""
+
-    # Always include current GPIO state (UI dedupes)
+
-    data = dict(data)  # Don't mutate original
+# -----------------------------------------------------------------------------
-    data["theme_switch"] = gpio.theme_switch
+# Service Callbacks (push data to WebSocket)
-
+# -----------------------------------------------------------------------------
-    def emit_fn(d):
+
-        socketio.emit("arduino", d)
+def on_arduino_data(data):
-
+    """Called by ArduinoService when new telemetry arrives."""
-    arduino_throttle.maybe_emit(data, emit_fn)
+    # Always include current GPIO state (UI dedupes)
-
+    data = dict(data)  # Don't mutate original
-
+    data["theme_switch"] = gpio.theme_switch
-def on_gps_data(data):
+    
-    """Called by GPSService when new fix arrives."""
+    # backend voltage offset correction
-    def emit_fn(d):
+    if "voltage" in data:
-        socketio.emit("gps", d)
+        data["voltage"] += 0.2  # Calibration offset
-
+
-    gps_throttle.maybe_emit(data, emit_fn)
+    def emit_fn(d):
-
+        socketio.emit("arduino", d)
-
+
-def on_arduino_ack(cmd, status, extra):
+    arduino_throttle.maybe_emit(data, emit_fn)
-    """Called by ArduinoService when ACK received from Arduino."""
+
-    socketio.emit("ack", {
+
-        "id": cmd.lower(),
+def on_gps_data(data):
-        "status": status.lower(),
+    """Called by GPSService when new fix arrives."""
-        "extra": extra,
+    def emit_fn(d):
-    })
+        socketio.emit("gps", d)
-
+
-
+    gps_throttle.maybe_emit(data, emit_fn)
-# -----------------------------------------------------------------------------
+
-# Background task to flush pending throttled data
+
-# -----------------------------------------------------------------------------
+def on_lte_data(data):
-
+    """Called by LteService when new status polled."""
-def throttle_flusher():
+    def emit_fn(d):
-    """Periodically flush pending throttled data."""
+        socketio.emit("lte", d)
-    import gevent
+
-    while True:
+    lte_throttle.maybe_emit(data, emit_fn)
-        gevent.sleep(0.05)  # 20Hz flush rate
+
-
+
-        if arduino_throttle.has_pending:
+def on_arduino_ack(cmd, status, extra):
-            arduino_throttle.flush(lambda d: socketio.emit("arduino", d))
+    """Called by ArduinoService when ACK received from Arduino."""
-
+    socketio.emit("ack", {
-        if gps_throttle.has_pending:
+        "id": cmd.lower(),
-            gps_throttle.flush(lambda d: socketio.emit("gps", d))
+        "status": status.lower(),
-
+        "extra": extra,
-
+    })
-# -----------------------------------------------------------------------------
+
-# REST API (backward compatibility)
+
-# -----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
-
+# Background task to flush pending throttled data
-@app.route("/health")
+# -----------------------------------------------------------------------------
-def health():
+
-    """Health check endpoint."""
+def throttle_flusher():
-    return jsonify({
+    """Periodically flush pending throttled data."""
-        "status": "ok",
+    import gevent
-        "gps_connected": gps.connected,
+    while True:
-        "arduino_connected": arduino.connected,
+        gevent.sleep(0.05)  # 20Hz flush rate
-        "ws_clients": len(connected_clients),
+
-    })
+        if arduino_throttle.has_pending:
-
+            arduino_throttle.flush(lambda d: socketio.emit("arduino", d))
-
+
-@app.route("/gps")
+        if gps_throttle.has_pending:
-def gps_data():
+            gps_throttle.flush(lambda d: socketio.emit("gps", d))
-    """Current GPS data."""
+
-    return jsonify(gps.get_latest())
+        if lte_throttle.has_pending:
-
+            lte_throttle.flush(lambda d: socketio.emit("lte", d))
-
+
-@app.route("/gps/history")
+
-def gps_history():
+# -----------------------------------------------------------------------------
-    """Buffered GPS history."""
+# REST API (backward compatibility)
-    return jsonify(gps.get_buffer())
+# -----------------------------------------------------------------------------
-
+
-
+@app.route("/health")
-@app.route("/arduino")
+def health():
-def arduino_data():
+    """Health check endpoint."""
-    """Current Arduino telemetry (voltage, rpm, etc)."""
+    gps_latest = gps.get_latest()
-    return jsonify(arduino.get_latest())
+    lte_latest = lte.get_latest()
-
+    return jsonify({
-
+        "status": "ok",
-@app.route("/arduino/history")
+        "gps_connected": gps.connected,
-def arduino_history():
+        "gps_state": gps_latest.get("gps_state", "acquiring"),
-    """Buffered Arduino telemetry history."""
+        "arduino_connected": arduino.connected,
-    return jsonify(arduino.get_buffer())
+        "lte_connected": lte.connected,
-
+        "lte_signal": lte_latest.get("signal"),
-
+        "ws_clients": len(connected_clients),
-# -----------------------------------------------------------------------------
+    })
-# Main Entry Point
+
-# -----------------------------------------------------------------------------
+
-
+@app.route("/gps")
-def main():
+def gps_data():
-    """Entry point."""
+    """Current GPS data."""
-    # Wire up callbacks
+    return jsonify(gps.get_latest())
-    arduino.set_on_data(on_arduino_data)
+
-    arduino.set_on_ack(on_arduino_ack)
+
-    gps.set_on_data(on_gps_data)
+@app.route("/gps/history")
-
+def gps_history():
-    # Start services
+    """Buffered GPS history."""
-    gps.start()
+    return jsonify(gps.get_buffer())
-    arduino.start()
+
-    gpio.start()
+
-
+@app.route("/lte")
-    # Start throttle flusher in background
+def lte_data():
-    socketio.start_background_task(throttle_flusher)
+    """Current LTE modem status."""
-
+    return jsonify(lte.get_latest())
-    try:
+
-        # Use socketio.run() instead of app.run() for WebSocket support
+
-        print("[Backend] Starting on http://0.0.0.0:5000")
+@app.route("/arduino")
-        socketio.run(app, host="0.0.0.0", port=5000, debug=False)
+def arduino_data():
-    finally:
+    """Current Arduino telemetry (voltage, rpm, etc)."""
-        arduino.stop()
+    return jsonify(arduino.get_latest())
-        gps.stop()
+
-        gpio.stop()
+
-
+@app.route("/arduino/history")
-
+def arduino_history():
-if __name__ == "__main__":
+    """Buffered Arduino telemetry history."""
-    main()
+    return jsonify(arduino.get_buffer())
+
+
+# -----------------------------------------------------------------------------
+# Main Entry Point
+# -----------------------------------------------------------------------------
+
+def main():
+    """Entry point."""
+    # Wire up callbacks
+    arduino.set_on_data(on_arduino_data)
+    arduino.set_on_ack(on_arduino_ack)
+    gps.set_on_data(on_gps_data)
+    lte.set_on_data(on_lte_data)
+
+    # Start services
+    gps.start()
+    arduino.start()
+    gpio.start()
+    lte.start()
+
+    # Start throttle flusher in background
+    socketio.start_background_task(throttle_flusher)
+
+    try:
+        # Use socketio.run() instead of app.run() for WebSocket support
+        print("[Backend] Starting on http://0.0.0.0:5000")
+        socketio.run(app, host="0.0.0.0", port=5000, debug=False)
+    finally:
+        arduino.stop()
+        gps.stop()
+        gpio.stop()
+        lte.stop()
+
+
+if __name__ == "__main__":
+    main()

pi/backend/pyproject.toml

@@ -1,26 +1,26 @@
-[project]
+[project]
-name = "smartserow-backend"
+name = "smartserow-backend"
-version = "0.1.0"
+version = "0.1.0"
-description = "GPS and Arduino telemetry service for Smart Serow"
+description = "GPS and Arduino telemetry service for Smart Serow"
-requires-python = ">=3.11"
+requires-python = ">=3.11"
-dependencies = [
+dependencies = [
-    "flask>=3.0",
+    "flask>=3.0",
-    "flask-socketio>=5.3.0",
+    "flask-socketio>=5.3.0",
-    "gevent>=24.0",
+    "gevent>=24.0",
-    "gevent-websocket>=0.10",
+    "gevent-websocket>=0.10",
-    "gpsdclient>=1.3",
+    "gpsdclient>=1.3",
-    "pyserial>=3.5",
+    "pyserial>=3.5",
-    # GPIO: install via apt (sudo apt install python3-rpi.gpio)
+    # GPIO: install via apt (sudo apt install python3-rpi.gpio)
-    # Not listed here because pip versions require compilation
+    # Not listed here because pip versions require compilation
-]
+]
-
+
-[project.optional-dependencies]
+[project.optional-dependencies]
-dev = [
+dev = [
-    "ruff",
+    "ruff",
-]
+]
-
+
-[project.scripts]
+[project.scripts]
-smartserow-backend = "main:main"
+smartserow-backend = "main:main"
-
+
-[tool.ruff]
+[tool.ruff]
-line-length = 100
+line-length = 100

pi/backend/throttle.py

@@ -1,61 +1,61 @@
-"""Throttle layer for rate-limiting telemetry emissions."""
+"""Throttle layer for rate-limiting telemetry emissions."""
-
+
-import time
+import time
-from typing import Any, Callable
+from typing import Any, Callable
-
+
-
+
-class Throttle:
+class Throttle:
-    """Rate limiter for WebSocket emissions.
+    """Rate limiter for WebSocket emissions.
-
+
-    Coalesces rapid updates - only emits at most once per min_interval.
+    Coalesces rapid updates - only emits at most once per min_interval.
-    If multiple updates arrive within the interval, the latest value wins.
+    If multiple updates arrive within the interval, the latest value wins.
-    """
+    """
-
+
-    def __init__(self, min_interval: float = 0.5):
+    def __init__(self, min_interval: float = 0.5):
-        """
+        """
-        Args:
+        Args:
-            min_interval: Minimum seconds between emissions (default 0.5 = 2Hz max)
+            min_interval: Minimum seconds between emissions (default 0.5 = 2Hz max)
-        """
+        """
-        self._last_emit: float = 0
+        self._last_emit: float = 0
-        self._min_interval = min_interval
+        self._min_interval = min_interval
-        self._pending: Any = None
+        self._pending: Any = None
-
+
-    def maybe_emit(self, data: Any, emit_fn: Callable[[Any], None]) -> bool:
+    def maybe_emit(self, data: Any, emit_fn: Callable[[Any], None]) -> bool:
-        """Emit if interval has passed, otherwise store as pending.
+        """Emit if interval has passed, otherwise store as pending.
-
+
-        Args:
+        Args:
-            data: Data to emit
+            data: Data to emit
-            emit_fn: Function to call with data when emitting
+            emit_fn: Function to call with data when emitting
-
+
-        Returns:
+        Returns:
-            True if emitted, False if stored as pending
+            True if emitted, False if stored as pending
-        """
+        """
-        now = time.time()
+        now = time.time()
-        if now - self._last_emit >= self._min_interval:
+        if now - self._last_emit >= self._min_interval:
-            emit_fn(data)
+            emit_fn(data)
-            self._last_emit = now
+            self._last_emit = now
-            self._pending = None
+            self._pending = None
-            return True
+            return True
-        else:
+        else:
-            self._pending = data  # Latest value wins
+            self._pending = data  # Latest value wins
-            return False
+            return False
-
+
-    def flush(self, emit_fn: Callable[[Any], None]) -> bool:
+    def flush(self, emit_fn: Callable[[Any], None]) -> bool:
-        """Emit pending data if any.
+        """Emit pending data if any.
-
+
-        Call this periodically to ensure pending data gets sent.
+        Call this periodically to ensure pending data gets sent.
-
+
-        Returns:
+        Returns:
-            True if pending data was emitted, False if nothing pending
+            True if pending data was emitted, False if nothing pending
-        """
+        """
-        if self._pending is not None:
+        if self._pending is not None:
-            emit_fn(self._pending)
+            emit_fn(self._pending)
-            self._last_emit = time.time()
+            self._last_emit = time.time()
-            self._pending = None
+            self._pending = None
-            return True
+            return True
-        return False
+        return False
-
+
-    @property
+    @property
-    def has_pending(self) -> bool:
+    def has_pending(self) -> bool:
-        """Check if there's pending data waiting to be emitted."""
+        """Check if there's pending data waiting to be emitted."""
-        return self._pending is not None
+        return self._pending is not None

pi/backend/utils/at_terminal.py

@@ -0,0 +1,49 @@
+"""Quick AT command terminal - minicom but less hostile.
+
+Usage:
+    python at_terminal.py [port]
+
+Default port: /dev/ttyUSB2 (SIM7600 AT command interface)
+"""
+
+import sys
+import serial
+import threading
+
+PORT = sys.argv[1] if len(sys.argv) > 1 else "/dev/ttyUSB2"
+BAUD = 115200
+
+
+def reader(ser):
+    """Background thread: print everything the modem sends."""
+    while True:
+        try:
+            data = ser.read(ser.in_waiting or 1)
+            if data:
+                sys.stdout.write(data.decode("utf-8", errors="replace"))
+                sys.stdout.flush()
+        except Exception:
+            break
+
+
+def main():
+    print(f"Opening {PORT} @ {BAUD} baud")
+    print("Type AT commands. Ctrl+C to quit.\n")
+
+    ser = serial.Serial(PORT, BAUD, timeout=0.1)
+
+    t = threading.Thread(target=reader, args=(ser,), daemon=True)
+    t.start()
+
+    try:
+        while True:
+            line = input()
+            ser.write((line + "\r\n").encode())
+    except (KeyboardInterrupt, EOFError):
+        print("\nBye.")
+    finally:
+        ser.close()
+
+
+if __name__ == "__main__":
+    main()

pi/ui/lib/README.md

@@ -34,6 +34,7 @@ All services use singleton pattern with `ServiceName.instance`.
 |--------|---------|
 | `NavigatorWidget` | Animated character with emotion states (images precached at startup) |
 | `AccelGraph` | Real-time accelerometer visualization with gravity compensation |
+| `GpsCompass` | GPS heading compass with rotating navigation icon and degree readout |
 | `WhiskeyMark` | Gimbal-style horizon indicator using IMU roll/pitch |
 | `SystemBar` | Top status bar (time, connection, Pi temp) |
 | `StatBox` | Reusable metric display box |

pi/ui/lib/app_root.dart

@@ -19,7 +19,7 @@ class AppRoot extends StatefulWidget {
 class _AppRootState extends State<AppRoot> {
   bool _initialized = false;
   bool _overheatTriggered = false;
-  String _initStatus = 'Starting...';
+  final Map<String, String> _initStatuses = {};
 
   @override
   void initState() {
@@ -33,27 +33,35 @@ class _AppRootState extends State<AppRoot> {
     super.dispose();
   }
 
+  void _updateStatus(String key, String value) {
+    setState(() => _initStatuses[key] = value);
+  }
+
   Future<void> _runInitSequence() async {
-    // Load config first
+    // Show all items from the start so the row doesn't jump around
-    setState(() => _initStatus = 'Loading config...');
+    _updateStatus('Config', '...');
+    _updateStatus('UART', '...');
+    _updateStatus('GPS', '...');
+    _updateStatus('Navigator', '...');
+
+    // Config must load first (everything else depends on it)
+    _updateStatus('Config', 'Loading');
     await ConfigService.instance.load();
+    _updateStatus('Config', 'Ready');
 
-    setState(() => _initStatus = 'Checking systems...');
+    // UART, GPS, and navigator image preload run truly in parallel
+    _updateStatus('UART', 'Connecting');
+    _updateStatus('GPS', 'Waiting');
+    _updateStatus('Navigator', 'Loading');
+    await Future.wait([
+      _waitForUart(),
+      _waitForGps(),
+      _preloadNavigatorImages(),
+    ]);
+
+    // Let the user see the all-ready state for a moment
     await Future.delayed(const Duration(milliseconds: 500));
 
-    // Check UART connection via backend health endpoint
-    // Also preload navigator images in parallel (usually UART is the bottleneck)
-    setState(() => _initStatus = 'UART: connecting...');
-    final imagePreloadFuture = _preloadNavigatorImages();
-    await _waitForUart();
-    await imagePreloadFuture;
-
-    setState(() => _initStatus = 'GPS: standby');
-    await Future.delayed(const Duration(milliseconds: 400));
-
-    setState(() => _initStatus = 'Ready');
-    await Future.delayed(const Duration(milliseconds: 300));
-
     // Start overheat monitoring
     OverheatMonitor.instance.start(
       onOverheat: () {
@@ -78,11 +86,8 @@ class _AppRootState extends State<AppRoot> {
 
         if (response.statusCode == 200) {
           final data = jsonDecode(response.body) as Map<String, dynamic>;
-          final arduinoOk = data['arduino_connected'] == true;
+          if (data['arduino_connected'] == true) {
-
+            _updateStatus('UART', 'Ready');
-          if (arduinoOk) {
-            setState(() => _initStatus = 'UART: OK');
-            await Future.delayed(const Duration(milliseconds: 300));
             return;
           }
         }
@@ -90,28 +95,57 @@ class _AppRootState extends State<AppRoot> {
         // Backend not reachable yet - keep trying
       }
 
-      // Not connected yet
+      _updateStatus('UART', 'Waiting');
-      setState(() => _initStatus = 'UART: waiting...');
       await Future.delayed(retryDelay);
     }
 
     // Timeout - proceed anyway (UI will show stale data indicators)
-    setState(() => _initStatus = 'UART: timeout');
+    _updateStatus('UART', 'Timeout');
-    await Future.delayed(const Duration(milliseconds: 500));
+  }
+
+  /// Poll backend health endpoint until GPS has a fix, or bail after 7.5s
+  Future<void> _waitForGps() async {
+    final backendUrl = ConfigService.instance.backendUrl;
+    const bailOut = Duration(milliseconds: 7500);
+    const retryDelay = Duration(seconds: 1);
+    final deadline = DateTime.now().add(bailOut);
+
+    _updateStatus('GPS', 'Acquiring');
+
+    while (DateTime.now().isBefore(deadline)) {
+      try {
+        final response = await http
+            .get(Uri.parse('$backendUrl/health'))
+            .timeout(const Duration(seconds: 2));
+
+        if (response.statusCode == 200) {
+          final data = jsonDecode(response.body) as Map<String, dynamic>;
+          if (data['gps_state'] == 'fix') {
+            _updateStatus('GPS', 'Ready');
+            return;
+          }
+        }
+      } catch (e) {
+        // Backend not reachable yet - keep trying
+      }
+
+      await Future.delayed(retryDelay);
+    }
+
+    // Bail out - dashboard will show live GPS state when it arrives
+    _updateStatus('GPS', 'Timeout');
   }
 
   /// Preload navigator images into Flutter's image cache
   ///
   /// Scans for all PNGs in the navigator folder and precaches them.
-  /// Runs silently - no status updates (meant to run parallel with UART).
   Future<void> _preloadNavigatorImages() async {
     final images = await ConfigService.instance.getNavigatorImages();
     for (final file in images) {
-      // precacheImage needs a context, but we're in initState territory
-      // Use the root context via a post-frame callback workaround
       if (!mounted) return;
       await precacheImage(FileImage(file), context);
     }
+    _updateStatus('Navigator', 'Ready');
   }
 
   @override
@@ -121,7 +155,7 @@ class _AppRootState extends State<AppRoot> {
     if (_overheatTriggered) {
       child = const OverheatScreen(key: ValueKey('overheat'));
     } else if (!_initialized) {
-      child = SplashScreen(key: const ValueKey('splash'), status: _initStatus);
+      child = SplashScreen(key: const ValueKey('splash'), statuses: _initStatuses);
     } else {
       child = const DashboardScreen(key: ValueKey('dashboard'));
     }

pi/ui/lib/screens/dashboard_screen.dart

@@ -1,280 +1,298 @@
-import 'dart:async';
+import 'dart:async';
-import 'dart:math' show sqrt, sin, cos, pi;
+import 'dart:math' show sqrt, sin, cos, pi;
-import 'package:flutter/material.dart';
+import 'package:flutter/material.dart';
-
+
-import '../services/backend_service.dart';
+import '../services/backend_service.dart';
-import '../services/websocket_service.dart';
+import '../services/websocket_service.dart';
-import '../services/pi_io.dart';
+import '../services/pi_io.dart';
-import '../theme/app_theme.dart';
+import '../theme/app_theme.dart';
-import '../widgets/navigator_widget.dart';
+import '../widgets/navigator_widget.dart';
-import '../widgets/stat_box.dart';
+import '../widgets/stat_box.dart';
-import '../widgets/stat_box_main.dart';
+import '../widgets/stat_box_main.dart';
-import '../widgets/system_bar.dart';
+import '../widgets/system_bar.dart';
-import '../widgets/debug_console.dart';
+import '../widgets/debug_console.dart';
-import '../widgets/whiskey_mark.dart';
+import '../widgets/whiskey_mark.dart';
-import '../widgets/accel_graph.dart';
+import '../widgets/accel_graph.dart';
-
+import '../widgets/gps_compass.dart';
-// test service for triggers
+
-import '../services/test_flipflop_service.dart';
+// test service for triggers
-
+import '../services/test_flipflop_service.dart';
-/// Main dashboard - displays Pi vitals and placeholder stats
+
-class DashboardScreen extends StatefulWidget {
+/// Main dashboard - displays Pi vitals and placeholder stats
-  const DashboardScreen({super.key});
+class DashboardScreen extends StatefulWidget {
-
+  const DashboardScreen({super.key});
-  @override
+
-  State<DashboardScreen> createState() => _DashboardScreenState();
+  @override
-}
+  State<DashboardScreen> createState() => _DashboardScreenState();
-
+}
-class _DashboardScreenState extends State<DashboardScreen> {
+
-  static const _surpriseThreshold = 0.24; // G threshold for navigator surprise
+class _DashboardScreenState extends State<DashboardScreen> {
-
+  static const _surpriseThreshold = 0.24; // G threshold for navigator surprise
-  final _navigatorKey = GlobalKey<NavigatorWidgetState>();
+
-
+  final _navigatorKey = GlobalKey<NavigatorWidgetState>();
-  // Timer for Pi temp only (safety critical, direct file read)
+
-  Timer? _piTempTimer;
+  // Timer for Pi temp only (safety critical, direct file read)
-
+  Timer? _piTempTimer;
-  // WebSocket stream subscriptions
+
-  StreamSubscription<ArduinoData>? _arduinoSub;
+  // WebSocket stream subscriptions
-  StreamSubscription<GpsData>? _gpsSub;
+  StreamSubscription<ArduinoData>? _arduinoSub;
-  StreamSubscription<WsConnectionState>? _connectionSub;
+  StreamSubscription<GpsData>? _gpsSub;
-
+  StreamSubscription<LteData>? _lteSub;
-  // Pi temperature - direct file read (safety critical)
+  StreamSubscription<WsConnectionState>? _connectionSub;
-  double? _piTemp;
+
-
+  // Pi temperature - direct file read (safety critical)
-  // From backend - Arduino data
+  double? _piTemp;
-  int? _rpm;
+
-  double? _voltage;
+  // From backend - Arduino data
-  int? _engineTemp;
+  int? _rpm;
-  int? _gear;
+  double? _voltage;
-  double? _roll;
+  int? _engineTemp;
-  double? _pitch;
+  int? _gear;
-  double? _ax;
+  double? _roll;
-  double? _ay;
+  double? _pitch;
-  double? _dynamicAx;  // Gravity-compensated
+  double? _ax;
-  double? _dynamicAy;
+  double? _ay;
-
+  double? _dynamicAx;  // Gravity-compensated
-  // From backend - GPS data
+  double? _dynamicAy;
-  double? _gpsSpeed;
+
-
+  // From backend - GPS data
-  // Placeholder values for system bar
+  double? _gpsSpeed;
-  int? _gpsSatellites;
+  double? _gpsTrack;
-  int? _lteSignal;
+
-
+  // Placeholder values for system bar
-  // WebSocket connection state
+  int? _gpsSatellites;
-  WsConnectionState _wsState = WsConnectionState.disconnected;
+  String? _gpsState;
-
+  int? _lteSignal;
-  @override
+
-  void initState() {
+  // WebSocket connection state
-    super.initState();
+  WsConnectionState _wsState = WsConnectionState.disconnected;
-
+
-    // Connect to WebSocket
+  @override
-    WebSocketService.instance.connect();
+  void initState() {
-
+    super.initState();
-    // Subscribe to Arduino data stream
+
-    _arduinoSub = WebSocketService.instance.arduinoStream.listen((data) {
+    // Connect to WebSocket
-      // Gravity-compensated acceleration
+    WebSocketService.instance.connect();
-      // When tilted, gravity "leaks" into horizontal axes - subtract it out
+
-      final rollRad = (data.roll ?? 0) * pi / 180;
+    // Subscribe to Arduino data stream
-      final pitchRad = (data.pitch ?? 0) * pi / 180;
+    _arduinoSub = WebSocketService.instance.arduinoStream.listen((data) {
-
+      // Gravity-compensated acceleration
-      // Subtract gravity leakage from measured acceleration
+      // When tilted, gravity "leaks" into horizontal axes - subtract it out
-      // Axes swapped for IMU mounting orientation
+      final rollRad = (data.roll ?? 0) * pi / 180;
-      final dynamicAx = (data.ay ?? 0) + sin(rollRad);
+      final pitchRad = (data.pitch ?? 0) * pi / 180;
-      final dynamicAy = (data.ax ?? 0) - (sin(pitchRad) * cos(rollRad));
+
-
+      // Subtract gravity leakage from measured acceleration
-      setState(() {
+      // Axes swapped for IMU mounting orientation
-        _voltage = data.voltage;
+      final dynamicAx = (data.ay ?? 0) + sin(rollRad);
-        _rpm = data.rpm;
+      final dynamicAy = (data.ax ?? 0) - (sin(pitchRad) * cos(rollRad));
-        _engineTemp = data.engTemp;
+
-        _gear = data.gear;
+      setState(() {
-        _roll = data.roll;
+        _voltage = data.voltage;
-        _pitch = data.pitch;
+        _rpm = data.rpm;
-        _ax = data.ax;
+        _engineTemp = data.engTemp;
-        _ay = data.ay;
+        _gear = data.gear;
-        _dynamicAx = dynamicAx;
+        _roll = data.roll;
-        _dynamicAy = dynamicAy;
+        _pitch = data.pitch;
-      });
+        _ax = data.ax;
-
+        _ay = data.ay;
-      final gMagnitude = sqrt(dynamicAx * dynamicAx + dynamicAy * dynamicAy);
+        _dynamicAx = dynamicAx;
-      if (gMagnitude > _surpriseThreshold) {
+        _dynamicAy = dynamicAy;
-        _navigatorKey.currentState?.setEmotion('surprise');
+      });
-      }
+
-    });
+      final gMagnitude = sqrt(dynamicAx * dynamicAx + dynamicAy * dynamicAy);
-
+      if (gMagnitude > _surpriseThreshold) {
-    // Subscribe to GPS data stream
+        _navigatorKey.currentState?.setEmotion('surprise');
-    _gpsSub = WebSocketService.instance.gpsStream.listen((data) {
+      }
-      setState(() {
+    });
-        _gpsSpeed = data.speed;
+
-        // Derive satellites from mode (placeholder logic)
+    // Subscribe to GPS data stream
-        _gpsSatellites = data.mode == 3 ? 8 : (data.mode == 2 ? 4 : 0);
+    _gpsSub = WebSocketService.instance.gpsStream.listen((data) {
-      });
+      setState(() {
-    });
+        _gpsSpeed = data.speed;
-
+        _gpsTrack = data.track;
-    // Subscribe to connection state
+        _gpsSatellites = data.satellites;
-    _connectionSub = WebSocketService.instance.connectionStream.listen((state) {
+        _gpsState = data.gpsState;
-      setState(() {
+      });
-        _wsState = state;
+    });
-      });
+
-    });
+    // Subscribe to LTE data stream
-
+    _lteSub = WebSocketService.instance.lteStream.listen((data) {
-    // Timer for Pi temp only (safety critical - bypasses backend)
+      setState(() {
-    _piTempTimer = Timer.periodic(const Duration(milliseconds: 500), (_) {
+        _lteSignal = data.signal;
-      setState(() {
+      });
-        _piTemp = PiIO.instance.getTemperature();
+    });
-      });
+
-    });
+    // Subscribe to connection state
-
+    _connectionSub = WebSocketService.instance.connectionStream.listen((state) {
-    // Initialize with any cached data from WebSocketService
+      setState(() {
-    final cachedArduino = WebSocketService.instance.latestArduino;
+        _wsState = state;
-    if (cachedArduino != null) {
+      });
-      _voltage = cachedArduino.voltage;
+    });
-      _rpm = cachedArduino.rpm;
+
-      _engineTemp = cachedArduino.engTemp;
+    // Timer for Pi temp only (safety critical - bypasses backend)
-      _gear = cachedArduino.gear;
+    _piTempTimer = Timer.periodic(const Duration(milliseconds: 500), (_) {
-      _roll = cachedArduino.roll;
+      setState(() {
-      _pitch = cachedArduino.pitch;
+        _piTemp = PiIO.instance.getTemperature();
-      _ax = cachedArduino.ax;
+      });
-      _ay = cachedArduino.ay;
+    });
-    }
+
-
+    // Initialize with any cached data from WebSocketService
-    final cachedGps = WebSocketService.instance.latestGps;
+    final cachedArduino = WebSocketService.instance.latestArduino;
-    if (cachedGps != null) {
+    if (cachedArduino != null) {
-      _gpsSpeed = cachedGps.speed;
+      _voltage = cachedArduino.voltage;
-      _gpsSatellites = cachedGps.mode == 3 ? 8 : (cachedGps.mode == 2 ? 4 : 0);
+      _rpm = cachedArduino.rpm;
-    }
+      _engineTemp = cachedArduino.engTemp;
-
+      _gear = cachedArduino.gear;
-    _wsState = WebSocketService.instance.connectionState;
+      _roll = cachedArduino.roll;
-
+      _pitch = cachedArduino.pitch;
-    // Placeholder: LTE signal (TODO: wire up when LTE service exists)
+      _ax = cachedArduino.ax;
-    _lteSignal = null;
+      _ay = cachedArduino.ay;
-
+    }
-    // DEBUG: flip-flop theme + navigator every 2s
+
-    TestFlipFlopService.instance.start(navigatorKey: _navigatorKey);
+    final cachedGps = WebSocketService.instance.latestGps;
-  }
+    if (cachedGps != null) {
-
+      _gpsSpeed = cachedGps.speed;
-  @override
+      _gpsTrack = cachedGps.track;
-  void dispose() {
+      _gpsSatellites = cachedGps.satellites;
-    _piTempTimer?.cancel();
+      _gpsState = cachedGps.gpsState;
-    _arduinoSub?.cancel();
+    }
-    _gpsSub?.cancel();
+
-    _connectionSub?.cancel();
+    _wsState = WebSocketService.instance.connectionState;
-    TestFlipFlopService.instance.stop();
+
-    super.dispose();
+    // Init from cached LTE data
-  }
+    final cachedLte = WebSocketService.instance.latestLte;
-
+    if (cachedLte != null) {
-  /// Format gear for display: null → "—", 0 → "N", 1-6 → "1"-"6"
+      _lteSignal = cachedLte.signal;
-  String _formatGear(int? gear) {
+    }
-    if (gear == null) return '—';
+
-    if (gear == 0) return 'N';
+    // DEBUG: flip-flop theme + navigator every 2s
-    return gear.toString();
+    TestFlipFlopService.instance.start(navigatorKey: _navigatorKey);
-  }
+  }
-
+
-  /// Format nullable int for display
+  @override
-  String _formatInt(int? value) => value?.toString() ?? '—';
+  void dispose() {
-
+    _piTempTimer?.cancel();
-  /// Format nullable double for display with decimal places
+    _arduinoSub?.cancel();
-  String _formatDouble(double? value, [int decimals = 1]) {
+    _gpsSub?.cancel();
-    if (value == null) return '—';
+    _lteSub?.cancel();
-    return value.toStringAsFixed(decimals);
+    _connectionSub?.cancel();
-  }
+    TestFlipFlopService.instance.stop();
-
+    super.dispose();
-  @override
+  }
-  Widget build(BuildContext context) {
+
-    final theme = AppTheme.of(context);
+  /// Format gear for display: null → "—", 0 → "N", 1-6 → "1"-"6"
-
+  String _formatGear(int? gear) {
-    return Scaffold(
+    if (gear == null) return '—';
-      backgroundColor: theme.background,
+    if (gear == 0) return 'N';
-      body: Padding(
+    return gear.toString();
-        padding: const EdgeInsets.all(16),
+  }
-        child: Row(
+
-          children: [
+  /// Format nullable int for display
-            // Left side: All dashboard widgets (flex: 2)
+  String _formatInt(int? value) => value?.toString() ?? '—';
-            Expanded(
+
-              flex: 2,
+  /// Format nullable double for display with decimal places
-              child: Column(
+  String _formatDouble(double? value, [int decimals = 1]) {
-                crossAxisAlignment: CrossAxisAlignment.stretch,
+    if (value == null) return '—';
-                children: [
+    return value.toStringAsFixed(decimals);
-                  // System status bar
+  }
-                  SystemBar(
+
-                    gpsSatellites: _gpsSatellites,
+  @override
-                    lteSignal: _lteSignal,
+  Widget build(BuildContext context) {
-                    piTemp: _piTemp,
+    final theme = AppTheme.of(context);
-                    voltage: _voltage,
+
-                    wsState: _wsState,
+    return Scaffold(
-                  ),
+      backgroundColor: theme.background,
-
+      body: Padding(
-                  const SizedBox(height: 5),
+        padding: const EdgeInsets.all(16),
-
+        child: Row(
-                  // Main content area - big stat boxes
+          children: [
-                  Expanded(
+            // Left side: All dashboard widgets (flex: 2)
-                    flex: 8,
+            Expanded(
-                    child: Row(
+              flex: 2,
-                      children: [
+              child: Column(
-                        // Attitude indicator (whiskey mark)
+                crossAxisAlignment: CrossAxisAlignment.stretch,
-                        Expanded(
+                children: [
-                          child: WhiskeyMark(
+                  // System status bar
-                            roll: _roll,
+                  SystemBar(
-                            pitch: _pitch,
+                    gpsSatellites: _gpsSatellites,
-                          ),
+                    gpsState: _gpsState,
-                        ),
+                    lteSignal: _lteSignal,
-                        Expanded(
+                    piTemp: _piTemp,
-                          child: AccelGraph(
+                    voltage: _voltage,
-                            ax: _dynamicAx,  // Gravity-compensated lateral
+                    wsState: _wsState,
-                            ay: _dynamicAy,  // Gravity-compensated longitudinal
+                  ),
-                            maxG: 0.8,
+
-                            ghostTrackPeriod: const Duration(seconds: 4),
+                  // Main content area - big widgets
-                          ),
+                  Expanded(
-                        )
+                    flex: 7,
-                      ],
+                    child: Row(
-                    ),
+                      children: [
-                  ),
+                        // Attitude indicator (whiskey mark)
-
+                        Expanded(
-                  // Bottom stats row
+                          child: WhiskeyMark(
-                  Expanded(
+                            roll: _roll,
-                    flex: 2,
+                            pitch: _pitch,
-                    child: Row(
+                          ),
-                      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+                        ),
-                      children: [
+                        Expanded(
-                        StatBox(value: _formatInt(_rpm), label: 'RPM', isWarning: () => (_rpm ?? 0) > 4000),
+                          child: AccelGraph(
-                        StatBox(value: _formatGear(_gear), label: 'GEAR'),
+                            ax: _dynamicAx,  // Gravity-compensated lateral
-                      ],
+                            ay: _dynamicAy,  // Gravity-compensated longitudinal
-                    ),
+                            maxG: 0.8,
-                  ),
+                            ghostTrackPeriod: const Duration(seconds: 4),
-                ],
+                          ),
-              ),
+                        )
-            ),
+                      ],
-
+                    ),
-            const SizedBox(width: 32),
+                  ),
-
+
-            // Right side: Navigator on top, debug console below
+                  // Bottom stats row
-            Expanded(
+                  Expanded(
-              flex: 1,
+                    flex: 3,
-              child: Column(
+                    child: Row(
-                children: [
+                      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
-                  // Navigator
+                      children: [
-                  Expanded(
+                        StatBox(value: _formatInt(_rpm), label: 'RPM', isWarning: () => (_rpm ?? 0) > 4000),
-                    flex: 3,
+                        GpsCompass(heading: _gpsTrack, gpsState: _gpsState),
-                    child: Center(
+                        StatBox(value: _formatGear(_gear), label: 'GEAR'),
-                      child: NavigatorWidget(key: _navigatorKey),
+                      ],
-                    ),
+                    ),
-                  ),
+                  ),
-                  // Debug console
+                ],
-                  Expanded(
+              ),
-                    flex: 1,
+            ),
-                    child: 
+
-                    DebugConsole(
+            const SizedBox(width: 32),
-                      messageStream: WebSocketService.instance.debugStream,
+
-                      initialMessages: WebSocketService.instance.debugMessages,
+            // Right side: Navigator on top, debug console below
-                      maxLines: 6,
+            Expanded(
-                      title: 'WebSocket messages',
+              flex: 1,
-                    ),
+              child: Column(
-                  ),
+                children: [
-                ],
+                  // Navigator
-              ),
+                  Expanded(
-            ),
+                    flex: 3,
-          ],
+                    child: Center(
-        ),
+                      child: NavigatorWidget(key: _navigatorKey),
-      ),
+                    ),
-    );
+                  ),
-  }
+                  // Debug console
-}
+                  Expanded(
+                    flex: 1,
+                    child: 
+                    DebugConsole(
+                      messageStream: WebSocketService.instance.debugStream,
+                      initialMessages: WebSocketService.instance.debugMessages,
+                      maxLines: 6,
+                      title: 'WebSocket messages',
+                    ),
+                  ),
+                ],
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

pi/ui/lib/screens/splash_screen.dart

@@ -3,10 +3,12 @@ import 'package:flutter/material.dart';
 import '../theme/app_theme.dart';
 
 /// Splash screen - shown during initialization
+///
+/// Displays parallel status items that independently flip to "Ready".
 class SplashScreen extends StatelessWidget {
-  final String status;
+  final Map<String, String> statuses;
 
-  const SplashScreen({super.key, required this.status});
+  const SplashScreen({super.key, required this.statuses});
 
   @override
   Widget build(BuildContext context) {
@@ -33,13 +35,19 @@ class SplashScreen extends StatelessWidget {
                 fontWeight: FontWeight.bold,
               ),
             ),
-            const SizedBox(height: 16),
+            const SizedBox(height: 32),
-            Text(
+            Row(
-              status,
+              mainAxisAlignment: MainAxisAlignment.spaceEvenly,
-              style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+              children: statuses.entries.map((entry) {
-                fontSize: 80,
+                final isReady = entry.value == 'Ready';
-                color: theme.subdued,
+                return Text(
-              ),
+                  '${entry.key}: ${entry.value}',
+                  style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+                    fontSize: 48,
+                    color: isReady ? theme.foreground : theme.subdued,
+                  ),
+                );
+              }).toList(),
             ),
           ],
         ),

pi/ui/lib/services/backend_service.dart

@@ -1,159 +1,182 @@
-import 'dart:async';
+import 'dart:async';
-import 'dart:convert';
+import 'dart:convert';
-import 'package:http/http.dart' as http;
+import 'package:http/http.dart' as http;
-
+
-/// Data from Arduino (voltage, rpm, engine temp, gear, IMU)
+/// Data from Arduino (voltage, rpm, engine temp, gear, IMU)
-class ArduinoData {
+class ArduinoData {
-  final double? voltage;
+  final double? voltage;
-  final int? rpm;
+  final int? rpm;
-  final int? engTemp;
+  final int? engTemp;
-  final int? gear; // 0 = neutral, 1-6 = gear
+  final int? gear; // 0 = neutral, 1-6 = gear
-  final double? roll;  // Euler angle in degrees (negative = left, positive = right)
+  final double? roll;  // Euler angle in degrees (negative = left, positive = right)
-  final double? pitch; // Euler angle in degrees (negative = nose down)
+  final double? pitch; // Euler angle in degrees (negative = nose down)
-  final double? ax;    // Lateral acceleration (g)
+  final double? ax;    // Lateral acceleration (g)
-  final double? ay;    // Longitudinal acceleration (g)
+  final double? ay;    // Longitudinal acceleration (g)
-  final double? az;    // Vertical acceleration (g)
+  final double? az;    // Vertical acceleration (g)
-
+
-  ArduinoData({this.voltage, this.rpm, this.engTemp, this.gear, this.roll, this.pitch, this.ax, this.ay, this.az});
+  ArduinoData({this.voltage, this.rpm, this.engTemp, this.gear, this.roll, this.pitch, this.ax, this.ay, this.az});
-
+
-  factory ArduinoData.fromJson(Map<String, dynamic> json) {
+  factory ArduinoData.fromJson(Map<String, dynamic> json) {
-    return ArduinoData(
+    return ArduinoData(
-      voltage: (json['voltage'] as num?)?.toDouble(),
+      voltage: (json['voltage'] as num?)?.toDouble(),
-      rpm: (json['rpm'] as num?)?.toInt(),
+      rpm: (json['rpm'] as num?)?.toInt(),
-      engTemp: (json['eng_temp'] as num?)?.toInt(),
+      engTemp: (json['eng_temp'] as num?)?.toInt(),
-      gear: (json['gear'] as num?)?.toInt(),
+      gear: (json['gear'] as num?)?.toInt(),
-      roll: (json['roll'] as num?)?.toDouble(),  // IMU mounted with axes swapped
+      roll: (json['roll'] as num?)?.toDouble(),  // IMU mounted with axes swapped
-      pitch: (json['pitch'] as num?)?.toDouble(),
+      pitch: (json['pitch'] as num?)?.toDouble(),
-      ax: (json['ax'] as num?)?.toDouble(),
+      ax: (json['ax'] as num?)?.toDouble(),
-      ay: (json['ay'] as num?)?.toDouble(),
+      ay: (json['ay'] as num?)?.toDouble(),
-      az: (json['az'] as num?)?.toDouble(),
+      az: (json['az'] as num?)?.toDouble(),
-    );
+    );
-  }
+  }
-}
+}
-
+
-/// Data from GPS
+/// Data from GPS
-class GpsData {
+class GpsData {
-  final double? lat;
+  final double? lat;
-  final double? lon;
+  final double? lon;
-  final double? speed; // m/s
+  final double? speed; // m/s
-  final double? alt;
+  final double? alt;
-  final double? track;
+  final double? track;
-  final int? mode; // 0=no fix, 2=2D, 3=3D
+  final int? mode; // 0=no fix, 2=2D, 3=3D
-
+  final int? satellites;
-  GpsData({this.lat, this.lon, this.speed, this.alt, this.track, this.mode});
+  final String? gpsState; // "acquiring", "fix", or "lost"
-
+
-  factory GpsData.fromJson(Map<String, dynamic> json) {
+  GpsData({this.lat, this.lon, this.speed, this.alt, this.track, this.mode, this.satellites, this.gpsState});
-    return GpsData(
+
-      lat: (json['lat'] as num?)?.toDouble(),
+  factory GpsData.fromJson(Map<String, dynamic> json) {
-      lon: (json['lon'] as num?)?.toDouble(),
+    return GpsData(
-      speed: (json['speed'] as num?)?.toDouble(),
+      lat: (json['lat'] as num?)?.toDouble(),
-      alt: (json['alt'] as num?)?.toDouble(),
+      lon: (json['lon'] as num?)?.toDouble(),
-      track: (json['track'] as num?)?.toDouble(),
+      speed: (json['speed'] as num?)?.toDouble(),
-      mode: (json['mode'] as num?)?.toInt(),
+      alt: (json['alt'] as num?)?.toDouble(),
-    );
+      track: (json['track'] as num?)?.toDouble(),
-  }
+      mode: (json['mode'] as num?)?.toInt(),
-}
+      satellites: (json['satellites'] as num?)?.toInt(),
-
+      gpsState: json['gps_state'] as String?,
-/// HTTP client for Flask backend - fire-and-forget async fetch, sync cache return
+    );
-///
+  }
-/// Follows the same pattern as PiIO: never blocks UI, always returns cached data.
+}
-class BackendService {
+
-  BackendService._() {
+/// Data from LTE modem (signal quality, connection state)
-    // Kick off initial fetches
+class LteData {
-    _refreshArduino();
+  final bool? connected;
-    _refreshGps();
+  final int? signal; // 0-100 percent
-  }
+  final String? operator_;
-  static final instance = BackendService._();
+  final String? accessTech;
-
+
-  static const _baseUrl = 'http://127.0.0.1:5000';
+  LteData({this.connected, this.signal, this.operator_, this.accessTech});
-  static const _timeout = Duration(seconds: 2);
+
-
+  factory LteData.fromJson(Map<String, dynamic> json) {
-  // Caches
+    return LteData(
-  ArduinoData? _arduinoCache;
+      connected: json['connected'] as bool?,
-  GpsData? _gpsCache;
+      signal: (json['signal'] as num?)?.toInt(),
-  bool _connected = false;
+      operator_: json['operator'] as String?,
-
+      accessTech: json['access_tech'] as String?,
-  // In-progress flags (prevent duplicate requests)
+    );
-  bool _arduinoFetchInProgress = false;
+  }
-  bool _gpsFetchInProgress = false;
+}
-
+
-  /// Whether backend is reachable
+/// HTTP client for Flask backend - fire-and-forget async fetch, sync cache return
-  bool get isConnected => _connected;
+///
-
+/// Follows the same pattern as PiIO: never blocks UI, always returns cached data.
-  /// Get Arduino data (sync, returns cached value)
+class BackendService {
-  ArduinoData? getArduinoData() {
+  BackendService._() {
-    if (!_arduinoFetchInProgress) {
+    // Kick off initial fetches
-      _refreshArduino();
+    _refreshArduino();
-    }
+    _refreshGps();
-    return _arduinoCache;
+  }
-  }
+  static final instance = BackendService._();
-
+
-  /// Get GPS data (sync, returns cached value)
+  static const _baseUrl = 'http://127.0.0.1:5000';
-  GpsData? getGpsData() {
+  static const _timeout = Duration(seconds: 2);
-    if (!_gpsFetchInProgress) {
+
-      _refreshGps();
+  // Caches
-    }
+  ArduinoData? _arduinoCache;
-    return _gpsCache;
+  GpsData? _gpsCache;
-  }
+  bool _connected = false;
-
+
-  /// Background fetch for Arduino data
+  // In-progress flags (prevent duplicate requests)
-  Future<void> _refreshArduino() async {
+  bool _arduinoFetchInProgress = false;
-    if (_arduinoFetchInProgress) return;
+  bool _gpsFetchInProgress = false;
-    _arduinoFetchInProgress = true;
+
-
+  /// Whether backend is reachable
-    try {
+  bool get isConnected => _connected;
-      final response = await http
+
-          .get(Uri.parse('$_baseUrl/arduino'))
+  /// Get Arduino data (sync, returns cached value)
-          .timeout(_timeout);
+  ArduinoData? getArduinoData() {
-
+    if (!_arduinoFetchInProgress) {
-      if (response.statusCode == 200) {
+      _refreshArduino();
-        final json = jsonDecode(response.body) as Map<String, dynamic>;
+    }
-        // Skip if backend returns error (no data yet) - keep cached value
+    return _arduinoCache;
-        if (!json.containsKey('error')) {
+  }
-          _arduinoCache = ArduinoData.fromJson(json);
+
-        }
+  /// Get GPS data (sync, returns cached value)
-        _connected = true;
+  GpsData? getGpsData() {
-      }
+    if (!_gpsFetchInProgress) {
-      // Non-200: keep cached data, just mark disconnected
+      _refreshGps();
-    } catch (e) {
+    }
-      // Network error, timeout, etc - keep cached data for transient hiccups
+    return _gpsCache;
-      _connected = false;
+  }
-    } finally {
+
-      _arduinoFetchInProgress = false;
+  /// Background fetch for Arduino data
-    }
+  Future<void> _refreshArduino() async {
-  }
+    if (_arduinoFetchInProgress) return;
-
+    _arduinoFetchInProgress = true;
-  /// Background fetch for GPS data
+
-  Future<void> _refreshGps() async {
+    try {
-    if (_gpsFetchInProgress) return;
+      final response = await http
-    _gpsFetchInProgress = true;
+          .get(Uri.parse('$_baseUrl/arduino'))
-
+          .timeout(_timeout);
-    try {
+
-      final response = await http
+      if (response.statusCode == 200) {
-          .get(Uri.parse('$_baseUrl/gps'))
+        final json = jsonDecode(response.body) as Map<String, dynamic>;
-          .timeout(_timeout);
+        // Skip if backend returns error (no data yet) - keep cached value
-
+        if (!json.containsKey('error')) {
-      if (response.statusCode == 200) {
+          _arduinoCache = ArduinoData.fromJson(json);
-        final json = jsonDecode(response.body) as Map<String, dynamic>;
+        }
-        // Skip if backend returns error (no data yet) - keep cached value
+        _connected = true;
-        if (!json.containsKey('error')) {
+      }
-          _gpsCache = GpsData.fromJson(json);
+      // Non-200: keep cached data, just mark disconnected
-        }
+    } catch (e) {
-        _connected = true;
+      // Network error, timeout, etc - keep cached data for transient hiccups
-      }
+      _connected = false;
-      // Non-200: keep cached data, just mark disconnected
+    } finally {
-    } catch (e) {
+      _arduinoFetchInProgress = false;
-      // Network error, timeout, etc - keep cached data for transient hiccups
+    }
-      _connected = false;
+  }
-    } finally {
+
-      _gpsFetchInProgress = false;
+  /// Background fetch for GPS data
-    }
+  Future<void> _refreshGps() async {
-  }
+    if (_gpsFetchInProgress) return;
-
+    _gpsFetchInProgress = true;
-  /// Force clear all caches
+
-  void clearCache() {
+    try {
-    _arduinoCache = null;
+      final response = await http
-    _gpsCache = null;
+          .get(Uri.parse('$_baseUrl/gps'))
-    _connected = false;
+          .timeout(_timeout);
-  }
+
-}
+      if (response.statusCode == 200) {
+        final json = jsonDecode(response.body) as Map<String, dynamic>;
+        // Skip if backend returns error (no data yet) - keep cached value
+        if (!json.containsKey('error')) {
+          _gpsCache = GpsData.fromJson(json);
+        }
+        _connected = true;
+      }
+      // Non-200: keep cached data, just mark disconnected
+    } catch (e) {
+      // Network error, timeout, etc - keep cached data for transient hiccups
+      _connected = false;
+    } finally {
+      _gpsFetchInProgress = false;
+    }
+  }
+
+  /// Force clear all caches
+  void clearCache() {
+    _arduinoCache = null;
+    _gpsCache = null;
+    _connected = false;
+  }
+}

pi/ui/lib/services/websocket_service.dart

@@ -1,332 +1,351 @@
-import 'dart:async';
+import 'dart:async';
-import 'package:socket_io_client/socket_io_client.dart' as io;
+import 'package:socket_io_client/socket_io_client.dart' as io;
-
+
-import 'backend_service.dart'; // Reuse ArduinoData, GpsData
+import 'backend_service.dart'; // Reuse ArduinoData, GpsData
-import 'theme_service.dart';
+import 'theme_service.dart';
-
+
-/// Connection state for WebSocket
+/// Connection state for WebSocket
-enum WsConnectionState {
+enum WsConnectionState {
-  disconnected,
+  disconnected,
-  connecting,
+  connecting,
-  connected,
+  connected,
-}
+}
-
+
-/// Acknowledgment from backend for a command
+/// Acknowledgment from backend for a command
-class CommandAck {
+class CommandAck {
-  final String id;
+  final String id;
-  final String status;
+  final String status;
-  final String? error;
+  final String? error;
-  final String? extra;
+  final String? extra;
-
+
-  CommandAck({
+  CommandAck({
-    required this.id,
+    required this.id,
-    required this.status,
+    required this.status,
-    this.error,
+    this.error,
-    this.extra,
+    this.extra,
-  });
+  });
-
+
-  bool get isSuccess => status == 'ok' || status == 'sent';
+  bool get isSuccess => status == 'ok' || status == 'sent';
-}
+}
-
+
-/// Alert from backend
+/// Alert from backend
-class BackendAlert {
+class BackendAlert {
-  final String type;
+  final String type;
-  final String message;
+  final String message;
-
+
-  BackendAlert({required this.type, required this.message});
+  BackendAlert({required this.type, required this.message});
-}
+}
-
+
-/// Backend status (connection states of GPS/Arduino)
+/// Backend status (connection states of GPS/Arduino)
-class BackendStatus {
+class BackendStatus {
-  final bool gpsConnected;
+  final bool gpsConnected;
-  final bool arduinoConnected;
+  final bool arduinoConnected;
-
+
-  BackendStatus({required this.gpsConnected, required this.arduinoConnected});
+  BackendStatus({required this.gpsConnected, required this.arduinoConnected});
-}
+}
-
+
-/// WebSocket service for real-time data from backend.
+/// WebSocket service for real-time data from backend.
-///
+///
-/// Replaces HTTP polling with push-based updates.
+/// Replaces HTTP polling with push-based updates.
-/// Maintains dual logical channels:
+/// Maintains dual logical channels:
-/// - Telemetry: arduino/gps data streams (throttled by backend)
+/// - Telemetry: arduino/gps data streams (throttled by backend)
-/// - Control: button commands and acknowledgments
+/// - Control: button commands and acknowledgments
-class WebSocketService {
+class WebSocketService {
-  WebSocketService._() {
+  WebSocketService._() {
-    _setupStreams();
+    _setupStreams();
-  }
+  }
-  static final instance = WebSocketService._();
+  static final instance = WebSocketService._();
-
+
-  static const _serverUrl = 'http://127.0.0.1:5000';
+  static const _serverUrl = 'http://127.0.0.1:5000';
-
+
-  io.Socket? _socket;
+  io.Socket? _socket;
-  WsConnectionState _connectionState = WsConnectionState.disconnected;
+  WsConnectionState _connectionState = WsConnectionState.disconnected;
-  Timer? _reconnectTimer;
+  Timer? _reconnectTimer;
-
+
-  // Latest values for sync access (backward compat)
+  // Latest values for sync access (backward compat)
-  ArduinoData? _latestArduino;
+  ArduinoData? _latestArduino;
-  GpsData? _latestGps;
+  GpsData? _latestGps;
-  BackendStatus? _latestStatus;
+  LteData? _latestLte;
-
+  BackendStatus? _latestStatus;
-  // Stream controllers
+
-  late StreamController<ArduinoData> _arduinoController;
+  // Stream controllers
-  late StreamController<GpsData> _gpsController;
+  late StreamController<ArduinoData> _arduinoController;
-  late StreamController<BackendStatus> _statusController;
+  late StreamController<GpsData> _gpsController;
-  late StreamController<CommandAck> _ackController;
+  late StreamController<LteData> _lteController;
-  late StreamController<BackendAlert> _alertController;
+  late StreamController<BackendStatus> _statusController;
-  late StreamController<WsConnectionState> _connectionController;
+  late StreamController<CommandAck> _ackController;
-  late StreamController<String> _debugController;
+  late StreamController<BackendAlert> _alertController;
-
+  late StreamController<WsConnectionState> _connectionController;
-  // Debug message buffer
+  late StreamController<String> _debugController;
-  static const int _maxDebugMessages = 50;
+
-  final List<String> _debugMessages = [];
+  // Debug message buffer
-
+  static const int _maxDebugMessages = 50;
-  void _setupStreams() {
+  final List<String> _debugMessages = [];
-    _arduinoController = StreamController<ArduinoData>.broadcast();
+
-    _gpsController = StreamController<GpsData>.broadcast();
+  void _setupStreams() {
-    _statusController = StreamController<BackendStatus>.broadcast();
+    _arduinoController = StreamController<ArduinoData>.broadcast();
-    _ackController = StreamController<CommandAck>.broadcast();
+    _gpsController = StreamController<GpsData>.broadcast();
-    _alertController = StreamController<BackendAlert>.broadcast();
+    _lteController = StreamController<LteData>.broadcast();
-    _connectionController = StreamController<WsConnectionState>.broadcast();
+    _statusController = StreamController<BackendStatus>.broadcast();
-    _debugController = StreamController<String>.broadcast();
+    _ackController = StreamController<CommandAck>.broadcast();
-  }
+    _alertController = StreamController<BackendAlert>.broadcast();
-
+    _connectionController = StreamController<WsConnectionState>.broadcast();
-  /// Log a debug message (adds to buffer and stream)
+    _debugController = StreamController<String>.broadcast();
-  void _log(String message) {
+  }
-    _debugMessages.add(message);
+
-    if (_debugMessages.length > _maxDebugMessages) {
+  /// Log a debug message (adds to buffer and stream)
-      _debugMessages.removeAt(0);
+  void _log(String message) {
-    }
+    _debugMessages.add(message);
-    _debugController.add(message);
+    if (_debugMessages.length > _maxDebugMessages) {
-  }
+      _debugMessages.removeAt(0);
-
+    }
-  // --- Public API: Streams ---
+    _debugController.add(message);
-
+  }
-  /// Stream of Arduino telemetry updates
+
-  Stream<ArduinoData> get arduinoStream => _arduinoController.stream;
+  // --- Public API: Streams ---
-
+
-  /// Stream of GPS updates
+  /// Stream of Arduino telemetry updates
-  Stream<GpsData> get gpsStream => _gpsController.stream;
+  Stream<ArduinoData> get arduinoStream => _arduinoController.stream;
-
+
-  /// Stream of backend status updates
+  /// Stream of GPS updates
-  Stream<BackendStatus> get statusStream => _statusController.stream;
+  Stream<GpsData> get gpsStream => _gpsController.stream;
-
+
-  /// Stream of command acknowledgments
+  /// Stream of LTE status updates
-  Stream<CommandAck> get ackStream => _ackController.stream;
+  Stream<LteData> get lteStream => _lteController.stream;
-
+
-  /// Stream of alerts from backend
+  /// Stream of backend status updates
-  Stream<BackendAlert> get alertStream => _alertController.stream;
+  Stream<BackendStatus> get statusStream => _statusController.stream;
-
+
-  /// Stream of connection state changes
+  /// Stream of command acknowledgments
-  Stream<WsConnectionState> get connectionStream => _connectionController.stream;
+  Stream<CommandAck> get ackStream => _ackController.stream;
-
+
-  /// Stream of debug log messages
+  /// Stream of alerts from backend
-  Stream<String> get debugStream => _debugController.stream;
+  Stream<BackendAlert> get alertStream => _alertController.stream;
-
+
-  /// Current debug message buffer (for initial display)
+  /// Stream of connection state changes
-  List<String> get debugMessages => List.unmodifiable(_debugMessages);
+  Stream<WsConnectionState> get connectionStream => _connectionController.stream;
-
+
-  // --- Public API: Sync getters (backward compat) ---
+  /// Stream of debug log messages
-
+  Stream<String> get debugStream => _debugController.stream;
-  /// Current connection state
+
-  WsConnectionState get connectionState => _connectionState;
+  /// Current debug message buffer (for initial display)
-
+  List<String> get debugMessages => List.unmodifiable(_debugMessages);
-  /// Whether connected to backend
+
-  bool get isConnected => _connectionState == WsConnectionState.connected;
+  // --- Public API: Sync getters (backward compat) ---
-
+
-  /// Latest Arduino data (may be null if not yet received)
+  /// Current connection state
-  ArduinoData? get latestArduino => _latestArduino;
+  WsConnectionState get connectionState => _connectionState;
-
+
-  /// Latest GPS data (may be null if not yet received)
+  /// Whether connected to backend
-  GpsData? get latestGps => _latestGps;
+  bool get isConnected => _connectionState == WsConnectionState.connected;
-
+
-  /// Latest backend status
+  /// Latest Arduino data (may be null if not yet received)
-  BackendStatus? get latestStatus => _latestStatus;
+  ArduinoData? get latestArduino => _latestArduino;
-
+
-  // --- Public API: Connection ---
+  /// Latest GPS data (may be null if not yet received)
-
+  GpsData? get latestGps => _latestGps;
-  /// Connect to backend WebSocket
+
-  void connect() {
+  /// Latest LTE data (may be null if not yet received)
-    if (_socket != null) return; // Already connected or connecting
+  LteData? get latestLte => _latestLte;
-
+
-    _setConnectionState(WsConnectionState.connecting);
+  /// Latest backend status
-
+  BackendStatus? get latestStatus => _latestStatus;
-    _socket = io.io(_serverUrl, <String, dynamic>{
+
-      'transports': ['websocket'],
+  // --- Public API: Connection ---
-      'autoConnect': true,
+
-      'reconnection': false, // We handle reconnection ourselves
+  /// Connect to backend WebSocket
-    });
+  void connect() {
-
+    if (_socket != null) return; // Already connected or connecting
-    _socket!.onConnect((_) {
+
-      _log('connected');
+    _setConnectionState(WsConnectionState.connecting);
-      _setConnectionState(WsConnectionState.connected);
+
-      _cancelReconnect();
+    _socket = io.io(_serverUrl, <String, dynamic>{
-    });
+      'transports': ['websocket'],
-
+      'autoConnect': true,
-    _socket!.onDisconnect((_) {
+      'reconnection': false, // We handle reconnection ourselves
-      _log('disconnected');
+    });
-      _setConnectionState(WsConnectionState.disconnected);
+
-      _scheduleReconnect();
+    _socket!.onConnect((_) {
-    });
+      _log('connected');
-
+      _setConnectionState(WsConnectionState.connected);
-    _socket!.onConnectError((error) {
+      _cancelReconnect();
-      _log('error: $error');
+    });
-      _setConnectionState(WsConnectionState.disconnected);
+
-      _scheduleReconnect();
+    _socket!.onDisconnect((_) {
-    });
+      _log('disconnected');
-
+      _setConnectionState(WsConnectionState.disconnected);
-    _socket!.onError((error) {
+      _scheduleReconnect();
-      _log('error: $error');
+    });
-    });
+
-
+    _socket!.onConnectError((error) {
-    // --- Telemetry Events ---
+      _log('error: $error');
-
+      _setConnectionState(WsConnectionState.disconnected);
-    _socket!.on('arduino', (data) {
+      _scheduleReconnect();
-      if (data is Map<String, dynamic>) {
+    });
-        final arduino = ArduinoData.fromJson(data);
+
-        _latestArduino = arduino;
+    _socket!.onError((error) {
-        _arduinoController.add(arduino);
+      _log('error: $error');
-        final rollStr = arduino.roll != null ? 'r${arduino.roll!.round()}' : '';
+    });
-        final pitchStr = arduino.pitch != null ? 'p${arduino.pitch!.round()}' : '';
+
-        final imuStr = (rollStr.isNotEmpty || pitchStr.isNotEmpty) ? ' $rollStr$pitchStr' : '';
+    // --- Telemetry Events ---
-        _log('ard: ${arduino.rpm ?? "-"}rpm ${arduino.voltage ?? "-"}V g${arduino.gear ?? "-"}$imuStr');
+
-
+    _socket!.on('arduino', (data) {
-        // Theme switch piggybacks on arduino packets (edge-triggered from backend)
+      if (data is Map<String, dynamic>) {
-        if (data.containsKey('theme_switch')) {
+        final arduino = ArduinoData.fromJson(data);
-          final isDark = data['theme_switch'] as bool;
+        _latestArduino = arduino;
-          ThemeService.instance.setDarkMode(isDark);
+        _arduinoController.add(arduino);
-          _log('theme: ${isDark ? "dark" : "light"}');
+        final rollStr = arduino.roll != null ? 'r${arduino.roll!.round()}' : '';
-        }
+        final pitchStr = arduino.pitch != null ? 'p${arduino.pitch!.round()}' : '';
-      }
+        final imuStr = (rollStr.isNotEmpty || pitchStr.isNotEmpty) ? ' $rollStr$pitchStr' : '';
-    });
+        _log('ard: ${arduino.rpm ?? "-"}rpm ${arduino.voltage ?? "-"}V g${arduino.gear ?? "-"}$imuStr');
-
+
-    _socket!.on('gps', (data) {
+        // Theme switch piggybacks on arduino packets (edge-triggered from backend)
-      if (data is Map<String, dynamic>) {
+        if (data.containsKey('theme_switch')) {
-        final gps = GpsData.fromJson(data);
+          final isDark = data['theme_switch'] as bool;
-        _latestGps = gps;
+          ThemeService.instance.setDarkMode(isDark);
-        _gpsController.add(gps);
+          _log('theme: ${isDark ? "dark" : "light"}');
-        _log('gps: ${gps.speed?.toStringAsFixed(1) ?? "-"}m/s mode${gps.mode ?? "-"}');
+        }
-      }
+      }
-    });
+    });
-
+
-    _socket!.on('status', (data) {
+    _socket!.on('gps', (data) {
-      if (data is Map<String, dynamic>) {
+      if (data is Map<String, dynamic>) {
-        final status = BackendStatus(
+        final gps = GpsData.fromJson(data);
-          gpsConnected: data['gps_connected'] ?? false,
+        _latestGps = gps;
-          arduinoConnected: data['arduino_connected'] ?? false,
+        _gpsController.add(gps);
-        );
+        _log('gps: ${gps.speed?.toStringAsFixed(1) ?? "-"}m/s hdg=${gps.track?.round() ?? "-"}° mode${gps.mode ?? "-"}');
-        _latestStatus = status;
+      }
-        _statusController.add(status);
+    });
-        _log('status: gps=${status.gpsConnected} ard=${status.arduinoConnected}');
+
-
+    _socket!.on('lte', (data) {
-        // Initial theme state comes with status on connect
+      if (data is Map<String, dynamic>) {
-        if (data.containsKey('theme_switch')) {
+        final lte = LteData.fromJson(data);
-          final isDark = data['theme_switch'] as bool;
+        _latestLte = lte;
-          ThemeService.instance.setDarkMode(isDark);
+        _lteController.add(lte);
-          _log('theme: ${isDark ? "dark" : "light"} (initial)');
+        _log('lte: ${lte.signal ?? "-"}% ${lte.operator_ ?? "-"} ${lte.accessTech ?? "-"}');
-        }
+      }
-      }
+    });
-    });
+
-
+    _socket!.on('status', (data) {
-    // --- Control Events ---
+      if (data is Map<String, dynamic>) {
-
+        final status = BackendStatus(
-    _socket!.on('ack', (data) {
+          gpsConnected: data['gps_connected'] ?? false,
-      if (data is Map<String, dynamic>) {
+          arduinoConnected: data['arduino_connected'] ?? false,
-        final ack = CommandAck(
+        );
-          id: data['id'] ?? 'unknown',
+        _latestStatus = status;
-          status: data['status'] ?? 'unknown',
+        _statusController.add(status);
-          error: data['error'],
+        _log('status: gps=${status.gpsConnected} ard=${status.arduinoConnected}');
-          extra: data['extra'],
+
-        );
+        // Initial theme state comes with status on connect
-        _ackController.add(ack);
+        if (data.containsKey('theme_switch')) {
-        _log('ack: ${ack.id}=${ack.status}${ack.error != null ? " err:${ack.error}" : ""}');
+          final isDark = data['theme_switch'] as bool;
-      }
+          ThemeService.instance.setDarkMode(isDark);
-    });
+          _log('theme: ${isDark ? "dark" : "light"} (initial)');
-
+        }
-    _socket!.on('alert', (data) {
+      }
-      if (data is Map<String, dynamic>) {
+    });
-        final alert = BackendAlert(
+
-          type: data['type'] ?? 'unknown',
+    // --- Control Events ---
-          message: data['message'] ?? '',
+
-        );
+    _socket!.on('ack', (data) {
-        _alertController.add(alert);
+      if (data is Map<String, dynamic>) {
-        _log('alert: [${alert.type}] ${alert.message}');
+        final ack = CommandAck(
-      }
+          id: data['id'] ?? 'unknown',
-    });
+          status: data['status'] ?? 'unknown',
-
+          error: data['error'],
-    _socket!.connect();
+          extra: data['extra'],
-  }
+        );
-
+        _ackController.add(ack);
-  /// Disconnect from backend
+        _log('ack: ${ack.id}=${ack.status}${ack.error != null ? " err:${ack.error}" : ""}');
-  void disconnect() {
+      }
-    _cancelReconnect();
+    });
-    _socket?.disconnect();
+
-    _socket?.dispose();
+    _socket!.on('alert', (data) {
-    _socket = null;
+      if (data is Map<String, dynamic>) {
-    _setConnectionState(WsConnectionState.disconnected);
+        final alert = BackendAlert(
-  }
+          type: data['type'] ?? 'unknown',
-
+          message: data['message'] ?? '',
-  // --- Public API: Commands ---
+        );
-
+        _alertController.add(alert);
-  /// Send button event to backend
+        _log('alert: [${alert.type}] ${alert.message}');
-  void sendButton(String id, String action, [Map<String, dynamic>? params]) {
+      }
-    if (_socket == null || !isConnected) {
+    });
-      print('[WS] Cannot send button, not connected');
+
-      return;
+    _socket!.connect();
-    }
+  }
-
+
-    final data = <String, dynamic>{
+  /// Disconnect from backend
-      'id': id,
+  void disconnect() {
-      'action': action,
+    _cancelReconnect();
-      ...?params,
+    _socket?.disconnect();
-    };
+    _socket?.dispose();
-
+    _socket = null;
-    _socket!.emit('button', data);
+    _setConnectionState(WsConnectionState.disconnected);
-  }
+  }
-
+
-  /// Send emergency signal to backend
+  // --- Public API: Commands ---
-  void sendEmergency(String type) {
+
-    if (_socket == null) {
+  /// Send button event to backend
-      print('[WS] Cannot send emergency, not connected');
+  void sendButton(String id, String action, [Map<String, dynamic>? params]) {
-      return;
+    if (_socket == null || !isConnected) {
-    }
+      print('[WS] Cannot send button, not connected');
-
+      return;
-    // Emergency should be sent even if not fully connected
+    }
-    _socket!.emit('emergency', {'type': type});
+
-  }
+    final data = <String, dynamic>{
-
+      'id': id,
-  // --- Private ---
+      'action': action,
-
+      ...?params,
-  void _setConnectionState(WsConnectionState state) {
+    };
-    if (_connectionState != state) {
+
-      _connectionState = state;
+    _socket!.emit('button', data);
-      _connectionController.add(state);
+  }
-    }
+
-  }
+  /// Send emergency signal to backend
-
+  void sendEmergency(String type) {
-  void _scheduleReconnect() {
+    if (_socket == null) {
-    _cancelReconnect();
+      print('[WS] Cannot send emergency, not connected');
-    _reconnectTimer = Timer(const Duration(seconds: 3), () {
+      return;
-      print('[WS] Attempting reconnect...');
+    }
-      _socket?.dispose();
+
-      _socket = null;
+    // Emergency should be sent even if not fully connected
-      connect();
+    _socket!.emit('emergency', {'type': type});
-    });
+  }
-  }
+
-
+  // --- Private ---
-  void _cancelReconnect() {
+
-    _reconnectTimer?.cancel();
+  void _setConnectionState(WsConnectionState state) {
-    _reconnectTimer = null;
+    if (_connectionState != state) {
-  }
+      _connectionState = state;
-
+      _connectionController.add(state);
-  /// Dispose all resources (call on app shutdown)
+    }
-  void dispose() {
+  }
-    disconnect();
+
-    _arduinoController.close();
+  void _scheduleReconnect() {
-    _gpsController.close();
+    _cancelReconnect();
-    _statusController.close();
+    _reconnectTimer = Timer(const Duration(seconds: 3), () {
-    _ackController.close();
+      print('[WS] Attempting reconnect...');
-    _alertController.close();
+      _socket?.dispose();
-    _connectionController.close();
+      _socket = null;
-    _debugController.close();
+      connect();
-  }
+    });
-}
+  }
+
+  void _cancelReconnect() {
+    _reconnectTimer?.cancel();
+    _reconnectTimer = null;
+  }
+
+  /// Dispose all resources (call on app shutdown)
+  void dispose() {
+    disconnect();
+    _arduinoController.close();
+    _gpsController.close();
+    _lteController.close();
+    _statusController.close();
+    _ackController.close();
+    _alertController.close();
+    _connectionController.close();
+    _debugController.close();
+  }
+}

pi/ui/lib/widgets/debug_console.dart

@@ -1,119 +1,119 @@
-import 'dart:async';
+import 'dart:async';
-import 'package:flutter/material.dart';
+import 'package:flutter/material.dart';
-
+
-import '../theme/app_theme.dart';
+import '../theme/app_theme.dart';
-
+
-/// Generic debug console that displays streaming log messages.
+/// Generic debug console that displays streaming log messages.
-///
+///
-/// Can be wired to any message source via [messageStream] and [initialMessages].
+/// Can be wired to any message source via [messageStream] and [initialMessages].
-/// Example sources: WebSocketService.debugStream, ArduinoService logs, etc.
+/// Example sources: WebSocketService.debugStream, ArduinoService logs, etc.
-class DebugConsole extends StatefulWidget {
+class DebugConsole extends StatefulWidget {
-  /// Stream of new messages to display
+  /// Stream of new messages to display
-  final Stream<String> messageStream;
+  final Stream<String> messageStream;
-
+
-  /// Initial messages to populate (e.g., from a buffer)
+  /// Initial messages to populate (e.g., from a buffer)
-  final List<String> initialMessages;
+  final List<String> initialMessages;
-
+
-  /// Maximum lines to display
+  /// Maximum lines to display
-  final int maxLines;
+  final int maxLines;
-
+
-  /// Optional title for the console (shown in title bar)
+  /// Optional title for the console (shown in title bar)
-  final String? title;
+  final String? title;
-
+
-  const DebugConsole({
+  const DebugConsole({
-    super.key,
+    super.key,
-    required this.messageStream,
+    required this.messageStream,
-    this.initialMessages = const [],
+    this.initialMessages = const [],
-    this.maxLines = 8,
+    this.maxLines = 8,
-    this.title,
+    this.title,
-  });
+  });
-
+
-  @override
+  @override
-  State<DebugConsole> createState() => _DebugConsoleState();
+  State<DebugConsole> createState() => _DebugConsoleState();
-}
+}
-
+
-class _DebugConsoleState extends State<DebugConsole> {
+class _DebugConsoleState extends State<DebugConsole> {
-  final List<String> _messages = [];
+  final List<String> _messages = [];
-  StreamSubscription<String>? _sub;
+  StreamSubscription<String>? _sub;
-
+
-  @override
+  @override
-  void initState() {
+  void initState() {
-    super.initState();
+    super.initState();
-
+
-    // Initialize with existing buffer
+    // Initialize with existing buffer
-    _messages.addAll(widget.initialMessages);
+    _messages.addAll(widget.initialMessages);
-    _trimMessages();
+    _trimMessages();
-
+
-    // Subscribe to new messages
+    // Subscribe to new messages
-    _sub = widget.messageStream.listen((msg) {
+    _sub = widget.messageStream.listen((msg) {
-      setState(() {
+      setState(() {
-        _messages.add(msg);
+        _messages.add(msg);
-        _trimMessages();
+        _trimMessages();
-      });
+      });
-    });
+    });
-  }
+  }
-
+
-  void _trimMessages() {
+  void _trimMessages() {
-    while (_messages.length > widget.maxLines) {
+    while (_messages.length > widget.maxLines) {
-      _messages.removeAt(0);
+      _messages.removeAt(0);
-    }
+    }
-  }
+  }
-
+
-  @override
+  @override
-  void dispose() {
+  void dispose() {
-    _sub?.cancel();
+    _sub?.cancel();
-    super.dispose();
+    super.dispose();
-  }
+  }
-
+
-  @override
+  @override
-  Widget build(BuildContext context) {
+  Widget build(BuildContext context) {
-    final theme = AppTheme.of(context);
+    final theme = AppTheme.of(context);
-
+
-    return Container(
+    return Container(
-      decoration: BoxDecoration(
+      decoration: BoxDecoration(
-        color: theme.background.withAlpha(64),
+        color: theme.background.withAlpha(64),
-        border: Border.all(color: theme.subdued, width: 2),
+        border: Border.all(color: theme.subdued, width: 2),
-        borderRadius: BorderRadius.circular(8),
+        borderRadius: BorderRadius.circular(8),
-      ),
+      ),
-      child: Column(
+      child: Column(
-        mainAxisSize: MainAxisSize.max,
+        mainAxisSize: MainAxisSize.max,
-        crossAxisAlignment: CrossAxisAlignment.stretch,
+        crossAxisAlignment: CrossAxisAlignment.stretch,
-        children: [
+        children: [
-          // Title bar (optional)
+          // Title bar (optional)
-          if (widget.title != null)
+          if (widget.title != null)
-            Container(
+            Container(
-              padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+              padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
-              decoration: BoxDecoration(
+              decoration: BoxDecoration(
-                border: Border(
+                border: Border(
-                  bottom: BorderSide(color: theme.subdued, width: 1),
+                  bottom: BorderSide(color: theme.subdued, width: 1),
-                ),
+                ),
-              ),
+              ),
-              child: Text(
+              child: Text(
-                widget.title!,
+                widget.title!,
-                style: TextStyle(
+                style: TextStyle(
-                  fontFamily: 'monospace',
+                  fontFamily: 'monospace',
-                  fontSize: 24,
+                  fontSize: 24,
-                  color: theme.subdued,
+                  color: theme.subdued,
-                ),
+                ),
-              ),
+              ),
-            ),
+            ),
-          // Console content
+          // Console content
-          Expanded(
+          Expanded(
-            child: Padding(
+            child: Padding(
-              padding: const EdgeInsets.all(8),
+              padding: const EdgeInsets.all(8),
-              child: Text(
+              child: Text(
-                _messages.isEmpty ? '(no messages)' : _messages.join('\n'),
+                _messages.isEmpty ? '(no messages)' : _messages.join('\n'),
-                style: TextStyle(
+                style: TextStyle(
-                  fontFamily: 'monospace',
+                  fontFamily: 'monospace',
-                  fontSize: 30,
+                  fontSize: 30,
-                  color: theme.foreground,
+                  color: theme.foreground,
-                  height: 1.0,
+                  height: 1.0,
-                ),
+                ),
-              ),
+              ),
-            ),
+            ),
-          ),
+          ),
-        ],
+        ],
-      ),
+      ),
-    );
+    );
-  }
+  }
-}
+}

pi/ui/lib/widgets/gps_compass.dart

@@ -0,0 +1,73 @@
+import 'dart:math' as math;
+import 'package:flutter/material.dart';
+import '../theme/app_theme.dart';
+
+class GpsCompass extends StatelessWidget {
+  final double? heading;
+  final String? gpsState; // "acquiring", "fix", "lost"
+
+  const GpsCompass({super.key, this.heading, this.gpsState});
+
+  bool get _hasSignal => heading != null;
+  bool get _isAcquiring => gpsState == 'acquiring';
+
+  String get _displayHeading {
+    if (!_hasSignal) return 'N/A';
+    return '${(heading! % 360).round()}';
+  }
+
+  String get _compassDirection {
+    if (!_hasSignal) return '';
+    final directions = [
+      'N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE',
+      'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'
+    ];
+    final index = ((heading! % 360) / 22.5).round() % 16;
+    return directions[index];
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = AppTheme.of(context);
+
+    // No signal = subdued color, valid = foreground
+    final iconColour = _hasSignal ? theme.foreground : theme.highlight;
+
+    // Convert to radians, 0 = no rotation when no signal
+    final angle = _hasSignal ? (heading! * math.pi / 180.0) : 0.0;
+
+    return Column(
+      mainAxisAlignment: MainAxisAlignment.center,
+      children: [
+        Flexible(
+          flex: 3,
+          child: Transform.rotate(
+            angle: _hasSignal ? angle : 0,
+            child: FittedBox(
+              fit: BoxFit.contain,
+              child: Icon(
+                _hasSignal ? Icons.navigation : Icons.navigation_outlined,
+                size: 120,
+                color: iconColour,
+              ),
+            ),
+          ),
+        ),
+        Flexible(
+          flex: 1,
+          child: FittedBox(
+            fit: BoxFit.contain,
+            child: Text(
+              _hasSignal ? "${_displayHeading} ${_compassDirection}" : (_isAcquiring ? "ACQ" : "N/A"),
+              style: TextStyle(
+                fontSize: 80,
+                color: theme.subdued, // less emphasis on text, let the icon have semantic colour
+                fontFamily: 'DIN1451',
+              ),
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+}

pi/ui/lib/widgets/navigator_widget.dart

@@ -1,100 +1,100 @@
-import 'dart:io';
+import 'dart:io';
-import 'dart:math';
+import 'dart:math';
-import 'package:flutter/material.dart';
+import 'package:flutter/material.dart';
-import '../services/config_service.dart';
+import '../services/config_service.dart';
-
+
-/// Displays the navigator character with emotion support.
+/// Displays the navigator character with emotion support.
-///
+///
-/// Use a GlobalKey to control emotions from parent:
+/// Use a GlobalKey to control emotions from parent:
-/// ```dart
+/// ```dart
-/// final _navigatorKey = GlobalKey<NavigatorWidgetState>();
+/// final _navigatorKey = GlobalKey<NavigatorWidgetState>();
-/// NavigatorWidget(key: _navigatorKey)
+/// NavigatorWidget(key: _navigatorKey)
-/// // Later:
+/// // Later:
-/// _navigatorKey.currentState?.setEmotion('happy');
+/// _navigatorKey.currentState?.setEmotion('happy');
-/// ```
+/// ```
-class NavigatorWidget extends StatefulWidget {
+class NavigatorWidget extends StatefulWidget {
-  const NavigatorWidget({super.key});
+  const NavigatorWidget({super.key});
-
+
-  @override
+  @override
-  State<NavigatorWidget> createState() => NavigatorWidgetState();
+  State<NavigatorWidget> createState() => NavigatorWidgetState();
-}
+}
-
+
-class NavigatorWidgetState extends State<NavigatorWidget>
+class NavigatorWidgetState extends State<NavigatorWidget>
-    with SingleTickerProviderStateMixin {
+    with SingleTickerProviderStateMixin {
-  String _emotion = 'default';
+  String _emotion = 'default';
-  late AnimationController _shakeController;
+  late AnimationController _shakeController;
-
+
-  @override
+  @override
-  void initState() {
+  void initState() {
-    super.initState();
+    super.initState();
-    _shakeController = AnimationController(
+    _shakeController = AnimationController(
-      duration: const Duration(milliseconds: 400),
+      duration: const Duration(milliseconds: 400),
-      vsync: this,
+      vsync: this,
-    );
+    );
-    // Auto-reset to default after surprise animation completes
+    // Auto-reset to default after surprise animation completes
-    _shakeController.addStatusListener((status) {
+    _shakeController.addStatusListener((status) {
-      if (status == AnimationStatus.completed && _emotion == 'surprise') {
+      if (status == AnimationStatus.completed && _emotion == 'surprise') {
-        setState(() => _emotion = 'default');
+        setState(() => _emotion = 'default');
-      }
+      }
-    });
+    });
-  }
+  }
-
+
-  @override
+  @override
-  void dispose() {
+  void dispose() {
-    _shakeController.dispose();
+    _shakeController.dispose();
-    super.dispose();
+    super.dispose();
-  }
+  }
-
+
-  /// Change the displayed emotion.
+  /// Change the displayed emotion.
-  /// Image file must exist at: {assetsPath}/navigator/{navigator}/{emotion}.png
+  /// Image file must exist at: {assetsPath}/navigator/{navigator}/{emotion}.png
-  void setEmotion(String emotion) {
+  void setEmotion(String emotion) {
-    if (emotion != _emotion) {
+    if (emotion != _emotion) {
-      setState(() => _emotion = emotion);
+      setState(() => _emotion = emotion);
-      if (emotion == 'surprise') {
+      if (emotion == 'surprise') {
-        _shakeController.forward(from: 0);
+        _shakeController.forward(from: 0);
-      }
+      }
-    }
+    }
-  }
+  }
-
+
-  /// Reset to default emotion
+  /// Reset to default emotion
-  void reset() => setEmotion('default');
+  void reset() => setEmotion('default');
-
+
-  /// Current emotion
+  /// Current emotion
-  String get emotion => _emotion;
+  String get emotion => _emotion;
-
+
-  @override
+  @override
-  Widget build(BuildContext context) {
+  Widget build(BuildContext context) {
-    final config = ConfigService.instance;
+    final config = ConfigService.instance;
-    final basePath = '${config.assetsPath}/navigator/${config.navigator}';
+    final basePath = '${config.assetsPath}/navigator/${config.navigator}';
-
+
-    final image = Image.file(
+    final image = Image.file(
-      File('$basePath/$_emotion.png'),
+      File('$basePath/$_emotion.png'),
-      fit: BoxFit.contain,
+      fit: BoxFit.contain,
-      errorBuilder: (context, error, stackTrace) {
+      errorBuilder: (context, error, stackTrace) {
-        // Fallback: try default.png if specific emotion missing
+        // Fallback: try default.png if specific emotion missing
-        if (_emotion != 'default') {
+        if (_emotion != 'default') {
-          return Image.file(
+          return Image.file(
-            File('$basePath/default.png'),
+            File('$basePath/default.png'),
-            fit: BoxFit.contain,
+            fit: BoxFit.contain,
-            errorBuilder: (_, __, ___) => const SizedBox.shrink(),
+            errorBuilder: (_, __, ___) => const SizedBox.shrink(),
-          );
+          );
-        }
+        }
-        return const SizedBox.shrink();
+        return const SizedBox.shrink();
-      },
+      },
-    );
+    );
-
+
-    // Shake animation for surprise
+    // Shake animation for surprise
-    return AnimatedBuilder(
+    return AnimatedBuilder(
-      animation: _shakeController,
+      animation: _shakeController,
-      child: image,
+      child: image,
-      builder: (context, child) {
+      builder: (context, child) {
-        final shake = sin(_shakeController.value * pi * 6) * 25 *
+        final shake = sin(_shakeController.value * pi * 6) * 25 *
-            (1 - _shakeController.value); // 6 oscillations, 25px amplitude, decay
+            (1 - _shakeController.value); // 6 oscillations, 25px amplitude, decay
-        return Transform.translate(
+        return Transform.translate(
-          offset: Offset(shake, 0),
+          offset: Offset(shake, 0),
-          child: child,
+          child: child,
-        );
+        );
-      },
+      },
-    );
+    );
-  }
+  }
-}
+}

pi/ui/lib/widgets/system_bar.dart

@@ -1,178 +1,174 @@
-import 'package:flutter/material.dart';
+import 'package:flutter/material.dart';
-
+
-import '../services/websocket_service.dart';
+import '../services/websocket_service.dart';
-import '../theme/app_theme.dart';
+import '../theme/app_theme.dart';
-
+
-/// Android-style persistent status bar for system indicators.
+/// Android-style persistent status bar for system indicators.
-/// Shows GPS satellites, LTE signal, Pi temp, voltage, WS status at a glance.
+/// Shows GPS satellites, LTE signal, Pi temp, voltage, WS status at a glance.
-class SystemBar extends StatelessWidget {
+class SystemBar extends StatelessWidget {
-  final int? gpsSatellites; // null = disconnected
+  final int? gpsSatellites; // null = disconnected
-  final int? lteSignal; // null = disconnected, 0-4 bars
+  final String? gpsState; // "acquiring", "fix", "lost"
-  final double? piTemp; // null = unavailable
+  final int? lteSignal; // null = disconnected, 0-4 bars
-  final double? voltage; // null = Arduino disconnected
+  final double? piTemp; // null = unavailable
-  final WsConnectionState? wsState; // WebSocket connection state
+  final double? voltage; // null = Arduino disconnected
-
+  final WsConnectionState? wsState; // WebSocket connection state
-  const SystemBar({
+
-    super.key,
+  const SystemBar({
-    this.gpsSatellites,
+    super.key,
-    this.lteSignal,
+    this.gpsSatellites,
-    this.piTemp,
+    this.gpsState,
-    this.voltage,
+    this.lteSignal,
-    this.wsState,
+    this.piTemp,
-  });
+    this.voltage,
-
+    this.wsState,
-  /// Get WebSocket status text and abnormal flag
+  });
-  (String, bool) _wsStatus() {
+
-    switch (wsState) {
+  /// Get WebSocket status text and abnormal flag
-      case WsConnectionState.connected:
+  (String, bool) _wsStatus() {
-        return ('OK', false);
+    switch (wsState) {
-      case WsConnectionState.connecting:
+      case WsConnectionState.connected:
-        return ('...', true);
+        return ('OK', false);
-      case WsConnectionState.disconnected:
+      case WsConnectionState.connecting:
-      case null:
+        return ('...', true);
-        return ('OFF', true);
+      case WsConnectionState.disconnected:
-    }
+      case null:
-  }
+        return ('OFF', true);
-
+    }
-  @override
+  }
-  Widget build(BuildContext context) {
+
-    final theme = AppTheme.of(context);
+  @override
-    final (wsText, wsAbnormal) = _wsStatus();
+  Widget build(BuildContext context) {
-
+    final theme = AppTheme.of(context);
-    return Expanded(
+    final (wsText, wsAbnormal) = _wsStatus();
-      flex: 1,
+
-      child: LayoutBuilder(
+    return Expanded(
-        builder: (context, constraints) {
+      flex: 1,
-          // Font sizes relative to bar height
+      child: LayoutBuilder(
-          final labelSize = constraints.maxHeight * 0.5;
+        builder: (context, constraints) {
-          final valueSize = constraints.maxHeight * 0.5;
+          // Font sizes relative to bar height
-
+          final labelSize = constraints.maxHeight * 0.5;
-          return Container(
+          final valueSize = constraints.maxHeight * 0.5;
-            padding: const EdgeInsets.symmetric(horizontal: 24),
+
-            decoration: BoxDecoration(
+          return Container(
-              border: Border(
+            padding: const EdgeInsets.symmetric(horizontal: 24),
-                bottom: BorderSide(
+            child: Row(
-                  color: theme.subdued.withValues(alpha: 0.3),
+              crossAxisAlignment: CrossAxisAlignment.center,
-                  width: 1,
+              children: [
-                ),
+                // Left group: WS, GPS, LTE
-              ),
+                _Indicator(
-            ),
+                  label: 'WS',
-            child: Row(
+                  value: wsText,
-              crossAxisAlignment: CrossAxisAlignment.center,
+                  isAbnormal: wsAbnormal,
-              children: [
+                  alignment: Alignment.centerLeft,
-                // Left group: WS, GPS, LTE
+                  labelSize: labelSize,
-                _Indicator(
+                  valueSize: valueSize,
-                  label: 'WS',
+                  flex: 2,
-                  value: wsText,
+                  theme: theme,
-                  isAbnormal: wsAbnormal,
+                ),
-                  alignment: Alignment.centerLeft,
+                _Indicator(
-                  labelSize: labelSize,
+                  label: 'GPS',
-                  valueSize: valueSize,
+                  value: gpsState == 'acquiring' ? 'ACQ'
-                  flex: 2,
+                       : gpsState == 'fix' ? (gpsSatellites?.toString() ?? 'N/A')
-                  theme: theme,
+                       : '0',  // lost or unknown
-                ),
+                  isAbnormal: gpsState != 'fix' || gpsSatellites == null,
-                _Indicator(
+                  alignment: Alignment.centerLeft,
-                  label: 'GPS',
+                  labelSize: labelSize,
-                  value: gpsSatellites?.toString() ?? 'N/A',
+                  valueSize: valueSize,
-                  isAbnormal: gpsSatellites == null || gpsSatellites == 0,
+                  flex: 2,
-                  alignment: Alignment.centerLeft,
+                  theme: theme,
-                  labelSize: labelSize,
+                ),
-                  valueSize: valueSize,
+                _Indicator(
-                  flex: 2,
+                  label: 'LTE',
-                  theme: theme,
+                  value: lteSignal?.toString() ?? 'N/A',
-                ),
+                  isAbnormal: lteSignal == null,
-                _Indicator(
+                  alignment: Alignment.centerLeft,
-                  label: 'LTE',
+                  labelSize: labelSize,
-                  value: lteSignal?.toString() ?? 'N/A',
+                  valueSize: valueSize,
-                  isAbnormal: lteSignal == null,
+                  flex: 2,
-                  alignment: Alignment.centerLeft,
+                  theme: theme,
-                  labelSize: labelSize,
+                ),
-                  valueSize: valueSize,
+
-                  flex: 2,
+                // Right group: Pi, Chassis
-                  theme: theme,
+                _Indicator(
-                ),
+                  label: 'Pi',
-
+                  value: piTemp != null ? '${piTemp!.toStringAsFixed(1)} °C' : 'N/A',
-                // Right group: Pi, Chassis
+                  isAbnormal: piTemp == null || piTemp! > 80,
-                _Indicator(
+                  alignment: Alignment.centerLeft,
-                  label: 'Pi',
+                  labelSize: labelSize,
-                  value: piTemp != null ? '${piTemp!.toStringAsFixed(1)} °C' : 'N/A',
+                  valueSize: valueSize,
-                  isAbnormal: piTemp == null || piTemp! > 80,
+                  flex: 2,
-                  alignment: Alignment.centerLeft,
+                  theme: theme,
-                  labelSize: labelSize,
+                ),
-                  valueSize: valueSize,
+                _Indicator(
-                  flex: 2,
+                  label: 'Mains',
-                  theme: theme,
+                  value: voltage != null ? '${voltage!.toStringAsFixed(1)} V' : 'N/A',
-                ),
+                  isAbnormal: voltage == null || voltage! < 11.7 || voltage! > 14.5,
-                _Indicator(
+                  alignment: Alignment.centerLeft,
-                  label: 'Mains',
+                  labelSize: labelSize,
-                  value: voltage != null ? '${voltage!.toStringAsFixed(1)} V' : 'N/A',
+                  valueSize: valueSize,
-                  isAbnormal: voltage == null || voltage! < 11.9,
+                  flex: 3,
-                  alignment: Alignment.centerLeft,
+                  theme: theme,
-                  labelSize: labelSize,
+                ),
-                  valueSize: valueSize,
+              ],
-                  flex: 3,
+            ),
-                  theme: theme,
+          );
-                ),
+        },
-              ],
+      ),
-            ),
+    );
-          );
+  }
-        },
+}
-      ),
+
-    );
+/// Single status indicator in a fixed-width flex slot.
-  }
+class _Indicator extends StatelessWidget {
-}
+  final String label;
-
+  final String value;
-/// Single status indicator in a fixed-width flex slot.
+  final bool isAbnormal;
-class _Indicator extends StatelessWidget {
+  final Alignment alignment;
-  final String label;
+  final double labelSize;
-  final String value;
+  final double valueSize;
-  final bool isAbnormal;
+  final int flex;
-  final Alignment alignment;
+  final AppTheme theme;
-  final double labelSize;
+
-  final double valueSize;
+  const _Indicator({
-  final int flex;
+    required this.label,
-  final AppTheme theme;
+    required this.value,
-
+    required this.isAbnormal,
-  const _Indicator({
+    required this.alignment,
-    required this.label,
+    required this.labelSize,
-    required this.value,
+    required this.valueSize,
-    required this.isAbnormal,
+    required this.flex,
-    required this.alignment,
+    required this.theme,
-    required this.labelSize,
+  });
-    required this.valueSize,
+
-    required this.flex,
+  @override
-    required this.theme,
+  Widget build(BuildContext context) {
-  });
+    return Expanded(
-
+      flex: flex,
-  @override
+      child: Align(
-  Widget build(BuildContext context) {
+        alignment: alignment,
-    return Expanded(
+        child: Row(
-      flex: flex,
+          mainAxisSize: MainAxisSize.min,
-      child: Align(
+          crossAxisAlignment: CrossAxisAlignment.baseline,
-        alignment: alignment,
+          textBaseline: TextBaseline.alphabetic,
-        child: Row(
+          children: [
-          mainAxisSize: MainAxisSize.min,
+            Text(
-          crossAxisAlignment: CrossAxisAlignment.baseline,
+              '$label ',
-          textBaseline: TextBaseline.alphabetic,
+              style: TextStyle(
-          children: [
+                fontSize: labelSize,
-            Text(
+                color: theme.subdued,
-              '$label ',
+              ),
-              style: TextStyle(
+            ),
-                fontSize: labelSize,
+            Text(
-                color: theme.subdued,
+              value,
-              ),
+              style: TextStyle(
-            ),
+                fontSize: valueSize,
-            Text(
+                fontFeatures: const [FontFeature.tabularFigures()],
-              value,
+                color: isAbnormal ? theme.highlight : theme.foreground,
-              style: TextStyle(
+              ),
-                fontSize: valueSize,
+            ),
-                fontFeatures: const [FontFeature.tabularFigures()],
+          ],
-                color: isAbnormal ? theme.highlight : theme.foreground,
+        ),
-              ),
+      ),
-            ),
+    );
-          ],
+  }
-        ),
+}
-      ),
-    );
-  }
-}

pi/ui/pubspec.yaml

@@ -1,26 +1,26 @@
-name: smartserow_ui
+name: smartserow_ui
-description: Smart Serow embedded UI for Raspberry Pi Zero 2W
+description: Smart Serow embedded UI for Raspberry Pi Zero 2W
-publish_to: 'none'
+publish_to: 'none'
-version: 0.1.0
+version: 0.1.0
-
+
-environment:
+environment:
-  sdk: '>=3.0.0 <4.0.0'
+  sdk: '>=3.0.0 <4.0.0'
-
+
-dependencies:
+dependencies:
-  flutter:
+  flutter:
-    sdk: flutter
+    sdk: flutter
-  http: ^1.2.0
+  http: ^1.2.0
-  socket_io_client: ^2.0.3+1
+  socket_io_client: ^2.0.3+1
-
+
-dev_dependencies:
+dev_dependencies:
-  flutter_test:
+  flutter_test:
-    sdk: flutter
+    sdk: flutter
-  flutter_lints: ^3.0.0
+  flutter_lints: ^3.0.0
-
+
-flutter:
+flutter:
-  uses-material-design: true
+  uses-material-design: true
-
+
-  fonts:
+  fonts:
-    - family: DIN1451
+    - family: DIN1451
-      fonts:
+      fonts:
-        - asset: assets/fonts/din1451alt.ttf
+        - asset: assets/fonts/din1451alt.ttf

scripts/build-deploy.py

@@ -1,88 +1,88 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python3
-"""One-click build and deploy for Smart Serow.
+"""One-click build and deploy for Smart Serow.
-
+
-Combines build.py and deploy.py with sensible defaults.
+Combines build.py and deploy.py with sensible defaults.
-Defaults to --restart since that's usually what you want.
+Defaults to --restart since that's usually what you want.
-"""
+"""
-
+
-import argparse
+import argparse
-import sys
+import sys
-from pathlib import Path
+from pathlib import Path
-
+
-# Import sibling modules
+# Import sibling modules
-sys.path.insert(0, str(Path(__file__).parent))
+sys.path.insert(0, str(Path(__file__).parent))
-from build import build
+from build import build
-from deploy import deploy
+from deploy import deploy
-from deploy_backend import deploy as deploy_backend
+from deploy_backend import deploy as deploy_backend
-
+
-
+
-def main():
+def main():
-    parser = argparse.ArgumentParser(
+    parser = argparse.ArgumentParser(
-        description="Build and deploy Smart Serow in one step",
+        description="Build and deploy Smart Serow in one step",
-    )
+    )
-    parser.add_argument(
+    parser.add_argument(
-        "--clean", "-c",
+        "--clean", "-c",
-        action="store_true",
+        action="store_true",
-        help="Clean CMake cache before building",
+        help="Clean CMake cache before building",
-    )
+    )
-    parser.add_argument(
+    parser.add_argument(
-        "--no-restart",
+        "--no-restart",
-        action="store_true",
+        action="store_true",
-        help="Don't restart service after deploy (default: restart)",
+        help="Don't restart service after deploy (default: restart)",
-    )
+    )
-    parser.add_argument(
+    parser.add_argument(
-        "--build-only",
+        "--build-only",
-        action="store_true",
+        action="store_true",
-        help="Only build, don't deploy",
+        help="Only build, don't deploy",
-    )
+    )
-    parser.add_argument(
+    parser.add_argument(
-        "--deploy-only",
+        "--deploy-only",
-        action="store_true",
+        action="store_true",
-        help="Only deploy, don't build",
+        help="Only deploy, don't build",
-    )
+    )
-    parser.add_argument(
+    parser.add_argument(
-        "--ui",
+        "--ui",
-        action="store_true",
+        action="store_true",
-        help="Build/deploy UI only (no backend)",
+        help="Build/deploy UI only (no backend)",
-    )
+    )
-    parser.add_argument(
+    parser.add_argument(
-        "--backend",
+        "--backend",
-        action="store_true",
+        action="store_true",
-        help="Deploy backend only (no UI, no build)",
+        help="Deploy backend only (no UI, no build)",
-    )
+    )
-    args = parser.parse_args()
+    args = parser.parse_args()
-
+
-    # Default: both UI and backend if neither flag specified
+    # Default: both UI and backend if neither flag specified
-    do_ui = args.ui or not args.backend
+    do_ui = args.ui or not args.backend
-    do_backend = args.backend or not args.ui
+    do_backend = args.backend or not args.ui
-
+
-    restart = not args.no_restart
+    restart = not args.no_restart
-
+
-    # Build UI (only if doing UI and not deploy-only)
+    # Build UI (only if doing UI and not deploy-only)
-    if do_ui and not args.deploy_only:
+    if do_ui and not args.deploy_only:
-        print()
+        print()
-        if not build(clean=args.clean):
+        if not build(clean=args.clean):
-            print("UI build failed!")
+            print("UI build failed!")
-            sys.exit(1)
+            sys.exit(1)
-
+
-    # Deploy backend FIRST (no build step needed - it's Python)
+    # Deploy backend FIRST (no build step needed - it's Python)
-    # Backend must be up before UI connects to WebSocket
+    # Backend must be up before UI connects to WebSocket
-    if do_backend and not args.build_only:
+    if do_backend and not args.build_only:
-        print()
+        print()
-        if not deploy_backend(restart=restart):
+        if not deploy_backend(restart=restart):
-            print("Backend deploy failed!")
+            print("Backend deploy failed!")
-            sys.exit(1)
+            sys.exit(1)
-
+
-    # Deploy UI after backend is ready
+    # Deploy UI after backend is ready
-    if do_ui and not args.build_only:
+    if do_ui and not args.build_only:
-        print()
+        print()
-        if not deploy(restart=restart):
+        if not deploy(restart=restart):
-            print("UI deploy failed!")
+            print("UI deploy failed!")
-            sys.exit(1)
+            sys.exit(1)
-
+
-    print()
+    print()
-    print("=== All done! ===")
+    print("=== All done! ===")
-
+
-
+
-if __name__ == "__main__":
+if __name__ == "__main__":
-    main()
+    main()

scripts/deploy_backend.py

@@ -1,157 +1,157 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python3
-"""Deploy script for Smart Serow Python backend.
+"""Deploy script for Smart Serow Python backend.
-
+
-Pushes backend source to Pi and optionally restarts service.
+Pushes backend source to Pi and optionally restarts service.
-Completely independent from UI deploy.
+Completely independent from UI deploy.
-"""
+"""
-
+
-import argparse
+import argparse
-import json
+import json
-import subprocess
+import subprocess
-import sys
+import sys
-import time
+import time
-from pathlib import Path
+from pathlib import Path
-
+
-
+
-SCRIPT_DIR = Path(__file__).parent.resolve()
+SCRIPT_DIR = Path(__file__).parent.resolve()
-PROJECT_ROOT = SCRIPT_DIR.parent
+PROJECT_ROOT = SCRIPT_DIR.parent
-CONFIG_FILE = SCRIPT_DIR / "deploy_target.json"
+CONFIG_FILE = SCRIPT_DIR / "deploy_target.json"
-BACKEND_DIR = PROJECT_ROOT / "pi" / "backend"
+BACKEND_DIR = PROJECT_ROOT / "pi" / "backend"
-SERVICE_FILE = SCRIPT_DIR / "smartserow-backend.service"
+SERVICE_FILE = SCRIPT_DIR / "smartserow-backend.service"
-
+
-
+
-def run(cmd: list[str], check: bool = True, **kwargs) -> subprocess.CompletedProcess:
+def run(cmd: list[str], check: bool = True, **kwargs) -> subprocess.CompletedProcess:
-    """Run a command."""
+    """Run a command."""
-    print(f"  → {' '.join(cmd)}")
+    print(f"  → {' '.join(cmd)}")
-    return subprocess.run(cmd, check=check, **kwargs)
+    return subprocess.run(cmd, check=check, **kwargs)
-
+
-
+
-def load_config() -> dict:
+def load_config() -> dict:
-    """Load deploy target configuration."""
+    """Load deploy target configuration."""
-    if not CONFIG_FILE.exists():
+    if not CONFIG_FILE.exists():
-        print(f"ERROR: Config file not found: {CONFIG_FILE}")
+        print(f"ERROR: Config file not found: {CONFIG_FILE}")
-        print("Create it based on deploy_target.sample.json")
+        print("Create it based on deploy_target.sample.json")
-        sys.exit(1)
+        sys.exit(1)
-
+
-    with open(CONFIG_FILE) as f:
+    with open(CONFIG_FILE) as f:
-        return json.load(f)
+        return json.load(f)
-
+
-
+
-def deploy(restart: bool = False) -> bool:
+def deploy(restart: bool = False) -> bool:
-    """Deploy backend to Pi. Returns True on success."""
+    """Deploy backend to Pi. Returns True on success."""
-    config = load_config()
+    config = load_config()
-
+
-    pi_user = config["user"]
+    pi_user = config["user"]
-    pi_host = config["host"]
+    pi_host = config["host"]
-
+
-    # Backend-specific config (with defaults)
+    # Backend-specific config (with defaults)
-    remote_path = config.get("backend_path", "/opt/smartserow-backend")
+    remote_path = config.get("backend_path", "/opt/smartserow-backend")
-    service_name = config.get("backend_service", "smartserow-backend")
+    service_name = config.get("backend_service", "smartserow-backend")
-
+
-    ssh_target = f"{pi_user}@{pi_host}"
+    ssh_target = f"{pi_user}@{pi_host}"
-
+
-    print("=== Smart Serow Backend Deploy ===")
+    print("=== Smart Serow Backend Deploy ===")
-    print(f"Target: {ssh_target}:{remote_path}")
+    print(f"Target: {ssh_target}:{remote_path}")
-    print(f"Source: {BACKEND_DIR}")
+    print(f"Source: {BACKEND_DIR}")
-
+
-    if not BACKEND_DIR.exists():
+    if not BACKEND_DIR.exists():
-        print(f"ERROR: Backend directory not found: {BACKEND_DIR}")
+        print(f"ERROR: Backend directory not found: {BACKEND_DIR}")
-        return False
+        return False
-
+
-    # Ensure remote directory exists
+    # Ensure remote directory exists
-    print()
+    print()
-    print("Ensuring remote directory...")
+    print("Ensuring remote directory...")
-    run(["ssh", ssh_target, f"mkdir -p {remote_path}"])
+    run(["ssh", ssh_target, f"mkdir -p {remote_path}"])
-
+
-    # Sync backend source to Pi
+    # Sync backend source to Pi
-    # Exclude __pycache__, .venv, etc.
+    # Exclude __pycache__, .venv, etc.
-    print()
+    print()
-    print("Syncing files...")
+    print("Syncing files...")
-    run([
+    run([
-        "rsync", "-avz", "--delete",
+        "rsync", "-avz", "--delete",
-        "--exclude", "__pycache__",
+        "--exclude", "__pycache__",
-        "--exclude", "*.pyc",
+        "--exclude", "*.pyc",
-        "--exclude", ".venv",
+        "--exclude", ".venv",
-        "--exclude", ".ruff_cache",
+        "--exclude", ".ruff_cache",
-        "--exclude", "uv.lock",  # Let Pi generate its own lockfile
+        "--exclude", "uv.lock",  # Let Pi generate its own lockfile
-        f"{BACKEND_DIR}/",
+        f"{BACKEND_DIR}/",
-        f"{ssh_target}:{remote_path}/",
+        f"{ssh_target}:{remote_path}/",
-    ])
+    ])
-
+
-    # Ensure system GPIO package is installed (pip version needs compilation)
+    # Ensure system GPIO package is installed (pip version needs compilation)
-    print()
+    print()
-    print("Ensuring system GPIO package...")
+    print("Ensuring system GPIO package...")
-    run(
+    run(
-        ["ssh", ssh_target, "dpkg -s python3-rpi.gpio >/dev/null 2>&1 || sudo apt install -y python3-rpi.gpio"],
+        ["ssh", ssh_target, "dpkg -s python3-rpi.gpio >/dev/null 2>&1 || sudo apt install -y python3-rpi.gpio"],
-        check=False,
+        check=False,
-    )
+    )
-
+
-    # Create venv with system-site-packages if it doesn't exist
+    # Create venv with system-site-packages if it doesn't exist
-    # This allows access to apt-installed packages like python3-rpi.gpio
+    # This allows access to apt-installed packages like python3-rpi.gpio
-    print()
+    print()
-    print("Ensuring venv with system-site-packages...")
+    print("Ensuring venv with system-site-packages...")
-    run(
+    run(
-        ["ssh", ssh_target, f"cd {remote_path} && [ -d .venv ] || ~/.local/bin/uv venv --system-site-packages"],
+        ["ssh", ssh_target, f"cd {remote_path} && [ -d .venv ] || ~/.local/bin/uv venv --system-site-packages"],
-        check=False,
+        check=False,
-    )
+    )
-
+
-    # Run uv sync to install/update dependencies
+    # Run uv sync to install/update dependencies
-    # Use full path since non-interactive SSH doesn't load .bashrc
+    # Use full path since non-interactive SSH doesn't load .bashrc
-    print()
+    print()
-    print("Running uv sync...")
+    print("Running uv sync...")
-    result = run(
+    result = run(
-        ["ssh", ssh_target, f"cd {remote_path} && ~/.local/bin/uv sync"],
+        ["ssh", ssh_target, f"cd {remote_path} && ~/.local/bin/uv sync"],
-        check=False,
+        check=False,
-    )
+    )
-    if result.returncode != 0:
+    if result.returncode != 0:
-        print("WARNING: uv sync failed - dependencies may be out of date")
+        print("WARNING: uv sync failed - dependencies may be out of date")
-        print("Make sure uv is installed on Pi: curl -LsSf https://astral.sh/uv/install.sh | sh")
+        print("Make sure uv is installed on Pi: curl -LsSf https://astral.sh/uv/install.sh | sh")
-
+
-    # Deploy service file if it exists
+    # Deploy service file if it exists
-    if SERVICE_FILE.exists():
+    if SERVICE_FILE.exists():
-        print()
+        print()
-        print("Deploying systemd service file...")
+        print("Deploying systemd service file...")
-        run(["scp", str(SERVICE_FILE), f"{ssh_target}:/tmp/"])
+        run(["scp", str(SERVICE_FILE), f"{ssh_target}:/tmp/"])
-        run([
+        run([
-            "ssh", ssh_target,
+            "ssh", ssh_target,
-            f"sudo mv /tmp/{SERVICE_FILE.name} /etc/systemd/system/ && sudo systemctl daemon-reload"
+            f"sudo mv /tmp/{SERVICE_FILE.name} /etc/systemd/system/ && sudo systemctl daemon-reload"
-        ])
+        ])
-
+
-    # Restart service if requested
+    # Restart service if requested
-    if restart:
+    if restart:
-        print()
+        print()
-        print(f"Restarting service: {service_name}")
+        print(f"Restarting service: {service_name}")
-        run(["ssh", ssh_target, f"sudo systemctl restart {service_name}"], check=False)
+        run(["ssh", ssh_target, f"sudo systemctl restart {service_name}"], check=False)
-        time.sleep(2)
+        time.sleep(2)
-        run(["ssh", ssh_target, f"systemctl status {service_name} --no-pager"], check=False)
+        run(["ssh", ssh_target, f"systemctl status {service_name} --no-pager"], check=False)
-    else:
+    else:
-        print()
+        print()
-        print("Deploy complete. To restart service, run:")
+        print("Deploy complete. To restart service, run:")
-        print(f"  ssh {ssh_target} 'sudo systemctl restart {service_name}'")
+        print(f"  ssh {ssh_target} 'sudo systemctl restart {service_name}'")
-        print()
+        print()
-        print("Or run this script with --restart flag")
+        print("Or run this script with --restart flag")
-
+
-    print()
+    print()
-    print("Note: First-time setup on Pi requires:")
+    print("Note: First-time setup on Pi requires:")
-    print(f"  ssh {ssh_target}")
+    print(f"  ssh {ssh_target}")
-    print("  curl -LsSf https://astral.sh/uv/install.sh | sh  # Install uv")
+    print("  curl -LsSf https://astral.sh/uv/install.sh | sh  # Install uv")
-    print("  sudo apt install python3-rpi.gpio                 # GPIO support")
+    print("  sudo apt install python3-rpi.gpio                 # GPIO support")
-
+
-    return True
+    return True
-
+
-
+
-def main():
+def main():
-    parser = argparse.ArgumentParser(description="Deploy Smart Serow backend to Pi")
+    parser = argparse.ArgumentParser(description="Deploy Smart Serow backend to Pi")
-    parser.add_argument(
+    parser.add_argument(
-        "--restart", "-r",
+        "--restart", "-r",
-        action="store_true",
+        action="store_true",
-        help="Restart the systemd service after deploy",
+        help="Restart the systemd service after deploy",
-    )
+    )
-    args = parser.parse_args()
+    args = parser.parse_args()
-
+
-    success = deploy(restart=args.restart)
+    success = deploy(restart=args.restart)
-    sys.exit(0 if success else 1)
+    sys.exit(0 if success else 1)
-
+
-
+
-if __name__ == "__main__":
+if __name__ == "__main__":
-    main()
+    main()