dmshell reliability tweaks

Co-authored-by: jp-bennett <5630967+jp-bennett@users.noreply.github.com>

.devcontainer/devcontainer.json

@@ -8,7 +8,7 @@
   "features": {
     "ghcr.io/devcontainers/features/python:1": {
       "installTools": true,
-      "version": "3.13"
+      "version": "3.14"
     }
   },
   "customizations": {

.github/copilot-instructions.md

@@ -575,8 +575,6 @@ Grouped by purpose. Full argument shapes in `mcp-server/README.md`; a few high-v
 
 `confirm=True` is a tool-level gate on top of whatever permission prompt your MCP host shows. **Don't bypass it** by asking the host to auto-approve — it exists specifically because MCP hosts sometimes remember "always allow this tool" and that's dangerous for `factory_reset`, `erase_and_flash`, `uhubctl_power(action='off')`, and `uhubctl_cycle`.
 
-**TCP / native-host nodes.** Setting `MESHTASTIC_MCP_TCP_HOST=<host[:port]>` makes `list_devices` surface a `meshtasticd` daemon (e.g. the `native-macos` build) as a synthetic `tcp://host:port` entry, and `connect()` routes through `meshtastic.tcp_interface.TCPInterface` instead of `SerialInterface`. Every read/write/admin tool that flows through `connect()` works against the daemon transparently. USB-only tools (`pio_flash`, `erase_and_flash`, `update_flash`, `touch_1200bps`, `serial_open`, `esptool_*`, `nrfutil_*`, `picotool_*`) raise a clear `ConnectionError` when handed a `tcp://` port; `pio_flash` against a `native*` env raises a `FlashError` (no upload step — use `build` and run the binary directly). The pytest harness still assumes USB-attached devices per role; TCP-aware fixtures are deferred. See `mcp-server/README.md` § "TCP / native-host nodes".
-
 ### Hardware test suite (`mcp-server/run-tests.sh`)
 
 The wrapper auto-detects connected devices (VID → role map: `0x239A` → `nrf52`, `0x303A`/`0x10C4` → `esp32s3`), maps each role to a PlatformIO env (`nrf52` → `rak4631`, `esp32s3` → `heltec-v3`, overridable via `MESHTASTIC_MCP_ENV_<ROLE>`), then invokes pytest. Zero pre-flight config needed from the operator.

.github/workflows/build_debian_src.yml

@@ -32,15 +32,10 @@ jobs:
         shell: bash
         working-directory: meshtasticd
         run: |
-          # Build-tools (notably platformio) come from the Meshtastic project
-          # on the OpenSUSE Build Service:
-          # https://build.opensuse.org/project/show/network:Meshtastic:build-tools
-          echo 'deb http://download.opensuse.org/repositories/network:/Meshtastic:/build-tools/xUbuntu_24.04/ /' \
-            | sudo tee /etc/apt/sources.list.d/network:Meshtastic:build-tools.list
-          curl -fsSL https://download.opensuse.org/repositories/network:Meshtastic:build-tools/xUbuntu_24.04/Release.key \
-            | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/network_Meshtastic_build-tools.gpg >/dev/null
           sudo apt-get update -y --fix-missing
-          sudo apt-get install -y build-essential devscripts equivs
+          sudo apt-get install -y software-properties-common build-essential devscripts equivs
+          sudo add-apt-repository ppa:meshtastic/build-tools -y
+          sudo apt-get update -y --fix-missing
           sudo mk-build-deps --install --remove --tool='apt-get -o Debug::pkgProblemResolver=yes --no-install-recommends --yes' debian/control
 
       - name: Import GPG key

.github/workflows/build_macos_bin.yml

@@ -24,7 +24,7 @@ jobs:
         shell: bash
         run: |
           brew update
-          brew install platformio yaml-cpp libuv openssl@3 libusb argp-standalone pkg-config ulfius
+          brew install platformio yaml-cpp libuv openssl@3 libusb argp-standalone pkg-config
 
       - name: Get release version string
         run: |

.trunk/trunk.yaml

@@ -8,7 +8,7 @@ plugins:
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.526
+    - checkov@3.2.525
     - renovate@43.150.0
     - prettier@3.8.3
     - trufflehog@3.95.2

.vscode/extensions.json

@@ -1,10 +1,10 @@
 {
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
     "recommendations": [
-        "Jason2866.esp-decoder",
-        "pioarduino.pioarduino-ide"
+        "platformio.platformio-ide"
     ],
     "unwantedRecommendations": [
-        "ms-vscode.cpptools-extension-pack",
-        "platformio.platformio-ide"
+        "ms-vscode.cpptools-extension-pack"
     ]
 }

AGENTS.md

@@ -126,17 +126,16 @@ Sequence these; don't parallelize on the same port.
 
 ## Environment variables (test harness)
 
-| Var                                  | Purpose                                                                                                                                                                                                    |
-| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `MESHTASTIC_MCP_ENV_<ROLE>`          | Override PlatformIO env for a role (e.g. `MESHTASTIC_MCP_ENV_NRF52=rak4631-dap`). Default map: `nrf52→rak4631`, `esp32s3→heltec-v3`.                                                                       |
-| `MESHTASTIC_MCP_SEED`                | PSK seed for the session test profile. Defaults to `mcp-<user>-<host>`.                                                                                                                                    |
-| `MESHTASTIC_MCP_FLASH_LOG`           | File path to tee pio/esptool/nrfutil/picotool output. `run-tests.sh` sets this to `tests/flash.log` so the TUI can stream live flash progress.                                                             |
-| `MESHTASTIC_MCP_TCP_HOST`            | `host` or `host:port` of a `meshtasticd` daemon (e.g. the `native-macos` build). Surfaces it in `list_devices` as `tcp://host:port` so `connect()`-based tools target it transparently. Default port 4403. |
-| `MESHTASTIC_UHUBCTL_BIN`             | Absolute path to `uhubctl` binary. Default: PATH lookup.                                                                                                                                                   |
-| `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` | Pin a role to a specific uhubctl hub location (e.g. `1-1.3`). Wins over VID auto-detection — use when multiple devices share a VID.                                                                        |
-| `MESHTASTIC_UHUBCTL_PORT_<ROLE>`     | Pin a role to a specific hub port number. Required alongside `LOCATION_<ROLE>`.                                                                                                                            |
-| `MESHTASTIC_UI_CAMERA_BACKEND`       | Camera backend for UI tier + `capture_screen` tool: `opencv` / `ffmpeg` / `null` / `auto` (default).                                                                                                       |
-| `MESHTASTIC_UI_CAMERA_DEVICE`        | Generic camera device (index or path). Used by the UI tier when no per-role var is set.                                                                                                                    |
-| `MESHTASTIC_UI_CAMERA_DEVICE_<ROLE>` | Per-role camera pinning (e.g. `MESHTASTIC_UI_CAMERA_DEVICE_ESP32S3=0` for the OLED-bearing heltec-v3).                                                                                                     |
-| `MESHTASTIC_UI_OCR_BACKEND`          | OCR engine selection: `easyocr` / `pytesseract` / `null` / `auto` (default).                                                                                                                               |
-| `MESHTASTIC_UI_TUI_CAMERA`           | Set to `1` to mount the live camera-feed panel in `meshtastic-mcp-test-tui`.                                                                                                                               |
+| Var                                  | Purpose                                                                                                                                        |
+| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MESHTASTIC_MCP_ENV_<ROLE>`          | Override PlatformIO env for a role (e.g. `MESHTASTIC_MCP_ENV_NRF52=rak4631-dap`). Default map: `nrf52→rak4631`, `esp32s3→heltec-v3`.           |
+| `MESHTASTIC_MCP_SEED`                | PSK seed for the session test profile. Defaults to `mcp-<user>-<host>`.                                                                        |
+| `MESHTASTIC_MCP_FLASH_LOG`           | File path to tee pio/esptool/nrfutil/picotool output. `run-tests.sh` sets this to `tests/flash.log` so the TUI can stream live flash progress. |
+| `MESHTASTIC_UHUBCTL_BIN`             | Absolute path to `uhubctl` binary. Default: PATH lookup.                                                                                       |
+| `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` | Pin a role to a specific uhubctl hub location (e.g. `1-1.3`). Wins over VID auto-detection — use when multiple devices share a VID.            |
+| `MESHTASTIC_UHUBCTL_PORT_<ROLE>`     | Pin a role to a specific hub port number. Required alongside `LOCATION_<ROLE>`.                                                                |
+| `MESHTASTIC_UI_CAMERA_BACKEND`       | Camera backend for UI tier + `capture_screen` tool: `opencv` / `ffmpeg` / `null` / `auto` (default).                                           |
+| `MESHTASTIC_UI_CAMERA_DEVICE`        | Generic camera device (index or path). Used by the UI tier when no per-role var is set.                                                        |
+| `MESHTASTIC_UI_CAMERA_DEVICE_<ROLE>` | Per-role camera pinning (e.g. `MESHTASTIC_UI_CAMERA_DEVICE_ESP32S3=0` for the OLED-bearing heltec-v3).                                         |
+| `MESHTASTIC_UI_OCR_BACKEND`          | OCR engine selection: `easyocr` / `pytesseract` / `null` / `auto` (default).                                                                   |
+| `MESHTASTIC_UI_TUI_CAMERA`           | Set to `1` to mount the live camera-feed panel in `meshtastic-mcp-test-tui`.                                                                   |

Dockerfile

@@ -3,17 +3,15 @@
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
-FROM debian:trixie AS builder
+FROM python:3.14-slim-trixie AS builder
 ARG PIO_ENV=native
 ENV DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC
 
 # Install Dependencies
 ENV PIP_ROOT_USER_ACTION=ignore
-ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apt-get update && apt-get install --no-install-recommends -y \
         curl wget g++ zip git ca-certificates pkg-config \
-        python3-pip python3-grpc-tools \
         libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
         libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \

alpine.Dockerfile

@@ -4,18 +4,12 @@
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
 # Ensure the Alpine version is updated in both stages of the container!
-FROM alpine:3.23 AS builder
+FROM python:3.14-alpine3.23 AS builder
 ARG PIO_ENV=native
-
-# Enable Alpine community repository (for 'py3-grpcio-tools')
-RUN echo "https://dl-cdn.alpinelinux.org/alpine/v$(cut -d. -f1,2 /etc/alpine-release)/community" >> /etc/apk/repositories
-
-# Install Dependencies
 ENV PIP_ROOT_USER_ACTION=ignore
-ENV PIP_BREAK_SYSTEM_PACKAGES=1
+
 RUN apk --no-cache add \
         bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
-        py3-pip py3-grpcio-tools \
         libgpiod-dev yaml-cpp-dev bluez-dev \
         libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
         libx11-dev libinput-dev libxkbcommon-dev sqlite-dev sdl2-dev \

bin/build-esp32.sh

@@ -38,4 +38,4 @@ cp bin/device-install.* $OUTDIR/
 cp bin/device-update.* $OUTDIR/
 
 echo "Copying manifest"
-cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json
+cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true

bin/dmshell_client.py

@@ -0,0 +1,941 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import queue
+import random
+import shutil
+import socket
+import select
+import subprocess
+import sys
+import tempfile
+import termios
+import threading
+import time
+import tty
+from collections import deque
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, TextIO
+
+
+START1 = 0x94
+START2 = 0xC3
+HEADER_LEN = 4
+DEFAULT_API_PORT = 4403
+DEFAULT_HOP_LIMIT = 0
+LOCAL_ESCAPE_BYTE = b"\x1d"  # Ctrl+]
+MISSING_SEQ_RETRY_INTERVAL_SEC = 1.0
+INPUT_BATCH_WINDOW_SEC = .5
+INPUT_BATCH_MAX_BYTES = 64
+HEARTBEAT_IDLE_DELAY_SEC = 5.0
+HEARTBEAT_REPEAT_SEC = 15.0
+HEARTBEAT_POLL_INTERVAL_SEC = 0.25
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Tiny DMShell client for Meshtastic native TCP API",
+        epilog=(
+            "Examples:\n"
+            "  bin/dmshell_client.py --to !170896f7\n"
+            "  bin/dmshell_client.py --to 0x170896f7 --command 'uname -a' --command 'id'"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--host", default="127.0.0.1", help="meshtasticd API host")
+    parser.add_argument("--port", type=int, default=DEFAULT_API_PORT, help="meshtasticd API port")
+    parser.add_argument(
+        "--serial",
+        nargs="?",
+        const="auto",
+        default=None,
+        help="use USB serial transport (optionally provide device path, default: auto-detect)",
+    )
+    parser.add_argument("--baud", type=int, default=115200, help="serial baud rate when using --serial")
+    parser.add_argument("--to", required=True, help="destination node number, e.g. !170896f7 or 0x170896f7")
+    parser.add_argument("--channel", type=int, default=0, help="channel index to use")
+    parser.add_argument("--cols", type=int, default=None, help="initial terminal columns (default: detect local terminal)")
+    parser.add_argument("--rows", type=int, default=None, help="initial terminal rows (default: detect local terminal)")
+    parser.add_argument("--command", action="append", default=[], help="send a command line after opening")
+    parser.add_argument("--close-after", type=float, default=2.0, help="seconds to wait before closing in command mode")
+    parser.add_argument("--timeout", type=float, default=10.0, help="seconds to wait for API/session events")
+    parser.add_argument("--verbose", action="store_true", help="print extra protocol events")
+    return parser.parse_args()
+
+
+def repo_root() -> Path:
+    return Path(__file__).resolve().parent.parent
+
+
+def load_proto_modules() -> object:
+    try:
+        import google.protobuf  # noqa: F401
+    except ImportError as exc:
+        raise SystemExit("python package 'protobuf' is required to run this client") from exc
+
+    protoc = shutil.which("protoc")
+    if not protoc:
+        raise SystemExit("'protoc' is required to generate temporary Python protobuf bindings")
+
+    out_dir = Path(tempfile.mkdtemp(prefix="meshtastic_dmshell_proto_"))
+    proto_dir = repo_root() / "protobufs"
+    
+    # Compile all required protos for DMShell client (mesh and dependencies)
+    # Excludes nanopb.proto and other complex build artifacts
+    required_protos = [
+        "mesh.proto",
+        "channel.proto", 
+        "config.proto",
+        "device_ui.proto",
+        "module_config.proto",
+        "atak.proto",
+        "portnums.proto",
+        "telemetry.proto",
+        "xmodem.proto",
+    ]
+    proto_files = [proto_dir / "meshtastic" / name for name in required_protos]
+    for pf in proto_files:
+        if not pf.exists():
+            raise SystemExit(f"could not find required proto file: {pf}")
+
+    # Create __init__.py to make meshtastic a package
+    (out_dir / "meshtastic").mkdir(exist_ok=True)
+    (out_dir / "meshtastic" / "__init__.py").touch()
+
+    # Build protoc command with just the meshtastic proto directory as include path
+    # protoc will use its built-in includes for standard google protobuf types
+    cmd = [protoc, f"-I{proto_dir}", f"--python_out={out_dir}", *[str(path) for path in proto_files]]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"protoc stderr: {result.stderr}", file=sys.stderr)
+        print(f"protoc stdout: {result.stdout}", file=sys.stderr)
+        print(f"protoc command: {' '.join(cmd)}", file=sys.stderr)
+        raise SystemExit(f"protoc failed with return code {result.returncode}")
+
+    # Create _pb2_grpc module stub if not present (protoc 3.20+)
+    mesh_pb2_file = out_dir / "meshtastic" / "mesh_pb2.py"
+    if not mesh_pb2_file.exists():
+        raise SystemExit(f"protoc did not generate mesh_pb2.py in {out_dir / 'meshtastic'}")
+
+    sys.path.insert(0, str(out_dir))
+    try:
+        from meshtastic import mesh_pb2, portnums_pb2  # type: ignore
+    except ImportError as exc:
+        print(f"Failed to import protobuf modules. Output dir contents:", file=sys.stderr)
+        for item in (out_dir / "meshtastic").iterdir():
+            print(f"  {item.name}", file=sys.stderr)
+        raise SystemExit(f"could not import meshtastic proto modules: {exc}") from exc
+
+    # Return an object that has both modules accessible
+    class ProtoModules:
+        pass
+    
+    pb2 = ProtoModules()
+    pb2.mesh = mesh_pb2
+    pb2.portnums = portnums_pb2
+    return pb2
+
+
+def parse_node_num(raw: str) -> int:
+    value = raw.strip()
+    if value.startswith("!"):
+        value = value[1:]
+    if value.lower().startswith("0x"):
+        return int(value, 16)
+    if any(ch in "abcdefABCDEF" for ch in value):
+        return int(value, 16)
+    return int(value, 10)
+
+
+class SerialTransport:
+    def __init__(self, serial_obj):
+        self._serial = serial_obj
+
+    def recv(self, length: int) -> bytes:
+        return self._serial.read(length)
+
+    def sendall(self, data: bytes) -> None:
+        self._serial.write(data)
+        self._serial.flush()
+
+    def close(self) -> None:
+        self._serial.close()
+
+
+def detect_meshtastic_serial_port() -> str:
+    try:
+        from serial.tools import list_ports
+    except ImportError as exc:
+        raise SystemExit("python package 'pyserial' is required for --serial mode") from exc
+
+    ports = list(list_ports.comports())
+    if not ports:
+        raise SystemExit("no serial ports found for --serial mode")
+
+    scored: list[tuple[int, str]] = []
+    for port in ports:
+        text = " ".join(
+            filter(
+                None,
+                [port.device, port.description, port.manufacturer, port.product, port.hwid],
+            )
+        ).lower()
+        score = 0
+        if "meshtastic" in text:
+            score += 100
+        if "lora" in text or "mesh" in text:
+            score += 10
+        if "ttyacm" in (port.device or "").lower() or "ttyusb" in (port.device or "").lower():
+            score += 1
+        scored.append((score, port.device))
+
+    scored.sort(reverse=True)
+    best_score, best_device = scored[0]
+    if best_score <= 0 and len(scored) > 1:
+        raise SystemExit(
+            "could not confidently auto-detect a Meshtastic serial port; pass --serial /dev/ttyXXX explicitly"
+        )
+    return best_device
+
+
+def open_transport(args: argparse.Namespace):
+    if args.serial is None:
+        sock = socket.create_connection((args.host, args.port), timeout=args.timeout)
+        sock.settimeout(None)
+        return sock
+
+    serial_path = args.serial
+    if serial_path == "auto":
+        serial_path = detect_meshtastic_serial_port()
+        print(f"[dmshell] using serial port {serial_path}", file=sys.stderr)
+
+    try:
+        import serial
+    except ImportError as exc:
+        raise SystemExit("python package 'pyserial' is required for --serial mode") from exc
+
+    try:
+        serial_obj = serial.Serial(serial_path, baudrate=args.baud, timeout=None, write_timeout=2)
+    except Exception as exc:
+        raise SystemExit(f"failed to open serial device {serial_path}: {exc}") from exc
+
+    return SerialTransport(serial_obj)
+
+
+def recv_exact(transport, length: int) -> bytes:
+    chunks = bytearray()
+    while len(chunks) < length:
+        piece = transport.recv(length - len(chunks))
+        if not piece:
+            raise ConnectionError("connection closed by transport")
+        chunks.extend(piece)
+    return bytes(chunks)
+
+
+def detect_local_terminal_size() -> tuple[int, int]:
+    size = shutil.get_terminal_size(fallback=(100, 40))
+    cols = max(1, int(size.columns))
+    rows = max(1, int(size.lines))
+    return cols, rows
+
+
+def resolve_initial_terminal_size(cols_override: Optional[int], rows_override: Optional[int]) -> tuple[int, int]:
+    detected_cols, detected_rows = detect_local_terminal_size()
+    cols = detected_cols if cols_override is None else max(1, cols_override)
+    rows = detected_rows if rows_override is None else max(1, rows_override)
+    return cols, rows
+
+
+def recv_stream_frame(transport) -> bytes:
+    while True:
+        start = recv_exact(transport, 1)[0]
+        if start != START1:
+            continue
+        if recv_exact(transport, 1)[0] != START2:
+            continue
+        header = recv_exact(transport, 2)
+        length = (header[0] << 8) | header[1]
+        return recv_exact(transport, length)
+
+
+def send_stream_frame(transport, payload: bytes) -> None:
+    if len(payload) > 0xFFFF:
+        raise ValueError("payload too large for stream API")
+    header = bytes((START1, START2, (len(payload) >> 8) & 0xFF, len(payload) & 0xFF))
+    transport.sendall(header + payload)
+
+
+@dataclass
+class SentShellFrame:
+    op: int
+    session_id: int
+    seq: int
+    ack_seq: int
+    payload: bytes = b""
+    cols: int = 0
+    rows: int = 0
+    flags: int = 0
+    last_tx_seq: int = 0
+    last_rx_seq: int = 0
+
+
+@dataclass
+class SessionState:
+    pb2: object  # ProtoModules with mesh and portnums attributes
+    target: int
+    channel: int
+    verbose: bool
+    session_id: int = field(default_factory=lambda: random.randint(1, 0x7FFFFFFF))
+    next_seq: int = 1
+    last_rx_seq: int = 0
+    next_expected_rx_seq: int = 1
+    highest_seen_rx_seq: int = 0
+    active: bool = False
+    stopped: bool = False
+    opened_event: threading.Event = field(default_factory=threading.Event)
+    closed_event: threading.Event = field(default_factory=threading.Event)
+    event_queue: "queue.Queue[str]" = field(default_factory=queue.Queue)
+    tx_lock: threading.Lock = field(default_factory=threading.Lock)
+    socket_lock: threading.Lock = field(default_factory=threading.Lock)
+    tx_history: deque[SentShellFrame] = field(default_factory=lambda: deque(maxlen=50))
+    pending_rx_frames: dict[int, object] = field(default_factory=dict)
+    last_requested_missing_seq: int = 0
+    last_missing_request_time: float = 0.0
+    requested_missing_seqs: set[int] = field(default_factory=set)
+    replay_log_lock: threading.Lock = field(default_factory=threading.Lock)
+    replay_log_file: Optional[TextIO] = None
+    replay_log_path: Optional[Path] = None
+    last_transport_activity_time: float = field(default_factory=time.monotonic)
+    last_heartbeat_sent_time: float = 0.0
+
+    def alloc_seq(self) -> int:
+        with self.tx_lock:
+            value = self.next_seq
+            self.next_seq += 1
+            return value
+
+    def current_ack_seq(self) -> int:
+        with self.tx_lock:
+            return self.last_rx_seq
+
+    def highest_sent_seq(self) -> int:
+        with self.tx_lock:
+            return max(0, self.next_seq - 1)
+
+    def note_outbound_packet(self, heartbeat: bool = False) -> None:
+        with self.tx_lock:
+            now = time.monotonic()
+            if heartbeat:
+                self.last_heartbeat_sent_time = now
+            else:
+                self.last_transport_activity_time = now
+
+    def note_inbound_packet(self) -> None:
+        with self.tx_lock:
+            self.last_transport_activity_time = time.monotonic()
+
+    def heartbeat_due(self) -> bool:
+        with self.tx_lock:
+            now = time.monotonic()
+            if (now - self.last_transport_activity_time) < HEARTBEAT_IDLE_DELAY_SEC:
+                return False
+            if self.last_heartbeat_sent_time <= self.last_transport_activity_time:
+                return True
+            return (now - self.last_heartbeat_sent_time) >= HEARTBEAT_REPEAT_SEC
+
+    def note_peer_reported_tx_seq(self, seq: int) -> None:
+        with self.tx_lock:
+            if seq > self.highest_seen_rx_seq:
+                self.highest_seen_rx_seq = seq
+
+    def note_received_seq(self, seq: int) -> tuple[str, Optional[int]]:
+        with self.tx_lock:
+            if seq == 0:
+                return ("process", None)
+            if seq < self.next_expected_rx_seq:
+                if self.highest_seen_rx_seq >= self.next_expected_rx_seq:
+                    return ("gap", self.next_expected_rx_seq)
+                return ("duplicate", None)
+            if seq > self.next_expected_rx_seq:
+                if seq > self.highest_seen_rx_seq:
+                    self.highest_seen_rx_seq = seq
+                return ("gap", self.next_expected_rx_seq)
+            self.last_rx_seq = seq
+            self.next_expected_rx_seq = seq + 1
+            if self.last_requested_missing_seq != 0 and self.next_expected_rx_seq > self.last_requested_missing_seq:
+                self.last_requested_missing_seq = 0
+            if seq > self.highest_seen_rx_seq:
+                self.highest_seen_rx_seq = seq
+            if self.highest_seen_rx_seq < self.next_expected_rx_seq:
+                self.highest_seen_rx_seq = 0
+            return ("process", None)
+
+    def remember_out_of_order_frame(self, shell) -> None:
+        with self.tx_lock:
+            if shell.seq <= self.next_expected_rx_seq:
+                return
+            if shell.seq not in self.pending_rx_frames:
+                self.pending_rx_frames[shell.seq] = shell
+            if shell.seq > self.highest_seen_rx_seq:
+                self.highest_seen_rx_seq = shell.seq
+
+    def pop_next_buffered_frame(self):
+        with self.tx_lock:
+            return self.pending_rx_frames.pop(self.next_expected_rx_seq, None)
+
+    def pending_missing_seq(self) -> Optional[int]:
+        with self.tx_lock:
+            if self.highest_seen_rx_seq >= self.next_expected_rx_seq:
+                return self.next_expected_rx_seq
+            return None
+
+    def request_missing_seq_once(self) -> Optional[int]:
+        with self.tx_lock:
+            if self.highest_seen_rx_seq < self.next_expected_rx_seq:
+                return None
+            now = time.monotonic()
+            if (
+                self.last_requested_missing_seq == self.next_expected_rx_seq
+                and (now - self.last_missing_request_time) < MISSING_SEQ_RETRY_INTERVAL_SEC
+            ):
+                return None
+            self.last_requested_missing_seq = self.next_expected_rx_seq
+            self.last_missing_request_time = now
+            return self.last_requested_missing_seq
+
+    def set_receive_cursor(self, seq: int) -> None:
+        with self.tx_lock:
+            self.last_rx_seq = seq
+            self.next_expected_rx_seq = seq + 1
+            self.highest_seen_rx_seq = seq
+
+    def open_replay_log(self, session_id: int) -> None:
+        with self.replay_log_lock:
+            if self.replay_log_file is not None:
+                return
+            path = Path.cwd() / f"{session_id:08x}.log"
+            self.replay_log_file = path.open("a", encoding="utf-8")
+            self.replay_log_path = path
+            self.replay_log_file.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} session_open session=0x{session_id:08x}\n")
+            self.replay_log_file.flush()
+
+    def log_replay_event(self, event: str, seq: int, detail: str = "") -> None:
+        with self.replay_log_lock:
+            if self.replay_log_file is None:
+                return
+            extra = f" {detail}" if detail else ""
+            self.replay_log_file.write(
+                f"{time.strftime('%Y-%m-%d %H:%M:%S')} {event} seq={seq}{extra}\n"
+            )
+            self.replay_log_file.flush()
+
+    def note_missing_seq_requested(self, seq: int, reason: str) -> None:
+        with self.tx_lock:
+            self.requested_missing_seqs.add(seq)
+        self.log_replay_event("missing_requested", seq, f"reason={reason}")
+
+    def note_replayed_seq_received(self, seq: int) -> None:
+        with self.tx_lock:
+            was_requested = seq in self.requested_missing_seqs
+            if was_requested:
+                self.requested_missing_seqs.remove(seq)
+        if was_requested:
+            self.log_replay_event("replay_received", seq)
+
+    def close_replay_log(self) -> None:
+        with self.replay_log_lock:
+            if self.replay_log_file is None:
+                return
+            self.replay_log_file.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} session_close\n")
+            self.replay_log_file.flush()
+            self.replay_log_file.close()
+            self.replay_log_file = None
+
+    def remember_sent_frame(self, frame: SentShellFrame) -> None:
+        if frame.seq == 0 or frame.op == self.pb2.mesh.RemoteShell.ACK:
+            return
+        with self.tx_lock:
+            self.tx_history.append(frame)
+
+    def prune_sent_frames(self, ack_seq: int) -> None:
+        if ack_seq <= 0:
+            return
+        with self.tx_lock:
+            self.tx_history = deque((frame for frame in self.tx_history if frame.seq > ack_seq), maxlen=50)
+
+    def replay_frames_from(self, start_seq: int) -> list[SentShellFrame]:
+        with self.tx_lock:
+            return [frame for frame in self.tx_history if frame.seq >= start_seq]
+
+
+def send_toradio(transport, toradio) -> None:
+    send_stream_frame(transport, toradio.SerializeToString())
+
+
+def make_toradio_packet(pb2, state: SessionState, shell_msg) -> object:
+    packet = pb2.mesh.MeshPacket()
+    packet.id = random.randint(1, 0x7FFFFFFF)
+    packet.to = state.target
+    # The 'from' field is a reserved keyword in Python, so use setattr
+    setattr(packet, "from", 0)
+    packet.channel = state.channel
+    packet.hop_limit = DEFAULT_HOP_LIMIT
+    packet.want_ack = False
+    packet.decoded.portnum = pb2.portnums.REMOTE_SHELL_APP
+    packet.decoded.payload = shell_msg.SerializeToString()
+    packet.decoded.want_response = False
+    packet.decoded.dest = state.target
+    packet.decoded.source = 0
+
+    toradio = pb2.mesh.ToRadio()
+    toradio.packet.CopyFrom(packet)
+    return toradio
+
+
+def send_shell_frame(
+    transport,
+    state: SessionState,
+    op: int,
+    payload: bytes = b"",
+    cols: int = 0,
+    rows: int = 0,
+    session_id: Optional[int] = None,
+    ack_seq: Optional[int] = None,
+    seq: Optional[int] = None,
+    flags: int = 0,
+    last_tx_seq: int = 0,
+    last_rx_seq: int = 0,
+    remember: bool = True,
+    heartbeat: bool = False,
+) -> int:
+    if seq is None:
+        seq = 0 if op == state.pb2.mesh.RemoteShell.ACK else state.alloc_seq()
+    if ack_seq is None:
+        ack_seq = state.current_ack_seq()
+    if session_id is None:
+        session_id = state.session_id
+
+    shell = state.pb2.mesh.RemoteShell()
+    shell.op = op
+    shell.session_id = session_id
+    shell.seq = seq
+    shell.ack_seq = ack_seq
+    shell.cols = cols
+    shell.rows = rows
+    shell.flags = flags
+    shell.last_tx_seq = last_tx_seq
+    shell.last_rx_seq = last_rx_seq
+    if payload:
+        shell.payload = payload
+    with state.socket_lock:
+        send_toradio(transport, make_toradio_packet(state.pb2, state, shell))
+    if remember:
+        state.remember_sent_frame(
+            SentShellFrame(
+                op=op,
+                session_id=session_id,
+                seq=seq,
+                ack_seq=ack_seq,
+                payload=payload,
+                cols=cols,
+                rows=rows,
+                flags=flags,
+                last_tx_seq=last_tx_seq,
+                last_rx_seq=last_rx_seq,
+            )
+        )
+    state.note_outbound_packet(heartbeat=heartbeat)
+    return seq
+
+
+def send_ack_frame(transport, state: SessionState, replay_from: Optional[int] = None) -> None:
+    send_shell_frame(
+        transport,
+        state,
+        state.pb2.mesh.RemoteShell.ACK,
+        seq=0,
+        last_rx_seq=0 if replay_from is None else replay_from - 1,
+        remember=False,
+    )
+
+
+def replay_frames_from(transport, state: SessionState, start_seq: int) -> None:
+    frame = next((f for f in state.replay_frames_from(start_seq) if f.seq == start_seq), None)
+    if frame is None:
+        #state.event_queue.put(f"replay unavailable from seq={start_seq}")
+        state.log_replay_event("replay_unavailable", start_seq)
+        return
+    state.log_replay_event("replay_sent", start_seq)
+    #state.event_queue.put(f"replay frame seq={start_seq}")
+    send_shell_frame(
+        transport,
+        state,
+        frame.op,
+        payload=frame.payload,
+        cols=frame.cols,
+        rows=frame.rows,
+        session_id=frame.session_id,
+        ack_seq=frame.ack_seq,
+        seq=frame.seq,
+        flags=frame.flags,
+        last_tx_seq=frame.last_tx_seq,
+        last_rx_seq=frame.last_rx_seq,
+        remember=False,
+    )
+
+
+def wait_for_config_complete(transport, pb2, timeout: float, verbose: bool) -> None:
+    nonce = random.randint(1, 0x7FFFFFFF)
+    toradio = pb2.mesh.ToRadio()
+    toradio.want_config_id = nonce
+    send_toradio(transport, toradio)
+
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        fromradio = pb2.mesh.FromRadio()
+        fromradio.ParseFromString(recv_stream_frame(transport))
+        variant = fromradio.WhichOneof("payload_variant")
+        if verbose and variant:
+            print(f"[api] fromradio {variant}", file=sys.stderr)
+        if variant == "config_complete_id" and fromradio.config_complete_id == nonce:
+            return
+    raise TimeoutError("timed out waiting for config handshake to complete")
+
+
+def decode_shell_packet(state: SessionState, packet) -> Optional[object]:
+    if packet.WhichOneof("payload_variant") != "decoded":
+        return None
+    if packet.decoded.portnum != state.pb2.portnums.REMOTE_SHELL_APP:
+        return None
+    shell = state.pb2.mesh.RemoteShell()
+    shell.ParseFromString(packet.decoded.payload)
+    return shell
+
+
+def reader_loop(transport, state: SessionState) -> None:
+    def handle_in_order_shell(shell) -> bool:
+        state.note_replayed_seq_received(shell.seq)
+        if shell.op == state.pb2.mesh.RemoteShell.OPEN_OK:
+            state.session_id = shell.session_id
+            state.open_replay_log(state.session_id)
+            state.set_receive_cursor(shell.seq)
+            state.active = True
+            state.opened_event.set()
+            state.event_queue.put(
+                f"opened session=0x{shell.session_id:08x} cols={shell.cols} rows={shell.rows}"
+            )
+            if state.replay_log_path is not None:
+                state.event_queue.put(f"replay log: {state.replay_log_path}")
+        elif shell.op == state.pb2.mesh.RemoteShell.OUTPUT:
+            if shell.payload:
+                sys.stdout.buffer.write(shell.payload)
+                sys.stdout.buffer.flush()
+        elif shell.op == state.pb2.mesh.RemoteShell.ERROR:
+            message = shell.payload.decode("utf-8", errors="replace")
+            if state.replay_log_file is None:
+                state.open_replay_log(shell.session_id or state.session_id)
+            sanitized = message.replace("\n", "\\n")
+            state.log_replay_event("error_received", shell.seq, f"message={sanitized}")
+            state.event_queue.put(f"remote error: {message}")
+        elif shell.op == state.pb2.mesh.RemoteShell.CLOSED:
+            message = shell.payload.decode("utf-8", errors="replace")
+            state.event_queue.put(f"session closed: {message}")
+            state.closed_event.set()
+            state.active = False
+            return True
+        elif shell.op == state.pb2.mesh.RemoteShell.PONG:
+            remote_last_tx_seq = shell.last_tx_seq
+            remote_last_rx_seq = shell.last_rx_seq
+            local_latest_tx_seq = state.highest_sent_seq()
+            if remote_last_rx_seq != 0 and remote_last_rx_seq < local_latest_tx_seq:
+                replay_frames_from(transport, state, remote_last_rx_seq + 1)
+            if remote_last_tx_seq > state.current_ack_seq():
+                state.note_peer_reported_tx_seq(remote_last_tx_seq)
+                req = state.request_missing_seq_once()
+                if req is not None:
+                    state.note_missing_seq_requested(req, "heartbeat_status")
+                    send_ack_frame(transport, state, replay_from=req)
+            #state.event_queue.put("pong")
+        return False
+
+    while not state.stopped:
+        try:
+            fromradio = state.pb2.mesh.FromRadio()
+            fromradio.ParseFromString(recv_stream_frame(transport))
+        except Exception as exc:
+            if not state.stopped:
+                state.event_queue.put(f"connection error: {exc}")
+                state.closed_event.set()
+            return
+
+        variant = fromradio.WhichOneof("payload_variant")
+        if variant == "packet":
+            shell = decode_shell_packet(state, fromradio.packet)
+            if not shell:
+                continue
+            state.note_inbound_packet()
+            #state.prune_sent_frames(shell.ack_seq)
+            if shell.op == state.pb2.mesh.RemoteShell.ACK:
+                #state.event_queue.put("peer requested replay")
+                replay_from = shell.last_rx_seq + 1 if shell.last_rx_seq > 0 else None
+                if replay_from is not None:
+                    #state.event_queue.put(f"peer requested replay from seq={replay_from}")
+                    replay_frames_from(transport, state, replay_from)
+                continue
+
+            action, missing_from = state.note_received_seq(shell.seq)
+            if action == "duplicate":
+                req = state.request_missing_seq_once()
+                if req is not None:
+                    state.note_missing_seq_requested(req, "duplicate")
+                    send_ack_frame(transport, state, replay_from=req)
+                continue
+            if action == "gap":
+                state.remember_out_of_order_frame(shell)
+                req = state.request_missing_seq_once()
+                if req is not None:
+                    state.note_missing_seq_requested(req, "gap")
+                    send_ack_frame(transport, state, replay_from=req)
+                continue
+
+            if handle_in_order_shell(shell):
+                return
+
+            while True:
+                buffered_shell = state.pop_next_buffered_frame()
+                if buffered_shell is None:
+                    break
+                buffered_action, _ = state.note_received_seq(buffered_shell.seq)
+                if buffered_action != "process":
+                    state.remember_out_of_order_frame(buffered_shell)
+                    break
+                if handle_in_order_shell(buffered_shell):
+                    return
+
+            req = state.request_missing_seq_once()
+            if req is not None:
+                state.note_missing_seq_requested(req, "post_process_gap")
+                send_ack_frame(transport, state, replay_from=req)
+        elif state.verbose and variant:
+            state.event_queue.put(f"fromradio {variant}")
+
+
+def drain_events(state: SessionState) -> None:
+    while True:
+        try:
+            event = state.event_queue.get_nowait()
+        except queue.Empty:
+            return
+        print(f"[dmshell] {event}", file=sys.stderr)
+
+
+def heartbeat_loop(transport, state: SessionState) -> None:
+    while not state.stopped and not state.closed_event.is_set():
+        if not state.active:
+            time.sleep(HEARTBEAT_POLL_INTERVAL_SEC)
+            continue
+        if state.heartbeat_due():
+            try:
+                send_shell_frame(
+                    transport,
+                    state,
+                    state.pb2.mesh.RemoteShell.PING,
+                    last_tx_seq=state.highest_sent_seq(),
+                    last_rx_seq=state.current_ack_seq(),
+                    remember=True,
+                    heartbeat=True,
+                )
+            except Exception as exc:
+                if not state.stopped:
+                    state.event_queue.put(f"heartbeat error: {exc}")
+                    state.closed_event.set()
+                    return
+        time.sleep(HEARTBEAT_POLL_INTERVAL_SEC)
+
+
+def run_command_mode(transport, state: SessionState, commands: list[str], close_after: float) -> None:
+    for command in commands:
+        send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.INPUT, (command + "\n").encode("utf-8"))
+    time.sleep(close_after)
+    send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.CLOSE)
+    state.closed_event.wait(timeout=close_after + 5.0)
+
+
+def run_interactive_mode(transport, state: SessionState) -> None:
+    def read_local_command() -> str:
+        prompt = "\r\n[dmshell] local command (resume|close|ping|resize C R): "
+        sys.stderr.write(prompt)
+        sys.stderr.flush()
+        buf = bytearray()
+
+        while True:
+            ch = os.read(sys.stdin.fileno(), 1)
+            if not ch:
+                sys.stderr.write("\r\n")
+                sys.stderr.flush()
+                return "close"
+
+            b = ch[0]
+            if b in (10, 13):
+                sys.stderr.write("\r\n")
+                sys.stderr.flush()
+                return buf.decode("utf-8", errors="replace").strip()
+
+            if b in (8, 127):
+                if buf:
+                    buf.pop()
+                    sys.stderr.write("\b \b")
+                    sys.stderr.flush()
+                continue
+
+            if b < 32:
+                continue
+
+            buf.append(b)
+            sys.stderr.write(chr(b))
+            sys.stderr.flush()
+
+    def handle_local_command(cmd: str) -> bool:
+        if cmd in ("", "resume"):
+            return True
+        if cmd == "close":
+            send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.CLOSE)
+            return False
+        if cmd == "ping":
+            send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.PING)
+            return True
+        if cmd.startswith("resize "):
+            parts = cmd.split()
+            if len(parts) != 3:
+                state.event_queue.put("usage: resize COLS ROWS")
+                return True
+            try:
+                cols = int(parts[1])
+                rows = int(parts[2])
+            except ValueError:
+                state.event_queue.put("usage: resize COLS ROWS")
+                return True
+            send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.RESIZE, cols=cols, rows=rows)
+            return True
+
+        state.event_queue.put(f"unknown local command: {cmd}")
+        return True
+
+    print(
+        "Raw input mode active. All keys (including Ctrl+C/Ctrl+X) are sent to remote. Ctrl+] for local commands.",
+        file=sys.stderr,
+    )
+
+    if not sys.stdin.isatty():
+        # Fallback for non-TTY stdin: still send input as it arrives.
+        while not state.closed_event.is_set():
+            drain_events(state)
+            data = sys.stdin.buffer.read(INPUT_BATCH_MAX_BYTES)
+            if not data:
+                send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.CLOSE)
+                break
+            send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.INPUT, data)
+        return
+
+    fd = sys.stdin.fileno()
+    old_attrs = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        while not state.closed_event.is_set():
+            drain_events(state)
+            ready, _, _ = select.select([sys.stdin], [], [], 0.05)
+            if not ready:
+                continue
+
+            data = os.read(fd, 1)
+            if not data:
+                send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.CLOSE)
+                break
+
+            if data == LOCAL_ESCAPE_BYTE:
+                keep_running = handle_local_command(read_local_command())
+                if not keep_running:
+                    break
+                continue
+
+            # Coalesce a short burst of bytes to reduce packet overhead for fast typing.
+            batched = bytearray(data)
+            enter_local_command = False
+            deadline = time.monotonic() + INPUT_BATCH_WINDOW_SEC
+            while len(batched) < INPUT_BATCH_MAX_BYTES:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    break
+                more_ready, _, _ = select.select([sys.stdin], [], [], remaining)
+                if not more_ready:
+                    break
+                next_byte = os.read(fd, 1)
+                if not next_byte:
+                    break
+                if next_byte == LOCAL_ESCAPE_BYTE:
+                    enter_local_command = True
+                    break
+                batched.extend(next_byte)
+                if next_byte == b'\r' or next_byte == b'\t':
+                    break
+                deadline = time.monotonic() + INPUT_BATCH_WINDOW_SEC
+
+            if batched:
+                send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.INPUT, bytes(batched))
+
+            if enter_local_command:
+                keep_running = handle_local_command(read_local_command())
+                if not keep_running:
+                    break
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_attrs)
+
+
+def main() -> int:
+    args = parse_args()
+    pb2 = load_proto_modules()
+
+    state = SessionState(
+            pb2=pb2,
+        target=parse_node_num(args.to),
+        channel=args.channel,
+        verbose=args.verbose,
+    )
+
+    cols, rows = resolve_initial_terminal_size(args.cols, args.rows)
+
+    transport = open_transport(args)
+    try:
+        wait_for_config_complete(transport, pb2, args.timeout, args.verbose)
+
+        reader = threading.Thread(target=reader_loop, args=(transport, state), daemon=True)
+        reader.start()
+
+        send_shell_frame(transport, state, pb2.mesh.RemoteShell.OPEN, cols=cols, rows=rows)
+        if not state.opened_event.wait(timeout=args.timeout):
+            raise SystemExit("timed out waiting for OPEN_OK from remote DMShell")
+
+        heartbeat = threading.Thread(target=heartbeat_loop, args=(transport, state), daemon=True)
+        heartbeat.start()
+
+        drain_events(state)
+        if args.command:
+            run_command_mode(transport, state, args.command, args.close_after)
+        else:
+            run_interactive_mode(transport, state)
+
+        state.stopped = True
+        drain_events(state)
+        reader.join(timeout=1.0)
+        heartbeat.join(timeout=1.0)
+        state.close_replay_log()
+    finally:
+        transport.close()
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bin/platformio-custom.py

@@ -293,12 +293,9 @@ if ("HAS_TFT", 1) in env.get("CPPDEFINES", []):
 board_arch = infer_architecture(env.BoardConfig())
 should_skip_manifest = board_arch is None
 
-# Most platforms can generate the manifest as part of the default 'buildprog' target.
-# Typically this passes success/failure properly.
-mtjson_deps = ["buildprog"]
-if platform.name == "espressif32":
-    # On ESP32, we need to explicitly depend upon the binary to prevent fake-success upon failure.
-    mtjson_deps = ["$BUILD_DIR/${PROGNAME}.bin"]
+# For host/native envs, avoid depending on 'buildprog' (some targets don't define it)
+mtjson_deps = [] if should_skip_manifest else ["buildprog"]
+if not should_skip_manifest and platform.name == "espressif32":
     # Build littlefs image as part of mtjson target
     # Equivalent to `pio run -t buildfs`
     target_lfs = env.DataToBin(
@@ -312,8 +309,7 @@ if should_skip_manifest:
 
     env.AddCustomTarget(
         name="mtjson",
-        # For host/native envs, avoid depending on 'buildprog' (some targets don't define it)
-        dependencies=[],
+        dependencies=mtjson_deps,
         actions=[skip_manifest],
         title="Meshtastic Manifest (skipped)",
         description="mtjson generation is skipped for native environments",

boards/CDEBYTE_EoRa-S3.json

@@ -7,7 +7,7 @@
     "extra_flags": [
       "-D CDEBYTE_EORA_S3",
       "-D ARDUINO_USB_CDC_ON_BOOT=1",
-      "-D ARDUINO_USB_MODE=1",
+      "-D ARDUINO_USB_MODE=0",
       "-D ARDUINO_RUNNING_CORE=1",
       "-D ARDUINO_EVENT_RUNNING_CORE=1",
       "-D BOARD_HAS_PSRAM"

boards/bpi_picow_esp32_s3.json

@@ -6,7 +6,7 @@
     "core": "esp32",
     "extra_flags": [
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1",
       "-DBOARD_HAS_PSRAM"

boards/hackaday-communicator.json

@@ -8,7 +8,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_vision_master_e213.json

@@ -9,7 +9,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_vision_master_e290.json

@@ -9,7 +9,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_vision_master_t190.json

@@ -9,7 +9,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_wireless_tracker.json

@@ -8,7 +8,7 @@
     "extra_flags": [
       "-DHELTEC_WIRELESS_TRACKER",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_wireless_tracker_v2.json

@@ -7,7 +7,7 @@
     "core": "esp32",
     "extra_flags": [
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/seeed-xiao-s3.json

@@ -8,7 +8,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=0"
     ],

boards/t-beam-1w.json

@@ -9,7 +9,7 @@
       "-DBOARD_HAS_PSRAM",
       "-DLILYGO_TBEAM_1W",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/t-deck.json

@@ -8,7 +8,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/tbeam-s3-core.json

@@ -8,7 +8,7 @@
       "-DBOARD_HAS_PSRAM",
       "-DLILYGO_TBEAM_S3_CORE",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/tlora-t3s3-v1.json

@@ -7,7 +7,7 @@
     "extra_flags": [
       "-DLILYGO_T3S3_V1",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1",
       "-DBOARD_HAS_PSRAM"

boards/unphone.json

@@ -10,7 +10,7 @@
       "-DBOARD_HAS_PSRAM",
       "-DUNPHONE_SPIN=9",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

default_16MB.csv

@@ -1,7 +0,0 @@
-# Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     0x9000,  0x5000,
-otadata,  data, ota,     0xe000,  0x2000,
-app0,     app,  ota_0,   0x10000, 0x640000,
-app1,     app,  ota_1,   0x650000,0x640000,
-spiffs,   data, spiffs,  0xc90000,0x360000,
-coredump, data, coredump,0xFF0000,0x10000,

default_8MB.csv

@@ -1,7 +0,0 @@
-# Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     0x9000,  0x5000,
-otadata,  data, ota,     0xe000,  0x2000,
-app0,     app,  ota_0,   0x10000, 0x330000,
-app1,     app,  ota_1,   0x340000,0x330000,
-spiffs,   data, spiffs,  0x670000,0x180000,
-coredump, data, coredump,0x7F0000,0x10000,

extra_scripts/esp32_extra.py

@@ -70,6 +70,17 @@ def esp32_create_combined_bin(source, target, env):
 
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_create_combined_bin)
 
-# Enable Newlib Nano formatting to save space
-# ...but allow printf float support (compromise)
-env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])
+esp32_kind = env.GetProjectOption("custom_esp32_kind")
+if esp32_kind == "esp32":
+    # Free up some IRAM by removing auxiliary SPI flash chip drivers.
+    # Wrapped stub symbols are defined in src/platform/esp32/iram-quirk.c.
+    env.Append(
+        LINKFLAGS=[
+            "-Wl,--wrap=esp_flash_chip_gd",
+            "-Wl,--wrap=esp_flash_chip_issi",
+            "-Wl,--wrap=esp_flash_chip_winbond",
+        ]
+    )
+else:
+    # For newer ESP32 targets, using newlib nano works better.
+    env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])

extra_scripts/ld_response_file.py

@@ -1,23 +0,0 @@
-#!/usr/bin/env python3
-# trunk-ignore-all(ruff/F821)
-# trunk-ignore-all(flake8/F821): For SConstruct imports
-
-# force linker response file instead of command line arguments
-
-Import("env")
-
-
-def wrap_with_tempfile(command_key):
-    command = env.get(command_key)
-    if not command or not isinstance(command, str):
-        return
-    if "TEMPFILE(" in command:
-        return
-    env.Replace(**{command_key: "${TEMPFILE('%s')}" % command})
-
-
-# Force SCons to spill long commands into response files on this target.
-env.Replace(MAXLINELENGTH=8192)
-
-for key in ("LINKCOM", "CXXLINKCOM", "SHLINKCOM", "SHCXXLINKCOM"):
-    wrap_with_tempfile(key)

mcp-server/README.md

@@ -166,73 +166,15 @@ rather than auto-`sudo`'ing mid-run.
 
 ## Environment variables
 
-| Var                        | Default                                                     | Purpose                                                                                                          |
-| -------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
-| `MESHTASTIC_FIRMWARE_ROOT` | walks up from cwd for `platformio.ini`                      | Pin the firmware repo                                                                                            |
-| `MESHTASTIC_PIO_BIN`       | `~/.platformio/penv/bin/pio` → `$PATH` `pio` → `platformio` | Override `pio` location                                                                                          |
-| `MESHTASTIC_ESPTOOL_BIN`   | `<firmware>/.venv/bin/esptool` → `$PATH`                    | Override esptool                                                                                                 |
-| `MESHTASTIC_NRFUTIL_BIN`   | `$PATH`                                                     | Override nrfutil                                                                                                 |
-| `MESHTASTIC_PICOTOOL_BIN`  | `$PATH`                                                     | Override picotool                                                                                                |
-| `MESHTASTIC_MCP_SEED`      | `mcp-<user>-<host>`                                         | PSK seed for test-harness session (CI override)                                                                  |
-| `MESHTASTIC_MCP_FLASH_LOG` | `<mcp-server>/tests/flash.log`                              | Tee target for pio/esptool/nrfutil subprocess output (TUI tails it)                                              |
-| `MESHTASTIC_MCP_TCP_HOST`  | unset                                                       | `host` or `host:port` of a `meshtasticd` daemon to surface as a TCP device (see "TCP / native-host nodes" below) |
-
-## TCP / native-host nodes
-
-The `native-macos` and `native` PlatformIO envs build a headless `meshtasticd`
-binary that runs on the host (Apple Silicon / Intel macOS, or Linux Portduino).
-The daemon exposes the meshtastic TCP API on port `4403` rather than a USB
-serial endpoint — point the MCP server at it via `MESHTASTIC_MCP_TCP_HOST`:
-
-```bash
-# 1. Build + run a daemon on this host (see variants/native/portduino/platformio.ini
-#    for full Homebrew prereqs and CH341 LoRa-adapter setup).
-pio run -e native-macos
-~/.meshtasticd/meshtasticd
-
-# 2. Point the MCP server at it.
-export MESHTASTIC_MCP_TCP_HOST=localhost     # or host:port, default port 4403
-```
-
-**First-run gotcha — MAC address.** `meshtasticd` derives its MAC from the
-USB adapter's serial-number / product strings. Many cheap CH341 dongles
-(MeshStick included — VID 0x1A86 / PID 0x5512) ship with `iSerialNumber=0`
-and `iProduct=0`, so the daemon aborts on boot with `*** Blank MAC Address
-not allowed!`. Set the MAC explicitly in `config.yaml`:
-
-```yaml
-# Under General:
-MACAddress: 02:CA:FE:BA:BE:01
-```
-
-Use a locally-administered address (first byte's second-LSB set, e.g.
-`02:*` / `06:*` / `0A:*` / `0E:*`) to avoid colliding with a real OUI.
-
-There is also a `--hwid AA:BB:CC:DD:EE:FF` CLI flag visible in
-`meshtasticd --help`, but it is **currently broken** in
-`MAC_from_string()` (`src/platform/portduino/PortduinoGlue.cpp`): the
-function strips colons from its parameter but then reads bytes from the
-global `portduino_config.mac_address`, so `--hwid` is silently overridden
-when `MACAddress:` is also set, and crashes the daemon (uncaught
-`std::invalid_argument: stoi: no conversion`) when it isn't. Use the YAML
-form until that's fixed upstream.
-
-`list_devices` will surface the daemon as `tcp://localhost:4403` with
-`likely_meshtastic=True`, so `device_info`, `list_nodes`, `get_config`,
-`set_config`, `set_owner`, `send_text`, `userprefs_*`, and the admin RPCs
-auto-select it when no `port` is passed. Pass `port="tcp://other-host:9999"`
-explicitly to target a different daemon.
-
-**Tools that don't apply to a TCP/native node** (no USB hardware to operate
-on) raise a clear `ConnectionError` rather than failing mysteriously:
-`pio_flash`, `erase_and_flash`, `update_flash`, `touch_1200bps`,
-`serial_open` (use info/admin tools directly), and the vendor escape hatches
-`esptool_*`, `nrfutil_*`, `picotool_*`. `pio_flash` against a `native*` env
-similarly raises — there's no upload step; use `build` and run the binary
-directly.
-
-The pytest harness in `tests/` still assumes USB-attached devices per role —
-TCP-aware fixtures are not part of this surface yet.
+| Var                        | Default                                                     | Purpose                                                             |
+| -------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------- |
+| `MESHTASTIC_FIRMWARE_ROOT` | walks up from cwd for `platformio.ini`                      | Pin the firmware repo                                               |
+| `MESHTASTIC_PIO_BIN`       | `~/.platformio/penv/bin/pio` → `$PATH` `pio` → `platformio` | Override `pio` location                                             |
+| `MESHTASTIC_ESPTOOL_BIN`   | `<firmware>/.venv/bin/esptool` → `$PATH`                    | Override esptool                                                    |
+| `MESHTASTIC_NRFUTIL_BIN`   | `$PATH`                                                     | Override nrfutil                                                    |
+| `MESHTASTIC_PICOTOOL_BIN`  | `$PATH`                                                     | Override picotool                                                   |
+| `MESHTASTIC_MCP_SEED`      | `mcp-<user>-<host>`                                         | PSK seed for test-harness session (CI override)                     |
+| `MESHTASTIC_MCP_FLASH_LOG` | `<mcp-server>/tests/flash.log`                              | Tee target for pio/esptool/nrfutil subprocess output (TUI tails it) |
 
 ## Hardware Test Suite
 

mcp-server/src/meshtastic_mcp/connection.py

@@ -1,4 +1,4 @@
-"""Context manager for meshtastic interface connections (serial + TCP).
+"""Context manager for meshtastic.SerialInterface connections.
 
 Every info/admin tool goes through `connect(port)` so we have a single place
 that:
@@ -6,16 +6,8 @@ that:
   - fails fast if a serial_session is already holding the port,
   - guarantees `.close()` is called, even on exception.
 
-Two transports:
-  - Serial: USB-attached firmware on `/dev/cu.*` / `/dev/ttyUSB*` / `COM*`.
-  - TCP: a `meshtasticd` daemon (e.g. the native macOS / Linux Portduino
-    headless build) addressed as `tcp://host[:port]` (default port 4403).
-    Surfaced by `devices.list_devices()` when `MESHTASTIC_MCP_TCP_HOST` is
-    set, so `resolve_port(None)` auto-selects it like a USB candidate.
-
-Both `SerialInterface` and `TCPInterface` block on construction waiting for
-the node database; that's fine for v1 since every tool is a short-lived
-request.
+The `SerialInterface` blocks on construction waiting for the node database;
+that's fine for v1 since every tool is a short-lived request.
 """
 
 from __future__ import annotations
@@ -25,107 +17,20 @@ from typing import Iterator
 
 from . import devices, registry
 
-DEFAULT_TCP_PORT = 4403
-TCP_SCHEME = "tcp://"
-TCP_HOST_ENV = "MESHTASTIC_MCP_TCP_HOST"
-
 
 class ConnectionError(RuntimeError):
     pass
 
 
-def is_tcp_port(port: str | None) -> bool:
-    return bool(port) and port.startswith(TCP_SCHEME)
-
-
-def parse_tcp_port(port: str) -> tuple[str, int]:
-    """Parse `tcp://host[:port]` → (host, port). Defaults to 4403.
-
-    Validates host shape (non-empty, no path separators) and port range
-    (1..65535). Raises `ConnectionError` on malformed input — never lets
-    a raw `ValueError` bubble up to a tool surface.
-    """
-    if not port.startswith(TCP_SCHEME):
-        raise ConnectionError(
-            f"Invalid TCP endpoint {port!r}: expected '{TCP_SCHEME}host[:port]'."
-        )
-    rest = port[len(TCP_SCHEME) :]
-    if ":" in rest:
-        host, port_str = rest.rsplit(":", 1)
-        try:
-            tcp_port = int(port_str)
-        except ValueError as e:
-            raise ConnectionError(
-                f"Invalid TCP endpoint {port!r}: port {port_str!r} is not an integer."
-            ) from e
-    else:
-        host, tcp_port = rest, DEFAULT_TCP_PORT
-    if not host:
-        raise ConnectionError(f"Invalid TCP endpoint {port!r}: empty host.")
-    if any(c in host for c in ("/", "\\")):
-        raise ConnectionError(
-            f"Invalid TCP endpoint {port!r}: host {host!r} contains a path "
-            "separator. TCP hostnames cannot contain '/' or '\\' — did you "
-            "pass a serial port path or a Windows drive path by mistake?"
-        )
-    if not (1 <= tcp_port <= 65535):
-        raise ConnectionError(
-            f"Invalid TCP endpoint {port!r}: port {tcp_port} out of range "
-            "(must be 1..65535)."
-        )
-    return host, tcp_port
-
-
-def normalize_tcp_endpoint(endpoint: str) -> str:
-    r"""Normalize `host`, `host:port`, or `tcp://host[:port]` → canonical
-    `tcp://host:port` form. One place that owns the lock-key shape.
-
-    Defers all validation to `parse_tcp_port`, so path-like inputs
-    (`/dev/cu.foo`, `C:\Windows\…`), empty hosts, non-integer ports,
-    and out-of-range ports raise `ConnectionError` here too.
-    """
-    if endpoint.startswith(TCP_SCHEME):
-        canonical = endpoint
-    elif ":" in endpoint:
-        canonical = f"{TCP_SCHEME}{endpoint}"
-    else:
-        canonical = f"{TCP_SCHEME}{endpoint}:{DEFAULT_TCP_PORT}"
-    host, port = parse_tcp_port(canonical)
-    return f"{TCP_SCHEME}{host}:{port}"
-
-
-def reject_if_tcp(port: str | None, tool_name: str) -> None:
-    """Raise if `port` is a TCP endpoint — for tools that need real USB
-    hardware (flash, bootloader, vendor escape hatches, serial monitor).
-
-    Only checks the explicit arg; auto-selection via env var is the caller's
-    responsibility to handle if it matters.
-    """
-    if is_tcp_port(port):
-        raise ConnectionError(
-            f"{tool_name} is not applicable to TCP/native nodes ({port}). "
-            "This tool requires USB-attached hardware."
-        )
-
-
 def resolve_port(port: str | None) -> str:
-    """Pick a port: explicit > sole likely_meshtastic candidate > error.
-
-    A `tcp://` string passes through (after canonicalization). When `port`
-    is None and no USB candidates are present, `MESHTASTIC_MCP_TCP_HOST`
-    is consulted via `devices.list_devices()`.
-    """
+    """Pick a port: explicit > sole likely_meshtastic candidate > error."""
     if port:
-        if is_tcp_port(port):
-            return normalize_tcp_endpoint(port)
         return port
     candidates = [d for d in devices.list_devices() if d["likely_meshtastic"]]
     if not candidates:
         raise ConnectionError(
-            "No Meshtastic devices detected. Plug one in, set "
-            f"{TCP_HOST_ENV}=<host[:port]> for a meshtasticd daemon, "
-            "or pass `port` explicitly. Run `list_devices` with "
-            "include_unknown=True to see all serial ports."
+            "No Meshtastic devices detected. Plug one in or pass `port` explicitly. "
+            "Run `list_devices` with include_unknown=True to see all serial ports."
         )
     if len(candidates) > 1:
         ports = ", ".join(c["port"] for c in candidates)
@@ -138,62 +43,17 @@ def resolve_port(port: str | None) -> str:
 
 @contextmanager
 def connect(port: str | None = None, timeout_s: float = 8.0) -> Iterator:
-    """Open a meshtastic interface (serial or TCP) and always close it.
+    """Open a `meshtastic.SerialInterface` and always close it.
 
-    For serial: raises `ConnectionError` immediately if another serial
-    session holds the port (a `pio device monitor` in `serial_sessions/`).
-    For TCP: no exclusive-access requirement, so the serial-session check
-    is skipped — but the `port_lock` still serializes parallel `connect()`
-    calls to the same daemon endpoint.
-
-    `timeout_s` is plumbed through to both `SerialInterface(timeout=...)`
-    and `TCPInterface(timeout=...)`. The meshtastic library uses the value
-    as the reply-wait deadline for `localNode.waitForConfig()` during
-    construction and for any subsequent admin RPC. `int()`-converted at
-    the boundary because the upstream API expects whole seconds.
+    Raises `ConnectionError` immediately if another serial session holds the
+    port (a `pio device monitor` in `serial_sessions/`, for instance).
     """
-    resolved = resolve_port(port)
-    timeout = int(timeout_s)
-
-    if is_tcp_port(resolved):
-        from meshtastic.tcp_interface import (
-            TCPInterface,  # type: ignore[import-untyped]
-        )
-
-        host, tcp_port = parse_tcp_port(resolved)
-        lock = registry.port_lock(resolved)
-        if not lock.acquire(blocking=False):
-            raise ConnectionError(
-                f"TCP endpoint {resolved} is busy — another device operation "
-                "is in flight. Retry shortly."
-            )
-
-        iface = None
-        try:
-            iface = TCPInterface(
-                hostname=host,
-                portNumber=tcp_port,
-                connectNow=True,
-                noProto=False,
-                timeout=timeout,
-            )
-            yield iface
-        finally:
-            if iface is not None:
-                try:
-                    iface.close()
-                except Exception:
-                    pass
-            try:
-                lock.release()
-            except RuntimeError:
-                pass
-        return
-
     from meshtastic.serial_interface import (
         SerialInterface,  # type: ignore[import-untyped]
     )
 
+    resolved = resolve_port(port)
+
     active = registry.active_session_for_port(resolved)
     if active is not None:
         raise ConnectionError(
@@ -210,12 +70,7 @@ def connect(port: str | None = None, timeout_s: float = 8.0) -> Iterator:
 
     iface = None
     try:
-        iface = SerialInterface(
-            devPath=resolved,
-            connectNow=True,
-            noProto=False,
-            timeout=timeout,
-        )
+        iface = SerialInterface(devPath=resolved, connectNow=True, noProto=False)
         yield iface
     finally:
         if iface is not None:

mcp-server/src/meshtastic_mcp/devices.py

@@ -1,18 +1,13 @@
-"""USB/serial + TCP device discovery.
+"""USB/serial device discovery.
 
 Combines the canonical `meshtastic.util.findPorts()` allowlist/blocklist with
 the richer metadata (`serial.tools.list_ports.comports()`) so callers see
 VID/PID, descriptions, and manufacturer strings alongside the "is this likely
 a Meshtastic device" signal.
-
-If `MESHTASTIC_MCP_TCP_HOST=<host[:port]>` is set, a synthetic entry for the
-`meshtasticd` daemon at that endpoint is prepended to the result, so
-`resolve_port(None)` auto-selects it like a USB candidate.
 """
 
 from __future__ import annotations
 
-import os
 from typing import Any
 
 from serial.tools import list_ports
@@ -24,45 +19,6 @@ def _to_hex(value: int | None) -> str | None:
     return f"0x{value:04x}"
 
 
-def _tcp_endpoint_from_env() -> dict[str, Any] | None:
-    """Synthesize a TCP device entry from MESHTASTIC_MCP_TCP_HOST, if set.
-
-    If the env var is malformed (non-integer port, path-like host, etc.),
-    return an entry with `likely_meshtastic=False` and the parser error in
-    the description, rather than raising — `list_devices` is the diagnostic
-    tool a user reaches for when their env var isn't working, so it must
-    not crash on misconfiguration.
-    """
-    host = os.environ.get("MESHTASTIC_MCP_TCP_HOST")
-    if not host:
-        return None
-    # Lazy import to avoid a circular dependency (connection imports devices).
-    from . import connection
-
-    try:
-        port = connection.normalize_tcp_endpoint(host)
-        description = "meshtasticd (TCP)"
-        likely = True
-    except connection.ConnectionError as e:
-        # Surface the raw env-var value plus the parser's reason so the
-        # user can see exactly what they set and why it was rejected.
-        # Don't double the scheme if the user already prefixed `tcp://`.
-        port = host if host.startswith(connection.TCP_SCHEME) else f"tcp://{host}"
-        description = f"meshtasticd (TCP) — invalid MESHTASTIC_MCP_TCP_HOST: {e}"
-        likely = False
-    return {
-        "port": port,
-        "vid": None,
-        "pid": None,
-        "description": description,
-        "manufacturer": None,
-        "product": None,
-        "serial_number": None,
-        "likely_meshtastic": likely,
-        "blacklisted": False,
-    }
-
-
 def list_devices(include_unknown: bool = False) -> list[dict[str, Any]]:
     """Return enriched info for serial ports, flagging Meshtastic candidates.
 
@@ -114,22 +70,6 @@ def list_devices(include_unknown: bool = False) -> list[dict[str, Any]]:
             }
         )
 
-    # Append the TCP endpoint (if env var set) and sort everything together.
-    tcp_entry = _tcp_endpoint_from_env()
-    if tcp_entry is not None:
-        results.append(tcp_entry)
-
-    # Stable ordering: likely_meshtastic first; within rank, TCP wins over
-    # USB (explicit env-var configuration takes precedence over USB
-    # enumeration); then by port path. A misconfigured TCP entry has
-    # likely_meshtastic=False and lands among the other ignored entries —
-    # it does NOT pre-empt real USB devices at the top of the list.
-    results.sort(
-        key=lambda r: (
-            not r["likely_meshtastic"],
-            not r["port"].startswith("tcp://"),
-            r["port"],
-        )
-    )
-
+    # Stable ordering: likely_meshtastic first, then by port path
+    results.sort(key=lambda r: (not r["likely_meshtastic"], r["port"]))
     return results

mcp-server/src/meshtastic_mcp/flash.py

@@ -17,7 +17,7 @@ from typing import Any
 
 import serial
 
-from . import boards, config, connection, devices, pio, userprefs
+from . import boards, config, devices, pio, userprefs
 
 # Meshtastic variants use both `esp32s3` and `esp32-s3` style names across
 # variants/*/platformio.ini (no consistency enforced). Accept both spellings.
@@ -46,18 +46,6 @@ def _require_confirm(confirm: bool, operation: str) -> None:
         )
 
 
-def _reject_native_env(env: str, operation: str) -> None:
-    """`native*` envs build a host executable, not firmware — there's no
-    upload step. The user wants `build` (or just runs the binary directly).
-    """
-    if env.startswith("native"):
-        raise FlashError(
-            f"{operation} is not applicable for env {env!r}: native envs "
-            "produce a host executable, not flashable firmware. Use `build` "
-            "instead, then run the resulting binary directly."
-        )
-
-
 def _artifacts_for(env: str) -> list[Path]:
     build_dir = config.firmware_root() / ".pio" / "build" / env
     if not build_dir.is_dir():
@@ -153,8 +141,6 @@ def flash(
     that pio performs will pick up the injected values.
     """
     _require_confirm(confirm, "flash")
-    _reject_native_env(env, "flash")
-    connection.reject_if_tcp(port, "flash")
     with userprefs.temporary_overrides(userprefs_overrides) as effective:
         result = pio.run(
             ["run", "-e", env, "-t", "upload", "--upload-port", port],
@@ -214,7 +200,6 @@ def erase_and_flash(
     in that case) since a cached factory.bin would not reflect the new prefs.
     """
     _require_confirm(confirm, "erase_and_flash")
-    connection.reject_if_tcp(port, "erase_and_flash")
     _check_esp32_env(env)
 
     if userprefs_overrides and skip_build:
@@ -272,7 +257,6 @@ def update_flash(
     overrides are provided we always force a rebuild.
     """
     _require_confirm(confirm, "update_flash")
-    connection.reject_if_tcp(port, "update_flash")
     _check_esp32_env(env)
 
     if userprefs_overrides and skip_build:
@@ -407,7 +391,6 @@ def touch_1200bps(
 
     Returns `{ok, former_port, new_port, new_port_vid_pid, attempts}`.
     """
-    connection.reject_if_tcp(port, "touch_1200bps")
     before_list = devices.list_devices(include_unknown=True)
     before_ports = {d["port"] for d in before_list}
 

mcp-server/src/meshtastic_mcp/hw_tools.py

@@ -16,7 +16,7 @@ import subprocess
 from pathlib import Path
 from typing import Any, Sequence
 
-from . import config, connection, pio
+from . import config, pio
 
 _TIMEOUT_SHORT = 30
 _TIMEOUT_LONG = 600
@@ -102,7 +102,6 @@ def _parse_esptool_chip_info(stdout: str) -> dict[str, Any]:
 
 
 def esptool_chip_info(port: str) -> dict[str, Any]:
-    connection.reject_if_tcp(port, "esptool_chip_info")
     binary = config.esptool_bin()
     # `chip_id` prints chip + mac + crystal + features. `flash_id` adds flash.
     combined = _run(binary, ["--port", port, "flash_id"], timeout=_TIMEOUT_SHORT)
@@ -117,7 +116,6 @@ def esptool_chip_info(port: str) -> dict[str, Any]:
 def esptool_erase_flash(port: str, confirm: bool = False) -> dict[str, Any]:
     """Full-chip erase. Leaves the device unbootable until reflashed."""
     _require_confirm(confirm, "esptool_erase_flash")
-    connection.reject_if_tcp(port, "esptool_erase_flash")
     binary = config.esptool_bin()
     # esptool v5 uses `erase-flash`, older uses `erase_flash`. Try the new name
     # first; if it fails with unknown command, retry old.
@@ -136,7 +134,6 @@ def esptool_raw(
     """Raw esptool passthrough. Destructive subcommands require confirm=True."""
     if not args:
         raise ToolError("args must not be empty")
-    connection.reject_if_tcp(port, "esptool_raw")
     # Find the first non-flag arg (the subcommand).
     subcommand = next((a for a in args if not a.startswith("-")), None)
     if subcommand and subcommand.replace("-", "_") in {
@@ -159,7 +156,6 @@ NRFUTIL_DESTRUCTIVE = {"dfu", "settings"}
 
 def nrfutil_dfu(port: str, package_path: str, confirm: bool = False) -> dict[str, Any]:
     _require_confirm(confirm, "nrfutil_dfu")
-    connection.reject_if_tcp(port, "nrfutil_dfu")
     pkg = Path(package_path).expanduser()
     if not pkg.is_file():
         raise ToolError(f"Package not found: {pkg}")
@@ -217,7 +213,6 @@ def _parse_picotool_info(stdout: str) -> dict[str, Any]:
 def picotool_info(port: str | None = None) -> dict[str, Any]:
     """Read device info from a Pico in BOOTSEL mode. `port` is informational
     only — picotool auto-detects."""
-    connection.reject_if_tcp(port, "picotool_info")
     binary = config.picotool_bin()
     res = _run(binary, ["info", "-a"], timeout=_TIMEOUT_SHORT)
     if res["exit_code"] != 0:

mcp-server/src/meshtastic_mcp/serial_session.py

@@ -71,10 +71,6 @@ def open_session(
     If `env` is supplied, pio resolves baud and filters from platformio.ini.
     Otherwise uses the supplied `baud` and `filters` (default `['direct']`).
     """
-    # Lazy import to avoid circular: registry imports serial_session.
-    from . import connection
-
-    connection.reject_if_tcp(port, "serial_open")
     args = ["device", "monitor", "--port", port, "--no-reconnect"]
     effective_filters: list[str]
     effective_baud: int = baud

mcp-server/tests/unit/test_connection_tcp.py

@@ -1,383 +0,0 @@
-"""TCP transport plumbing in connection.py + devices.py.
-
-Pure-Python tests — no real device or daemon required. Mocks `TCPInterface`
-when exercising `connect()`.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-
-import pytest
-from meshtastic_mcp import connection, devices
-
-# ---------- helpers --------------------------------------------------------
-
-
-class TestIsTcpPort:
-    def test_tcp_scheme(self) -> None:
-        assert connection.is_tcp_port("tcp://localhost") is True
-        assert connection.is_tcp_port("tcp://localhost:4403") is True
-        assert connection.is_tcp_port("tcp://192.168.1.50:9999") is True
-
-    def test_serial_paths(self) -> None:
-        assert connection.is_tcp_port("/dev/cu.usbmodem1234") is False
-        assert connection.is_tcp_port("/dev/ttyUSB0") is False
-        assert connection.is_tcp_port("COM3") is False
-
-    def test_empty_or_none(self) -> None:
-        assert connection.is_tcp_port(None) is False
-        assert connection.is_tcp_port("") is False
-
-
-class TestParseTcpPort:
-    def test_default_port(self) -> None:
-        assert connection.parse_tcp_port("tcp://localhost") == ("localhost", 4403)
-
-    def test_explicit_port(self) -> None:
-        assert connection.parse_tcp_port("tcp://localhost:9999") == (
-            "localhost",
-            9999,
-        )
-
-    def test_ip_with_port(self) -> None:
-        assert connection.parse_tcp_port("tcp://192.168.1.50:4403") == (
-            "192.168.1.50",
-            4403,
-        )
-
-
-class TestNormalizeTcpEndpoint:
-    def test_bare_host(self) -> None:
-        assert connection.normalize_tcp_endpoint("localhost") == "tcp://localhost:4403"
-
-    def test_host_port(self) -> None:
-        assert (
-            connection.normalize_tcp_endpoint("localhost:5000")
-            == "tcp://localhost:5000"
-        )
-
-    def test_full_url(self) -> None:
-        assert (
-            connection.normalize_tcp_endpoint("tcp://1.2.3.4") == "tcp://1.2.3.4:4403"
-        )
-        assert (
-            connection.normalize_tcp_endpoint("tcp://1.2.3.4:9999")
-            == "tcp://1.2.3.4:9999"
-        )
-
-    def test_idempotent(self) -> None:
-        once = connection.normalize_tcp_endpoint("localhost:4403")
-        twice = connection.normalize_tcp_endpoint(once)
-        assert once == twice == "tcp://localhost:4403"
-
-    def test_path_like_endpoint_rejected(self) -> None:
-        # Serial port paths and Windows drive paths are common config typos
-        # (someone passes a serial path to MESHTASTIC_MCP_TCP_HOST). Reject
-        # rather than producing a nonsense `tcp:///dev/cu.foo:4403` URL.
-        with pytest.raises(connection.ConnectionError, match="path separator"):
-            connection.normalize_tcp_endpoint("/dev/cu.foo")
-        with pytest.raises(connection.ConnectionError):
-            connection.normalize_tcp_endpoint("tcp:///dev/cu.foo:4403")
-        with pytest.raises(connection.ConnectionError):
-            connection.normalize_tcp_endpoint(r"C:\Windows\System32")
-
-    def test_non_integer_port_rejected(self) -> None:
-        with pytest.raises(connection.ConnectionError, match="not an integer"):
-            connection.normalize_tcp_endpoint("tcp://host:notaport")
-        with pytest.raises(connection.ConnectionError, match="not an integer"):
-            connection.normalize_tcp_endpoint("host:notaport")
-
-    def test_empty_host_rejected(self) -> None:
-        with pytest.raises(connection.ConnectionError, match="empty host"):
-            connection.normalize_tcp_endpoint("tcp://:4403")
-
-    def test_port_out_of_range_rejected(self) -> None:
-        with pytest.raises(connection.ConnectionError, match="out of range"):
-            connection.normalize_tcp_endpoint("tcp://host:0")
-        with pytest.raises(connection.ConnectionError, match="out of range"):
-            connection.normalize_tcp_endpoint("tcp://host:65536")
-        with pytest.raises(connection.ConnectionError, match="out of range"):
-            connection.normalize_tcp_endpoint("host:99999")
-
-
-class TestParseTcpPortValidation:
-    def test_missing_scheme_rejected(self) -> None:
-        # parse_tcp_port is a low-level helper that requires the scheme.
-        # Misuse should fail loudly rather than silently mis-parsing.
-        with pytest.raises(connection.ConnectionError, match="expected"):
-            connection.parse_tcp_port("localhost:4403")
-
-    def test_negative_port_rejected(self) -> None:
-        with pytest.raises(connection.ConnectionError, match="out of range"):
-            connection.parse_tcp_port("tcp://host:-1")
-
-
-# ---------- reject_if_tcp --------------------------------------------------
-
-
-class TestRejectIfTcp:
-    def test_rejects_tcp(self) -> None:
-        with pytest.raises(connection.ConnectionError, match="not applicable"):
-            connection.reject_if_tcp("tcp://localhost", "esptool_chip_info")
-
-    def test_passes_through_serial(self) -> None:
-        connection.reject_if_tcp("/dev/cu.usbmodem1", "esptool_chip_info")  # no raise
-
-    def test_passes_through_none(self) -> None:
-        # None means "auto-detect"; not the explicit-arg case we guard.
-        connection.reject_if_tcp(None, "esptool_chip_info")  # no raise
-
-
-# ---------- resolve_port ---------------------------------------------------
-
-
-class TestResolvePort:
-    def test_explicit_serial_passthrough(self) -> None:
-        assert connection.resolve_port("/dev/cu.usbmodem999") == "/dev/cu.usbmodem999"
-
-    def test_explicit_tcp_normalized(self) -> None:
-        assert connection.resolve_port("tcp://localhost") == "tcp://localhost:4403"
-
-    def test_no_port_no_devices_errors(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
-        with patch.object(devices, "list_devices", return_value=[]):
-            with pytest.raises(
-                connection.ConnectionError, match="No Meshtastic devices"
-            ):
-                connection.resolve_port(None)
-
-    def test_no_port_one_candidate_selected(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
-        fake = [{"port": "/dev/cu.usbmodem1", "likely_meshtastic": True}]
-        with patch.object(devices, "list_devices", return_value=fake):
-            assert connection.resolve_port(None) == "/dev/cu.usbmodem1"
-
-    def test_no_port_multiple_candidates_errors(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
-        fake = [
-            {"port": "/dev/cu.usbmodem1", "likely_meshtastic": True},
-            {"port": "/dev/cu.usbmodem2", "likely_meshtastic": True},
-        ]
-        with patch.object(devices, "list_devices", return_value=fake):
-            with pytest.raises(connection.ConnectionError, match="Multiple"):
-                connection.resolve_port(None)
-
-    def test_env_var_surfaces_tcp_via_devices(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "localhost")
-        # Don't patch list_devices — let the real env-var path run, but stub
-        # the USB enumeration to keep the test hermetic.
-        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
-            assert connection.resolve_port(None) == "tcp://localhost:4403"
-
-
-# ---------- devices.list_devices TCP entry --------------------------------
-
-
-class TestDevicesTcpEntry:
-    def test_no_env_var_no_tcp_entry(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
-        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
-            ds = devices.list_devices()
-        assert all(not d["port"].startswith("tcp://") for d in ds)
-
-    def test_env_var_adds_tcp_entry(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "myhost:9999")
-        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
-            ds = devices.list_devices()
-        tcp = [d for d in ds if d["port"].startswith("tcp://")]
-        assert len(tcp) == 1
-        assert tcp[0]["port"] == "tcp://myhost:9999"
-        assert tcp[0]["likely_meshtastic"] is True
-        assert tcp[0]["description"] == "meshtasticd (TCP)"
-
-    def test_tcp_entry_first_in_results(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "localhost")
-        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
-            ds = devices.list_devices()
-        assert ds, "expected at least the TCP entry"
-        assert ds[0]["port"].startswith("tcp://")
-
-    def test_invalid_env_var_does_not_break_list_devices(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        # `list_devices` is the diagnostic tool reached for when an env var
-        # isn't working — it must not throw on misconfiguration.
-        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "host:notaport")
-        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
-            ds = devices.list_devices(include_unknown=True)
-        tcp = [d for d in ds if "TCP" in (d["description"] or "")]
-        assert len(tcp) == 1
-        assert tcp[0]["likely_meshtastic"] is False
-        assert "invalid MESHTASTIC_MCP_TCP_HOST" in tcp[0]["description"]
-        assert "not an integer" in tcp[0]["description"]
-
-    def test_invalid_env_var_excluded_from_resolve_port_autodetect(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        # `likely_meshtastic=False` keeps the bad TCP entry out of the
-        # auto-select path — `resolve_port(None)` should still report
-        # "no Meshtastic devices" rather than picking a broken endpoint.
-        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "host:notaport")
-        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
-            with pytest.raises(connection.ConnectionError, match="No Meshtastic"):
-                connection.resolve_port(None)
-
-    def test_invalid_env_var_does_not_double_tcp_scheme(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        # If a user mistakenly sets `MESHTASTIC_MCP_TCP_HOST=tcp://host:bad`,
-        # the diagnostic entry must surface the raw value as-is rather than
-        # producing `tcp://tcp://host:bad`.
-        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "tcp://host:notaport")
-        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
-            ds = devices.list_devices(include_unknown=True)
-        tcp = [d for d in ds if "TCP" in (d["description"] or "")]
-        assert len(tcp) == 1
-        assert tcp[0]["port"] == "tcp://host:notaport"
-        assert "tcp://tcp://" not in tcp[0]["port"]
-
-    def test_invalid_env_var_does_not_pre_empt_real_usb_devices(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        # Sort ordering: a misconfigured TCP env var must NOT take position 0
-        # ahead of real USB candidates. Position 0 is reserved for the highest
-        # rank (likely_meshtastic=True), with TCP-before-USB as a tiebreaker
-        # within rank.
-        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "host:notaport")
-
-        # Stub a USB Meshtastic candidate (Espressif VID, port present in
-        # findPorts).
-        class FakeInfo:
-            def __init__(self, device: str, vid: int, pid: int) -> None:
-                self.device = device
-                self.vid = vid
-                self.pid = pid
-                self.description = "Heltec V3"
-                self.manufacturer = "Espressif"
-                self.product = "USB JTAG/serial"
-                self.serial_number = "abc"
-
-        fake_port = FakeInfo("/dev/cu.usbmodem4201", 0x303A, 0x1001)
-        with patch(
-            "meshtastic_mcp.devices.list_ports.comports", return_value=[fake_port]
-        ), patch(
-            "meshtastic.util.findPorts",
-            return_value=["/dev/cu.usbmodem4201"],
-        ):
-            ds = devices.list_devices(include_unknown=True)
-
-        assert ds, "expected at least the USB + TCP entries"
-        # Real USB candidate must be at position 0 — it's likely_meshtastic.
-        assert ds[0]["port"] == "/dev/cu.usbmodem4201"
-        assert ds[0]["likely_meshtastic"] is True
-        # The malformed TCP entry exists but lands among the unlikely entries.
-        tcp = [d for d in ds if "TCP" in (d["description"] or "")]
-        assert len(tcp) == 1
-        assert tcp[0]["likely_meshtastic"] is False
-        assert ds.index(tcp[0]) > 0
-
-    def test_likely_tcp_entry_wins_tiebreak_over_usb(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        # Conversely, a *valid* TCP env var should sort ahead of USB
-        # candidates of equal likely_meshtastic rank — explicit env-var
-        # configuration is a precedence signal.
-        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "localhost:4403")
-
-        class FakeInfo:
-            def __init__(self, device: str, vid: int, pid: int) -> None:
-                self.device = device
-                self.vid = vid
-                self.pid = pid
-                self.description = "Heltec V3"
-                self.manufacturer = "Espressif"
-                self.product = "USB JTAG/serial"
-                self.serial_number = "abc"
-
-        fake_port = FakeInfo("/dev/cu.usbmodem4201", 0x303A, 0x1001)
-        with patch(
-            "meshtastic_mcp.devices.list_ports.comports", return_value=[fake_port]
-        ), patch(
-            "meshtastic.util.findPorts",
-            return_value=["/dev/cu.usbmodem4201"],
-        ):
-            ds = devices.list_devices()
-
-        assert ds[0]["port"] == "tcp://localhost:4403"
-        assert ds[0]["likely_meshtastic"] is True
-
-
-# ---------- connect() routing ---------------------------------------------
-
-
-class TestConnectRoutesTcp:
-    def test_connect_uses_tcp_interface_for_tcp_port(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Verify the TCP branch instantiates `TCPInterface(hostname, portNumber)`
-        and never touches `SerialInterface`."""
-        # Make sure the env var doesn't leak in and confuse resolve_port.
-        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
-
-        with patch("meshtastic.tcp_interface.TCPInterface") as mock_tcp, patch(
-            "meshtastic.serial_interface.SerialInterface"
-        ) as mock_serial:
-            mock_tcp.return_value.close.return_value = None
-            with connection.connect(port="tcp://example.com:1234", timeout_s=12.0):
-                pass
-
-        mock_tcp.assert_called_once_with(
-            hostname="example.com",
-            portNumber=1234,
-            connectNow=True,
-            noProto=False,
-            timeout=12,
-        )
-        mock_serial.assert_not_called()
-
-    def test_connect_plumbs_timeout_to_serial_interface(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Verify the serial branch also propagates `timeout_s` so callers
-        passing a custom timeout to `device_info` / `list_nodes` / etc. don't
-        silently get the library default."""
-        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
-
-        with patch("meshtastic.serial_interface.SerialInterface") as mock_serial, patch(
-            "meshtastic.tcp_interface.TCPInterface"
-        ) as mock_tcp:
-            mock_serial.return_value.close.return_value = None
-            with connection.connect(port="/dev/cu.fake", timeout_s=20.0):
-                pass
-
-        mock_serial.assert_called_once_with(
-            devPath="/dev/cu.fake",
-            connectNow=True,
-            noProto=False,
-            timeout=20,
-        )
-        mock_tcp.assert_not_called()
-
-    def test_connect_releases_lock_on_tcp_failure(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
-        with patch("meshtastic.tcp_interface.TCPInterface") as mock_tcp:
-            mock_tcp.side_effect = RuntimeError("boom")
-            with pytest.raises(RuntimeError, match="boom"):
-                with connection.connect(port="tcp://locktest:4403"):
-                    pass
-
-        # Lock should be released — a second connect attempt must not fail
-        # with "busy".
-        with patch("meshtastic.tcp_interface.TCPInterface") as mock_tcp:
-            mock_tcp.return_value.close.return_value = None
-            with connection.connect(port="tcp://locktest:4403"):
-                pass

platformio.ini

@@ -2,7 +2,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = heltec-v3
+default_envs = tbeam
 
 extra_configs =
 	variants/*/*.ini
@@ -120,7 +120,7 @@ lib_deps =
 [radiolib_base]
 lib_deps =
 	# renovate: datasource=github-tags depName=RadioLib packageName=jgromes/RadioLib
-	https://github.com/jgromes/RadioLib/archive/afe72ae46a343e15e3cac7f26ac585c7f98bffe5.zip
+	https://github.com/jgromes/RadioLib/archive/refs/tags/7.6.0.zip
 
 [device-ui_base]
 lib_deps =
@@ -170,8 +170,8 @@ lib_deps =
 	https://github.com/EmotiBit/EmotiBit_MLX90632/archive/refs/tags/v1.0.8.zip
 	# renovate: datasource=github-tags depName=Adafruit MLX90614 packageName=adafruit/Adafruit_MLX90614
 	https://github.com/adafruit/Adafruit-MLX90614-Library/archive/refs/tags/2.1.6.zip
-	# renovate: datasource=github-tags depName=INA3221_RT packageName=RobTillaart/INA3221_RT
-	https://github.com/RobTillaart/INA3221_RT/archive/refs/tags/0.4.2.zip
+	# renovate: datasource=git-refs depName=INA3221 packageName=https://github.com/sgtwilko/INA3221 gitBranch=FixOverflow
+	https://github.com/sgtwilko/INA3221/archive/bb03d7e9bfcc74fc798838a54f4f99738f29fc6a.zip
 	# renovate: datasource=github-tags depName=QMC5883L Compass packageName=mprograms/QMC5883LCompass
 	https://github.com/mprograms/QMC5883LCompass/archive/refs/tags/v1.2.3.zip
 	# renovate: datasource=github-tags depName=DFRobot_RTU packageName=dfrobot/DFRobot_RTU

src/DebugConfiguration.h

@@ -151,8 +151,9 @@ extern "C" void logLegacy(const char *level, const char *fmt, ...);
 #include <RAK13800_W5100S.h>
 #endif // HAS_ETHERNET
 
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 
 #if HAS_WIFI

src/FSCommon.cpp

@@ -79,46 +79,28 @@ bool copyFile(const char *from, const char *to)
 bool renameFile(const char *pathFrom, const char *pathTo)
 {
 #ifdef FSCom
+
+#ifdef ARCH_ESP32
+    // take SPI Lock
     spiLock->lock();
+    // rename was fixed for ESP32 IDF LittleFS in April
     bool result = FSCom.rename(pathFrom, pathTo);
     spiLock->unlock();
     return result;
 #else
-    return false;
+    // copyFile does its own locking.
+    if (copyFile(pathFrom, pathTo) && FSCom.remove(pathFrom)) {
+        return true;
+    } else {
+        return false;
+    }
+#endif
+
 #endif
 }
 
 #include <vector>
 
-/**
- * @brief Platform-agnostic filesystem format / wipe.
- *
- * On embedded targets (ESP32, NRF52, STM32WL, RP2040) this calls the
- * native FSCom.format() which erases and reinitialises the LittleFS
- * partition.
- *
- * On Portduino the fs::FS backend has no format() method. We instead
- * delete /prefs (the only meshtastic data directory written at runtime)
- * and return. rmDir("/prefs") is already called unconditionally by
- * factoryReset() so this is a proven primitive on Portduino.
- * FSBegin() is a no-op (#define FSBegin() true) on Portduino.
- *
- * @return true on success, false on failure or if no filesystem is configured.
- */
-bool fsFormat()
-{
-#ifdef FSCom
-#if defined(ARCH_PORTDUINO)
-    rmDir("/prefs");
-    return FSBegin();
-#else
-    return FSCom.format();
-#endif
-#else
-    return false;
-#endif
-}
-
 /**
  * @brief Get the list of files in a directory.
  *
@@ -141,21 +123,23 @@ std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels)
 
     File file = root.openNextFile();
     while (file) {
-#ifdef ARCH_ESP32
-        const char *filepath = file.path();
-#else
-        const char *filepath = file.name();
-#endif
         if (file.isDirectory() && !String(file.name()).endsWith(".")) {
             if (levels) {
-                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(filepath, levels - 1);
+#ifdef ARCH_ESP32
+                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(file.path(), levels - 1);
+#else
+                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(file.name(), levels - 1);
+#endif
                 filenames.insert(filenames.end(), subDirFilenames.begin(), subDirFilenames.end());
                 file.close();
             }
         } else {
             meshtastic_FileInfo fileInfo = {"", static_cast<uint32_t>(file.size())};
-            strncpy(fileInfo.file_name, filepath, sizeof(fileInfo.file_name) - 1);
-            fileInfo.file_name[sizeof(fileInfo.file_name) - 1] = '\0';
+#ifdef ARCH_ESP32
+            strcpy(fileInfo.file_name, file.path());
+#else
+            strcpy(fileInfo.file_name, file.name());
+#endif
             if (!String(fileInfo.file_name).endsWith(".")) {
                 filenames.push_back(fileInfo);
             }
@@ -179,59 +163,98 @@ std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels)
 void listDir(const char *dirname, uint8_t levels, bool del)
 {
 #ifdef FSCom
+#if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
     char buffer[255];
+#endif
     File root = FSCom.open(dirname, FILE_O_READ);
-    if (!root || !root.isDirectory())
+    if (!root) {
         return;
+    }
+    if (!root.isDirectory()) {
+        return;
+    }
 
     File file = root.openNextFile();
-    while (file && file.name()[0]) { // file.name()[0] check: workaround for Adafruit LittleFS nRF52 bug #4395
-#ifdef ARCH_ESP32
-        const char *filepath = file.path();
-#else
-        const char *filepath = file.name();
-#endif
+    while (
+        file &&
+        file.name()[0]) { // This file.name() check is a workaround for a bug in the Adafruit LittleFS nrf52 glue (see issue 4395)
         if (file.isDirectory() && !String(file.name()).endsWith(".")) {
             if (levels) {
-                listDir(filepath, levels - 1, del);
+#ifdef ARCH_ESP32
+                listDir(file.path(), levels - 1, del);
                 if (del) {
-                    LOG_DEBUG("Remove %s", filepath);
-                    strncpy(buffer, filepath, sizeof(buffer) - 1);
-                    buffer[sizeof(buffer) - 1] = '\0';
+                    LOG_DEBUG("Remove %s", file.path());
+                    strncpy(buffer, file.path(), sizeof(buffer));
                     file.close();
                     FSCom.rmdir(buffer);
                 } else {
                     file.close();
                 }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+                listDir(file.name(), levels - 1, del);
+                if (del) {
+                    LOG_DEBUG("Remove %s", file.name());
+                    strncpy(buffer, file.name(), sizeof(buffer));
+                    file.close();
+                    FSCom.rmdir(buffer);
+                } else {
+                    file.close();
+                }
+#else
+                LOG_DEBUG(" %s (directory)", file.name());
+                listDir(file.name(), levels - 1, del);
+                file.close();
+#endif
             }
         } else {
+#ifdef ARCH_ESP32
             if (del) {
-                LOG_DEBUG("Delete %s", filepath);
-                strncpy(buffer, filepath, sizeof(buffer) - 1);
-                buffer[sizeof(buffer) - 1] = '\0';
+                LOG_DEBUG("Delete %s", file.path());
+                strncpy(buffer, file.path(), sizeof(buffer));
                 file.close();
                 FSCom.remove(buffer);
             } else {
-                LOG_DEBUG(" %s (%i Bytes)", filepath, file.size());
+                LOG_DEBUG(" %s (%i Bytes)", file.path(), file.size());
                 file.close();
             }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+            if (del) {
+                LOG_DEBUG("Delete %s", file.name());
+                strncpy(buffer, file.name(), sizeof(buffer));
+                file.close();
+                FSCom.remove(buffer);
+            } else {
+                LOG_DEBUG(" %s (%i Bytes)", file.name(), file.size());
+                file.close();
+            }
+#else
+            LOG_DEBUG("   %s (%i Bytes)", file.name(), file.size());
+            file.close();
+#endif
         }
         file = root.openNextFile();
     }
 #ifdef ARCH_ESP32
-    const char *rootpath = root.path();
-#else
-    const char *rootpath = root.name();
-#endif
     if (del) {
-        LOG_DEBUG("Remove %s", rootpath);
-        strncpy(buffer, rootpath, sizeof(buffer) - 1);
-        buffer[sizeof(buffer) - 1] = '\0';
+        LOG_DEBUG("Remove %s", root.path());
+        strncpy(buffer, root.path(), sizeof(buffer));
         root.close();
         FSCom.rmdir(buffer);
     } else {
         root.close();
     }
+#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
+    if (del) {
+        LOG_DEBUG("Remove %s", root.name());
+        strncpy(buffer, root.name(), sizeof(buffer));
+        root.close();
+        FSCom.rmdir(buffer);
+    } else {
+        root.close();
+    }
+#else
+    root.close();
+#endif
 #endif
 }
 
@@ -245,7 +268,14 @@ void listDir(const char *dirname, uint8_t levels, bool del)
 void rmDir(const char *dirname)
 {
 #ifdef FSCom
+
+#if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
     listDir(dirname, 10, true);
+#elif defined(ARCH_NRF52)
+    // nRF52 implementation of LittleFS has a recursive delete function
+    FSCom.rmdir_r(dirname);
+#endif
+
 #endif
 }
 
@@ -277,7 +307,7 @@ void fsInit()
  */
 void setupSDCard()
 {
-#if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI) && !defined(HAS_SD_MMC)
+#if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI)
     concurrency::LockGuard g(spiLock);
     SDHandler.begin(SPI_SCK, SPI_MISO, SPI_MOSI);
     if (!SD.begin(SDCARD_CS, SDHandler, SD_SPI_FREQUENCY)) {

src/FSCommon.h

@@ -52,7 +52,6 @@ void fsInit();
 void fsListFiles();
 bool copyFile(const char *from, const char *to);
 bool renameFile(const char *pathFrom, const char *pathTo);
-bool fsFormat();
 std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels);
 void listDir(const char *dirname, uint8_t levels, bool del = false);
 void rmDir(const char *dirname);

src/SafeFile.cpp

@@ -7,6 +7,10 @@ static File openFile(const char *filename, bool fullAtomic)
 {
     concurrency::LockGuard g(spiLock);
     LOG_DEBUG("Opening %s, fullAtomic=%d", filename, fullAtomic);
+#ifdef ARCH_NRF52
+    FSCom.remove(filename);
+    return FSCom.open(filename, FILE_O_WRITE);
+#endif
     if (!fullAtomic) {
         FSCom.remove(filename); // Nuke the old file to make space (ignore if it !exists)
     }
@@ -63,6 +67,9 @@ bool SafeFile::close()
     f.close();
     spiLock->unlock();
 
+#ifdef ARCH_NRF52
+    return true;
+#endif
     if (!testReadback())
         return false;
 

src/configuration.h

@@ -80,7 +80,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 // Pre-hop drop handling (compile-time flag).
 #ifndef MESHTASTIC_PREHOP_DROP
-#define MESHTASTIC_PREHOP_DROP 1
+#define MESHTASTIC_PREHOP_DROP 0
 #endif
 
 /// Convert a preprocessor name into a quoted string

src/graphics/niche/InkHUD/MessageStore.cpp

@@ -53,11 +53,10 @@ void InkHUD::MessageStore::saveToFlash()
         f.write(reinterpret_cast<const uint8_t *>(&m.timestamp), sizeof(m.timestamp));       // Write timestamp. 4 bytes
         f.write(reinterpret_cast<const uint8_t *>(&m.sender), sizeof(m.sender));             // Write sender NodeId. 4 Bytes
         f.write(reinterpret_cast<const uint8_t *>(&m.channelIndex), sizeof(m.channelIndex)); // Write channel index. 1 Byte
-        f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()),
-                min((size_t)MAX_MESSAGE_SIZE, m.text.size())); // Write message text
-        f.write('\0');                                         // Append null term
-        LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i),
-                  min((size_t)MAX_MESSAGE_SIZE, m.text.size()), m.text.c_str());
+        f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()), min(MAX_MESSAGE_SIZE, m.text.size())); // Write message text
+        f.write('\0');                                                                                    // Append null term
+        LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i), min(MAX_MESSAGE_SIZE, m.text.size()),
+                  m.text.c_str());
     }
 
     // Release firmware's SPI lock, because SafeFile::close needs it

src/input/ExpressLRSFiveWay.h

@@ -13,8 +13,6 @@
 
 #ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
 
-// REVISIT esp_adc_cal.h
-// "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h"
 #include <esp_adc_cal.h>
 #include <soc/adc_channel.h>
 

src/input/TLoraPagerKeyboard.cpp

@@ -68,7 +68,7 @@ TLoraPagerKeyboard::TLoraPagerKeyboard()
     : TCA8418KeyboardBase(_TCA8418_ROWS, _TCA8418_COLS), modifierFlag(0), last_modifier_time(0), last_key(UINT8_MAX),
       next_key(UINT8_MAX), last_tap(0L), char_idx(0), tap_interval(0)
 {
-#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
     ledcAttach(KB_BL_PIN, LEDC_BACKLIGHT_FREQ, LEDC_BACKLIGHT_BIT_WIDTH);
 #else
     ledcSetup(LEDC_BACKLIGHT_CHANNEL, LEDC_BACKLIGHT_FREQ, LEDC_BACKLIGHT_BIT_WIDTH);
@@ -108,7 +108,7 @@ void TLoraPagerKeyboard::setBacklight(bool on)
     uint32_t _brightness = 0;
     if (on)
         _brightness = brightness;
-#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
     ledcWrite(KB_BL_PIN, _brightness);
 #else
     ledcWrite(LEDC_BACKLIGHT_CHANNEL, _brightness);

src/mesh/NodeDB.cpp

@@ -1611,10 +1611,12 @@ bool NodeDB::saveToDisk(int saveWhat)
 
     if (!success) {
         LOG_ERROR("Failed to save to disk, retrying");
+#ifdef ARCH_NRF52 // @geeksville is not ready yet to say we should do this on other platforms.  See bug #4184 discussion
         spiLock->lock();
-        fsFormat();
+        FSCom.format();
         spiLock->unlock();
 
+#endif
         success = saveToDiskNoRetry(saveWhat);
 
         RECORD_CRITICALERROR(success ? meshtastic_CriticalErrorCode_FLASH_CORRUPTION_RECOVERABLE

src/mesh/PhoneAPI.cpp

@@ -522,6 +522,11 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
             // LOG_INFO("nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s", nodeInfoForPhone.num, nodeInfoForPhone.last_heard,
             // nodeInfoForPhone.user.id, nodeInfoForPhone.user.long_name);
 
+            // Occasional progress logging. (readIndex==2 will be true for the first non-us node)
+            if (readIndex == 2 || readIndex % 20 == 0) {
+                LOG_DEBUG("nodeinfo: %d/%d", readIndex, nodeDB->getNumMeshNodes());
+            }
+
             fromRadioScratch.which_payload_variant = meshtastic_FromRadio_node_info_tag;
             fromRadioScratch.node_info = infoToSend;
             prefetchNodeInfos();
@@ -652,11 +657,9 @@ void PhoneAPI::releaseQueueStatusPhonePacket()
 void PhoneAPI::prefetchNodeInfos()
 {
     bool added = false;
-    bool wasEmpty = false;
     // Keep the queue topped up so BLE reads stay responsive even if DB fetches take a moment.
     {
         concurrency::LockGuard guard(&nodeInfoMutex);
-        wasEmpty = nodeInfoQueue.empty();
         while (nodeInfoQueue.size() < kNodePrefetchDepth) {
             auto nextNode = nodeDB->readNextMeshNode(readIndex);
             if (!nextNode)
@@ -670,15 +673,11 @@ void PhoneAPI::prefetchNodeInfos()
             info.via_mqtt = isUs ? false : info.via_mqtt;
             info.is_favorite = info.is_favorite || isUs;
             nodeInfoQueue.push_back(info);
-            // Log progress here (at fetch time) so readIndex is accurate and each value logs only once.
-            if (readIndex == 2 || readIndex % 20 == 0) {
-                LOG_DEBUG("nodeinfo: %d/%d", readIndex, nodeDB->getNumMeshNodes());
-            }
             added = true;
         }
     }
 
-    if (added && wasEmpty)
+    if (added)
         onNowHasData(0);
 }
 

src/mesh/RadioLibInterface.h

@@ -179,6 +179,8 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
     virtual bool findInTxQueue(NodeNum from, PacketId id) override;
 
+    uint8_t packetsInTxQueue() { return txQueue.getMaxLen() - txQueue.getFree(); }
+
     /**
      * Request randomness sourced from the LoRa modem, if supported by the active RadioLib interface.
      * @return true if len bytes were produced, false otherwise.

src/mesh/api/WiFiServerAPI.h

@@ -3,8 +3,9 @@
 #include "ServerAPI.h"
 #include <WiFi.h>
 
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 
 /**

src/mesh/http/WebServer.cpp

@@ -13,8 +13,9 @@
 #include <WebServer.h>
 #include <WiFi.h>
 
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 
 #ifdef ARCH_ESP32

src/mesh/raspihttp/PiWebServer.cpp

@@ -1,34 +1,22 @@
 /*
-Adds a WebServer and WebService callbacks to meshtastic via the Portduino/native target (Linux and
-macOS). The WebServer & Webservices run in a real host thread beside the Portduino threading
-emulation. It replaces the complete ESP32 Webserver libs including generation of SSL certificates,
-because those libs use ESP-specific details that can't be emulated.
+Adds a WebServer and WebService callbacks to meshtastic as Linux Version. The WebServer & Webservices
+runs in a real linux thread beside the portdunio threading emulation. It replaces the complete ESP32
+Webserver libs including generation of SSL certifcicates,  because the use ESP specific details in
+the lib that can't be emulated.
 
 The WebServices adapt to the two major phoneapi functions "handleAPIv1FromRadio,handleAPIv1ToRadio"
-The WebServer just adds basic support to deliver WebContent, so it can be used to
-deliver the WebGui defined by the WebClient Project.
+The WebServer just adds basaic support to deliver WebContent, so it can be used to
+deliver the WebGui definded by the WebClient Project.
 
 Steps to get it running:
-
-Linux (apt):
-1.) Add these libs to the compile and target machine:
+1.) Add these Linux Libs to the compile and target machine:
 
     sudo apt update && \
-        apt -y install openssl libssl-dev libsdl2-dev \
+        apt -y install openssl libssl-dev libopenssl libsdl2-dev \
                      libulfius-dev liborcania-dev
 
-macOS (Homebrew):
-1.) Install prerequisites via Homebrew:
-
-    brew install ulfius openssl@3
-
-    The PlatformIO env (native-macos) picks up compiler/linker flags via
-    `pkg-config`. In particular, OpenSSL needs `pkg-config --cflags --libs openssl@3`
-    so both the Homebrew include path and linker flags are provided; ulfius and its
-    dependencies (liborcania, libyder) are also resolved via `pkg-config`.
-
 2.) Configure the root directory of the web Content in the config.yaml file.
-    The following tags should be included and set at your needs
+    The followinng tags should be included and set at your needs
 
     Example entry in the config.yaml
     Webserver:
@@ -46,10 +34,7 @@ Author: Marc Philipp Hammermann
 mail:   marchammermann@googlemail.com
 
 */
-// Mirrors the guard in PiWebServer.h — see comment there. macOS Homebrew
-// provides ulfius + deps; Linux pulls them via apt. Either way, this
-// translation unit only compiles when the headers are present.
-#ifdef ARCH_PORTDUINO
+#ifdef PORTDUINO_LINUX_HARDWARE
 #if __has_include(<ulfius.h>)
 #include "PiWebServer.h"
 #include "NodeDB.h"

src/mesh/raspihttp/PiWebServer.h

@@ -1,9 +1,5 @@
 #pragma once
-// Portduino webserver is built whenever the ulfius headers are reachable,
-// not only on Linux. macOS users can `brew install ulfius` to enable it;
-// without ulfius the entire body is skipped and main.cpp's matching
-// __has_include guard avoids referencing the type.
-#ifdef ARCH_PORTDUINO
+#ifdef PORTDUINO_LINUX_HARDWARE
 #if __has_include(<ulfius.h>)
 #include "PhoneAPI.h"
 #include "ulfius-cfg.h"

src/mesh/udp/UdpMulticastHandler.h

@@ -12,8 +12,9 @@
 
 #include <AsyncUDP.h>
 
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 
 #define UDP_MULTICAST_DEFAUL_PORT 4403 // Default port for UDP multicast is same as TCP api server

src/mesh/wifi/WiFiAPClient.cpp

@@ -10,8 +10,9 @@
 #include "target_specific.h"
 #include <WiFi.h>
 
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 
 #include <WiFiUdp.h>

src/mesh/wifi/WiFiAPClient.h

@@ -9,8 +9,9 @@
 #include <WiFi.h>
 #endif
 
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 
 extern bool needReconnect;

src/modules/AdminModule.cpp

@@ -262,7 +262,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
         break;
     }
     case meshtastic_AdminMessage_ota_request_tag: {
-#if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WIFI
+#if defined(ARCH_ESP32)
         LOG_INFO("OTA Requested");
 
         if (r->ota_request.ota_hash.size != 32) {
@@ -1412,9 +1412,7 @@ void AdminModule::saveChanges(int saveWhat, bool shouldReboot)
 
 void AdminModule::handleStoreDeviceUIConfig(const meshtastic_DeviceUIConfig &uicfg)
 {
-#if HAS_SCREEN
     nodeDB->saveProto("/prefs/uiconfig.proto", meshtastic_DeviceUIConfig_size, &meshtastic_DeviceUIConfig_msg, &uicfg);
-#endif
 }
 
 void AdminModule::handleSetHamMode(const meshtastic_HamParameters &p)

src/modules/DMShell.cpp

@@ -0,0 +1,604 @@
+#include "DMShell.h"
+
+#if defined(ARCH_PORTDUINO)
+
+#include "Channels.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "Throttle.h"
+#include "configuration.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
+#include "mesh/mesh-pb-constants.h"
+#include "pb_decode.h"
+#include "pb_encode.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <pty.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+DMShellModule *dmShellModule;
+
+namespace
+{
+constexpr uint16_t PTY_COLS_DEFAULT = 120;
+constexpr uint16_t PTY_ROWS_DEFAULT = 40;
+constexpr size_t MAX_MESSAGE_SIZE = 200;
+} // namespace
+
+DMShellModule::DMShellModule()
+    : SinglePortModule("DMShellModule", meshtastic_PortNum_REMOTE_SHELL_APP), concurrency::OSThread("DMShell", 100)
+{
+    LOG_WARN("DMShell enabled on Portduino: remote shell access is dangerous and intended for trusted debugging only");
+}
+
+ProcessMessage DMShellModule::handleReceived(const meshtastic_MeshPacket &mp)
+{
+    meshtastic_RemoteShell frame = meshtastic_RemoteShell_init_zero;
+    if (!mp.pki_encrypted) {
+        LOG_WARN("DMShell: ignoring packet without PKI from 0x%x", mp.from);
+        return ProcessMessage::STOP;
+    }
+
+    if (!parseFrame(mp, frame)) {
+        LOG_WARN("DMShell: ignoring malformed frame");
+        return ProcessMessage::STOP;
+    }
+
+    if (frame.op == meshtastic_RemoteShell_OpCode_ACK) {
+        if (session.active && frame.session_id == session.sessionId && getFrom(&mp) == session.peer && frame.last_rx_seq > 0) {
+            resendFramesFrom(frame.last_rx_seq + 1);
+        }
+        return ProcessMessage::CONTINUE;
+    }
+
+    if (frame.op >= 64) {
+        LOG_WARN("DMShell: ignoring frame with op code %d, seq %d", frame.op, frame.seq);
+        return ProcessMessage::CONTINUE;
+    }
+
+    if (!isAuthorizedPacket(mp)) {
+        LOG_WARN("DMShell: unauthorized sender 0x%x, %u", mp.from, frame.op);
+        myReply = allocErrorResponse(meshtastic_Routing_Error_NOT_AUTHORIZED, &mp);
+        return ProcessMessage::STOP;
+    }
+
+    if (frame.op == meshtastic_RemoteShell_OpCode_OPEN) {
+        LOG_WARN("DMShell: received OPEN from 0x%x sessionId=0x%x", mp.from, frame.session_id);
+        if (!openSession(mp, frame)) {
+            sendError("open_failed", getFrom(&mp));
+        }
+        return ProcessMessage::STOP;
+    }
+
+    if (!session.active || frame.session_id != session.sessionId || getFrom(&mp) != session.peer) {
+        if (!session.active) {
+            LOG_WARN("DMShell: no active session, rejecting op %d from 0x%x", frame.op, mp.from);
+        } else {
+            LOG_WARN("DMShell: session ID mismatch (got 0x%x expected 0x%x) or peer mismatch (got 0x%x expected 0x%x), rejecting "
+                     "op %d",
+                     frame.session_id, session.sessionId, mp.from, session.peer, frame.op);
+        }
+        sendError("invalid_session", getFrom(&mp));
+        return ProcessMessage::STOP;
+    }
+
+    if (!shouldProcessIncomingFrame(frame)) {
+        return ProcessMessage::STOP;
+    }
+
+    session.lastActivityMs = millis();
+
+    switch (frame.op) {
+    case meshtastic_RemoteShell_OpCode_INPUT:
+        if (!writeSessionInput(frame)) {
+            sendError("input_write_failed");
+        } else {
+            uint8_t outBuf[MAX_MESSAGE_SIZE];
+            const ssize_t bytesRead = read(session.masterFd, outBuf, sizeof(outBuf));
+            if (bytesRead > 0) {
+                LOG_WARN("DMShell: read %zd bytes from PTY", bytesRead);
+                meshtastic_RemoteShell frame = {
+                    .op = meshtastic_RemoteShell_OpCode_OUTPUT,
+                    .session_id = session.sessionId,
+                    .seq = session.nextTxSeq++,
+                    .ack_seq = session.lastAckedRxSeq,
+                    .cols = 0,
+                    .rows = 0,
+                    .flags = 0,
+                };
+                assert(bytesRead <= sizeof(frame.payload.bytes));
+                memcpy(frame.payload.bytes, outBuf, bytesRead);
+                frame.payload.size = bytesRead;
+                sendFrameToPeer(session.peer, frame, true);
+                session.lastActivityMs = millis();
+            }
+        }
+        break;
+    case meshtastic_RemoteShell_OpCode_RESIZE:
+        if (frame.rows > 0 && frame.cols > 0) {
+            struct winsize ws = {};
+            ws.ws_row = frame.rows;
+            ws.ws_col = frame.cols;
+            if (session.masterFd >= 0) {
+                ioctl(session.masterFd, TIOCSWINSZ, &ws);
+            }
+        }
+        break;
+    case meshtastic_RemoteShell_OpCode_PING: {
+        uint32_t peerLastRxSeq = frame.ack_seq;
+        if (frame.last_rx_seq > 0) {
+            peerLastRxSeq = frame.last_rx_seq;
+        }
+
+        const uint32_t nextMissingForPeer = peerLastRxSeq + 1;
+        if (nextMissingForPeer > 0 && nextMissingForPeer < session.nextTxSeq) {
+            resendFramesFrom(nextMissingForPeer);
+        }
+
+        meshtastic_RemoteShell frame = {
+            .op = meshtastic_RemoteShell_OpCode_PONG,
+            .session_id = session.sessionId,
+            .seq = session.nextTxSeq++,
+            .ack_seq = session.lastAckedRxSeq,
+            .cols = 0,
+            .rows = 0,
+            .flags = 0,
+            .last_tx_seq = session.nextTxSeq > 0 ? session.nextTxSeq - 1 : 0,
+            .last_rx_seq = session.lastAckedRxSeq,
+        };
+        frame.payload.size = 0;
+        sendFrameToPeer(session.peer, frame, true);
+        break;
+    }
+    case meshtastic_RemoteShell_OpCode_CLOSE:
+        closeSession("peer_close", true);
+        break;
+    default:
+        sendError("unsupported_op");
+        break;
+    }
+
+    return ProcessMessage::STOP;
+}
+
+int32_t DMShellModule::runOnce()
+{
+    processPendingChildReap();
+
+    if (!session.active) {
+        return 100;
+    }
+
+    reapChildIfExited();
+    if (!session.active) {
+        return 100;
+    }
+
+    if (Throttle::isWithinTimespanMs(session.lastActivityMs, SESSION_IDLE_TIMEOUT_MS) == false) {
+        closeSession("idle_timeout", true);
+        return 100;
+    }
+
+    if (RadioLibInterface::instance->packetsInTxQueue() > 1) {
+        return 50;
+    }
+
+    uint8_t outBuf[MAX_MESSAGE_SIZE];
+    while (session.masterFd >= 0) {
+        const ssize_t bytesRead = read(session.masterFd, outBuf, sizeof(outBuf));
+        if (bytesRead > 0) {
+            LOG_WARN("DMShell: read %zd bytes from PTY", bytesRead);
+
+            meshtastic_RemoteShell frame = {
+                .op = meshtastic_RemoteShell_OpCode_OUTPUT,
+                .session_id = session.sessionId,
+                .seq = session.nextTxSeq++,
+                .ack_seq = session.lastAckedRxSeq,
+                .cols = 0,
+                .rows = 0,
+                .flags = 0,
+            };
+            assert(bytesRead <= sizeof(frame.payload.bytes));
+            memcpy(frame.payload.bytes, outBuf, bytesRead);
+            frame.payload.size = bytesRead;
+            sendFrameToPeer(session.peer, frame, true);
+
+            session.lastActivityMs = millis();
+            // continue;
+            // do we want to ack every data message, and only send the next on ack?
+            // would require some retry logic. Maybe re-use the wantAck bit
+            return 50;
+        }
+
+        if (bytesRead == 0) {
+            closeSession("pty_eof", true);
+            break;
+        }
+
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
+            break;
+        }
+
+        LOG_WARN("DMShell: PTY read error errno=%d", errno);
+        closeSession("pty_read_error", true);
+        break;
+    }
+
+    return 100;
+}
+
+bool DMShellModule::parseFrame(const meshtastic_MeshPacket &mp, meshtastic_RemoteShell &outFrame)
+{
+    if (mp.which_payload_variant != meshtastic_MeshPacket_decoded_tag) {
+        return false;
+    }
+
+    if (pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, meshtastic_RemoteShell_fields, &outFrame)) {
+        LOG_INFO("Received a DMShell message");
+    } else {
+        LOG_ERROR("Error decoding DMShell message!");
+        return false;
+    }
+
+    return true;
+}
+
+bool DMShellModule::isAuthorizedPacket(const meshtastic_MeshPacket &mp) const
+{
+    if (mp.from == 0) {
+        return !config.security.is_managed;
+    }
+
+    const meshtastic_Channel *ch = &channels.getByIndex(mp.channel);
+    if (strcasecmp(ch->settings.name, Channels::adminChannel) == 0) {
+        return config.security.admin_channel_enabled;
+    }
+
+    if (mp.pki_encrypted) {
+        for (uint8_t i = 0; i < 3; ++i) {
+            if (config.security.admin_key[i].size == 32 &&
+                memcmp(mp.public_key.bytes, config.security.admin_key[i].bytes, 32) == 0) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool DMShellModule::openSession(const meshtastic_MeshPacket &mp, const meshtastic_RemoteShell &frame)
+{
+    if (session.active) {
+        closeSession("preempted", false);
+    }
+
+    int masterFd = -1;
+    struct winsize ws = {};
+    if (frame.rows > 0) {
+        ws.ws_row = frame.rows;
+    } else {
+        ws.ws_row = PTY_ROWS_DEFAULT;
+    }
+    if (frame.cols > 0) {
+        ws.ws_col = frame.cols;
+    } else {
+        ws.ws_col = PTY_COLS_DEFAULT;
+    }
+    const pid_t childPid = forkpty(&masterFd, nullptr, nullptr, &ws);
+    if (childPid < 0) {
+        LOG_ERROR("DMShell: forkpty failed errno=%d", errno);
+        return false;
+    }
+
+    if (childPid == 0) {
+        const char *shell = getenv("SHELL");
+        if (!shell || !*shell) {
+            shell = "/bin/sh";
+        }
+        execl(shell, shell, "-i", static_cast<char *>(nullptr));
+        _exit(127);
+    }
+
+    const int flags = fcntl(masterFd, F_GETFL, 0);
+    if (flags >= 0) {
+        fcntl(masterFd, F_SETFL, flags | O_NONBLOCK);
+    }
+
+    session.active = true;
+    session.sessionId = (frame.session_id != 0) ? frame.session_id : static_cast<uint32_t>(random(1, 0x7fffffff));
+    session.peer = getFrom(&mp);
+    session.channel = mp.channel;
+    session.masterFd = masterFd;
+    session.childPid = childPid;
+    session.nextTxSeq = 1;
+    session.lastAckedRxSeq = frame.seq;
+    session.nextExpectedRxSeq = frame.seq + 1;
+    session.highestSeenRxSeq = frame.seq;
+    session.lastActivityMs = millis();
+
+    meshtastic_RemoteShell newFrame = {
+        .op = meshtastic_RemoteShell_OpCode_OPEN_OK,
+        .session_id = session.sessionId,
+        .seq = session.nextTxSeq++,
+        .ack_seq = frame.seq,
+        .cols = ws.ws_col,
+        .rows = ws.ws_row,
+        .flags = 0,
+    };
+    newFrame.payload.size = 0;
+    sendFrameToPeer(session.peer, newFrame, true);
+
+    LOG_INFO("DMShell: opened session=0x%x peer=0x%x pid=%d", session.sessionId, session.peer, session.childPid);
+    return true;
+}
+
+bool DMShellModule::writeSessionInput(const meshtastic_RemoteShell &frame)
+{
+    if (session.masterFd < 0) {
+        return false;
+    }
+    if (frame.payload.size == 0) {
+        return true;
+    }
+
+    const ssize_t bytesWritten = write(session.masterFd, frame.payload.bytes, frame.payload.size);
+    return bytesWritten >= 0;
+}
+
+void DMShellModule::closeSession(const char *reason, bool notifyPeer)
+{
+    if (!session.active) {
+        return;
+    }
+
+    if (notifyPeer) {
+        const size_t reasonLen = strnlen(reason, 256);
+        meshtastic_RemoteShell frame = {
+            .op = meshtastic_RemoteShell_OpCode_CLOSED,
+            .session_id = session.sessionId,
+            .seq = session.nextTxSeq++,
+            .ack_seq = session.lastAckedRxSeq,
+            .cols = 0,
+            .rows = 0,
+            .flags = 0,
+        };
+        assert(reasonLen <= sizeof(frame.payload.bytes));
+        memcpy(frame.payload.bytes, reason, reasonLen);
+        frame.payload.size = reasonLen;
+        sendFrameToPeer(session.peer, frame, true);
+    }
+
+    if (session.masterFd >= 0) {
+        close(session.masterFd);
+        session.masterFd = -1;
+    }
+
+    if (session.childPid > 0) {
+        // Run this to avoid forgetting a child
+        processPendingChildReap();
+
+        if (kill(session.childPid, SIGTERM) < 0 && errno != ESRCH) {
+            LOG_WARN("DMShell: failed to send SIGTERM to pid=%d errno=%d", session.childPid, errno);
+        }
+
+        pendingChildPid = session.childPid;
+        session.childPid = -1;
+    }
+
+    LOG_INFO("DMShell: closed session=0x%x reason=%s", session.sessionId, reason);
+    session = DMShellSession{};
+}
+
+void DMShellModule::reapChildIfExited()
+{
+    if (!session.active || session.childPid <= 0) {
+        return;
+    }
+
+    int status = 0;
+    const pid_t result = waitpid(session.childPid, &status, WNOHANG);
+    if (result == session.childPid) {
+        closeSession("shell_exited", true);
+    }
+}
+
+void DMShellModule::processPendingChildReap()
+{
+    if (pendingChildPid <= 0) {
+        return;
+    }
+
+    int status = 0;
+    const pid_t result = waitpid(pendingChildPid, &status, WNOHANG);
+
+    if (result == pendingChildPid || (result < 0 && errno == ECHILD)) {
+        pendingChildPid = -1;
+        return;
+    }
+
+    if (result < 0) {
+        LOG_WARN("DMShell: waitpid failed for pid=%d errno=%d", pendingChildPid, errno);
+        pendingChildPid = -1;
+        return;
+    }
+
+    if (pendingChildPid > 0) {
+        if (kill(pendingChildPid, SIGKILL) < 0 && errno != ESRCH) {
+            LOG_WARN("DMShell: failed to send SIGKILL to pid=%d errno=%d", pendingChildPid, errno);
+        }
+        pendingChildPid = -1;
+    }
+}
+
+void DMShellModule::rememberSentFrame(meshtastic_RemoteShell frame)
+{
+    if (frame.seq == 0 || frame.op == meshtastic_RemoteShell_OpCode_ACK) {
+        return;
+    }
+
+    auto &entry = session.txHistory[session.txHistoryNext];
+    entry.valid = true;
+    entry.op = frame.op;
+    entry.sessionId = frame.session_id;
+    entry.seq = frame.seq;
+    entry.ackSeq = frame.ack_seq;
+    entry.cols = frame.cols;
+    entry.rows = frame.rows;
+    entry.flags = frame.flags;
+    entry.payloadLen = frame.payload.size;
+    if (frame.payload.size > 0) {
+        memcpy(entry.payload, frame.payload.bytes, frame.payload.size);
+    }
+
+    session.txHistoryNext = (session.txHistoryNext + 1) % session.txHistory.size();
+}
+
+void DMShellModule::resendFramesFrom(uint32_t startSeq)
+{
+    if (startSeq == 0) {
+        return;
+    }
+
+    DMShellSession::SentFrame *match = nullptr;
+    for (auto &entry : session.txHistory) {
+        if (!entry.valid || entry.seq != startSeq) {
+            continue;
+        }
+        match = &entry;
+        break;
+    }
+
+    if (!match) {
+        LOG_WARN("DMShell: replay request for seq=%u not found in history", startSeq);
+        return;
+    }
+
+    LOG_INFO("DMShell: replaying frame seq=%u op=%d", match->seq, match->op);
+    meshtastic_RemoteShell frame = {
+        .op = match->op,
+        .session_id = match->sessionId,
+        .seq = match->seq,
+        .ack_seq = match->ackSeq,
+        .cols = match->cols,
+        .rows = match->rows,
+        .flags = match->flags,
+    };
+    assert(match->payloadLen <= sizeof(frame.payload.bytes));
+    memcpy(frame.payload.bytes, match->payload, match->payloadLen);
+    frame.payload.size = match->payloadLen;
+    sendFrameToPeer(session.peer, frame, false);
+}
+
+void DMShellModule::sendAck(uint32_t replayFromSeq)
+{
+    if (replayFromSeq > 0) {
+        LOG_WARN("DMShell: requesting replay from seq=%u", replayFromSeq);
+    }
+    meshtastic_RemoteShell frame = {
+        .op = meshtastic_RemoteShell_OpCode_ACK,
+        .session_id = session.sessionId,
+        .seq = 0,
+        .ack_seq = session.lastAckedRxSeq,
+        .cols = 0,
+        .rows = 0,
+        .flags = 0,
+        .last_rx_seq = replayFromSeq - 1,
+    };
+    frame.payload.size = 0;
+    sendFrameToPeer(session.peer, frame, false);
+}
+
+bool DMShellModule::shouldProcessIncomingFrame(const meshtastic_RemoteShell &frame)
+{
+    if (frame.seq == 0) {
+        return true;
+    }
+
+    if (frame.seq < session.nextExpectedRxSeq) {
+        if (session.highestSeenRxSeq >= session.nextExpectedRxSeq) {
+            sendAck(session.nextExpectedRxSeq);
+        } else {
+            sendAck();
+        }
+        return false;
+    }
+
+    if (frame.seq > session.nextExpectedRxSeq) {
+        if (frame.seq > session.highestSeenRxSeq) {
+            session.highestSeenRxSeq = frame.seq;
+        }
+        sendAck(session.nextExpectedRxSeq);
+        return false;
+    }
+
+    session.lastAckedRxSeq = frame.seq;
+    session.nextExpectedRxSeq = frame.seq + 1;
+    if (frame.seq > session.highestSeenRxSeq) {
+        session.highestSeenRxSeq = frame.seq;
+    }
+    if (session.highestSeenRxSeq >= session.nextExpectedRxSeq) {
+        sendAck(session.nextExpectedRxSeq);
+    } else {
+        session.highestSeenRxSeq = 0;
+    }
+    return true;
+}
+
+void DMShellModule::sendFrameToPeer(NodeNum peer, meshtastic_RemoteShell frame, bool remember)
+{
+    meshtastic_MeshPacket *packet = allocDataPacket();
+    if (!packet) {
+        return;
+    }
+    LOG_WARN("DMShell: building packet op=%u session=0x%x seq=%u payloadLen=%zu", frame.op, frame.session_id, frame.seq,
+             frame.payload.size);
+    const size_t encoded = pb_encode_to_bytes(packet->decoded.payload.bytes, sizeof(packet->decoded.payload.bytes),
+                                              meshtastic_RemoteShell_fields, &frame);
+    if (encoded == 0) {
+        return;
+    }
+    packet->decoded.payload.size = encoded;
+
+    if (remember) {
+        rememberSentFrame(frame);
+    }
+
+    packet->to = peer;
+    packet->hop_limit = 0;
+    packet->hop_start = 0;
+    packet->channel = 0;
+    packet->want_ack = false;
+    packet->pki_encrypted = true;
+    packet->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+    service->sendToMesh(packet);
+}
+
+void DMShellModule::sendError(const char *message, NodeNum peer)
+{
+    const size_t len = strnlen(message, MAX_MESSAGE_SIZE);
+    meshtastic_RemoteShell frame = {
+        .op = meshtastic_RemoteShell_OpCode_ERROR,
+        .session_id = session.sessionId,
+        .seq = session.nextTxSeq++,
+        .ack_seq = session.lastAckedRxSeq,
+        .cols = 0,
+        .rows = 0,
+        .flags = 0,
+    };
+    if (message && len > 0) {
+        assert(len <= sizeof(frame.payload.bytes));
+        memcpy(frame.payload.bytes, message, len);
+        frame.payload.size = len;
+    }
+    if (peer == 0) {
+        peer = session.peer;
+    }
+    sendFrameToPeer(peer, frame, true);
+}
+#endif

src/modules/DMShell.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "MeshModule.h"
+#include "Router.h"
+#include "SinglePortModule.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
+#include <Arduino.h>
+#include <array>
+#include <functional>
+
+#if defined(ARCH_PORTDUINO)
+
+struct DMShellSession {
+    bool active = false;
+    uint32_t sessionId = 0;
+    NodeNum peer = 0;
+    uint8_t channel = 0;
+    int masterFd = -1;
+    int childPid = -1;
+    uint32_t nextTxSeq = 1;
+    uint32_t lastAckedRxSeq = 0;
+    uint32_t nextExpectedRxSeq = 1;
+    uint32_t highestSeenRxSeq = 0;
+    uint32_t lastActivityMs = 0;
+    struct SentFrame {
+        bool valid = false;
+        meshtastic_RemoteShell_OpCode op = meshtastic_RemoteShell_OpCode_ERROR;
+        uint32_t sessionId = 0;
+        uint32_t seq = 0;
+        uint32_t ackSeq = 0;
+        uint32_t cols = 0;
+        uint32_t rows = 0;
+        uint32_t flags = 0;
+        uint8_t payload[meshtastic_Constants_DATA_PAYLOAD_LEN] = {0};
+        size_t payloadLen = 0;
+    };
+    std::array<SentFrame, 50> txHistory = {};
+    size_t txHistoryNext = 0;
+};
+
+class DMShellModule : private concurrency::OSThread, public SinglePortModule
+{
+
+  public:
+    DMShellModule();
+
+  protected:
+    virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
+    virtual int32_t runOnce() override;
+
+  private:
+    static constexpr uint32_t SESSION_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+
+    DMShellSession session;
+    pid_t pendingChildPid = -1;
+
+    bool parseFrame(const meshtastic_MeshPacket &mp, meshtastic_RemoteShell &outFrame);
+    bool isAuthorizedPacket(const meshtastic_MeshPacket &mp) const;
+    bool openSession(const meshtastic_MeshPacket &mp, const meshtastic_RemoteShell &frame);
+    bool shouldProcessIncomingFrame(const meshtastic_RemoteShell &frame);
+    bool writeSessionInput(const meshtastic_RemoteShell &frame);
+    void closeSession(const char *reason, bool notifyPeer);
+    void reapChildIfExited();
+    void processPendingChildReap();
+
+    void rememberSentFrame(meshtastic_RemoteShell frame);
+    void resendFramesFrom(uint32_t startSeq);
+    void sendAck(uint32_t replayFromSeq = 0);
+    void sendFrameToPeer(NodeNum peer, meshtastic_RemoteShell frame, bool remember = true);
+    void sendError(const char *message, NodeNum peer = 0);
+};
+
+extern DMShellModule *dmShellModule;
+
+#endif

src/modules/Modules.cpp

@@ -49,6 +49,7 @@
 #include "modules/WaypointModule.h"
 #endif
 #if ARCH_PORTDUINO
+#include "modules/DMShell.h"
 #include "modules/Telemetry/HostMetrics.h"
 #if !MESHTASTIC_EXCLUDE_STOREFORWARD
 #include "modules/StoreForwardModule.h"
@@ -195,6 +196,7 @@ void setupModules()
 #endif
 #if ARCH_PORTDUINO
     new HostMetricsModule();
+    dmShellModule = new DMShellModule();
 #endif
 #if HAS_TELEMETRY
     new DeviceTelemetryModule();

src/modules/Telemetry/Sensor/INA3221Sensor.cpp

@@ -16,28 +16,10 @@ int32_t INA3221Sensor::runOnce()
         return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
     }
     if (!status) {
-        // Re-initialise with the address and Wire bus from the telemetry sensors map.
-        // (Rob Tillaart INA3221_RT takes address + TwoWire*, unlike sgtwilko which took Wire in begin().)
-        ina3221 = INA3221(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
-        status = ina3221.begin();
-        if (status) {
-            // Default all three channels to a 0.1 Ω shunt resistor.
-            // Override per-variant by defining INA3221_SHUNT_R_CH1/CH2/CH3 (in Ohms) in variant.h.
-#ifndef INA3221_SHUNT_R_CH1
-#define INA3221_SHUNT_R_CH1 0.1f
-#endif
-#ifndef INA3221_SHUNT_R_CH2
-#define INA3221_SHUNT_R_CH2 0.1f
-#endif
-#ifndef INA3221_SHUNT_R_CH3
-#define INA3221_SHUNT_R_CH3 0.1f
-#endif
-            ina3221.setShuntR(0, INA3221_SHUNT_R_CH1);
-            ina3221.setShuntR(1, INA3221_SHUNT_R_CH2);
-            ina3221.setShuntR(2, INA3221_SHUNT_R_CH3);
-        }
+        ina3221.begin(nodeTelemetrySensorsMap[sensorType].second);
+        ina3221.setShuntRes(100, 100, 100); // 0.1 Ohm shunt resistors
+        status = true;
     } else {
-        // Already initialised; status stays true and initI2CSensor() returns next poll interval.
         status = true;
     }
     return initI2CSensor();
@@ -45,14 +27,12 @@ int32_t INA3221Sensor::runOnce()
 
 void INA3221Sensor::setup() {}
 
-struct _INA3221Measurement INA3221Sensor::getMeasurement(uint8_t ch)
+struct _INA3221Measurement INA3221Sensor::getMeasurement(ina3221_ch_t ch)
 {
     struct _INA3221Measurement measurement;
 
-    measurement.voltage = ina3221.getBusVoltage(ch); // Volts
-    // getCurrent_mA() is used instead of getCurrent() because Rob Tillaart's getCurrent()
-    // returns Amperes; the telemetry proto and VoltageSensor/CurrentSensor interfaces expect mA.
-    measurement.current = ina3221.getCurrent_mA(ch); // milliAmps
+    measurement.voltage = ina3221.getVoltage(ch);
+    measurement.current = ina3221.getCurrent(ch);
 
     return measurement;
 }
@@ -63,7 +43,7 @@ struct _INA3221Measurements INA3221Sensor::getMeasurements()
 
     // INA3221 has 3 channels starting from 0
     for (int i = 0; i < 3; i++) {
-        measurements.measurements[i] = getMeasurement((uint8_t)i);
+        measurements.measurements[i] = getMeasurement((ina3221_ch_t)i);
     }
 
     return measurements;
@@ -107,41 +87,24 @@ bool INA3221Sensor::getPowerMetrics(meshtastic_Telemetry *measurement)
     measurement->variant.power_metrics.has_ch3_voltage = true;
     measurement->variant.power_metrics.has_ch3_current = true;
 
-    // INA3221 channel indices are zero-based (0=CH1, 1=CH2, 2=CH3).
-    measurement->variant.power_metrics.ch1_voltage = m.measurements[0].voltage;
-    measurement->variant.power_metrics.ch1_current = m.measurements[0].current;
-    measurement->variant.power_metrics.ch2_voltage = m.measurements[1].voltage;
-    measurement->variant.power_metrics.ch2_current = m.measurements[1].current;
-    measurement->variant.power_metrics.ch3_voltage = m.measurements[2].voltage;
-    measurement->variant.power_metrics.ch3_current = m.measurements[2].current;
+    measurement->variant.power_metrics.ch1_voltage = m.measurements[INA3221_CH1].voltage;
+    measurement->variant.power_metrics.ch1_current = m.measurements[INA3221_CH1].current;
+    measurement->variant.power_metrics.ch2_voltage = m.measurements[INA3221_CH2].voltage;
+    measurement->variant.power_metrics.ch2_current = m.measurements[INA3221_CH2].current;
+    measurement->variant.power_metrics.ch3_voltage = m.measurements[INA3221_CH3].voltage;
+    measurement->variant.power_metrics.ch3_current = m.measurements[INA3221_CH3].current;
 
     return true;
 }
 
 uint16_t INA3221Sensor::getBusVoltageMv()
 {
-    return lround(ina3221.getBusVoltage_mV(BAT_CH));
+    return lround(ina3221.getVoltage(BAT_CH) * 1000);
 }
 
 int16_t INA3221Sensor::getCurrentMa()
 {
-    return lround(ina3221.getCurrent_mA(BAT_CH));
-}
-
-// Bus voltage register (0x02 + ch*2): bits [15:3] unsigned, 1 LSB = 8 mV (datasheet p.6).
-// Voltage raw units: 1 count = 8 mV, so V_mV = raw * 8.
-int16_t INA3221Sensor::getRawBusVoltage(uint8_t ch)
-{
-    return (int16_t)(ina3221.getRegister(0x02 + ch * 2) >> 3);
-}
-
-// Shunt voltage register (0x01 + ch*2): bits [15:3] signed two's complement, 1 LSB = 40 µV (datasheet p.6).
-// Current raw units are shunt-voltage counts: 1 count = 40 uV, signed.
-// I_mA = (raw * 40 uV) / R_mOhm, because uV / mOhm = mA.
-// Example for 100 mOhm shunt: I_mA = raw * 40 / 100 = raw * 0.4.
-int16_t INA3221Sensor::getRawShuntCurrent(uint8_t ch)
-{
-    return (int16_t)(ina3221.getRegister(0x01 + ch * 2) >> 3);
+    return lround(ina3221.getCurrent(BAT_CH));
 }
 
 #endif

src/modules/Telemetry/Sensor/INA3221Sensor.h

@@ -1,9 +1,3 @@
-// INA3221 channel aliases (zero-based: 0 = CH1, 1 = CH2, 2 = CH3).
-// Defined before configuration.h so variant.h can use them in INA3221_ENV_CH / INA3221_BAT_CH.
-#define INA3221_CH1 0
-#define INA3221_CH2 1
-#define INA3221_CH3 2
-
 #include "configuration.h"
 
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<INA3221.h>)
@@ -15,29 +9,26 @@
 #include <INA3221.h>
 
 #ifndef INA3221_ENV_CH
-#define INA3221_ENV_CH INA3221_CH1 // channel to report in environment metrics (default: CH1)
+#define INA3221_ENV_CH INA3221_CH1
 #endif
 
 #ifndef INA3221_BAT_CH
-#define INA3221_BAT_CH INA3221_CH1 // channel for device_battery_ina_address (default: CH1)
+#define INA3221_BAT_CH INA3221_CH1
 #endif
 
 class INA3221Sensor : public TelemetrySensor, VoltageSensor, CurrentSensor
 {
   private:
-    // Placeholder constructor; re-initialised with correct address and Wire in runOnce().
-    INA3221 ina3221 = INA3221(INA3221_ADDR);
+    INA3221 ina3221 = INA3221(INA3221_ADDR42_SDA);
 
     // channel to report voltage/current for environment metrics
-    static const uint8_t ENV_CH = INA3221_ENV_CH;
-    static_assert(INA3221_ENV_CH >= 0 && INA3221_ENV_CH <= 2, "INA3221_ENV_CH must be 0, 1, or 2");
+    static const ina3221_ch_t ENV_CH = INA3221_ENV_CH;
 
     // channel to report battery voltage for device_battery_ina_address
-    static const uint8_t BAT_CH = INA3221_BAT_CH;
-    static_assert(INA3221_BAT_CH >= 0 && INA3221_BAT_CH <= 2, "INA3221_BAT_CH must be 0, 1, or 2");
+    static const ina3221_ch_t BAT_CH = INA3221_BAT_CH;
 
     // get a single measurement for a channel
-    struct _INA3221Measurement getMeasurement(uint8_t ch);
+    struct _INA3221Measurement getMeasurement(ina3221_ch_t ch);
 
     // get all measurements for all channels
     struct _INA3221Measurements getMeasurements();
@@ -54,10 +45,6 @@ class INA3221Sensor : public TelemetrySensor, VoltageSensor, CurrentSensor
     bool getMetrics(meshtastic_Telemetry *measurement) override;
     virtual uint16_t getBusVoltageMv() override;
     virtual int16_t getCurrentMa() override;
-
-    // Raw register reads (bits [15:3] right-shifted), no conversion applied.
-    int16_t getRawBusVoltage(uint8_t ch);
-    int16_t getRawShuntCurrent(uint8_t ch);
 };
 
 struct _INA3221Measurement {

src/modules/esp32/PaxcounterModule.cpp

@@ -90,8 +90,8 @@ int32_t PaxcounterModule::runOnce()
             configuration.blecounter = 1;
             configuration.blescantime = 0; // infinite
             configuration.wificounter = 1;
-            // configuration.wifi_channel_map = WIFI_CHANNEL_ALL;
-            // configuration.wifi_channel_switch_interval = 50;
+            configuration.wifi_channel_map = WIFI_CHANNEL_ALL;
+            configuration.wifi_channel_switch_interval = 50;
             configuration.wifi_rssi_threshold = Default::getConfiguredOrDefault(moduleConfig.paxcounter.wifi_threshold, -80);
             configuration.ble_rssi_threshold = Default::getConfiguredOrDefault(moduleConfig.paxcounter.ble_threshold, -80);
             libpax_update_config(&configuration);

src/mqtt/MQTT.cpp

@@ -19,8 +19,9 @@
 #include "mesh/wifi/WiFiAPClient.h"
 #include <WiFi.h>
 #endif
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 #include "Default.h"
 #if !defined(ARCH_NRF52) || NRF52_USE_JSON

src/nimble/NimbleBluetooth.cpp

@@ -10,18 +10,23 @@
 #include "mesh/PhoneAPI.h"
 #include "mesh/mesh-pb-constants.h"
 #include "sleep.h"
-#include <BLE2904.h>
-#include <BLEAdvertising.h>
-#include <BLEDevice.h>
-#include <BLESecurity.h>
-#include <BLEUtils.h>
+#include <NimBLEDevice.h>
 #include <atomic>
 #include <mutex>
 
+#ifdef NIMBLE_TWO
+#include "NimBLEAdvertising.h"
+#include "NimBLEExtAdvertising.h"
 #include "PowerStatus.h"
+#endif
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
-#include "host/ble_store.h"
+#else
+#include "nimble/nimble/host/include/host/ble_gap.h"
+#endif
+
+#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)
 
 namespace
 {
@@ -29,6 +34,7 @@ constexpr uint16_t kPreferredBleMtu = 517;
 constexpr uint16_t kPreferredBleTxOctets = 251;
 constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
 } // namespace
+#endif
 
 // Debugging options: careful, they slow things down quite a bit!
 // #define DEBUG_NIMBLE_ON_READ_TIMING  // uncomment to time onRead duration
@@ -38,10 +44,10 @@ constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
 #define NIMBLE_BLUETOOTH_TO_PHONE_QUEUE_SIZE 3
 #define NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE 3
 
-BLECharacteristic *fromNumCharacteristic;
-BLECharacteristic *BatteryCharacteristic;
-BLECharacteristic *logRadioCharacteristic;
-BLEServer *bleServer;
+NimBLECharacteristic *fromNumCharacteristic;
+NimBLECharacteristic *BatteryCharacteristic;
+NimBLECharacteristic *logRadioCharacteristic;
+NimBLEServer *bleServer;
 
 static bool passkeyShowing;
 static std::atomic<uint16_t> nimbleBluetoothConnHandle{BLE_HS_CONN_HANDLE_NONE}; // BLE_HS_CONN_HANDLE_NONE means "no connection"
@@ -112,8 +118,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
         - Yes, we have to do some copy operations on pop because of this, but it's worth it to avoid cross-task memory management.
 
       NOTIFY IS BROKEN:
-        - Adding BLECharacteristic::PROPERTY_NOTIFY to FromRadioCharacteristic appears to break things. It is NOT backwards
-      compatible.
+        - Adding NIMBLE_PROPERTY::NOTIFY to FromRadioCharacteristic appears to break things. It is NOT backwards compatible.
 
       ZERO-SIZE READS:
         - Returning a zero-size read from onRead breaks some clients during the config phase. So we have to block onRead until we
@@ -134,7 +139,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
     std::mutex fromPhoneMutex;
     std::atomic<size_t> fromPhoneQueueSize{0};
     // We use array here (and pay the cost of memcpy) to avoid dynamic memory allocations and frees across FreeRTOS tasks.
-    std::array<BLEValue, NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE> fromPhoneQueue{};
+    std::array<NimBLEAttValue, NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE> fromPhoneQueue{};
 
     /* Packets to phone (BLE onRead callback) */
     std::mutex toPhoneMutex;
@@ -296,7 +301,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
             LOG_DEBUG("NimbleBluetooth: handling ToRadio packet, fromPhoneQueueSize=%u", fromPhoneQueueSize.load());
 
             // Pop the front of fromPhoneQueue, holding the mutex only briefly while we pop.
-            BLEValue val;
+            NimBLEAttValue val;
             { // scope for fromPhoneMutex mutex
                 std::lock_guard<std::mutex> guard(fromPhoneMutex);
                 val = fromPhoneQueue[0];
@@ -311,7 +316,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
                     fromPhoneQueueSize--;
             }
 
-            handleToRadio(val.getData(), val.getLength());
+            handleToRadio(val.data(), val.length());
         }
     }
 
@@ -323,7 +328,9 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
         PhoneAPI::onNowHasData(fromRadioNum);
 
 #ifdef DEBUG_NIMBLE_NOTIFY
+
         int currentNotifyCount = notifyCount.fetch_add(1);
+
         uint8_t cc = bleServer->getConnectedCount();
         // This logging slows things down when there are lots of packets going to the phone, like initial connection:
         LOG_DEBUG("BLE notify(%d) fromNum: %d connections: %d", currentNotifyCount, fromRadioNum, cc);
@@ -333,7 +340,13 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
         put_le32(val, fromRadioNum);
 
         fromNumCharacteristic->setValue(val, sizeof(val));
+#ifdef NIMBLE_TWO
+        // NOTE: I don't have any NIMBLE_TWO devices, but this line makes me suspicious, and I suspect it needs to just be
+        // notify().
+        fromNumCharacteristic->notify(val, sizeof(val), BLE_HS_CONN_HANDLE_NONE);
+#else
         fromNumCharacteristic->notify();
+#endif
     }
 
     /// Check the current underlying physical link to see if the client is currently connected
@@ -396,9 +409,14 @@ static BluetoothPhoneAPI *bluetoothPhoneAPI;
 // Last ToRadio value received from the phone
 static uint8_t lastToRadio[MAX_TO_FROM_RADIO_SIZE];
 
-class NimbleBluetoothToRadioCallback : public BLECharacteristicCallbacks
+class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
 {
-    void onWrite(BLECharacteristic *pCharacteristic) override
+#ifdef NIMBLE_TWO
+    virtual void onWrite(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo) override
+#else
+    virtual void onWrite(NimBLECharacteristic *pCharacteristic) override
+
+#endif
     {
         // CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.
         // Assumption: onWrite is serialized by NimBLE, so we don't need to lock here against multiple concurrent onWrite calls.
@@ -410,17 +428,15 @@ class NimbleBluetoothToRadioCallback : public BLECharacteristicCallbacks
         LOG_DEBUG("BLE onWrite(%d): start millis=%d", currentWriteCount, startMillis);
 #endif
 
-        // Create a BLEValue and populate it with the received data
-        BLEValue val;
-        val.setValue(pCharacteristic->getData(), pCharacteristic->getLength());
+        auto val = pCharacteristic->getValue();
 
-        if (memcmp(lastToRadio, val.getData(), val.getLength()) != 0) {
+        if (memcmp(lastToRadio, val.data(), val.length()) != 0) {
             if (bluetoothPhoneAPI->fromPhoneQueueSize < NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE) {
                 // Note: the comparison above is safe without a mutex because we are the only method that *increases*
                 // fromPhoneQueueSize. (It's okay if fromPhoneQueueSize *decreases* in the main task meanwhile.)
-                memcpy(lastToRadio, val.getData(), val.getLength());
+                memcpy(lastToRadio, val.data(), val.length());
 
-                { // scope for fromPhoneMutex mutexv, pCharacteristic->getLen
+                { // scope for fromPhoneMutex mutex
                     // Append to fromPhoneQueue, protected by fromPhoneMutex. Hold the mutex as briefly as possible.
                     std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->fromPhoneMutex);
                     bluetoothPhoneAPI->fromPhoneQueue.at(bluetoothPhoneAPI->fromPhoneQueueSize) = val;
@@ -434,21 +450,24 @@ class NimbleBluetoothToRadioCallback : public BLECharacteristicCallbacks
 #ifdef DEBUG_NIMBLE_ON_WRITE_TIMING
                 int finishMillis = millis();
                 LOG_DEBUG("BLE onWrite(%d): append to fromPhoneQueue took %u ms. numBytes=%d", currentWriteCount,
-                          finishMillis - startMillis, val.getLength());
+                          finishMillis - startMillis, val.length());
 #endif
             } else {
-                LOG_WARN("BLE onWrite(%d): Drop ToRadio packet, fromPhoneQueue full (%u bytes)", currentWriteCount,
-                         val.getLength());
+                LOG_WARN("BLE onWrite(%d): Drop ToRadio packet, fromPhoneQueue full (%u bytes)", currentWriteCount, val.length());
             }
         } else {
-            LOG_DEBUG("BLE onWrite(%d): Drop duplicate ToRadio packet (%u bytes)", currentWriteCount, val.getLength());
+            LOG_DEBUG("BLE onWrite(%d): Drop duplicate ToRadio packet (%u bytes)", currentWriteCount, val.length());
         }
     }
 };
 
-class NimbleBluetoothFromRadioCallback : public BLECharacteristicCallbacks
+class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks
 {
-    void onRead(BLECharacteristic *pCharacteristic) override
+#ifdef NIMBLE_TWO
+    virtual void onRead(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo) override
+#else
+    virtual void onRead(NimBLECharacteristic *pCharacteristic) override
+#endif
     {
         // CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.
 
@@ -554,15 +573,34 @@ class NimbleBluetoothFromRadioCallback : public BLECharacteristicCallbacks
     }
 };
 
-class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
+class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
 {
-    void onPassKeyNotify(uint32_t passkey) override
+#ifdef NIMBLE_TWO
+  public:
+    NimbleBluetoothServerCallback(NimbleBluetooth *ble) { this->ble = ble; }
+
+  private:
+    NimbleBluetooth *ble;
+
+    virtual uint32_t onPassKeyDisplay() override
+#else
+    virtual uint32_t onPassKeyRequest() override
+#endif
     {
-        LOG_INFO("*** Enter passkey %06u on the peer side ***", passkey);
+        uint32_t passkey = config.bluetooth.fixed_pin;
+
+        if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
+            LOG_INFO("Use random passkey");
+            // This is the passkey to be entered on peer - we pick a number >100,000 to ensure 6 digits
+            passkey = random(100000, 999999);
+        }
+        LOG_INFO("*** Enter passkey %d on the peer side ***", passkey);
+
         powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
         meshtastic::BluetoothStatus newStatus(std::to_string(passkey));
         bluetoothStatus->updateStatus(&newStatus);
-#if HAS_SCREEN
+
+#if HAS_SCREEN // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
         if (screen) {
             screen->startAlert([passkey](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
                 char btPIN[16] = "888888";
@@ -592,8 +630,15 @@ class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
         }
 #endif
         passkeyShowing = true;
+
+        return passkey;
     }
-    void onAuthenticationComplete(ble_gap_conn_desc *desc) override
+
+#ifdef NIMBLE_TWO
+    virtual void onAuthenticationComplete(NimBLEConnInfo &connInfo) override
+#else
+    virtual void onAuthenticationComplete(ble_gap_conn_desc *desc) override
+#endif
     {
         LOG_INFO("BLE authentication complete");
 
@@ -601,47 +646,58 @@ class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
         bluetoothStatus->updateStatus(&newStatus);
         clearPairingDisplay();
 
+        // Store the connection handle for future use
+#ifdef NIMBLE_TWO
+        nimbleBluetoothConnHandle = connInfo.getConnHandle();
+#else
         nimbleBluetoothConnHandle = desc->conn_handle;
+#endif
     }
-};
 
-class NimbleBluetoothServerCallback : public BLEServerCallbacks
-{
-  public:
-    explicit NimbleBluetoothServerCallback(NimbleBluetooth *ble) : ble(ble) {}
-
-  private:
-    NimbleBluetooth *ble;
-
-    void onConnect(BLEServer *pServer, struct ble_gap_conn_desc *desc)
+#ifdef NIMBLE_TWO
+    virtual void onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo) override
     {
-        BLEAddress peer_addr(desc->peer_id_addr);
-        LOG_INFO("BLE incoming connection %s", peer_addr.toString().c_str());
+        LOG_INFO("BLE incoming connection %s", connInfo.getAddress().toString().c_str());
 
-        const uint16_t connHandle = desc->conn_handle;
+        const uint16_t connHandle = connInfo.getConnHandle();
+#if NIMBLE_ENABLE_2M_PHY && (defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6))
+        int phyResult =
+            ble_gap_set_prefered_le_phy(connHandle, BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_CODED_ANY);
+        if (phyResult == 0) {
+            LOG_INFO("BLE conn %u requested 2M PHY", connHandle);
+        } else {
+            LOG_WARN("Failed to prefer 2M PHY for conn %u, rc=%d", connHandle, phyResult);
+        }
+#endif
 
-        // With Google Pixel 8 Android devices, this causes ESP32 device crash
-        // when phone reconnects. Disable this to make progress on the
-        // Arduino v3 migration while we investigate the Android compatibility
-        // issue.
-#if 0
         int dataLenResult = ble_gap_set_data_len(connHandle, kPreferredBleTxOctets, kPreferredBleTxTimeUs);
         if (dataLenResult == 0) {
             LOG_INFO("BLE conn %u requested data length %u bytes", connHandle, kPreferredBleTxOctets);
         } else {
             LOG_WARN("Failed to raise data length for conn %u, rc=%d", connHandle, dataLenResult);
         }
-#endif
 
-        LOG_INFO("BLE conn %u peer MTU %u (target %u)", connHandle, pServer->getPeerMTU(connHandle), kPreferredBleMtu);
+        LOG_INFO("BLE conn %u initial MTU %u (target %u)", connHandle, connInfo.getMTU(), kPreferredBleMtu);
         pServer->updateConnParams(connHandle, 6, 12, 0, 200);
     }
+#endif
 
-    void onDisconnect(BLEServer *pServer, struct ble_gap_conn_desc *desc)
+#ifdef NIMBLE_TWO
+    virtual void onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason) override
     {
-        LOG_INFO("BLE disconnected");
+        LOG_INFO("BLE disconnect reason: %d", reason);
+#else
+    virtual void onDisconnect(NimBLEServer *pServer, ble_gap_conn_desc *desc) override
+    {
+        LOG_INFO("BLE disconnect");
+#endif
+#ifdef NIMBLE_TWO
         if (ble->isDeInit)
             return;
+#else
+        if (nimbleBluetooth && nimbleBluetooth->isDeInit)
+            return;
+#endif
 
         meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
         bluetoothStatus->updateStatus(&newStatus);
@@ -666,51 +722,43 @@ class NimbleBluetoothServerCallback : public BLEServerCallbacks
             bluetoothPhoneAPI->writeCount = 0;
         }
 
+        // Clear the last ToRadio packet buffer to avoid rejecting first packet from new connection
         memset(lastToRadio, 0, sizeof(lastToRadio));
 
-        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE;
+        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE; // BLE_HS_CONN_HANDLE_NONE means "no connection"
 
+#ifdef NIMBLE_TWO
+        // Restart Advertising
         ble->startAdvertising();
+#else
+        NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+        if (!pAdvertising->start(0)) {
+            if (pAdvertising->isAdvertising()) {
+                LOG_DEBUG("BLE advertising already running");
+            } else {
+                LOG_ERROR("BLE failed to restart advertising");
+            }
+        }
+#endif
     }
 };
 
 static NimbleBluetoothToRadioCallback *toRadioCallbacks;
 static NimbleBluetoothFromRadioCallback *fromRadioCallbacks;
 
-void NimbleBluetooth::startAdvertising()
-{
-    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
-    pAdvertising->stop();
-    pAdvertising->reset();
-
-    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
-    // if (powerStatus->getHasBattery() == 1) {
-    //     pAdvertising->addServiceUUID(BLEUUID((uint16_t)0x180f));
-    // }
-
-    BLEAdvertisementData scan = BLEAdvertisementData();
-    scan.setName(getDeviceName());
-    pAdvertising->setScanResponseData(scan);
-    pAdvertising->setMinPreferred(0x06); // functions that help with iPhone connections issue
-    pAdvertising->setMaxPreferred(0x12);
-
-    if (!pAdvertising->start(0)) {
-        LOG_ERROR("BLE failed to start advertising");
-    } else {
-        LOG_DEBUG("BLE Advertising started");
-    }
-}
-
 void NimbleBluetooth::shutdown()
 {
+    // No measurable power saving for ESP32 during light-sleep(?)
 #ifndef ARCH_ESP32
+    // Shutdown bluetooth for minimum power draw
     LOG_INFO("Disable bluetooth");
-    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
+    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
     pAdvertising->reset();
     pAdvertising->stop();
 #endif
 }
 
+// Proper shutdown for ESP32. Needs reboot to reverse.
 void NimbleBluetooth::deinit()
 {
 #ifdef ARCH_ESP32
@@ -720,19 +768,21 @@ void NimbleBluetooth::deinit()
 #ifdef BLE_LED
     digitalWrite(BLE_LED, LED_STATE_OFF);
 #endif
-
-    BLEDevice::deinit(true);
+#ifndef NIMBLE_TWO
+    NimBLEDevice::deinit();
+#endif
 #endif
 }
 
+// Has initial setup been completed
 bool NimbleBluetooth::isActive()
 {
-    return bleServer != nullptr;
+    return bleServer;
 }
 
 bool NimbleBluetooth::isConnected()
 {
-    return bleServer && bleServer->getConnectedCount() > 0;
+    return bleServer->getConnectedCount() > 0;
 }
 
 int NimbleBluetooth::getRssi()
@@ -745,9 +795,9 @@ int NimbleBluetooth::getRssi()
     uint16_t connHandle = nimbleBluetoothConnHandle.load();
 
     if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
-        const auto peers = bleServer->getPeerDevices(true);
+        const auto peers = bleServer->getPeerDevices();
         if (!peers.empty()) {
-            connHandle = peers.begin()->first;
+            connHandle = peers.front();
             nimbleBluetoothConnHandle = connHandle;
         }
     }
@@ -775,84 +825,74 @@ void NimbleBluetooth::setup()
 
     LOG_INFO("Init the NimBLE bluetooth module");
 
-    BLEDevice::init(getDeviceName());
-    BLEDevice::setPower(ESP_PWR_LVL_P9);
+    NimBLEDevice::init(getDeviceName());
+    NimBLEDevice::setPower(ESP_PWR_LVL_P9);
 
-    int mtuResult = BLEDevice::setMTU(kPreferredBleMtu);
+#if NIMBLE_ENABLE_2M_PHY && (defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6))
+    int mtuResult = NimBLEDevice::setMTU(kPreferredBleMtu);
     if (mtuResult == 0) {
         LOG_INFO("BLE MTU request set to %u", kPreferredBleMtu);
     } else {
         LOG_WARN("Unable to request MTU %u, rc=%d", kPreferredBleMtu, mtuResult);
     }
 
-    BLESecurity *pSecurity = new BLESecurity();
-    pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
-    pSecurity->setRespEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
-    if (config.bluetooth.mode != meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
-        // Set IO capability to DisplayOnly for MITM authentication
-        pSecurity->setCapability(ESP_IO_CAP_OUT);
-        // Set the passkey
-        if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
-            LOG_INFO("Use random passkey");
-            pSecurity->setPassKey(false); // generate a random passkey
-        } else {
-            LOG_INFO("Use fixed passkey");
-            pSecurity->setPassKey(true, config.bluetooth.fixed_pin);
-        }
-        // Enable authorization requirements:
-        // - bonding: true (for persistent storage of the keys)
-        // - MITM: true (enables Man-In-The-Middle protection for password prompts)
-        // - secure connection: true (enables secure connection for encryption)
-        pSecurity->setAuthenticationMode(true, true, true);
+    int phyResult = ble_gap_set_prefered_default_le_phy(BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_2M_MASK);
+    if (phyResult == 0) {
+        LOG_INFO("BLE default PHY preference set to 2M");
     } else {
-        // No IO capability for no PIN mode
-        pSecurity->setCapability(ESP_IO_CAP_NONE);
-        // No PIN mode: no MITM protection
-        pSecurity->setAuthenticationMode(true, false, false);
-    }
-    // Set the security callbacks
-    BLEDevice::setSecurityCallbacks(new NimbleBluetoothSecurityCallback());
-    bleServer = BLEDevice::createServer();
-
-    // BLEDevice::createServer calls ble_svc_gap_init, which resets the device
-    // name to default, so set it again.
-    int nameRc = ble_svc_gap_device_name_set(BLEDevice::getDeviceName().c_str());
-    if (nameRc != 0) {
-        LOG_ERROR("ble_svc_gap_device_name_set: rc=%d %s", nameRc, BLEUtils::returnCodeToString(nameRc));
+        LOG_WARN("Failed to prefer 2M PHY by default, rc=%d", phyResult);
     }
 
-    bleServer->setCallbacks(new NimbleBluetoothServerCallback(this));
+    int dataLenResult = ble_gap_write_sugg_def_data_len(kPreferredBleTxOctets, kPreferredBleTxTimeUs);
+    if (dataLenResult == 0) {
+        LOG_INFO("BLE suggested data length set to %u bytes", kPreferredBleTxOctets);
+    } else {
+        LOG_WARN("Failed to raise suggested data length (%u/%u), rc=%d", kPreferredBleTxOctets, kPreferredBleTxTimeUs,
+                 dataLenResult);
+    }
+#endif
+
+    if (config.bluetooth.mode != meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
+        NimBLEDevice::setSecurityAuth(BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM | BLE_SM_PAIR_AUTHREQ_SC);
+        NimBLEDevice::setSecurityInitKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
+        NimBLEDevice::setSecurityRespKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
+        NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY);
+    }
+    bleServer = NimBLEDevice::createServer();
+#ifdef NIMBLE_TWO
+    NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback(this);
+#else
+    NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback();
+#endif
+    bleServer->setCallbacks(serverCallbacks, true);
     setupService();
     startAdvertising();
 }
 
 void NimbleBluetooth::setupService()
 {
-    BLEService *bleService = bleServer->createService(MESH_SERVICE_UUID);
-    BLECharacteristic *ToRadioCharacteristic;
-    BLECharacteristic *FromRadioCharacteristic;
+    NimBLEService *bleService = bleServer->createService(MESH_SERVICE_UUID);
+    NimBLECharacteristic *ToRadioCharacteristic;
+    NimBLECharacteristic *FromRadioCharacteristic;
     // Define the characteristics that the app is looking for
     if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
-        ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE);
+        ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, NIMBLE_PROPERTY::WRITE);
         // Allow notifications so phones can stream FromRadio without polling.
-        FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ);
-        fromNumCharacteristic =
-            bleService->createCharacteristic(FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ);
-        logRadioCharacteristic = bleService->createCharacteristic(LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY |
-                                                                                     BLECharacteristic::PROPERTY_READ);
+        FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, NIMBLE_PROPERTY::READ);
+        fromNumCharacteristic = bleService->createCharacteristic(FROMNUM_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ);
+        logRadioCharacteristic =
+            bleService->createCharacteristic(LOGRADIO_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ, 512U);
     } else {
-        ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE |
-                                                                                   BLECharacteristic::PROPERTY_WRITE_AUTHEN |
-                                                                                   BLECharacteristic::PROPERTY_WRITE_ENC);
-        FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ |
-                                                                                       BLECharacteristic::PROPERTY_READ_AUTHEN |
-                                                                                       BLECharacteristic::PROPERTY_READ_ENC);
-        fromNumCharacteristic = bleService->createCharacteristic(
-            FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
-                              BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
+        ToRadioCharacteristic = bleService->createCharacteristic(
+            TORADIO_UUID, NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_AUTHEN | NIMBLE_PROPERTY::WRITE_ENC);
+        FromRadioCharacteristic = bleService->createCharacteristic(
+            FROMRADIO_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
+        fromNumCharacteristic =
+            bleService->createCharacteristic(FROMNUM_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ |
+                                                               NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
         logRadioCharacteristic = bleService->createCharacteristic(
-            LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
-                               BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
+            LOGRADIO_UUID,
+            NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC, 512U);
     }
     bluetoothPhoneAPI = new BluetoothPhoneAPI();
 
@@ -865,31 +905,76 @@ void NimbleBluetooth::setupService()
     bleService->start();
 
     // Setup the battery service
-    BLEService *batteryService = bleServer->createService(BLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
-    BLE2904 *batteryLevelDescriptor = new BLE2904();
-    batteryLevelDescriptor->setFormat(BLE2904::FORMAT_UINT8);
+    NimBLEService *batteryService = bleServer->createService(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
+    BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
+        (uint16_t)0x2a19, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY, 1);
+#ifdef NIMBLE_TWO
+    NimBLE2904 *batteryLevelDescriptor = BatteryCharacteristic->create2904();
+#else
+    NimBLE2904 *batteryLevelDescriptor = (NimBLE2904 *)BatteryCharacteristic->createDescriptor((uint16_t)0x2904);
+#endif
+    batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
     batteryLevelDescriptor->setNamespace(1);
     batteryLevelDescriptor->setUnit(0x27ad);
-    BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
-        (uint16_t)0x2a19, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
-    BatteryCharacteristic->addDescriptor(batteryLevelDescriptor);
+
     batteryService->start();
 }
 
+void NimbleBluetooth::startAdvertising()
+{
+#ifdef NIMBLE_TWO
+    NimBLEExtAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    NimBLEExtAdvertisement legacyAdvertising;
+
+    legacyAdvertising.setLegacyAdvertising(true);
+    legacyAdvertising.setScannable(true);
+    legacyAdvertising.setConnectable(true);
+    legacyAdvertising.setFlags(BLE_HS_ADV_F_DISC_GEN);
+    if (powerStatus->getHasBattery() == 1) {
+        legacyAdvertising.setCompleteServices(NimBLEUUID((uint16_t)0x180f));
+    }
+    legacyAdvertising.setCompleteServices(NimBLEUUID(MESH_SERVICE_UUID));
+    legacyAdvertising.setMinInterval(500);
+    legacyAdvertising.setMaxInterval(1000);
+
+    NimBLEExtAdvertisement legacyScanResponse;
+    legacyScanResponse.setLegacyAdvertising(true);
+    legacyScanResponse.setConnectable(true);
+    legacyScanResponse.setName(getDeviceName());
+
+    if (!pAdvertising->setInstanceData(0, legacyAdvertising)) {
+        LOG_ERROR("BLE failed to set legacyAdvertising");
+    } else if (!pAdvertising->setScanResponseData(0, legacyScanResponse)) {
+        LOG_ERROR("BLE failed to set legacyScanResponse");
+    } else if (!pAdvertising->start(0, 0, 0)) {
+        LOG_ERROR("BLE failed to start legacyAdvertising");
+    }
+#else
+    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    pAdvertising->reset();
+    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
+    pAdvertising->addServiceUUID(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
+    pAdvertising->start(0);
+#endif
+}
+
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level)
 {
     if ((config.bluetooth.enabled == true) && bleServer && nimbleBluetooth->isConnected()) {
         BatteryCharacteristic->setValue(&level, 1);
+#ifdef NIMBLE_TWO
+        BatteryCharacteristic->notify(&level, 1, BLE_HS_CONN_HANDLE_NONE);
+#else
         BatteryCharacteristic->notify();
+#endif
     }
 }
 
 void NimbleBluetooth::clearBonds()
 {
     LOG_INFO("Clearing bluetooth bonds!");
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
+    NimBLEDevice::deleteAllBonds();
 }
 
 void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
@@ -897,16 +982,11 @@ void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
     if (!bleServer || !isConnected() || length > 512) {
         return;
     }
-    logRadioCharacteristic->setValue(logMessage, length);
-    logRadioCharacteristic->notify();
+#ifdef NIMBLE_TWO
+    logRadioCharacteristic->notify(logMessage, length, BLE_HS_CONN_HANDLE_NONE);
+#else
+    logRadioCharacteristic->notify(logMessage, length, true);
+#endif
 }
 
-void clearNVS()
-{
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
-#ifdef ARCH_ESP32
-    ESP.restart();
-#endif
-}
 #endif

src/nimble/NimbleBluetooth.h

@@ -12,11 +12,16 @@ class NimbleBluetooth : BluetoothApi
     bool isConnected();
     int getRssi();
     void sendLog(const uint8_t *logMessage, size_t length);
+#if defined(NIMBLE_TWO)
     void startAdvertising();
+#endif
     bool isDeInit = false;
 
   private:
     void setupService();
+#if !defined(NIMBLE_TWO)
+    void startAdvertising();
+#endif
 };
 
 void setBluetoothEnable(bool enable);

src/platform/esp32/IramMemcpy.c

@@ -1,42 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "esp_attr.h"
-
-#ifdef ESP32_FORCE_IRAM_MEMSET
-
-/*
- * T-Beam/classic ESP32 boot workaround
- * ------------------------------------
- * During early flash operations the ESP32 disables cache, but some IRAM flash
- * code paths still reach libc memcpy/memset. If those resolve to flash-resident
- * implementations, startup can panic with cache-disabled access errors.
- *
- * We wrap memcpy/memset for the T-Beam environment. Fast path uses the
- * normal libc routines when cache is enabled; slow path uses IRAM-safe byte
- * loops when cache is disabled.
- */
-
-extern void *__real_memcpy(void *dst, const void *src, size_t n);
-
-static inline bool IRAM_ATTR cache_is_enabled(void)
-{
-    return (*(volatile uint32_t *)0x3FF00040u) & (1u << 3);
-}
-
-extern void *IRAM_ATTR __wrap_memcpy(void *dst, const void *src, size_t n)
-{
-    if (cache_is_enabled()) {
-        return __real_memcpy(dst, src, n);
-    }
-
-    uint8_t *d = (uint8_t *)dst;
-    const uint8_t *s = (const uint8_t *)src;
-    while (n--) {
-        *d++ = *s++;
-    }
-    return dst;
-}
-
-#endif

src/platform/esp32/IramMemset.c

@@ -1,42 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "esp_attr.h"
-
-#ifdef ESP32_FORCE_IRAM_MEMSET
-
-/*
- * T-Beam/classic ESP32 boot workaround
- * ------------------------------------
- * During early flash operations the ESP32 disables cache, but some IRAM flash
- * code paths still reach libc memcpy/memset. If those resolve to flash-resident
- * implementations, startup can panic with cache-disabled access errors.
- *
- * We wrap memcpy/memset for the T-Beam environment. Fast path uses the
- * normal libc routines when cache is enabled; slow path uses IRAM-safe byte
- * loops when cache is disabled.
- */
-
-extern void *__real_memset(void *dst, int c, size_t n);
-
-static inline bool IRAM_ATTR cache_is_enabled(void)
-{
-    return (*(volatile uint32_t *)0x3FF00040u) & (1u << 3);
-}
-
-extern void *IRAM_ATTR __wrap_memset(void *dst, int c, size_t n)
-{
-    if (cache_is_enabled()) {
-        return __real_memset(dst, c, n);
-    }
-
-    uint8_t *ptr = (uint8_t *)dst;
-    const uint8_t fill = (uint8_t)c;
-    while (n--) {
-        *ptr++ = fill;
-    }
-    return dst;
-}
-
-#endif

src/platform/esp32/align-text.handler_execute-4.ld

@@ -1,11 +0,0 @@
-/* Arduino fix: catch esp_event's orphaned .text.handler_execute section and align to 4 bytes */
-SECTIONS
-{
-  .text.handler_execute ALIGN(4) :
-  {
-    KEEP(*(.text.handler_execute))
-    KEEP(*(.text.handler_execute.*))
-    . = ALIGN(4);
-  }
-}
-INSERT AFTER .flash.text;

src/platform/esp32/main-esp32.cpp

@@ -165,30 +165,17 @@ void esp32Setup()
 // #define APP_WATCHDOG_SECS 45
 #define APP_WATCHDOG_SECS 90
 
-#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
-    const esp_task_wdt_config_t wdt_config = {
-        .timeout_ms = APP_WATCHDOG_SECS * 1000,
-        .idle_core_mask = (1U << CONFIG_FREERTOS_NUMBER_OF_CORES) - 1U,
-        .trigger_panic = true,
-    };
-    res = esp_task_wdt_init(&wdt_config);
-    if (res == ESP_ERR_INVALID_STATE) {
-        LOG_WARN("Task watchdog already initialized, reconfiguring existing instance");
-        res = esp_task_wdt_reconfigure(&wdt_config);
-    }
+#ifdef CONFIG_IDF_TARGET_ESP32C6
+    esp_task_wdt_config_t *wdt_config = (esp_task_wdt_config_t *)malloc(sizeof(esp_task_wdt_config_t));
+    wdt_config->timeout_ms = APP_WATCHDOG_SECS * 1000;
+    wdt_config->trigger_panic = true;
+    res = esp_task_wdt_init(wdt_config);
     assert(res == ESP_OK);
 #else
     res = esp_task_wdt_init(APP_WATCHDOG_SECS, true);
-    if (res == ESP_ERR_INVALID_STATE) {
-        LOG_WARN("Task watchdog already initialized, reusing existing instance");
-        res = ESP_OK;
-    }
     assert(res == ESP_OK);
 #endif
-    res = esp_task_wdt_status(NULL);
-    if (res == ESP_ERR_NOT_FOUND) {
-        res = esp_task_wdt_add(NULL);
-    }
+    res = esp_task_wdt_add(NULL);
     assert(res == ESP_OK);
 
 #if HAS_32768HZ
@@ -271,10 +258,8 @@ void cpuDeepSleep(uint32_t msecToWake)
 #endif
     variant_shutdown();
 
-#if SOC_PM_SUPPORT_RTC_PERIPH_PD
     // We want RTC peripherals to stay on
     esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
-#endif
 
     esp_sleep_enable_timer_wakeup(msecToWake * 1000ULL); // call expects usecs
     esp_deep_sleep_start();                              // TBD mA sleep current (battery)

src/platform/portduino/PortduinoGlue.cpp

@@ -13,7 +13,6 @@
 #include <ErriezCRC32.h>
 #include <Utility.h>
 #include <assert.h>
-#include <cctype>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -33,16 +32,6 @@
 #include <cxxabi.h>
 #endif
 
-#ifdef __APPLE__
-// Used by getMacAddr()'s macOS fallback to read the en0 link-layer address.
-// `getifaddrs()` is the BSD-portable way; `<net/if_dl.h>` provides the
-// `sockaddr_dl` cast and the `LLADDR()` macro that points at the 6-byte MAC.
-#include <cstring> // strcmp, memcpy
-#include <ifaddrs.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#endif
-
 #include "platform/portduino/USBHal.h"
 
 portduino_config_struct portduino_config;
@@ -166,35 +155,9 @@ void getMacAddr(uint8_t *dmac)
         dmac[3] = di.bdaddr.b[2];
         dmac[4] = di.bdaddr.b[1];
         dmac[5] = di.bdaddr.b[0];
-#elif defined(__APPLE__)
-        // No BlueZ on macOS, but we can fall back to the host's primary
-        // network interface MAC. `en0` is Wi-Fi on every shipping Mac
-        // (Ethernet, when present, is en1 or higher), which gives the user
-        // the same kind of stable, host-derived identifier that the BlueZ
-        // path provides on Linux. If en0 isn't found or has no MAC, dmac is
-        // left untouched and the caller's "Blank MAC Address not allowed!"
-        // check will still fire — preserving existing behavior for users
-        // who deliberately rely on --hwid or YAML override.
-        struct ifaddrs *ifap = nullptr;
-        if (getifaddrs(&ifap) == 0) {
-            for (struct ifaddrs *p = ifap; p != nullptr; p = p->ifa_next) {
-                if (p->ifa_addr == nullptr || p->ifa_addr->sa_family != AF_LINK) {
-                    continue;
-                }
-                if (strcmp(p->ifa_name, "en0") != 0) {
-                    continue;
-                }
-                auto *sdl = reinterpret_cast<struct sockaddr_dl *>(p->ifa_addr);
-                if (sdl->sdl_alen == 6) {
-                    memcpy(dmac, LLADDR(sdl), 6);
-                    break;
-                }
-            }
-            freeifaddrs(ifap);
-        }
 #else
-        // No platform-specific MAC source; leave dmac at its default. Caller
-        // can override via the --hwid CLI flag or the YAML config.
+        // No BlueZ on non-Linux hosts (e.g. macOS). Leave dmac at its default;
+        // the caller can override via the --hwid CLI flag or the YAML config.
         (void)dmac;
 #endif
     }
@@ -1093,31 +1056,17 @@ static bool ends_with(std::string_view str, std::string_view suffix)
 bool MAC_from_string(std::string mac_str, uint8_t *dmac)
 {
     mac_str.erase(std::remove(mac_str.begin(), mac_str.end(), ':'), mac_str.end());
-    if (mac_str.length() != 12) {
+    if (mac_str.length() == 12) {
+        dmac[0] = std::stoi(portduino_config.mac_address.substr(0, 2), nullptr, 16);
+        dmac[1] = std::stoi(portduino_config.mac_address.substr(2, 2), nullptr, 16);
+        dmac[2] = std::stoi(portduino_config.mac_address.substr(4, 2), nullptr, 16);
+        dmac[3] = std::stoi(portduino_config.mac_address.substr(6, 2), nullptr, 16);
+        dmac[4] = std::stoi(portduino_config.mac_address.substr(8, 2), nullptr, 16);
+        dmac[5] = std::stoi(portduino_config.mac_address.substr(10, 2), nullptr, 16);
+        return true;
+    } else {
         return false;
     }
-    // Validate every character is a hex digit before parsing. std::stoi
-    // would otherwise skip leading whitespace and silently truncate at the
-    // first non-digit, which is too lenient for a MAC address.
-    for (char c : mac_str) {
-        if (!isxdigit(static_cast<unsigned char>(c))) {
-            return false;
-        }
-    }
-    // Parse into a temporary so dmac is not partially modified if a later
-    // byte fails. At least one caller in getMacAddr() ignores the bool
-    // return, so leaving stale bytes in dmac on failure would silently
-    // produce a wrong MAC.
-    uint8_t tmp[6];
-    try {
-        for (int i = 0; i < 6; i++) {
-            tmp[i] = static_cast<uint8_t>(std::stoi(mac_str.substr(i * 2, 2), nullptr, 16));
-        }
-    } catch (const std::exception &) {
-        return false;
-    }
-    memcpy(dmac, tmp, 6);
-    return true;
 }
 
 std::string exec(const char *cmd)

src/platform/stm32wl/LittleFS.cpp

@@ -25,27 +25,23 @@
 #include "LittleFS.h"
 #include "stm32wlxx_hal_flash.h"
 
-/** Suppress unused-parameter warnings. */
+/**********************************************************************************************************************
+ * Macro definitions
+ **********************************************************************************************************************/
+/** This macro is used to suppress compiler messages about a parameter not being used in a function. */
 #define LFS_UNUSED(p) (void)((p))
 
-#define STM32WL_PAGE_SIZE (FLASH_PAGE_SIZE) // physical flash erase granularity: 2048 B
+#define STM32WL_PAGE_SIZE (FLASH_PAGE_SIZE)
 #define STM32WL_PAGE_COUNT (FLASH_PAGE_NB)
 #define STM32WL_FLASH_BASE (FLASH_BASE)
 
 /*
- * LFS tunables — all of these are stored in the LFS superblock.
- * Changing ANY of them is incompatible with the existing on-disk format;
- * the filesystem will be detected as corrupted and reformatted on first boot.
- *
- * LFS_FLASH_TOTAL_SIZE and LFS_BLOCK_SIZE are the only values to edit here.
- * All other parameters are derived.
- *
- * FLASH_END_ADDR is computed from FLASH_SIZE (read from the chip at link time).
+ * FLASH_SIZE from stm32wle5xx.h will read the actual FLASH size from the chip.
+ * FLASH_END_ADDR is calculated from FLASH_SIZE.
+ * Use the last 28 KiB of the FLASH
  */
-#define LFS_FLASH_TOTAL_SIZE                                                                                                     \
-    (7 * STM32WL_PAGE_SIZE)  /* 14 KiB — last 7 physical pages (FORMAT BREAK: reduced from 10 pages / 20 KiB) */
-#define LFS_BLOCK_SIZE (256) /* virtual block size (FORMAT BREAK if changed) */
-
+#define LFS_FLASH_TOTAL_SIZE (14 * 2048) /* needs to be a multiple of LFS_BLOCK_SIZE */
+#define LFS_BLOCK_SIZE (2048)
 #define LFS_FLASH_ADDR_END (FLASH_END_ADDR)
 #define LFS_FLASH_ADDR_BASE (LFS_FLASH_ADDR_END - LFS_FLASH_TOTAL_SIZE + 1)
 
@@ -55,80 +51,6 @@
 #define _LFS_DBG(fmt, ...) printf("%s:%d (%s): " fmt "\n", __FILE__, __LINE__, __func__, __VA_ARGS__)
 #endif
 
-//--------------------------------------------------------------------+
-// Write-behind page cache
-//
-// LFS requires block_size == erase granularity, but the STM32WL flash
-// erases in 2048-byte pages.  To use smaller virtual LFS blocks we
-// maintain a single-page RAM cache: the LFS erase/prog callbacks only
-// update this buffer; the physical erase+reprogram is deferred to
-// _internal_flash_sync() (or triggered automatically when a different
-// physical page is addressed).
-//
-// This mirrors the approach used by the NRF52 Adafruit driver
-// (flash_cache.c / flash_nrf5x.c) but adapted for the 2048-byte STM32WL
-// page size and HAL doubleword-program requirement.
-//--------------------------------------------------------------------+
-
-alignas(8) static uint8_t _page_cache[STM32WL_PAGE_SIZE];
-static uint32_t _page_cache_addr = UINT32_MAX; // UINT32_MAX = no page cached
-static bool _page_cache_dirty = false;
-
-/** Flush the cached page to flash (physical erase + doubleword program). */
-static int _flash_cache_flush(void)
-{
-    if (!_page_cache_dirty)
-        return LFS_ERR_OK;
-
-    FLASH_EraseInitTypeDef erase = {
-        .TypeErase = FLASH_TYPEERASE_PAGES,
-        .Page = (_page_cache_addr - STM32WL_FLASH_BASE) / STM32WL_PAGE_SIZE,
-        .NbPages = 1,
-    };
-    uint32_t page_error = 0;
-
-    if (HAL_FLASH_Unlock() != HAL_OK)
-        return LFS_ERR_IO;
-    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_ALL_ERRORS);
-
-    HAL_StatusTypeDef rc = HAL_FLASHEx_Erase(&erase, &page_error);
-    if (rc == HAL_OK) {
-        const uint64_t *p = (const uint64_t *)_page_cache;
-        uint32_t addr = _page_cache_addr;
-        for (size_t i = 0; i < STM32WL_PAGE_SIZE / 8; i++) {
-            rc = HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, addr, *p++);
-            if (rc != HAL_OK)
-                break;
-            addr += 8;
-        }
-    }
-    HAL_StatusTypeDef lock_rc = HAL_FLASH_Lock();
-    if (rc == HAL_OK)
-        rc = lock_rc;
-
-    if (rc == HAL_OK)
-        _page_cache_dirty = false;
-    return rc == HAL_OK ? LFS_ERR_OK : LFS_ERR_IO;
-}
-
-/**
- * Ensure the physical page containing `page_addr` is loaded into the cache.
- * If a different dirty page is already cached it is flushed first.
- */
-static int _flash_cache_load(uint32_t page_addr)
-{
-    if (_page_cache_addr == page_addr)
-        return LFS_ERR_OK; // already cached
-
-    int rc = _flash_cache_flush();
-    if (rc != LFS_ERR_OK)
-        return rc;
-
-    memcpy(_page_cache, (const void *)page_addr, STM32WL_PAGE_SIZE);
-    _page_cache_addr = page_addr;
-    return LFS_ERR_OK;
-}
-
 //--------------------------------------------------------------------+
 // LFS Disk IO
 //--------------------------------------------------------------------+
@@ -137,82 +59,111 @@ static int _internal_flash_read(const struct lfs_config *c, lfs_block_t block, l
 {
     LFS_UNUSED(c);
 
-    uint32_t addr = LFS_FLASH_ADDR_BASE + block * LFS_BLOCK_SIZE + off;
-    uint32_t page_addr = addr & ~(uint32_t)(STM32WL_PAGE_SIZE - 1);
-    uint32_t page_off = addr & (uint32_t)(STM32WL_PAGE_SIZE - 1);
+    if (!buffer || !size) {
+        _LFS_DBG("%s Invalid parameter!\r\n", __func__);
+        return LFS_ERR_INVAL;
+    }
 
-    if (_page_cache_addr == page_addr)
-        memcpy(buffer, _page_cache + page_off, size);
-    else
-        memcpy(buffer, (const void *)addr, size);
+    lfs_block_t address = LFS_FLASH_ADDR_BASE + (block * STM32WL_PAGE_SIZE + off);
+
+    memcpy(buffer, (void *)address, size);
 
     return LFS_ERR_OK;
 }
 
-// Program a region in a block. The block must have previously been erased.
-// Writes are accumulated in the page cache and flushed on sync or page eviction.
+// Program a region in a block. The block must have previously
+// been erased. Negative error codes are propogated to the user.
+// May return LFS_ERR_CORRUPT if the block should be considered bad.
 static int _internal_flash_prog(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size)
 {
+    lfs_block_t address = LFS_FLASH_ADDR_BASE + (block * STM32WL_PAGE_SIZE + off);
+    HAL_StatusTypeDef hal_rc = HAL_OK;
+    uint32_t dw_count = size / 8;
+    uint64_t *bufp = (uint64_t *)buffer;
+
     LFS_UNUSED(c);
 
-    uint32_t addr = LFS_FLASH_ADDR_BASE + block * LFS_BLOCK_SIZE + off;
-    uint32_t page_addr = addr & ~(uint32_t)(STM32WL_PAGE_SIZE - 1);
-    uint32_t page_off = addr & (uint32_t)(STM32WL_PAGE_SIZE - 1);
+    _LFS_DBG("Programming %d bytes/%d doublewords at address 0x%08x/block %d, offset %d.", size, dw_count, address, block, off);
+    if (HAL_FLASH_Unlock() != HAL_OK) {
+        return LFS_ERR_IO;
+    }
+    for (uint32_t i = 0; i < dw_count; i++) {
+        if ((address < LFS_FLASH_ADDR_BASE) || (address > LFS_FLASH_ADDR_END)) {
+            _LFS_DBG("Wanted to program out of bound of FLASH: 0x%08x.\n", address);
+            HAL_FLASH_Lock();
+            return LFS_ERR_INVAL;
+        }
+        hal_rc = HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, address, *bufp);
+        if (hal_rc != HAL_OK) {
+            /* Error occurred while writing data in Flash memory.
+             * User can add here some code to deal with this error.
+             */
+            _LFS_DBG("Program error at (0x%08x), 0x%X, error: 0x%08x\n", address, hal_rc, HAL_FLASH_GetError());
+        }
+        address += 8;
+        bufp += 1;
+    }
+    if (HAL_FLASH_Lock() != HAL_OK) {
+        return LFS_ERR_IO;
+    }
 
-    int rc = _flash_cache_load(page_addr);
-    if (rc != LFS_ERR_OK)
-        return rc;
-
-    memcpy(_page_cache + page_off, buffer, size);
-    _page_cache_dirty = true;
-    return LFS_ERR_OK;
+    return hal_rc == HAL_OK ? LFS_ERR_OK : LFS_ERR_IO; // If HAL_OK, return LFS_ERR_OK, else return LFS_ERR_IO
 }
 
-// Erase a virtual block. Marks the corresponding region in the page cache as 0xFF.
-// Physical erase of the containing page is deferred until sync or page eviction.
+// Erase a block. A block must be erased before being programmed.
+// The state of an erased block is undefined. Negative error codes
+// are propogated to the user.
+// May return LFS_ERR_CORRUPT if the block should be considered bad.
 static int _internal_flash_erase(const struct lfs_config *c, lfs_block_t block)
 {
+    lfs_block_t address = LFS_FLASH_ADDR_BASE + (block * STM32WL_PAGE_SIZE);
+    HAL_StatusTypeDef hal_rc;
+    FLASH_EraseInitTypeDef EraseInitStruct = {.TypeErase = FLASH_TYPEERASE_PAGES, .Page = 0, .NbPages = 1};
+    uint32_t PAGEError = 0;
+
     LFS_UNUSED(c);
 
-    uint32_t addr = LFS_FLASH_ADDR_BASE + block * LFS_BLOCK_SIZE;
-    uint32_t page_addr = addr & ~(uint32_t)(STM32WL_PAGE_SIZE - 1);
-    uint32_t page_off = addr & (uint32_t)(STM32WL_PAGE_SIZE - 1);
+    if ((address < LFS_FLASH_ADDR_BASE) || (address > LFS_FLASH_ADDR_END)) {
+        _LFS_DBG("Wanted to erase out of bound of FLASH: 0x%08x.\n", address);
+        return LFS_ERR_INVAL;
+    }
+    /* calculate the absolute page, i.e. what the ST wants */
+    EraseInitStruct.Page = (address - STM32WL_FLASH_BASE) / STM32WL_PAGE_SIZE;
+    _LFS_DBG("Erasing block %d at 0x%08x... ", block, address);
+    HAL_FLASH_Unlock();
+    hal_rc = HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError);
+    HAL_FLASH_Lock();
 
-    int rc = _flash_cache_load(page_addr);
-    if (rc != LFS_ERR_OK)
-        return rc;
-
-    memset(_page_cache + page_off, 0xFF, LFS_BLOCK_SIZE);
-    _page_cache_dirty = true;
-    return LFS_ERR_OK;
+    return hal_rc == HAL_OK ? LFS_ERR_OK : LFS_ERR_IO; // If HAL_OK, return LFS_ERR_OK, else return LFS_ERR_IO
 }
 
-// Flush the write-behind cache to flash.
+// Sync the state of the underlying block device. Negative error codes
+// are propogated to the user.
 static int _internal_flash_sync(const struct lfs_config *c)
 {
     LFS_UNUSED(c);
-    return _flash_cache_flush();
+    // write function performs no caching.  No need for sync.
+
+    return LFS_ERR_OK;
 }
 
-static struct lfs_config _InternalFSConfig = {
-    .context = NULL,
+static struct lfs_config _InternalFSConfig = {.context = NULL,
 
-    .read = _internal_flash_read,
-    .prog = _internal_flash_prog,
-    .erase = _internal_flash_erase,
-    .sync = _internal_flash_sync,
+                                              .read = _internal_flash_read,
+                                              .prog = _internal_flash_prog,
+                                              .erase = _internal_flash_erase,
+                                              .sync = _internal_flash_sync,
 
-    .read_size = LFS_BLOCK_SIZE,
-    .prog_size = LFS_BLOCK_SIZE,
-    .block_size = LFS_BLOCK_SIZE,
-    .block_count = LFS_FLASH_TOTAL_SIZE / LFS_BLOCK_SIZE,
-    .lookahead = 128,
+                                              .read_size = LFS_BLOCK_SIZE,
+                                              .prog_size = LFS_BLOCK_SIZE,
+                                              .block_size = LFS_BLOCK_SIZE,
+                                              .block_count = LFS_FLASH_TOTAL_SIZE / LFS_BLOCK_SIZE,
+                                              .lookahead = 128,
 
-    .read_buffer = NULL,
-    .prog_buffer = NULL,
-    .lookahead_buffer = NULL,
-    .file_buffer = NULL,
-};
+                                              .read_buffer = NULL,
+                                              .prog_buffer = NULL,
+                                              .lookahead_buffer = NULL,
+                                              .file_buffer = NULL};
 
 LittleFS InternalFS;
 
@@ -228,17 +179,17 @@ bool LittleFS::begin(void)
         /* There is not enough space on this device for a filesystem. */
         return false;
     }
-    // failed to mount, erase all virtual blocks then format and mount again
+    // failed to mount, erase all pages then format and mount again
     if (!STM32_LittleFS::begin()) {
-        for (lfs_block_t block = 0; block < _InternalFSConfig.block_count; block++) {
-            _internal_flash_erase(&_InternalFSConfig, block);
+        // Erase all pages of internal flash region for Filesystem.
+        for (uint32_t addr = LFS_FLASH_ADDR_BASE; addr < (LFS_FLASH_ADDR_END + 1); addr += STM32WL_PAGE_SIZE) {
+            _internal_flash_erase(&_InternalFSConfig, (addr - LFS_FLASH_ADDR_BASE) / STM32WL_PAGE_SIZE);
         }
-        _flash_cache_flush(); // flush the last cached page
 
         // lfs format
         this->format();
 
-        // mount again; if still failed, give up
+        // mount again if still failed, give up
         if (!STM32_LittleFS::begin())
             return false;
     }

src/platform/stm32wl/STM32_LittleFS_File.cpp

@@ -22,7 +22,6 @@
  * THE SOFTWARE.
  */
 
-#include "LittleFS.h"
 #include "STM32_LittleFS.h"
 #include <Arduino.h>
 
@@ -392,8 +391,3 @@ void File::rewindDirectory(void)
     }
     _fs->_unlockFS();
 }
-
-// Default constructor — binds to the global InternalFS instance.
-// Allows File to be declared without an explicit filesystem argument,
-// matching the API of ESP32/RP2040/Portduino File objects.
-File::File() : File(InternalFS) {}

src/platform/stm32wl/STM32_LittleFS_File.h

@@ -44,7 +44,6 @@ class File : public Stream
   public:
     explicit File(STM32_LittleFS &fs);
     File(char const *filename, uint8_t mode, STM32_LittleFS &fs);
-    File(); // default-constructs against InternalFS; defined in STM32_LittleFS_File.cpp
 
   public:
     bool open(char const *filename, uint8_t mode);

src/power.h

@@ -4,10 +4,8 @@
 #include "configuration.h"
 
 #ifdef ARCH_ESP32
-// #include <driver/adc.h>
-#include <esp_adc/adc_cali.h>
-#include <esp_adc/adc_cali_scheme.h>
-#include <esp_adc/adc_oneshot.h>
+// "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h
+#include <esp_adc_cal.h>
 #include <soc/adc_channel.h>
 #endif
 
@@ -30,6 +28,11 @@
 #define NUM_CELLS 1
 #endif
 
+#ifdef BAT_MEASURE_ADC_UNIT
+extern RTC_NOINIT_ATTR uint64_t RTC_reg_b;
+#include "soc/sens_reg.h" // needed for adc pin reset
+#endif
+
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
 #include "modules/Telemetry/Sensor/nullSensor.h"
 #if __has_include(<Adafruit_INA219.h>)

src/power/BatteryLevel.cpp

@@ -1,693 +0,0 @@
-#include "power/BatteryLevel.h"
-
-#include "NodeDB.h"
-#include "Throttle.h"
-#include "meshUtils.h"
-#include "power/PowerHAL.h"
-
-#if defined(ARCH_NRF52)
-#include "Nrf52SaadcLock.h"
-#include "concurrency/LockGuard.h"
-#endif
-
-#if defined(HAS_BQ27220)
-#include "bq27220.h"
-#endif
-
-#if defined(HAS_PPM) && HAS_PPM
-#include <XPowersLib.h>
-#endif
-
-#ifdef HELTEC_MESH_SOLAR
-#include "meshSolarApp.h"
-#endif
-
-#if !MESHTASTIC_EXCLUDE_I2C
-#include <Wire.h>
-#include <utility>
-extern std::pair<uint8_t, TwoWire *> nodeTelemetrySensorsMap[_meshtastic_TelemetrySensorType_MAX + 1];
-#endif
-
-#ifndef ADC_MULTIPLIER
-#define ADC_MULTIPLIER 2.0
-#endif
-
-#ifndef BATTERY_SENSE_SAMPLES
-#define BATTERY_SENSE_SAMPLES 15
-#endif
-
-#if !defined(AREF_VOLTAGE) && !defined(ARCH_NRF52)
-#define AREF_VOLTAGE 3.3
-#endif
-
-#if defined(BATTERY_PIN) && defined(ARCH_ESP32)
-
-#ifndef BAT_MEASURE_ADC_UNIT
-static const adc_channel_t adc_channel = ADC_CHANNEL;
-static const adc_unit_t unit = ADC_UNIT_1;
-#else
-static const adc_channel_t adc_channel = ADC_CHANNEL;
-static const adc_unit_t unit = ADC_UNIT_2;
-#endif
-
-static adc_oneshot_unit_handle_t adc_handle = nullptr;
-static adc_cali_handle_t adc_cali_handle = nullptr;
-static bool adc_calibrated = false;
-
-#ifndef ADC_ATTENUATION
-static const adc_atten_t atten = ADC_ATTEN_DB_12;
-#else
-static const adc_atten_t atten = ADC_ATTENUATION;
-#endif
-
-#ifdef ADC_BITWIDTH
-static const adc_bitwidth_t adc_width = ADC_BITWIDTH;
-#else
-static const adc_bitwidth_t adc_width = ADC_BITWIDTH_DEFAULT;
-#endif
-
-static int adcBitWidthToBits(adc_bitwidth_t width)
-{
-    switch (width) {
-    case ADC_BITWIDTH_9:
-        return 9;
-    case ADC_BITWIDTH_10:
-        return 10;
-    case ADC_BITWIDTH_11:
-        return 11;
-    case ADC_BITWIDTH_12:
-        return 12;
-#ifdef ADC_BITWIDTH_13
-    case ADC_BITWIDTH_13:
-        return 13;
-#endif
-    default:
-        return 12;
-    }
-}
-
-static bool initAdcCalibration()
-{
-#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
-    adc_cali_curve_fitting_config_t cali_config = {
-        .unit_id = unit,
-        .atten = atten,
-        .bitwidth = adc_width,
-    };
-    esp_err_t ret = adc_cali_create_scheme_curve_fitting(&cali_config, &adc_cali_handle);
-    if (ret == ESP_OK) {
-        LOG_INFO("ADC calibration: curve fitting enabled");
-        return true;
-    }
-    if (ret != ESP_ERR_NOT_SUPPORTED) {
-        LOG_WARN("ADC calibration: curve fitting failed: %s", esp_err_to_name(ret));
-    }
-#endif
-
-#if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
-    adc_cali_line_fitting_config_t cali_config = {
-        .unit_id = unit,
-        .atten = atten,
-        .bitwidth = adc_width,
-        .default_vref = DEFAULT_VREF,
-    };
-    esp_err_t ret = adc_cali_create_scheme_line_fitting(&cali_config, &adc_cali_handle);
-    if (ret == ESP_OK) {
-        LOG_INFO("ADC calibration: line fitting enabled");
-        return true;
-    }
-    if (ret != ESP_ERR_NOT_SUPPORTED) {
-        LOG_WARN("ADC calibration: line fitting failed: %s", esp_err_to_name(ret));
-    }
-#endif
-
-    LOG_INFO("ADC calibration not supported; using approximate scaling");
-    return false;
-}
-
-#endif
-
-void battery_adcEnable()
-{
-#ifdef ADC_CTRL
-#ifdef ADC_USE_PULLUP
-    pinMode(ADC_CTRL, INPUT_PULLUP);
-#else
-#ifdef HELTEC_V3
-    pinMode(ADC_CTRL, INPUT);
-    uint8_t adc_ctl_enable_value = !(digitalRead(ADC_CTRL));
-    pinMode(ADC_CTRL, OUTPUT);
-    digitalWrite(ADC_CTRL, adc_ctl_enable_value);
-#else
-    pinMode(ADC_CTRL, OUTPUT);
-    digitalWrite(ADC_CTRL, ADC_CTRL_ENABLED);
-#endif
-#endif
-    delay(10);
-#endif
-}
-
-static void battery_adcDisable()
-{
-#ifdef ADC_CTRL
-#ifdef ADC_USE_PULLUP
-    pinMode(ADC_CTRL, INPUT_PULLDOWN);
-#else
-#ifdef HELTEC_V3
-    pinMode(ADC_CTRL, ANALOG);
-#else
-    digitalWrite(ADC_CTRL, !ADC_CTRL_ENABLED);
-#endif
-#endif
-#endif
-}
-
-bool battery_adcInit()
-{
-#if defined(BATTERY_PIN) && defined(ARCH_ESP32)
-    adc_oneshot_unit_init_cfg_t init_config = {
-        .unit_id = unit,
-    };
-
-    if (!adc_handle) {
-        esp_err_t err = adc_oneshot_new_unit(&init_config, &adc_handle);
-        if (err != ESP_OK) {
-            LOG_ERROR("ADC oneshot init failed: %s", esp_err_to_name(err));
-            return false;
-        }
-    }
-
-    adc_oneshot_chan_cfg_t chan_cfg = {
-        .atten = atten,
-        .bitwidth = adc_width,
-    };
-
-    esp_err_t err = adc_oneshot_config_channel(adc_handle, adc_channel, &chan_cfg);
-    if (err != ESP_OK) {
-        LOG_ERROR("ADC channel config failed: %s", esp_err_to_name(err));
-        return false;
-    }
-
-    adc_calibrated = initAdcCalibration();
-#endif
-    return true;
-}
-
-int AnalogBatteryLevel::getBatteryPercent()
-{
-#if defined(HAS_RAKPROT) && !defined(HAS_PMU)
-    if (hasRAK()) {
-        return rak9154Sensor.getBusBatteryPercent();
-    }
-#endif
-
-    float v = getBattVoltage();
-    if (v < noBatVolt)
-        return -1;
-
-#ifdef NO_BATTERY_LEVEL_ON_CHARGE
-    if (v > chargingVolt)
-        return 0;
-#endif
-
-    float battery_SOC = 0.0;
-    uint16_t voltage = v / NUM_CELLS;
-    for (int i = 0; i < NUM_OCV_POINTS; i++) {
-        if (OCV[i] <= voltage) {
-            if (i == 0) {
-                battery_SOC = 100.0;
-            } else {
-                battery_SOC = (float)100.0 / (NUM_OCV_POINTS - 1.0) *
-                              (NUM_OCV_POINTS - 1.0 - i + ((float)voltage - OCV[i]) / (OCV[i - 1] - OCV[i]));
-            }
-            break;
-        }
-    }
-#if defined(BATTERY_CHARGING_INV)
-    if (!digitalRead(BATTERY_CHARGING_INV) && battery_SOC > 99)
-        battery_SOC = 99;
-#endif
-    return clamp((int)(battery_SOC), 0, 100);
-}
-
-uint16_t AnalogBatteryLevel::getBattVoltage()
-{
-#if HAS_TELEMETRY && defined(HAS_RAKPROT) && !defined(HAS_PMU) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-    if (hasRAK()) {
-        return getRAKVoltage();
-    }
-#endif
-
-#if HAS_TELEMETRY && !defined(HAS_PMU) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-    if (hasINA()) {
-        return getINAVoltage();
-    }
-#endif
-
-#ifdef BATTERY_PIN
-    float operativeAdcMultiplier =
-        config.power.adc_multiplier_override > 0 ? config.power.adc_multiplier_override : ADC_MULTIPLIER;
-    const uint32_t min_read_interval = 5000;
-    if (!initial_read_done || !Throttle::isWithinTimespanMs(last_read_time_ms, min_read_interval)) {
-        last_read_time_ms = millis();
-
-        uint32_t raw = 0;
-        float scaled = 0;
-
-        battery_adcEnable();
-#ifdef ARCH_STM32WL
-        Vref = __LL_ADC_CALC_VREFANALOG_VOLTAGE(analogRead(AVREF), LL_ADC_RESOLUTION);
-        raw = analogRead(BATTERY_PIN);
-        scaled = __LL_ADC_CALC_DATA_TO_VOLTAGE(Vref, raw, LL_ADC_RESOLUTION);
-        scaled *= operativeAdcMultiplier;
-#elif defined(ARCH_ESP32)
-        raw = espAdcRead();
-        int voltage_mv = 0;
-        if (adc_calibrated && adc_cali_handle) {
-            if (adc_cali_raw_to_voltage(adc_cali_handle, raw, &voltage_mv) != ESP_OK) {
-                LOG_WARN("ADC calibration read failed; using raw value");
-                voltage_mv = 0;
-            }
-        }
-        if (voltage_mv == 0) {
-            const int bits = adcBitWidthToBits(adc_width);
-            const float max_code = powf(2.0f, bits) - 1.0f;
-            voltage_mv = (int)((raw / max_code) * DEFAULT_VREF);
-        }
-        scaled = voltage_mv * operativeAdcMultiplier;
-#else
-#ifdef ARCH_NRF52
-        concurrency::LockGuard saadcGuard(concurrency::nrf52SaadcLock);
-#endif
-        for (uint32_t i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-            raw += analogRead(BATTERY_PIN);
-        }
-        raw = raw / BATTERY_SENSE_SAMPLES;
-        scaled = operativeAdcMultiplier * ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * raw;
-#endif
-        battery_adcDisable();
-
-        if (!initial_read_done) {
-            if (scaled > last_read_value)
-                last_read_value = scaled;
-            initial_read_done = true;
-        } else {
-            last_read_value += (scaled - last_read_value) * 0.5;
-        }
-    }
-    return last_read_value;
-#endif
-    return 0;
-}
-
-#if defined(ARCH_ESP32) && !defined(HAS_PMU) && defined(BATTERY_PIN)
-uint32_t AnalogBatteryLevel::espAdcRead()
-{
-    uint32_t raw = 0;
-    uint8_t raw_c = 0;
-
-    if (!adc_handle) {
-        LOG_ERROR("ADC oneshot handle not initialized");
-        return 0;
-    }
-
-    for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-        int val = 0;
-        esp_err_t err = adc_oneshot_read(adc_handle, adc_channel, &val);
-        if (err == ESP_OK) {
-            raw += val;
-            raw_c++;
-        } else {
-            LOG_DEBUG("ADC read failed: %s", esp_err_to_name(err));
-        }
-    }
-
-    return (raw / (raw_c < 1 ? 1 : raw_c));
-}
-#endif
-
-bool AnalogBatteryLevel::isBatteryConnect()
-{
-#ifdef BATTERY_IMMUTABLE
-    return true;
-#elif defined(ADC_V)
-    int lastReading = digitalRead(ADC_V);
-    for (int i = 2; i < 500; i++) {
-        int reading = digitalRead(ADC_V);
-        if (reading != lastReading) {
-            return false;
-        }
-    }
-    return true;
-#else
-    return getBatteryPercent() != -1;
-#endif
-}
-
-bool AnalogBatteryLevel::isVbusIn()
-{
-#ifdef EXT_PWR_DETECT
-    return digitalRead(EXT_PWR_DETECT) == EXT_PWR_DETECT_VALUE;
-#elif defined(MUZI_BASE) || defined(PROMICRO_DIY_TCXO)
-    return powerHAL_isVBUSConnected();
-#endif
-    return getBattVoltage() > chargingVolt;
-}
-
-bool AnalogBatteryLevel::isCharging()
-{
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT) && !defined(HAS_PMU)
-    if (hasRAK()) {
-        return (rak9154Sensor.isCharging()) ? OptTrue : OptFalse;
-    }
-#endif
-#if defined(ELECROW_ThinkNode_M6)
-    return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE || isVbusIn();
-#elif defined(EXT_CHRG_DETECT)
-    return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
-#elif defined(BATTERY_CHARGING_INV)
-    return !digitalRead(BATTERY_CHARGING_INV);
-#else
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !defined(DISABLE_INA_CHARGING_DETECTION)
-    if (hasINA()) {
-        LOG_DEBUG("Using INA on I2C addr 0x%x for charging detection", config.power.device_battery_ina_address);
-#if defined(INA_CHARGING_DETECTION_INVERT)
-        return getINACurrent() > 0;
-#else
-        return getINACurrent() < 0;
-#endif
-    }
-    return isBatteryConnect() && isVbusIn();
-#endif
-#endif
-    return isVbusIn();
-}
-
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT)
-uint16_t AnalogBatteryLevel::getRAKVoltage()
-{
-    return rak9154Sensor.getBusVoltageMv();
-}
-
-bool AnalogBatteryLevel::hasRAK()
-{
-    if (!rak9154Sensor.isInitialized())
-        return rak9154Sensor.runOnce() > 0;
-    return rak9154Sensor.isRunning();
-}
-#endif
-
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-uint16_t AnalogBatteryLevel::getINAVoltage()
-{
-    if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == config.power.device_battery_ina_address) {
-        return ina219Sensor.getBusVoltageMv();
-    } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA226].first == config.power.device_battery_ina_address) {
-        return ina226Sensor.getBusVoltageMv();
-    } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first == config.power.device_battery_ina_address) {
-        return ina260Sensor.getBusVoltageMv();
-    } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first == config.power.device_battery_ina_address) {
-        return ina3221Sensor.getBusVoltageMv();
-    }
-    return 0;
-}
-
-int16_t AnalogBatteryLevel::getINACurrent()
-{
-    if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == config.power.device_battery_ina_address) {
-        return ina219Sensor.getCurrentMa();
-    } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA226].first == config.power.device_battery_ina_address) {
-        return ina226Sensor.getCurrentMa();
-    } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first == config.power.device_battery_ina_address) {
-        return ina3221Sensor.getCurrentMa();
-    }
-    return 0;
-}
-
-bool AnalogBatteryLevel::hasINA()
-{
-    if (!config.power.device_battery_ina_address) {
-        return false;
-    }
-    if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA219].first == config.power.device_battery_ina_address) {
-        if (!ina219Sensor.isInitialized())
-            return ina219Sensor.runOnce() > 0;
-        return ina219Sensor.isRunning();
-    } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA226].first == config.power.device_battery_ina_address) {
-        if (!ina226Sensor.isInitialized())
-            return ina226Sensor.runOnce() > 0;
-        return ina226Sensor.isRunning();
-    } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first == config.power.device_battery_ina_address) {
-        if (!ina260Sensor.isInitialized())
-            return ina260Sensor.runOnce() > 0;
-        return ina260Sensor.isRunning();
-    } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA3221].first == config.power.device_battery_ina_address) {
-        if (!ina3221Sensor.isInitialized())
-            return ina3221Sensor.runOnce() > 0;
-        return ina3221Sensor.isRunning();
-    }
-    return false;
-}
-#endif
-
-#if !MESHTASTIC_EXCLUDE_I2C && __has_include(<Adafruit_MAX1704X.h>)
-bool MAX17048BatteryLevel::runOnce()
-{
-    if (max17048 == nullptr) {
-        max17048 = MAX17048Singleton::GetInstance();
-    }
-
-    if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MAX17048].first != 0) {
-        return max17048->runOnce(nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MAX17048].second);
-    }
-    return false;
-}
-
-int MAX17048BatteryLevel::getBatteryPercent()
-{
-    return max17048->getBusBatteryPercent();
-}
-
-uint16_t MAX17048BatteryLevel::getBattVoltage()
-{
-    return max17048->getBusVoltageMv();
-}
-
-bool MAX17048BatteryLevel::isBatteryConnect()
-{
-    return max17048->isBatteryConnected();
-}
-
-bool MAX17048BatteryLevel::isVbusIn()
-{
-    return max17048->isExternallyPowered();
-}
-
-bool MAX17048BatteryLevel::isCharging()
-{
-    return max17048->isBatteryCharging();
-}
-#endif
-
-#if !MESHTASTIC_EXCLUDE_I2C && HAS_CW2015
-int CW2015BatteryLevel::getBatteryPercent()
-{
-    int data = -1;
-    Wire.beginTransmission(CW2015_ADDR);
-    Wire.write(0x04);
-    if (Wire.endTransmission() == 0) {
-        if (Wire.requestFrom(CW2015_ADDR, (uint8_t)1)) {
-            data = Wire.read();
-        }
-    }
-    return data;
-}
-
-uint16_t CW2015BatteryLevel::getBattVoltage()
-{
-    uint16_t mv = 0;
-    Wire.beginTransmission(CW2015_ADDR);
-    Wire.write(0x02);
-    if (Wire.endTransmission() == 0) {
-        if (Wire.requestFrom(CW2015_ADDR, (uint8_t)2)) {
-            mv = Wire.read();
-            mv <<= 8;
-            mv |= Wire.read();
-            mv = mv * 305 / 1000;
-        }
-    }
-    return mv;
-}
-#endif
-
-#if defined(HAS_PPM) && HAS_PPM
-extern XPowersPPM *PPM;
-
-bool LipoCharger::runOnce()
-{
-    if (PPM == nullptr) {
-        PPM = new XPowersPPM;
-        bool result = PPM->init(Wire, I2C_SDA, I2C_SCL, BQ25896_ADDR);
-        if (result) {
-            LOG_INFO("PPM BQ25896 init succeeded");
-            PPM->setChargeTargetVoltage(4288);
-            PPM->setChargerConstantCurr(1024);
-            PPM->enableMeasure();
-            PPM->enableCharge();
-        } else {
-            LOG_WARN("PPM BQ25896 init failed");
-            delete PPM;
-            PPM = nullptr;
-            return false;
-        }
-    }
-    if (bq == nullptr) {
-        bq = new BQ27220;
-        bq->setDefaultCapacity(BQ27220_DESIGN_CAPACITY);
-
-        bool result = bq->init();
-        if (result) {
-            LOG_DEBUG("BQ27220 design capacity: %d", bq->getDesignCapacity());
-            LOG_DEBUG("BQ27220 fullCharge capacity: %d", bq->getFullChargeCapacity());
-            LOG_DEBUG("BQ27220 remaining capacity: %d", bq->getRemainingCapacity());
-            return true;
-        }
-
-        LOG_WARN("BQ27220 init failed");
-        delete bq;
-        bq = nullptr;
-        return false;
-    }
-    return false;
-}
-
-int LipoCharger::getBatteryPercent()
-{
-    return -1;
-}
-
-uint16_t LipoCharger::getBattVoltage()
-{
-    return bq->getVoltage();
-}
-
-bool LipoCharger::isBatteryConnect()
-{
-    return PPM->getBattVoltage() > 0;
-}
-
-bool LipoCharger::isVbusIn()
-{
-    return PPM->isVbusIn();
-}
-
-bool LipoCharger::isCharging()
-{
-    bool charging = PPM->isCharging();
-    if (charging) {
-        LOG_DEBUG("BQ27220 time to full charge: %d min", bq->getTimeToFull());
-    } else if (!PPM->isVbusIn()) {
-        LOG_DEBUG("BQ27220 time to empty: %d min (%d mAh)", bq->getTimeToEmpty(), bq->getRemainingCapacity());
-    }
-    return charging;
-}
-#endif
-
-#ifdef HELTEC_MESH_SOLAR
-bool meshSolarBatteryLevel::runOnce()
-{
-    meshSolarStart();
-    return true;
-}
-
-int meshSolarBatteryLevel::getBatteryPercent()
-{
-    return meshSolarGetBatteryPercent();
-}
-
-uint16_t meshSolarBatteryLevel::getBattVoltage()
-{
-    return meshSolarGetBattVoltage();
-}
-
-bool meshSolarBatteryLevel::isBatteryConnect()
-{
-    return meshSolarIsBatteryConnect();
-}
-
-bool meshSolarBatteryLevel::isVbusIn()
-{
-    return meshSolarIsVbusIn();
-}
-
-bool meshSolarBatteryLevel::isCharging()
-{
-    return meshSolarIsCharging();
-}
-#endif
-
-#ifdef HAS_SERIAL_BATTERY_LEVEL
-bool SerialBatteryLevel::runOnce()
-{
-    BatterySerial.begin(4800);
-    return true;
-}
-
-int SerialBatteryLevel::getBatteryPercent()
-{
-    return v_percent;
-}
-
-uint16_t SerialBatteryLevel::getBattVoltage()
-{
-    return voltage * 1000;
-}
-
-bool SerialBatteryLevel::isBatteryConnect()
-{
-    if (BatterySerial.available() > 5) {
-        while (BatterySerial.available() > 11) {
-            BatterySerial.read();
-        }
-        int tries = 0;
-        while (BatterySerial.read() != 0xFE) {
-            tries++;
-            if (tries > 10) {
-                LOG_WARN("SerialBatteryLevel: no start byte found");
-                return true;
-            }
-        }
-
-        Data[1] = BatterySerial.read();
-        Data[2] = BatterySerial.read();
-        Data[3] = BatterySerial.read();
-        Data[4] = BatterySerial.read();
-        Data[5] = BatterySerial.read();
-        if (Data[5] != 0xFD) {
-            LOG_WARN("SerialBatteryLevel: invalid end byte %02x", Data[5]);
-            return true;
-        }
-        v_percent = Data[1];
-        voltage = Data[2] + (((float)Data[3]) / 100) + (((float)Data[4]) / 10000);
-        voltage *= 2;
-        return true;
-    }
-    return true;
-}
-
-bool SerialBatteryLevel::isVbusIn()
-{
-#ifdef EXT_CHRG_DETECT
-    return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
-#endif
-    return false;
-}
-
-bool SerialBatteryLevel::isCharging()
-{
-#ifdef EXT_CHRG_DETECT
-    return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
-#endif
-    return isVbusIn();
-}
-#endif

src/power/BatteryLevel.h

@@ -1,175 +0,0 @@
-#pragma once
-
-#include "power.h"
-
-#ifdef HAS_SERIAL_BATTERY_LEVEL
-#include <SoftwareSerial.h>
-#endif
-
-#if defined(ARCH_STM32WL) && defined(BATTERY_PIN)
-#include "stm32yyxx_ll_adc.h"
-
-/* Analog read resolution */
-#if defined(LL_ADC_RESOLUTION_12B)
-#define LL_ADC_RESOLUTION LL_ADC_RESOLUTION_12B
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#elif defined(LL_ADC_DS_DATA_WIDTH_12_BIT)
-#define LL_ADC_RESOLUTION LL_ADC_DS_DATA_WIDTH_12_BIT
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#else
-#error "ADC resolution could not be defined!"
-#endif
-#define ADC_RANGE (1 << BATTERY_SENSE_RESOLUTION_BITS)
-#endif
-
-#ifdef EXT_PWR_DETECT
-#ifndef EXT_PWR_DETECT_MODE
-#define EXT_PWR_DETECT_MODE INPUT
-#elif EXT_PWR_DETECT_MODE == INPUT_PULLUP
-#define EXT_PWR_DETECT_VALUE LOW
-#elif EXT_PWR_DETECT_MODE == INPUT_PULLDOWN
-#define EXT_PWR_DETECT_VALUE HIGH
-#endif
-#ifndef EXT_PWR_DETECT_VALUE
-#define EXT_PWR_DETECT_VALUE HIGH
-#endif
-#endif
-
-#ifdef EXT_CHRG_DETECT
-#ifndef EXT_CHRG_DETECT_MODE
-#define EXT_CHRG_DETECT_MODE INPUT
-#elif EXT_CHRG_DETECT_MODE == INPUT_PULLUP
-#define EXT_CHRG_DETECT_VALUE LOW
-#elif EXT_CHRG_DETECT_MODE == INPUT_PULLDOWN
-#define EXT_CHRG_DETECT_VALUE HIGH
-#endif
-#ifndef EXT_CHRG_DETECT_VALUE
-#define EXT_CHRG_DETECT_VALUE HIGH
-#endif
-#endif
-
-#ifndef HAS_PMU
-class HasBatteryLevel
-{
-  public:
-    virtual int getBatteryPercent() { return -1; }
-    virtual uint16_t getBattVoltage() { return 0; }
-    virtual bool isBatteryConnect() { return false; }
-    virtual bool isVbusIn() { return false; }
-    virtual bool isCharging() { return false; }
-};
-#endif
-
-class AnalogBatteryLevel : public HasBatteryLevel
-{
-  public:
-    int getBatteryPercent() override;
-    uint16_t getBattVoltage() override;
-    bool isBatteryConnect() override;
-    bool isVbusIn() override;
-    bool isCharging() override;
-
-#if defined(ARCH_ESP32) && !defined(HAS_PMU) && defined(BATTERY_PIN)
-    uint32_t espAdcRead();
-#endif
-
-  private:
-    const uint16_t OCV[NUM_OCV_POINTS] = {OCV_ARRAY};
-    const float chargingVolt = (OCV[0] + 10) * NUM_CELLS;
-    const float noBatVolt = (OCV[NUM_OCV_POINTS - 1] - 500) * NUM_CELLS;
-    bool initial_read_done = false;
-    float last_read_value = (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS);
-    uint32_t last_read_time_ms = 0;
-
-#ifdef ARCH_STM32WL
-    uint32_t Vref = 3300;
-#endif
-
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT)
-    uint16_t getRAKVoltage();
-    bool hasRAK();
-#endif
-
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-    uint16_t getINAVoltage();
-    int16_t getINACurrent();
-    bool hasINA();
-#endif
-};
-
-#if !MESHTASTIC_EXCLUDE_I2C && HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_MAX1704X.h>)
-class MAX17048BatteryLevel : public HasBatteryLevel
-{
-  private:
-    MAX17048Singleton *max17048 = nullptr;
-
-  public:
-    bool runOnce();
-    int getBatteryPercent() override;
-    uint16_t getBattVoltage() override;
-    bool isBatteryConnect() override;
-    bool isVbusIn() override;
-    bool isCharging() override;
-};
-#endif
-
-#if !MESHTASTIC_EXCLUDE_I2C && HAS_CW2015
-class CW2015BatteryLevel : public AnalogBatteryLevel
-{
-  public:
-    int getBatteryPercent() override;
-    uint16_t getBattVoltage() override;
-};
-#endif
-
-#if defined(HAS_PPM) && HAS_PPM
-class BQ27220;
-
-class LipoCharger : public HasBatteryLevel
-{
-  private:
-    BQ27220 *bq = nullptr;
-
-  public:
-    bool runOnce();
-    int getBatteryPercent() override;
-    uint16_t getBattVoltage() override;
-    bool isBatteryConnect() override;
-    bool isVbusIn() override;
-    bool isCharging() override;
-};
-#endif
-
-#ifdef HELTEC_MESH_SOLAR
-class meshSolarBatteryLevel : public HasBatteryLevel
-{
-  public:
-    bool runOnce();
-    int getBatteryPercent() override;
-    uint16_t getBattVoltage() override;
-    bool isBatteryConnect() override;
-    bool isVbusIn() override;
-    bool isCharging() override;
-};
-#endif
-
-#ifdef HAS_SERIAL_BATTERY_LEVEL
-class SerialBatteryLevel : public HasBatteryLevel
-{
-  public:
-    bool runOnce();
-    int getBatteryPercent() override;
-    uint16_t getBattVoltage() override;
-    bool isBatteryConnect() override;
-    bool isVbusIn() override;
-    bool isCharging() override;
-
-  private:
-    SoftwareSerial BatterySerial = SoftwareSerial(SERIAL_BATTERY_RX, SERIAL_BATTERY_TX);
-    uint8_t Data[6] = {0};
-    int v_percent = 0;
-    float voltage = 0.0;
-};
-#endif
-
-bool battery_adcInit();

src/sleep.cpp

@@ -18,6 +18,8 @@
 #include "target_specific.h"
 
 #ifdef ARCH_ESP32
+// "esp_pm_config_esp32_t is deprecated, please include esp_pm.h and use esp_pm_config_t instead"
+#include "esp32/pm.h"
 #include "esp_pm.h"
 #if HAS_WIFI
 #include "mesh/wifi/WiFiAPClient.h"
@@ -144,31 +146,15 @@ void initDeepSleep()
     // If we booted because our timer ran out or the user pressed reset, send those as fake events
     RESET_REASON hwReason = rtc_get_reset_reason(0);
 
-#ifdef CONFIG_IDF_TARGET_ESP32P4
-    if (hwReason == BROWN_OUT_RESET)
-        reason = "brownout";
-    else if (hwReason == HP_CORE_HP_WDT_RESET)
-        reason = "taskWatchdog";
-    else if (hwReason == HP_CORE_LP_WDT_RESET)
-        reason = "intWatchdog";
-    else if (hwReason == CHIP_LP_WDT_RESET)
-        reason = "chipWatchdog";
-    else if (hwReason == SUPER_WDT_RESET)
-        reason = "superWatchdog";
-    else if (hwReason == HP_SYS_HP_WDT_RESET)
-        reason = "systemWatchdog";
-    else if (hwReason == HP_SYS_LP_WDT_RESET)
-        reason = "systemLowPowerWatchdog";
-#else
     if (hwReason == RTCWDT_BROWN_OUT_RESET)
         reason = "brownout";
-    else if (hwReason == RTCWDT_RTC_RESET)
-        reason = "rtcWatchdog";
-    else if (hwReason == TG0WDT_SYS_RESET)
+
+    if (hwReason == TG0WDT_SYS_RESET)
         reason = "taskWatchdog";
-    else if (hwReason == TG1WDT_SYS_RESET)
+
+    if (hwReason == TG1WDT_SYS_RESET)
         reason = "intWatchdog";
-#endif
+
     LOG_INFO("Booted, wake cause %d (boot count %d), reset_reason=%s", wakeCause, bootCount, reason);
 #endif
 
@@ -411,10 +397,8 @@ esp_sleep_wakeup_cause_t doLightSleep(uint64_t sleepMsec) // FIXME, use a more r
 
     // NOTE! ESP docs say we must disable bluetooth and wifi before light sleep
 
-#if SOC_PM_SUPPORT_RTC_PERIPH_PD
     // We want RTC peripherals to stay on
     esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
-#endif
 
 #if defined(BUTTON_PIN) && defined(BUTTON_NEED_PULLUP)
     gpio_pullup_en((gpio_num_t)BUTTON_PIN);
@@ -548,7 +532,11 @@ esp_sleep_wakeup_cause_t doLightSleep(uint64_t sleepMsec) // FIXME, use a more r
  */
 void enableModemSleep()
 {
+#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
     static esp_pm_config_t esp32_config; // filled with zeros because bss
+#else
+    static esp_pm_config_esp32_t esp32_config; // filled with zeros because bss
+#endif
 #if CONFIG_IDF_TARGET_ESP32S3
     esp32_config.max_freq_mhz = CONFIG_ESP32S3_DEFAULT_CPU_FREQ_MHZ;
 #elif CONFIG_IDF_TARGET_ESP32S2
@@ -557,12 +545,6 @@ void enableModemSleep()
     esp32_config.max_freq_mhz = CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ;
 #elif CONFIG_IDF_TARGET_ESP32C3
     esp32_config.max_freq_mhz = CONFIG_ESP32C3_DEFAULT_CPU_FREQ_MHZ;
-#elif CONFIG_IDF_TARGET_ESP32P4
-#if CONFIG_ESP32P4_REV_MIN_FULL < 300
-    esp32_config.max_freq_mhz = 360;
-#else
-    esp32_config.max_freq_mhz = 400;
-#endif
 #else
     esp32_config.max_freq_mhz = CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ;
 #endif
@@ -580,8 +562,8 @@ bool shouldLoraWake(uint32_t msecToWake)
 
 void enableLoraInterrupt()
 {
-#if SOC_PM_SUPPORT_EXT_WAKEUP && defined(LORA_DIO1) && (LORA_DIO1 != RADIOLIB_NC)
     esp_err_t res;
+#if SOC_PM_SUPPORT_EXT_WAKEUP && defined(LORA_DIO1) && (LORA_DIO1 != RADIOLIB_NC)
     res = gpio_pulldown_en((gpio_num_t)LORA_DIO1);
     if (res != ESP_OK) {
         LOG_ERROR("gpio_pulldown_en(LORA_DIO1) result %d", res);

src/xmodem.h

@@ -61,7 +61,11 @@ class XModemAdapter
 
     uint16_t packetno = 0;
 
+#if defined(ARCH_NRF52) || defined(ARCH_STM32WL)
+    File file = File(FSCom);
+#else
     File file;
+#endif
 
     char filename[sizeof(meshtastic_XModem_buffer_t::bytes)] = {0};
 

test/test_mac_from_string/test_main.cpp

@@ -1,195 +0,0 @@
-// Unit tests for MAC_from_string in src/platform/portduino/PortduinoGlue.cpp.
-//
-// Regression coverage for when the function stripped colons from
-// its mac_str parameter but then read bytes from the global
-// portduino_config.mac_address. Symptoms: --hwid silently ignored when
-// MACAddress: was also set, and SIGABRT (stoi: no conversion) when --hwid
-// was used without MACAddress: in config.yaml.
-#include "Arduino.h"
-#include "TestUtil.h"
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <unity.h>
-
-// Forward-declare instead of including PortduinoGlue.h to avoid pulling in
-// LR11x0Interface, USBHal, mesh.pb.h, yaml-cpp, and the full portduino_config
-// struct just to test a self-contained string parser. The symbol is defined
-// in PortduinoGlue.cpp and resolved at link time.
-bool MAC_from_string(std::string mac_str, uint8_t *dmac);
-
-void setUp(void) {}
-void tearDown(void) {}
-
-// --- Happy-path parsing ---
-
-void test_colon_separated_uppercase()
-{
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("AA:BB:CC:DD:EE:FF", dmac));
-    TEST_ASSERT_EQUAL_HEX8(0xAA, dmac[0]);
-    TEST_ASSERT_EQUAL_HEX8(0xBB, dmac[1]);
-    TEST_ASSERT_EQUAL_HEX8(0xCC, dmac[2]);
-    TEST_ASSERT_EQUAL_HEX8(0xDD, dmac[3]);
-    TEST_ASSERT_EQUAL_HEX8(0xEE, dmac[4]);
-    TEST_ASSERT_EQUAL_HEX8(0xFF, dmac[5]);
-}
-
-void test_colon_separated_lowercase()
-{
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("02:ca:fe:ba:be:01", dmac));
-    TEST_ASSERT_EQUAL_HEX8(0x02, dmac[0]);
-    TEST_ASSERT_EQUAL_HEX8(0xCA, dmac[1]);
-    TEST_ASSERT_EQUAL_HEX8(0xFE, dmac[2]);
-    TEST_ASSERT_EQUAL_HEX8(0xBA, dmac[3]);
-    TEST_ASSERT_EQUAL_HEX8(0xBE, dmac[4]);
-    TEST_ASSERT_EQUAL_HEX8(0x01, dmac[5]);
-}
-
-void test_no_colons_packed_hex()
-{
-    // The CLI form produced by some tools — 12 hex chars, no separators.
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("AABBCCDDEEFF", dmac));
-    TEST_ASSERT_EQUAL_HEX8(0xAA, dmac[0]);
-    TEST_ASSERT_EQUAL_HEX8(0xFF, dmac[5]);
-}
-
-void test_two_distinct_inputs_yield_distinct_outputs()
-{
-    // Direct regression for the original bug: parsing two different MAC
-    // strings in succession must produce two different byte sequences.
-    // Pre-fix, both calls would have produced identical bytes derived from
-    // the (untouched) global portduino_config.mac_address.
-    uint8_t a[6] = {0};
-    uint8_t b[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("AA:BB:CC:DD:EE:FF", a));
-    TEST_ASSERT_TRUE(MAC_from_string("02:CA:FE:BA:BE:01", b));
-    TEST_ASSERT_NOT_EQUAL(0, std::memcmp(a, b, 6));
-    TEST_ASSERT_EQUAL_HEX8(0xAA, a[0]);
-    TEST_ASSERT_EQUAL_HEX8(0x02, b[0]);
-}
-
-void test_does_not_read_external_state()
-{
-    // The function must derive every byte from its parameter, not from any
-    // global. Provide a unique MAC and verify all six bytes match the input
-    // exactly — leaves no room for the function to be smuggling bytes from
-    // elsewhere.
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("12:34:56:78:9A:BC", dmac));
-    const uint8_t expected[6] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC};
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, dmac, 6);
-}
-
-// --- Rejected inputs ---
-// Pre-fix, the empty/short cases either crashed (stoi exception on substr("")
-// of the empty global) or silently filled dmac with stale bytes. Post-fix,
-// the length guard rejects them cleanly with `false` and dmac is unchanged.
-
-void test_empty_string_returns_false()
-{
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string("", dmac));
-    // dmac must be untouched on failure.
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_too_short_returns_false()
-{
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string("AA:BB:CC", dmac));
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_too_long_returns_false()
-{
-    uint8_t dmac[6] = {0};
-    // 14 hex chars after colon-strip > 12.
-    TEST_ASSERT_FALSE(MAC_from_string("AA:BB:CC:DD:EE:FF:00", dmac));
-}
-
-void test_only_colons_returns_false()
-{
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string(":::::", dmac));
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_extra_colons_still_parses()
-{
-    // Colon stripping happens before length check, so an unconventional
-    // grouping that totals 12 hex chars after stripping is still accepted.
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("AABB:CCDD:EEFF", dmac));
-    TEST_ASSERT_EQUAL_HEX8(0xAA, dmac[0]);
-    TEST_ASSERT_EQUAL_HEX8(0xFF, dmac[5]);
-}
-
-void test_non_hex_input_returns_false()
-{
-    // 12 chars of non-hex would have made std::stoi throw before the
-    // try/catch wrapper was added, killing the daemon. Now must return false
-    // and leave dmac untouched.
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string("ZZ:ZZ:ZZ:ZZ:ZZ:ZZ", dmac));
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_partial_hex_failure_preserves_dmac()
-{
-    // First five bytes are valid hex; the sixth ("ZZ") is not. Without the
-    // temp-buffer staging, dmac would be partially overwritten with the five
-    // good bytes plus stale data in slot 5 — silently producing a wrong MAC
-    // since the only caller that uses this in getMacAddr() ignores the bool
-    // return value.
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string("AA:BB:CC:DD:EE:ZZ", dmac));
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_embedded_non_hex_returns_false()
-{
-    // std::stoi tolerates leading whitespace and a "0x" prefix, so a stray
-    // space inside a 2-char window like " F" would silently parse as 0xF.
-    // The per-character isxdigit() pre-check rejects these. The 14-char
-    // "0xAABBCCDDEEFF" is also rejected by the length check.
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_FALSE(MAC_from_string("AA:BB:CC:DD:EE: F", dmac));
-    TEST_ASSERT_FALSE(MAC_from_string("0xAABBCCDDEEFF", dmac));
-}
-
-// --- Unity lifecycle ---
-
-void setup()
-{
-    initializeTestEnvironment();
-    UNITY_BEGIN();
-    RUN_TEST(test_colon_separated_uppercase);
-    RUN_TEST(test_colon_separated_lowercase);
-    RUN_TEST(test_no_colons_packed_hex);
-    RUN_TEST(test_two_distinct_inputs_yield_distinct_outputs);
-    RUN_TEST(test_does_not_read_external_state);
-    RUN_TEST(test_empty_string_returns_false);
-    RUN_TEST(test_too_short_returns_false);
-    RUN_TEST(test_too_long_returns_false);
-    RUN_TEST(test_only_colons_returns_false);
-    RUN_TEST(test_extra_colons_still_parses);
-    RUN_TEST(test_non_hex_input_returns_false);
-    RUN_TEST(test_partial_hex_failure_preserves_dmac);
-    RUN_TEST(test_embedded_non_hex_returns_false);
-    exit(UNITY_END());
-}
-
-void loop() {}

test/test_meshpacket_serializer/ports/test_dmshell.cpp

@@ -0,0 +1,97 @@
+#include "../test_helpers.h"
+#include "mesh/mesh-pb-constants.h"
+
+namespace
+{
+struct BytesDecodeState {
+    uint8_t *buffer;
+    size_t capacity;
+    size_t length;
+};
+
+struct BytesEncodeState {
+    const uint8_t *buffer;
+    size_t length;
+};
+
+bool decodeBytesField(pb_istream_t *stream, const pb_field_iter_t *field, void **arg)
+{
+    (void)field;
+    auto *state = static_cast<BytesDecodeState *>(*arg);
+    if (!state) {
+        return false;
+    }
+
+    const size_t fieldLen = stream->bytes_left;
+    if (fieldLen > state->capacity) {
+        return false;
+    }
+
+    if (!pb_read(stream, state->buffer, fieldLen)) {
+        return false;
+    }
+
+    state->length = fieldLen;
+    return true;
+}
+
+bool encodeBytesField(pb_ostream_t *stream, const pb_field_iter_t *field, void *const *arg)
+{
+    auto *state = static_cast<const BytesEncodeState *>(*arg);
+    if (!state || !state->buffer || state->length == 0) {
+        return true;
+    }
+
+    if (!pb_encode_tag_for_field(stream, field)) {
+        return false;
+    }
+
+    return pb_encode_string(stream, state->buffer, state->length);
+}
+
+void assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode op, uint32_t sessionId, uint32_t seq, const uint8_t *payload,
+                              size_t payloadLen, uint32_t cols = 0, uint32_t rows = 0)
+{
+    meshtastic_RemoteShell tx = meshtastic_RemoteShell_init_zero;
+    tx.op = op;
+    tx.session_id = sessionId;
+    tx.seq = seq;
+    tx.cols = cols;
+    tx.rows = rows;
+
+    uint8_t encoded[meshtastic_Constants_DATA_PAYLOAD_LEN] = {0};
+    size_t encodedLen = pb_encode_to_bytes(encoded, sizeof(encoded), meshtastic_RemoteShell_fields, &tx);
+    TEST_ASSERT_GREATER_THAN_UINT32(0, encodedLen);
+
+    meshtastic_RemoteShell rx = meshtastic_RemoteShell_init_zero;
+
+    TEST_ASSERT_TRUE(pb_decode_from_bytes(encoded, encodedLen, meshtastic_RemoteShell_fields, &rx));
+    TEST_ASSERT_EQUAL(op, rx.op);
+    TEST_ASSERT_EQUAL_UINT32(sessionId, rx.session_id);
+    TEST_ASSERT_EQUAL_UINT32(seq, rx.seq);
+    TEST_ASSERT_EQUAL_UINT32(cols, rx.cols);
+    TEST_ASSERT_EQUAL_UINT32(rows, rx.rows);
+}
+} // namespace
+
+void test_dmshell_open_roundtrip()
+{
+    assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode_OPEN, 0x101, 1, nullptr, 0, 120, 40);
+}
+
+void test_dmshell_input_roundtrip()
+{
+    const uint8_t payload[] = {'l', 's', '\n'};
+    assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode_INPUT, 0x202, 2, payload, sizeof(payload));
+}
+
+void test_dmshell_resize_roundtrip()
+{
+    assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode_RESIZE, 0x303, 3, nullptr, 0, 180, 55);
+}
+
+void test_dmshell_close_roundtrip()
+{
+    const uint8_t reason[] = {'b', 'y', 'e'};
+    assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode_CLOSE, 0x404, 4, reason, sizeof(reason));
+}

test/test_meshpacket_serializer/test_serializer.cpp

@@ -19,6 +19,10 @@ void test_telemetry_environment_metrics_complete_coverage();
 void test_telemetry_environment_metrics_unset_fields();
 void test_encrypted_packet_serialization();
 void test_empty_encrypted_packet();
+void test_dmshell_open_roundtrip();
+void test_dmshell_input_roundtrip();
+void test_dmshell_resize_roundtrip();
+void test_dmshell_close_roundtrip();
 
 void setup()
 {
@@ -52,6 +56,12 @@ void setup()
     RUN_TEST(test_encrypted_packet_serialization);
     RUN_TEST(test_empty_encrypted_packet);
 
+    // DMShell protobuf transport tests
+    RUN_TEST(test_dmshell_open_roundtrip);
+    RUN_TEST(test_dmshell_input_roundtrip);
+    RUN_TEST(test_dmshell_resize_roundtrip);
+    RUN_TEST(test_dmshell_close_roundtrip);
+
     UNITY_END();
 }
 

variants/esp32/chatter2/variant.h

@@ -70,7 +70,7 @@
 // Battery
 
 #define BATTERY_PIN 34 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_6
+#define ADC_CHANNEL ADC1_GPIO34_CHANNEL
 #define ADC_ATTENUATION                                                                                                          \
     ADC_ATTEN_DB_2_5       // 2_5-> 100mv-1250mv, 11-> 150mv-3100mv for ESP32
                            // ESP32-S2/C3/S3 are different

variants/esp32/diy/9m2ibr_aprs_lora_tracker/variant.h

@@ -30,7 +30,7 @@
 // Battery sense
 #define BATTERY_PIN 35
 #define ADC_MULTIPLIER 2.01 // 100k + 100k, and add 1% tolerance
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define BATTERY_SENSE_RESOLUTION_BITS ADC_RESOLUTION
 
 // SPI

variants/esp32/diy/dr-dev/variant.h

@@ -3,7 +3,7 @@
 #define I2C_SDA 4
 #define I2C_SCL 5
 #define BATTERY_PIN 34
-#define ADC_CHANNEL ADC_CHANNEL_6
+#define ADC_CHANNEL ADC1_GPIO34_CHANNEL
 
 // GPS
 #undef GPS_RX_PIN

variants/esp32/diy/hydra/variant.h

@@ -11,7 +11,7 @@
 // Note: On the ESP32 base version, gpio34-39 are input-only, and do not have internal pull-ups.
 // If 39 is not being used for a button, it is suggested to remove the #define.
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define ADC_MULTIPLIER 1.85 // (R1 = 470k, R2 = 680k)
 #define EXT_PWR_DETECT 4    // Pin to detect connected external power source for LILYGO® TTGO T-Energy T18 and other DIY boards
 #define EXT_NOTIFY_OUT 12   // Overridden default pin to use for Ext Notify Module (#975).

variants/esp32/diy/v1/variant.h

@@ -11,7 +11,7 @@
 
 #define BUTTON_PIN 39  // The middle button GPIO on the T-Beam
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define ADC_MULTIPLIER 1.85 // (R1 = 470k, R2 = 680k)
 #define EXT_PWR_DETECT 4    // Pin to detect connected external power source for LILYGO® TTGO T-Energy T18 and other DIY boards
 #define EXT_NOTIFY_OUT 12   // Overridden default pin to use for Ext Notify Module (#975).

variants/esp32/esp32-common.ini

@@ -4,9 +4,8 @@ extends = arduino_base
 custom_esp32_kind =
 custom_mtjson_part =
 platform =
-  # TODO renovate
-  https://github.com/pioarduino/platform-espressif32/releases/download/55.03.38-1/platform-espressif32.zip
-  ; https://github.com/pioarduino/platform-espressif32.git#develop
+  # renovate: datasource=custom.pio depName=platformio/espressif32 packageName=platformio/platform/espressif32
+  platformio/espressif32@6.13.0
 platform_packages =
   # renovate: datasource=custom.pio depName=platformio/tool-mklittlefs packageName=platformio/tool/tool-mklittlefs
   platformio/tool-mklittlefs@1.203.210628
@@ -36,18 +35,20 @@ build_unflags =
   -std=gnu++11
 build_flags =
   ${arduino_base.build_flags}
+  -flto
   -Wall
   -Wextra
   -Isrc/platform/esp32
   -std=gnu++17
   -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG
-  # DO NOT INCREASE THIS TO DEBUG. It appears to trigger a bug in ESP-IDF
-  # Bluetooth stack with Pixel 8 Android devices:
-  # https://github.com/espressif/esp-idf/issues/18126#issuecomment-4286197744
-  # Once the bug is resolved, we can remove this warning.
-  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_INFO
+  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
   -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
   -DAXP_DEBUG_PORT=Serial
+  -DCONFIG_BT_NIMBLE_ENABLED
+  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
+  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
+  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
+  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
   -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
   -DSERIAL_BUFFER_SIZE=4096
   -DSERIAL_HAS_ON_RECEIVE
@@ -61,13 +62,16 @@ build_flags =
 lib_deps =
   ${arduino_base.lib_deps}
   ${networking_base.lib_deps}
+  ${networking_extra.lib_deps}
   ${environmental_base.lib_deps}
   ${environmental_extra.lib_deps}
   ${radiolib_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
   https://github.com/meshtastic/esp32_https_server/archive/0c71f380390ad483ff134ad938e07f6cf1226c5b.zip
-  # TODO renovate
-  https://github.com/mverch67/libpax/archive/6f52ee989301cdabaeef00bcbf93bff55708ce2f.zip
+  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
+  h2zero/NimBLE-Arduino@1.4.3
+  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
+  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
   # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
   lewisxhe/XPowersLib@0.3.3
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
@@ -75,30 +79,7 @@ lib_deps =
 
 lib_ignore = 
   segger_rtt
-  ; ESP32 BLE Arduino
-  ; BLE
-  ; Ignore select Bluetooth libs
-  NimBLE-Arduino
-  BluetoothSerial
-  SimpleBLE
-  WiFiProv
-  ArduinoOTA
-  ; Ignore pioarduino esp32 libs we don't use
-  ESP_I2S
-  ESP_NOW
-  ESP_SR
-  Insights
-  Matter
-  OpenThread
-  RainMaker
-  ;SPIFFS
-  USB
-  ;NetworkClientSecure
-  Zigbee
-  Micro-RTSP
-  ; testing below
-  mqtt
-  esp-mqtt
+  ESP32 BLE Arduino
 
 ; leave this commented out to avoid breaking Windows
 ;upload_port = /dev/ttyUSB0
@@ -111,226 +92,3 @@ lib_ignore =
 ; customize the partition table
 ; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
 board_build.partitions = partition-table.csv
-
-custom_component_remove =
-  espressif/esp_hosted
-  espressif/esp_wifi_remote
-  espressif/esp_modem
-  espressif/esp-dsp
-  espressif/esp32-camera
-  espressif/libsodium
-  espressif/esp-modbus
-  espressif/qrcode
-  espressif/esp_insights
-  espressif/esp_diag_data_store
-  espressif/esp_diagnostics
-  espressif/esp_rainmaker
-  espressif/rmaker_common
-  espressif/network_provisioning
-  chmorgan/esp-libhelix-mp3
-  espressif/esp-tflite-micro
-  espressif/esp-sr
-  espressif/esp_matter
-  espressif/esp-zboss-lib
-  espressif/esp-zigbee-lib
-  espressif/mqtt
-
-custom_sdkconfig =
-  ; CONFIG_LOG_DEFAULT_LEVEL=4
-  ; CONFIG_LOG_MAXIMUM_LEVEL=4
-  '# CONFIG_BT_NIMBLE_LOG_LEVEL_INFO is not set'
-  CONFIG_BT_NIMBLE_LOG_LEVEL_ERROR=y
-  CONFIG_LOG_COLORS=y
-  CONFIG_ARDUHAL_LOG_COLORS=y
-  CONFIG_BOOTLOADER_LOG_LEVEL_NONE=y
-  CONFIG_IDF_EXPERIMENTAL_FEATURES=y
-  ;
-  ; Compiler options
-  ;
-  CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=n
-  CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE=y
-  CONFIG_COMPILER_CXX_EXCEPTIONS=n
-  CONFIG_COMPILER_STACK_CHECK_MODE_NORM=n
-  CONFIG_COMPILER_STACK_CHECK_MODE_NONE=y
-  CONFIG_COMPILER_DISABLE_GCC12_WARNINGS=y
-  CONFIG_COMPILER_DISABLE_GCC13_WARNINGS=y
-  CONFIG_COMPILER_DISABLE_GCC14_WARNINGS=y
-  CONFIG_COMPILER_ORPHAN_SECTIONS_WARNING=n
-  CONFIG_COMPILER_ORPHAN_SECTIONS_PLACE=y
-  CONFIG_ESP_GDBSTUB_ENABLED=n
-  CONFIG_ESP_TASK_WDT_INIT=n
-  CONFIG_NEWLIB_NANO_FORMAT=y
-  ; LIBC_NEWLIB_NANO_FORMAT is enabled via 'esp32_extra.py' to allow float support
-  CONFIG_ESP_COREDUMP_ENABLE=n
-  CONFIG_ESP_COREDUMP_ENABLE_TO_FLASH=n
-  CONFIG_ESP_COREDUMP_ENABLE_TO_NONE=y
-  CONFIG_ESP32_ENABLE_COREDUMP=n
-  CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=n
-  CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS=n
-  CONFIG_FREERTOS_USE_TRACE_FACILITY=n
-  CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH=y
-  CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH=y
-  CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH=y
-  CONFIG_ESP_SYSTEM_ESP32_SRAM1_REGION_AS_IRAM=y
-  CONFIG_ESP_WIFI_IRAM_OPT=n
-  CONFIG_ESP32_WIFI_RX_IRAM_OPT=n
-  CONFIG_SPIRAM_CACHE_LIBCHAR_IN_IRAM=n
-  CONFIG_SPIRAM_CACHE_LIBSTR_IN_IRAM=n
-  CONFIG_SPIRAM_CACHE_LIBMISC_IN_IRAM=n
-  CONFIG_SPIRAM_CACHE_LIBTIME_IN_IRAM=n
-  CONFIG_UNITY_ENABLE_FLOAT=n
-  CONFIG_UNITY_ENABLE_DOUBLE=n
-  CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=n
-  CONFIG_SUPPORT_TERMIOS=n
-  CONFIG_VFS_SUPPORT_TERMIOS=n
-  CONFIG_VFS_SUPPORT_SELECT=n
-  CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT=n
-  CONFIG_WS_TRANSPORT=n
-  CONFIG_PPP_SUPPORT=n
-  CONFIG_NETWORK_PROV_NETWORK_TYPE_WIFI=n
-  ; CONFIG_LWIP_DHCPS=n
-  CONFIG_LWIP_PPP_SUPPORT=n
-  CONFIG_LWIP_IP_FORWARD=n
-  CONFIG_LWIP_IPV4_NAPT=n
-  ;
-  ; MBEDTLS
-  ;
-  CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=8192
-  CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL=n
-  CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN=y
-  ; Switch to custom CA bundle (for Meshtastic MQTT/etc) in the future
-  ; https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-reference/kconfig-reference.html#certificate-bundle-configuration
-  ; CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE=y
-  ; CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE_PATH=""
-  CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_MAX_CERTS=1
-  ; #shame
-  CONFIG_MBEDTLS_ALLOW_WEAK_CERTIFICATE_VERIFICATION=y
-  CONFIG_MBEDTLS_SSL_RENEGOTIATION=n
-  CONFIG_MBEDTLS_SSL_PROTO_DTLS=n
-  CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=n
-  CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=n
-  CONFIG_MBEDTLS_PKCS7_C=n
-  CONFIG_MBEDTLS_CAMELLIA_C=n
-  CONFIG_MBEDTLS_CCM_C=n
-  CONFIG_MBEDTLS_CMAC_C=n
-  CONFIG_MBEDTLS_SHA512_C=n
-  CONFIG_MBEDTLS_X509_CRL_PARSE_C=n
-  CONFIG_MBEDTLS_X509_CSR_PARSE_C=n
-  CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_PSK=n
-  CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=n
-  CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=n
-  CONFIG_MBEDTLS_KEY_EXCHANGE_ECJPAKE=n
-  CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=n
-  CONFIG_MDNS_ENABLE_CONSOLE_CLI=n
-  CONFIG_MDNS_PREDEF_NETIF_AP=n
-  ; CONFIG_ESP_WIFI_SOFTAP_SUPPORT=n
-  CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT=n
-  CONFIG_ESP_WIFI_ENABLE_WPA3_SAE=n
-  CONFIG_ESP_WIFI_ENABLE_WPA3_OWE_STA=n
-  CONFIG_ESP_WIFI_ENABLE_SAE_H2E=n
-  CONFIG_OPENTHREAD_ENABLED=n
-  CONFIG_ZB_ENABLED=n
-  CONFIG_IEEE802154_ENABLED=n
-  CONFIG_ESP_INSIGHTS_ENABLED=n
-  CONFIG_HTTPD_WS_SUPPORT=n
-  CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS=n
-  CONFIG_ESP_HTTP_CLIENT_ENABLE_BASIC_AUTH=n
-  ; using esp-idf5-https_server library instead, for now?
-  CONFIG_ESP_HTTPS_SERVER_ENABLE=n
-  ;
-  ; Builtin ESP-MQTT, we don't use this (yet?)
-  ;
-  CONFIG_MQTT_TRANSPORT_SSL=n
-  CONFIG_MQTT_TRANSPORT_WEBSOCKET=n
-  CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=n
-  CONFIG_MQTT_PROTOCOL_311=n
-  ;
-  ; Ethernet
-  ; Disabled in esp32_common, re-enable on variants that need it
-  ;
-  CONFIG_ETH_ENABLED=n
-  CONFIG_ARDUINO_SELECTIVE_Ethernet=n
-  ;
-  ; Bluetooth
-  ;
-  CONFIG_BLE_MESH=n
-  CONFIG_BT_ENABLED=y
-  CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
-  CONFIG_BT_BLUEDROID_ENABLED=n
-  CONFIG_BT_NIMBLE_ENABLED=y
-  CONFIG_BT_NIMBLE_NVS_PERSIST=y
-  CONFIG_BT_NIMBLE_ROLE_CENTRAL=n
-  CONFIG_BT_NIMBLE_ROLE_OBSERVER=n
-  CONFIG_BT_CONTROLLER_ENABLED=y
-  CONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
-  CONFIG_BT_NIMBLE_MAX_CCCDS=20
-  CONFIG_BT_NIMBLE_MAX_BONDS=6
-  CONFIG_BT_NIMBLE_ENABLE_PERIODIC_SYNC=n
-  CONFIG_BT_NIMBLE_ENABLE_PERIODIC_ADV=n
-  CONFIG_BT_NIMBLE_EXT_SCAN=n
-  CONFIG_BT_NIMBLE_EXT_ADV=n
-  CONFIG_BT_NIMBLE_PERIODIC_ADV_SYNC_TRANSFER=n
-  CONFIG_BT_NIMBLE_LL_CFG_FEAT_LE_2M_PHY=n
-  CONFIG_BT_NIMBLE_BLUFI_ENABLE=n
-  CONFIG_BT_NIMBLE_PROX_SERVICE=n
-  CONFIG_BT_NIMBLE_ANS_SERVICE=n
-  CONFIG_BT_NIMBLE_CTS_SERVICE=n
-  CONFIG_BT_NIMBLE_HTP_SERVICE=n
-  CONFIG_BT_NIMBLE_IPSS_SERVICE=n
-  CONFIG_BT_NIMBLE_TPS_SERVICE=n
-  CONFIG_BT_NIMBLE_IAS_SERVICE=n
-  CONFIG_BT_NIMBLE_LLS_SERVICE=n
-  CONFIG_BT_NIMBLE_SPS_SERVICE=y
-  CONFIG_BT_NIMBLE_HR_SERVICE=n
-  CONFIG_BT_NIMBLE_HID_SERVICE=n
-  CONFIG_BT_NIMBLE_BAS_SERVICE=n
-  CONFIG_BT_NIMBLE_DIS_SERVICE=n
-  ;
-  ; Arduino selective compilation
-  ; Disable unused Arduino libraries to save space
-  ;
-  CONFIG_ARDUINO_SELECTIVE_COMPILATION=y
-  CONFIG_ARDUINO_SELECTIVE_SPI=y
-  CONFIG_ARDUINO_SELECTIVE_Wire=y
-  CONFIG_ARDUINO_SELECTIVE_ESP_SR=n
-  CONFIG_ARDUINO_SELECTIVE_EEPROM=y
-  CONFIG_ARDUINO_SELECTIVE_Preferences=y
-  CONFIG_ARDUINO_SELECTIVE_Ticker=y
-  CONFIG_ARDUINO_SELECTIVE_Update=y
-  CONFIG_ARDUINO_SELECTIVE_Zigbee=n
-  CONFIG_ARDUINO_SELECTIVE_FS=y
-  CONFIG_ARDUINO_SELECTIVE_SD=y
-  CONFIG_ARDUINO_SELECTIVE_SD_MMC=y
-  CONFIG_ARDUINO_SELECTIVE_SPIFFS=y
-  CONFIG_ARDUINO_SELECTIVE_FFat=n
-  CONFIG_ARDUINO_SELECTIVE_LittleFS=y
-  CONFIG_ARDUINO_SELECTIVE_Network=y
-  ; CONFIG_ARDUINO_SELECTIVE_Ethernet=n
-  CONFIG_ARDUINO_SELECTIVE_PPP=n
-  CONFIG_ARDUINO_SELECTIVE_Hash=y
-  CONFIG_ARDUINO_SELECTIVE_ArduinoOTA=n
-  CONFIG_ARDUINO_SELECTIVE_AsyncUDP=y
-  CONFIG_ARDUINO_SELECTIVE_DNSServer=n
-  CONFIG_ARDUINO_SELECTIVE_ESPmDNS=y
-  CONFIG_ARDUINO_SELECTIVE_HTTPClient=n
-  CONFIG_ARDUINO_SELECTIVE_Matter=n
-  CONFIG_ARDUINO_SELECTIVE_NetBIOS=n
-  CONFIG_ARDUINO_SELECTIVE_WebServer=n
-  CONFIG_ARDUINO_SELECTIVE_WiFi=y
-  CONFIG_ARDUINO_SELECTIVE_NetworkClientSecure=y
-  CONFIG_ARDUINO_SELECTIVE_WiFiProv=n
-  CONFIG_ARDUINO_SELECTIVE_BLE=y
-  CONFIG_ARDUINO_SELECTIVE_BluetoothSerial=n
-  CONFIG_ARDUINO_SELECTIVE_SimpleBLE=n
-  CONFIG_ARDUINO_SELECTIVE_RainMaker=n
-  CONFIG_ARDUINO_SELECTIVE_OpenThread=n
-  CONFIG_ARDUINO_SELECTIVE_Insights=n

variants/esp32/esp32.ini

@@ -11,39 +11,12 @@ build_src_filter =
 
 build_flags =
   ${esp32_common.build_flags}
-  -mtext-section-literals
-  -D ESP32_FORCE_IRAM_MEMSET
-  -Wl,--wrap=memset
-  -Wl,--wrap=memcpy
   -DMESHTASTIC_EXCLUDE_AUDIO=1
   -DMESHTASTIC_EXCLUDE_ACCELEROMETER=1
   -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
   -DMESHTASTIC_EXCLUDE_WEBSERVER=1
   -DMESHTASTIC_EXCLUDE_RANGETEST=1
-  ; HACK HACK HACK this is just a proof of concept ESP32+NimBLE but these
-  ; includes need to be done properly somehow
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/host/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/porting/nimble/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/port/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/porting/npl/freertos/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/transport/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/host/services/gap/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/esp-hci/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/host/services/gatt/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/host/util/include
 
-custom_sdkconfig =
-  ${esp32_common.custom_sdkconfig}
-  CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
-  '# CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY is not set'
-  '# CONFIG_BTDM_CTRL_MODE_BTDM is not set'
-  '# CONFIG_BT_BLUEDROID_ENABLED is not set'
-  CONFIG_BT_NIMBLE_ENABLED=y
-  CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP=y
-
-; Override lib_deps to use environmental_extra_no_bsec instead of environmental_extra
-; BSEC library uses ~3.5KB DRAM which causes overflow on original ESP32 targets
 lib_deps =
   ${arduino_base.lib_deps}
   ${networking_base.lib_deps}
@@ -51,8 +24,8 @@ lib_deps =
   ${radiolib_base.lib_deps}
   ${environmental_base.lib_deps}
   ${environmental_extra_no_bsec.lib_deps}
-  # TODO renovate
-  https://github.com/mverch67/libpax/archive/6f52ee989301cdabaeef00bcbf93bff55708ce2f.zip
+  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
+  h2zero/NimBLE-Arduino@1.4.3
   # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
   lewisxhe/XPowersLib@0.3.3
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto

variants/esp32/heltec_wsl_v2.1/variant.h

@@ -12,7 +12,7 @@
 #define ADC_CTRL 21
 #define ADC_CTRL_ENABLED LOW
 #define BATTERY_PIN 37 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_1
+#define ADC_CHANNEL ADC1_CHANNEL_1
 // ratio of voltage divider = 3.20 (R1=100k, R2=220k)
 #define ADC_MULTIPLIER 3.2
 

variants/esp32/m5stack_coreink/variant.h

@@ -92,7 +92,7 @@
 #define PIN_EINK_MOSI 23 // EPD_MOSI
 
 #define BATTERY_PIN 35
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 // https://m5stack.oss-cn-shenzhen.aliyuncs.com/resource/docs/schematic/Core/m5paper/M5_PAPER_SCH.pdf
 // https://github.com/m5stack/M5Core-Ink/blob/master/examples/Basics/FactoryTest/FactoryTest.ino#L58
 //  VBAT

variants/esp32/nano-g1-explorer/variant.h

@@ -33,7 +33,7 @@
 #endif
 
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define BATTERY_SENSE_SAMPLES 15 // Set the number of samples, It has an effect of increasing sensitivity.
 #define ADC_MULTIPLIER 2
 

variants/esp32/radiomaster_900_bandit/platformio.ini

@@ -7,7 +7,7 @@ build_flags =
   -DVTABLES_IN_FLASH=1
   -DCONFIG_DISABLE_HAL_LOCKS=1
   -DHAS_STK8XXX=1
-  ; -O2
+  -O2
   -I variants/esp32/radiomaster_900_bandit
 board_build.f_cpu = 240000000L
 upload_protocol = esptool

variants/esp32/rak11200/variant.h

@@ -47,7 +47,7 @@ static const uint8_t SCK = 33;
 
 #define PIN_VBAT WB_A0
 #define BATTERY_PIN PIN_VBAT
-#define ADC_CHANNEL ADC_CHANNEL_0
+#define ADC_CHANNEL ADC1_GPIO36_CHANNEL
 
 // https://docs.rakwireless.com/Product-Categories/WisBlock/RAK13300/
 

variants/esp32/station-g1/variant.h

@@ -32,7 +32,7 @@
 #endif
 
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define BATTERY_SENSE_SAMPLES 30 // Set the number of samples, It has an effect of increasing sensitivity.
 #define ADC_MULTIPLIER 6.45
 #define CELL_TYPE_LION // same curve for liion/lipo

variants/esp32/tbeam/platformio.ini

@@ -16,7 +16,6 @@ board_check = true
 build_flags = ${esp32_base.build_flags}
   -D TBEAM_V10
   -I variants/esp32/tbeam
-
 upload_speed = 921600
 
 [env:tbeam-displayshield]

variants/esp32/tbeam_v07/variant.h

@@ -6,7 +6,7 @@
 #define BUTTON_PIN 39
 #define BATTERY_PIN 35    // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 #define EXT_NOTIFY_OUT 13 // Default pin to use for Ext Notify Module.
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 
 #define USE_RF95
 #define LORA_DIO0 26 // a No connect on the SX1262 module

variants/esp32/tlora_v1_3/variant.h

@@ -1,5 +1,5 @@
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 
 #define I2C_SDA 21 // I2C pins for this board
 #define I2C_SCL 22

variants/esp32/tlora_v2/variant.h

@@ -1,5 +1,5 @@
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 
 #define I2C_SDA 21 // I2C pins for this board
 #define I2C_SCL 22