Merge pull request #253 from pyMC-dev/wip/null-radio-before-pr250

Wip/null radio before pr250

Author: rightup

config.yaml.example

@@ -1,7 +1,3 @@
-# Default Repeater Configuration
-# radio_type: sx1262 | kiss (use kiss for serial KISS TNC modem)
-radio_type: sx1262
-
 repeater:
   # Node name for logging and identification
   node_name: "mesh-repeater-01"
@@ -317,7 +313,8 @@ identities:
 #   - kiss          (KISS-modem over a serial port; alias: kiss-modem)
 #   - pymc_tcp      (pymc_usb firmware modem over Wi-Fi/TCP)
 #   - pymc_usb      (pymc_usb firmware modem over USB-CDC)
-radio_type: sx1262
+#   - null/none     (disable radio hardware; daemon starts without RF I/O)
+radio_type: null
 
 # CH341 USB-to-SPI adapter settings (only used when radio_type: sx1262_ch341)
 # NOTE: VID/PID are integers. Hex is also accepted in YAML, e.g. 0x1A86.

radio-settings.json

@@ -186,6 +186,7 @@
     "ch341-usb-sx1262": {
       "name": "CH341 USB-SPI + SX1262 (example)",
       "description": "SX1262 via CH341 USB-to-SPI adapter. NOTE: pin numbers are CH341 GPIO 0-7, not BCM.",
+      "connection_type": "usb",
       "radio_type": "sx1262_ch341",
       "vid": 6790,
       "pid": 21778,
@@ -322,6 +323,30 @@
       "use_dio2_rf": false,
       "use_dio3_tcxo": true,
       "preamble_length": 17
+    },
+    "pymc_usb": {
+      "name": "pymc_usb modem (USB-CDC)",
+      "description": "ESP32-S3 / nRF52 board running pymc_usb firmware as a USB-CDC LoRa modem. Pick this if the modem is plugged into the host's USB port (e.g. /dev/ttyACM0). Edit the 'pymc_usb' section after first-run to point at the right serial device.",
+      "connection_type": "usb",
+      "radio_type": "pymc_usb",
+      "tx_power": 22,
+      "preamble_length": 16
+    },
+    "pymc_tcp": {
+      "name": "pymc_tcp modem (Wi-Fi / Ethernet)",
+      "description": "ESP32 board running pymc_usb firmware exposed as a TCP server over Wi-Fi or Ethernet. After first-run, set 'pymc_tcp.host' to the modem's LAN address or mDNS name (e.g. pymc-3e2834.local).",
+      "connection_type": "network",
+      "radio_type": "pymc_tcp",
+      "tx_power": 22,
+      "preamble_length": 16
+    },
+    "kiss": {
+      "name": "KISS modem (serial)",
+      "description": "MeshCore KISS modem over serial - requires pyMC_core with KISS support.",
+      "connection_type": "usb",
+      "radio_type": "kiss",
+      "tx_power": 14,
+      "preamble_length": 17
     }
   }
 }

repeater/config.py

@@ -2,13 +2,47 @@
 import logging
 import os
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, overload
 
 import yaml
 
 logger = logging.getLogger("Config")
 
 
+class NullRadio:
+    """No-op radio used when radio_type disables hardware initialization."""
+
+    def __init__(self):
+        self._rx_callback = None
+
+    def begin(self):
+        return True
+
+    async def send(self, data: bytes):
+        raise RuntimeError("Radio is disabled (radio_type is null/none)")
+
+    async def wait_for_rx(self) -> bytes:
+        import asyncio
+
+        while True:
+            await asyncio.sleep(3600)
+
+    def sleep(self):
+        return None
+
+    def get_last_rssi(self) -> int:
+        return 0
+
+    def get_last_snr(self) -> float:
+        return 0.0
+
+    def set_rx_callback(self, callback):
+        self._rx_callback = callback
+
+    def check_radio_health(self):
+        return True
+
+
 def resolve_storage_dir(
     config: Dict[str, Any],
     *,
@@ -299,7 +333,13 @@ def _load_or_create_identity_key(path: Optional[str] = None) -> bytes:
 
 def get_radio_for_board(board_config: dict):
 
-    def _parse_int(value, *, default=None) -> int:
+    @overload
+    def _parse_int(value, *, default: None = None) -> Optional[int]: ...
+
+    @overload
+    def _parse_int(value, *, default: int) -> int: ...
+
+    def _parse_int(value, *, default=None):
         if value is None:
             return default
         if isinstance(value, int):
@@ -322,7 +362,16 @@ def _parse_int_list(value):
             return [_parse_int(item) for item in stripped.split(",") if item.strip()]
         raise ValueError(f"Invalid int list value type: {type(value)}")
 
-    radio_type = board_config.get("radio_type", "sx1262").lower().strip()
+    radio_type_raw = board_config.get("radio_type")
+    if radio_type_raw is None:
+        radio_type = "none"
+    else:
+        radio_type = str(radio_type_raw).lower().strip()
+
+    if radio_type in ("", "none", "null", "disabled", "off", "no_radio"):
+        logger.warning("Radio disabled by configuration (radio_type=%r)", radio_type_raw)
+        return NullRadio()
+
     if radio_type == "kiss-modem":
         radio_type = "kiss"
 
@@ -483,7 +532,7 @@ def _parse_int_list(value):
             spreading_factor=int(radio_cfg.get("spreading_factor", 8)),
             coding_rate=int(radio_cfg.get("coding_rate", 8)),
             tx_power=int(radio_cfg.get("tx_power", 22)),
-            sync_word=_parse_int(radio_cfg.get("sync_word", 0x12)),
+            sync_word=_parse_int(radio_cfg.get("sync_word", 0x12), default=0x12),
             preamble_length=int(radio_cfg.get("preamble_length", 16)),
             lbt_enabled=bool(tcp_cfg.get("lbt_enabled", True)),
             lbt_max_attempts=int(tcp_cfg.get("lbt_max_attempts", 5)),
@@ -527,7 +576,7 @@ def _parse_int_list(value):
             spreading_factor=int(radio_cfg.get("spreading_factor", 8)),
             coding_rate=int(radio_cfg.get("coding_rate", 8)),
             tx_power=int(radio_cfg.get("tx_power", 22)),
-            sync_word=_parse_int(radio_cfg.get("sync_word", 0x12)),
+            sync_word=_parse_int(radio_cfg.get("sync_word", 0x12), default=0x12),
             preamble_length=int(radio_cfg.get("preamble_length", 16)),
             lbt_enabled=bool(usb_cfg.get("lbt_enabled", True)),
             lbt_max_attempts=int(usb_cfg.get("lbt_max_attempts", 5)),

repeater/main.py

@@ -8,7 +8,7 @@
 import time
 
 from repeater.companion.utils import validate_companion_node_name, normalize_companion_identity_key
-from repeater.config import get_radio_for_board, load_config, save_config
+from repeater.config import NullRadio, get_radio_for_board, load_config, save_config
 from repeater.config_manager import ConfigManager
 from repeater.data_acquisition.glass_handler import GlassHandler
 from repeater.data_acquisition.gps_service import GPSService
@@ -59,6 +59,8 @@ def __init__(self, config: dict, radio=None):
         self.companion_frame_servers: list = []
         self._shutdown_started = False
         self._main_task = None
+        self.radio_status = "unknown"
+        self.radio_error = None
 
         log_level = config.get("logging", {}).get("level", "INFO")
         logging.basicConfig(
@@ -97,11 +99,34 @@ async def initialize(self):
         #-----------------------------------------------
 
         if self.radio is None:
-            radio_type = self.config.get("radio_type", "sx1262")
+            radio_type_raw = self.config.get("radio_type")
+            radio_type = "none" if radio_type_raw is None else str(radio_type_raw)
+            radio_type_lower = radio_type.lower().strip()
+            radio_explicitly_disabled = radio_type_lower in (
+                "",
+                "none",
+                "null",
+                "disabled",
+                "off",
+                "no_radio",
+            )
             logger.info(f"Initializing radio hardware... (radio_type={radio_type})")
             try:
                 self.radio = get_radio_for_board(self.config)
 
+                if isinstance(self.radio, NullRadio):
+                    self.radio_status = "disabled" if radio_explicitly_disabled else "degraded"
+                    if self.radio_status == "disabled":
+                        self.radio_error = None
+                    else:
+                        self.radio_error = (
+                            self.radio_error
+                            or f"Radio type '{radio_type}' unavailable; running in no-radio mode"
+                        )
+                else:
+                    self.radio_status = "ok"
+                    self.radio_error = None
+
                 # KISS modem: schedule RX callbacks on the event loop for thread safety
                 if hasattr(self.radio, "set_event_loop"):
                     self.radio.set_event_loop(asyncio.get_running_loop())
@@ -133,7 +158,14 @@ async def initialize(self):
                 logger.info("Radio hardware initialized")
             except Exception as e:
                 logger.error(f"Failed to initialize radio hardware: {e}")
-                raise RuntimeError("Repeater requires real LoRa hardware") from e
+                self.radio_status = "degraded"
+                self.radio_error = str(e)
+                logger.warning(
+                    "Radio type '%s' unavailable; starting in no-radio mode to keep service alive. "
+                    "Check radio configuration and hardware mapping.",
+                    radio_type,
+                )
+                self.radio = NullRadio()
 
         try:
             from pymc_core import LocalIdentity
@@ -944,6 +976,10 @@ def get_stats(self) -> dict:
         if self.sensor_manager:
             stats["sensors"] = self.sensor_manager.get_summary()
 
+        stats["radio_status"] = self.radio_status
+        if self.radio_error:
+            stats["radio_error"] = self.radio_error
+
         return stats
 
     async def _get_companion_stats(self, stats_type: int) -> dict:
@@ -1200,7 +1236,9 @@ async def _shutdown(self):
 
         # Release CH341 USB device if in use
         try:
-            if self.config.get("radio_type", "sx1262").lower() == "sx1262_ch341":
+            radio_type_raw = self.config.get("radio_type")
+            radio_type = "" if radio_type_raw is None else str(radio_type_raw).lower()
+            if radio_type == "sx1262_ch341":
                 from pymc_core.hardware.ch341.ch341_async import CH341Async
 
                 CH341Async.reset_instance()

repeater/web/api_endpoints.py

@@ -317,13 +317,18 @@ def needs_setup(self):
             )
             has_default_password = admin_password in ["admin123", ""]
 
-            needs_setup = has_default_name or has_default_password
+            radio_type_raw = config.get("radio_type")
+            radio_type = "" if radio_type_raw is None else str(radio_type_raw).lower().strip()
+            radio_not_configured = radio_type in ("", "none", "null", "disabled", "off", "no_radio")
+
+            needs_setup = has_default_name or has_default_password or radio_not_configured
 
             return {
                 "needs_setup": needs_setup,
                 "reasons": {
                     "default_name": has_default_name,
                     "default_password": has_default_password,
+                    "radio_not_configured": radio_not_configured,
                 },
             }
         except Exception as e:
@@ -360,16 +365,6 @@ def hardware_options(self):
                             }
                         )
 
-            # Add MeshCore KISS modem option (serial TNC)
-            hardware_list.append(
-                {
-                    "key": "kiss",
-                    "name": "KISS modem (serial)",
-                    "description": "MeshCore KISS modem over serial – requires pyMC_core with KISS support",
-                    "config": {},
-                }
-            )
-
             return {"hardware": hardware_list}
         except Exception as e:
             logger.error(f"Error loading hardware options: {e}")
@@ -491,6 +486,49 @@ def setup_wizard(self):
                 config_yaml["radio"]["tx_power"] = int(radio_preset.get("tx_power", 14))
                 if "preamble_length" not in config_yaml["radio"]:
                     config_yaml["radio"]["preamble_length"] = 17
+            elif hardware_key == "pymc_usb":
+                # pymc_usb modem: external SX1262 board over USB-CDC.
+                # Accept pymc_usb_port / pymc_usb_baudrate from the request body
+                # (mirrors the KISS pattern) so a future SPA can expose inputs;
+                # fall back to /dev/ttyACM0 at 921600 baud, which matches the
+                # firmware default and the typical USB-CDC modem device on Linux.
+                config_yaml["radio_type"] = "pymc_usb"
+                usb_port = (data.get("pymc_usb_port") or "").strip() or "/dev/ttyACM0"
+                usb_baud = int(data.get("pymc_usb_baudrate", data.get("pymc_usb_baud", 921600)))
+                pymc_usb_section = config_yaml.setdefault("pymc_usb", {})
+                pymc_usb_section["port"] = usb_port
+                pymc_usb_section["baudrate"] = usb_baud
+                pymc_usb_section.setdefault("lbt_enabled", True)
+                pymc_usb_section.setdefault("lbt_max_attempts", 5)
+                if "tx_power" in hw_config:
+                    config_yaml["radio"]["tx_power"] = hw_config.get("tx_power", 22)
+                if "preamble_length" in hw_config:
+                    config_yaml["radio"]["preamble_length"] = hw_config.get("preamble_length", 16)
+            elif hardware_key == "pymc_tcp":
+                # pymc_tcp modem: external SX1262 board exposed as TCP over Wi-Fi/Ethernet.
+                # 'host' has no sensible default — must be the modem's LAN address or
+                # mDNS name. Accept it from the request body if the SPA provides it,
+                # otherwise write a clearly-placeholder hostname so the file is valid
+                # YAML and the user gets a startup error pointing them at the right
+                # section to edit (see config.py: ValueError 'Missing host …').
+                config_yaml["radio_type"] = "pymc_tcp"
+                tcp_host = (data.get("pymc_tcp_host") or "").strip() or "REPLACE_WITH_MODEM_HOST"
+                tcp_port = int(data.get("pymc_tcp_port", 5055))
+                pymc_tcp_section = config_yaml.setdefault("pymc_tcp", {})
+                pymc_tcp_section["host"] = tcp_host
+                pymc_tcp_section["port"] = tcp_port
+                tcp_token = data.get("pymc_tcp_token")
+                if tcp_token is not None:
+                    pymc_tcp_section["token"] = str(tcp_token)
+                else:
+                    pymc_tcp_section.setdefault("token", "")
+                pymc_tcp_section.setdefault("connect_timeout", 5.0)
+                pymc_tcp_section.setdefault("lbt_enabled", True)
+                pymc_tcp_section.setdefault("lbt_max_attempts", 5)
+                if "tx_power" in hw_config:
+                    config_yaml["radio"]["tx_power"] = hw_config.get("tx_power", 22)
+                if "preamble_length" in hw_config:
+                    config_yaml["radio"]["preamble_length"] = hw_config.get("preamble_length", 16)
             else:
                 # SX1262 / sx1262_ch341: radio_type and optional CH341 from hw_config
                 if "radio_type" in hw_config:
@@ -577,7 +615,7 @@ def delayed_restart():
             result_config = {
                 "node_name": node_name,
                 "hardware": hardware_key,
-                "radio_type": config_yaml.get("radio_type", "sx1262"),
+                "radio_type": config_yaml.get("radio_type"),
                 "frequency": freq_mhz,
                 "spreading_factor": radio_preset.get("spreading_factor"),
                 "bandwidth": radio_preset.get("bandwidth"),
@@ -586,6 +624,15 @@ def delayed_restart():
             if hardware_key == "kiss":
                 result_config["kiss_port"] = config_yaml.get("kiss", {}).get("port")
                 result_config["kiss_baud_rate"] = config_yaml.get("kiss", {}).get("baud_rate")
+            elif hardware_key == "pymc_usb":
+                pymc_usb_cfg = config_yaml.get("pymc_usb", {})
+                result_config["pymc_usb_port"] = pymc_usb_cfg.get("port")
+                result_config["pymc_usb_baudrate"] = pymc_usb_cfg.get("baudrate")
+            elif hardware_key == "pymc_tcp":
+                pymc_tcp_cfg = config_yaml.get("pymc_tcp", {})
+                result_config["pymc_tcp_host"] = pymc_tcp_cfg.get("host")
+                result_config["pymc_tcp_port"] = pymc_tcp_cfg.get("port")
+                # token deliberately omitted from response (sensitive)
             return {
                 "success": True,
                 "message": "Setup completed successfully. Service is restarting...",