Merge branch 'develop' into t-watch-ultra

.github/copilot-instructions.md

@@ -13,7 +13,6 @@ Meshtastic is an open-source LoRa mesh networking project for long-range, low-po
 - **RP2040/RP2350** - Raspberry Pi Pico variants
 - **STM32WL** - STM32 with integrated LoRa
 - **Linux/Portduino** - Native Linux builds (Raspberry Pi, etc.)
-- **macOS native** - Headless `meshtasticd` on Apple Silicon / x86_64; see `variants/native/portduino/platformio.ini` for Homebrew prereqs + CH341 LoRa setup
 
 ### Supported Radio Chips
 
@@ -370,7 +369,7 @@ To reduce avoidable agent mistakes, assume these tools are available (or install
 - **Required CLI basics**: `bash`, `git`, `find`, `grep`, `sed`, `awk`, `xargs`
 - **Strongly recommended**: `rg` (ripgrep) for fast file/text search, `jq` for JSON processing
 - **Build/test tools**: `python3`, `pip`, virtualenv (`python3 -m venv`), `platformio` (`pio`)
-- **Containerized native testing**: `docker` (fallback for non-Linux hosts; macOS can also build natively via `pio run -e native-macos`)
+- **Containerized native testing**: `docker` (especially important on macOS / non-Linux hosts)
 
 Fallback expectations for agents:
 
@@ -389,7 +388,6 @@ Build commands:
 pio run -e tbeam              # Build specific target
 pio run -e tbeam -t upload    # Build and upload
 pio run -e native             # Build native/Linux version
-pio run -e native-macos       # Build headless macOS meshtasticd (Homebrew prereqs in variants/native/portduino/platformio.ini)
 ```
 
 ### Build Manifest

.github/workflows/build_macos_bin.yml

@@ -1,51 +0,0 @@
-name: Build MacOS Binary
-
-on:
-  workflow_call:
-    inputs:
-      macos_ver:
-        required: false
-        default: "26" # ARM64
-        type: string
-
-permissions:
-  contents: read
-
-jobs:
-  build-MacOS:
-    runs-on: macos-${{ inputs.macos_ver }}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-
-      - name: Install deps
-        shell: bash
-        run: |
-          brew update
-          brew install platformio yaml-cpp libuv openssl@3 libusb argp-standalone pkg-config
-
-      - name: Get release version string
-        run: |
-          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Build for MacOS
-        run: |
-          platformio run -e native-macos
-        env:
-          PKG_VERSION: ${{ steps.version.outputs.long }}
-        # Errors in this step should not fail the entire workflow while MacOS support is in development.
-        continue-on-error: true
-
-      - name: List output files
-        run: ls -lah .pio/build/native-macos/
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: firmware-macos-${{ inputs.macos_ver }}-${{ steps.version.outputs.long }}
-          overwrite: true
-          path: |
-            .pio/build/native-macos/meshtasticd

.github/workflows/docker_build.yml

@@ -73,9 +73,7 @@ jobs:
       - name: Sanitize platform string
         id: sanitize_platform
         # Replace slashes with underscores
-        env:
-          plat: ${{ inputs.platform }}
-        run: echo "cleaned_platform=${plat}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
+        run: echo "cleaned_platform=${{ inputs.platform }}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
 
       - name: Docker login
         if: ${{ inputs.push }}

.github/workflows/docker_manifest.yml

@@ -43,15 +43,6 @@ jobs:
       push: true
     secrets: inherit
 
-  docker-debian-riscv64:
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/riscv64
-      runs-on: ubuntu-24.04-arm
-      push: true
-    secrets: inherit
-
   docker-alpine-amd64:
     uses: ./.github/workflows/docker_build.yml
     with:
@@ -79,27 +70,16 @@ jobs:
       push: true
     secrets: inherit
 
-  docker-alpine-riscv64:
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: alpine
-      platform: linux/riscv64
-      runs-on: ubuntu-24.04-arm
-      push: true
-    secrets: inherit
-
   docker-manifest:
     needs:
       # Debian
       - docker-debian-amd64
       - docker-debian-arm64
       - docker-debian-armv7
-      - docker-debian-riscv64
       # Alpine
       - docker-alpine-amd64
       - docker-alpine-arm64
       - docker-alpine-armv7
-      - docker-alpine-riscv64
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
@@ -182,7 +162,6 @@ jobs:
             meshtastic/meshtasticd@${{ needs.docker-debian-amd64.outputs.digest }}
             meshtastic/meshtasticd@${{ needs.docker-debian-arm64.outputs.digest }}
             meshtastic/meshtasticd@${{ needs.docker-debian-armv7.outputs.digest }}
-            meshtastic/meshtasticd@${{ needs.docker-debian-riscv64.outputs.digest }}
 
       - name: Docker meta (Alpine)
         id: meta_alpine
@@ -203,4 +182,3 @@ jobs:
             meshtastic/meshtasticd@${{ needs.docker-alpine-amd64.outputs.digest }}
             meshtastic/meshtasticd@${{ needs.docker-alpine-arm64.outputs.digest }}
             meshtastic/meshtasticd@${{ needs.docker-alpine-armv7.outputs.digest }}
-            meshtastic/meshtasticd@${{ needs.docker-alpine-riscv64.outputs.digest }}

.github/workflows/main_matrix.yml

@@ -116,20 +116,6 @@ jobs:
       build_location: local
     secrets: inherit
 
-  MacOS:
-    strategy:
-      fail-fast: false
-      matrix:
-        macos_ver:
-          - "26" # ARM64
-          # - '26-intel' # x86_64
-          - "15" # ARM64
-          # - '15-intel' # x86_64
-    uses: ./.github/workflows/build_macos_bin.yml
-    with:
-      macos_ver: ${{ matrix.macos_ver }}
-    # secrets: inherit
-
   package-pio-deps-native-tft:
     if: ${{ github.repository == 'meshtastic/firmware' && github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/package_pio_deps.yml
@@ -300,7 +286,6 @@ jobs:
       - gather-artifacts
       - build-debian-src
       - package-pio-deps-native-tft
-      # - MacOS
     steps:
       - name: Checkout
         uses: actions/checkout@v6

.trunk/trunk.yaml

@@ -4,19 +4,19 @@ cli:
 plugins:
   sources:
     - id: trunk
-      ref: v1.8.0
+      ref: v1.7.6
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.525
-    - renovate@43.150.0
+    - checkov@3.2.524
+    - renovate@43.141.0
     - prettier@3.8.3
     - trufflehog@3.95.2
     - yamllint@1.38.0
     - bandit@1.9.4
     - trivy@0.70.0
     - taplo@0.10.0
-    - ruff@0.15.12
+    - ruff@0.15.11
     - isort@8.0.1
     - markdownlint@0.48.0
     - oxipng@10.1.1
@@ -36,7 +36,7 @@ lint:
         - bin/**
 runtimes:
   enabled:
-    - python@3.14.4
+    - python@3.10.8
     - go@1.21.0
     - node@22.16.0
 actions:

AGENTS.md

@@ -10,18 +10,17 @@ This file (`AGENTS.md`) is a short pointer + quick reference for agents that don
 
 ## Quick command reference
 
-| Action                           | Command                                                                                                       |
-| -------------------------------- | ------------------------------------------------------------------------------------------------------------- |
-| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                        |
-| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`) |
-| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                               |
-| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                           |
-| Run firmware unit tests (native) | `pio test -e native`                                                                                          |
-| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                   |
-| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                |
-| Format before commit             | `trunk fmt`                                                                                                   |
-| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                         |
-| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                |
+| Action                           | Command                                                                             |
+| -------------------------------- | ----------------------------------------------------------------------------------- |
+| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)              |
+| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                     |
+| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool) |
+| Run firmware unit tests (native) | `pio test -e native`                                                                |
+| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                         |
+| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                      |
+| Format before commit             | `trunk fmt`                                                                         |
+| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                               |
+| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                      |
 
 ## MCP server (device + test automation)
 
@@ -122,7 +121,6 @@ Sequence these; don't parallelize on the same port.
 - **Device fully wedged (no DFU)?** `mcp__meshtastic__uhubctl_cycle(role="nrf52", confirm=True)` hard-power-cycles it via USB hub PPPS. Needs `uhubctl` installed (`brew install uhubctl` / `apt install uhubctl`); on Linux without udev rules, permission errors fail fast, so use `sudo uhubctl` yourself or configure udev access.
 - **Port busy?** `lsof <port>` to find the holder. Usually a stale `pio device monitor` or zombie `meshtastic_mcp` process. Kill it.
 - **Multiple MCP servers running?** `ps aux | grep meshtastic_mcp` — zombies hold ports. Kill all but the one your host spawned.
-- **macOS: `LIBUSB_ERROR_BUSY` on a CH341 LoRa adapter?** A third-party WCH `CH34xVCPDriver` is claiming interface 0. Find the bundle ID with `ioreg -p IOUSB -l -w 0 | grep -B2 -A30 0x5512`, then `sudo kmutil unload -b <bundleID>`. Apple's bundled CH34x kext targets the CH340 UART (PID 0x7523), not the SPI bridge — it's never the culprit.
 
 ## Environment variables (test harness)
 

alpine.Dockerfile

@@ -3,8 +3,7 @@
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
-# Ensure the Alpine version is updated in both stages of the container!
-FROM python:3.14-alpine3.23 AS builder
+FROM python:3.14-alpine3.22 AS builder
 ARG PIO_ENV=native
 ENV PIP_ROOT_USER_ACTION=ignore
 
@@ -61,4 +60,4 @@ EXPOSE 4403
 
 CMD [ "sh",  "-cx", "meshtasticd --fsdir=/var/lib/meshtasticd" ]
 
-HEALTHCHECK NONE
+HEALTHCHECK NONE

bin/dmshell_client.py

@@ -1,941 +0,0 @@
-#!/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())

boards/t-watch-ultra.json

@@ -2,42 +2,39 @@
   "build": {
     "arduino": {
       "ldscript": "esp32s3_out.ld",
-      "partitions": "default_16MB.csv",
-      "memory_type": "qio_opi"
+      "memory_type": "qio_qspi"
     },
     "core": "esp32",
     "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"
     ],
     "f_cpu": "240000000L",
     "f_flash": "80000000L",
     "flash_mode": "qio",
-    "psram_type": "opi",
+    "psram_type": "qio",
     "hwids": [["0x303A", "0x1001"]],
     "mcu": "esp32s3",
-    "variant": "heltec_v4_r8"
+    "variant": "t-watch-ultra"
   },
   "connectivity": ["wifi", "bluetooth", "lora"],
   "debug": {
-    "default_tool": "esp-builtin",
-    "onboard_tools": ["esp-builtin"],
     "openocd_target": "esp32s3.cfg"
   },
-  "frameworks": ["arduino", "espidf"],
-  "name": "heltec_wifi_lora_32 v4 r8 (16 MB FLASH, 8 MB PSRAM)",
+  "frameworks": ["arduino"],
+  "name": "LilyGo T-Watch Ultra",
   "upload": {
     "flash_size": "16MB",
     "maximum_ram_size": 327680,
     "maximum_size": 16777216,
+    "require_upload_port": true,
     "use_1200bps_touch": true,
     "wait_for_upload_port": true,
-    "require_upload_port": true,
     "speed": 921600
   },
-  "url": "https://heltec.org/",
-  "vendor": "heltec"
+  "url": "https://www.lilygo.cc/en-pl/products/t-watch-ultra",
+  "vendor": "LilyGo"
 }

debian/ci_pack_sdeb.sh

@@ -1,5 +1,4 @@
 #!/usr/bin/bash
-set -e
 export DEBEMAIL="jbennett@incomsystems.biz"
 export PLATFORMIO_LIBDEPS_DIR=pio/libdeps
 export PLATFORMIO_PACKAGES_DIR=pio/packages

platformio.ini

@@ -125,7 +125,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/4bf593a82100b911ff816dddf7158ffdee2114cd.zip
+	https://github.com/meshtastic/device-ui/archive/56e1da4e7d30abcd746a2092a30e422f8cf5fc2b.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]

src/Power.cpp

@@ -1310,6 +1310,48 @@ bool Power::axpChipInit()
             PMU->disablePowerOutput(XPOWERS_DLDO1); // Invalid power channel, it does not exist
             PMU->disablePowerOutput(XPOWERS_DLDO2); // Invalid power channel, it does not exist
             PMU->disablePowerOutput(XPOWERS_VBACKUP);
+        } else if (HW_VENDOR == meshtastic_HardwareModel_T_WATCH_ULTRA) {
+            PMU->clearIrqStatus();
+
+            // Turn off the PMU charging indicator light, no physical connection
+            PMU->setChargingLedMode(XPOWERS_CHG_LED_OFF); // NO LED
+
+            PMU->setPowerChannelVoltage(XPOWERS_ALDO1, 3300); // SD Card
+            PMU->enablePowerOutput(XPOWERS_ALDO1);
+
+            PMU->setPowerChannelVoltage(XPOWERS_ALDO2, 3300); // Display
+            PMU->enablePowerOutput(XPOWERS_ALDO2);
+
+            PMU->setPowerChannelVoltage(XPOWERS_ALDO3, 3300); // LoRa
+            PMU->enablePowerOutput(XPOWERS_ALDO3);
+
+            PMU->setPowerChannelVoltage(XPOWERS_ALDO4, 1800); // Sensor
+            PMU->enablePowerOutput(XPOWERS_ALDO4);
+
+            PMU->setPowerChannelVoltage(XPOWERS_BLDO1, 3300); // GPS
+            PMU->enablePowerOutput(XPOWERS_BLDO1);
+
+            PMU->setPowerChannelVoltage(XPOWERS_BLDO2, 3300); // Speaker
+            PMU->enablePowerOutput(XPOWERS_BLDO2);
+
+            PMU->setPowerChannelVoltage(XPOWERS_VBACKUP, 3300); // RTC Button battery
+            PMU->enablePowerOutput(XPOWERS_VBACKUP);
+
+            // PMU->enablePowerOutput(XPOWERS_DLDO1); // NFC
+
+            // UNUSED POWER CHANNEL
+            PMU->disablePowerOutput(XPOWERS_DCDC2);
+            PMU->disablePowerOutput(XPOWERS_DCDC3);
+            PMU->disablePowerOutput(XPOWERS_DCDC4);
+            PMU->disablePowerOutput(XPOWERS_DCDC5);
+            PMU->disablePowerOutput(XPOWERS_CPULDO);
+
+            // Enable Measure
+            PMU->enableBattDetection();
+            PMU->enableVbusVoltageMeasure();
+            PMU->enableBattVoltageMeasure();
+            PMU->enableSystemVoltageMeasure();
+            PMU->enableTemperatureMeasure();
         }
 
         // disable all axp chip interrupt

src/configuration.h

@@ -162,9 +162,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #elif defined(HELTEC_MESH_NODE_T096)
 #define NUM_PA_POINTS 22
 #define TX_GAIN_LORA 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 12, 11, 10, 9, 8, 7
-#elif defined(HELTEC_V4_R8)
-#define NUM_PA_POINTS 22
-#define TX_GAIN_LORA 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 12, 12, 11, 11, 10, 9, 8, 7
 #else
 // If a board enables USE_KCT8103L_PA but does not match a known variant and has
 // not already provided a PA curve, fail at compile time to avoid unsafe defaults.

src/gps/GPS.cpp

@@ -947,8 +947,8 @@ void GPS::setPowerPMU(bool on)
         } else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE) {
             // t-beam-s3-core GNSS power channel
             on ? PMU->enablePowerOutput(XPOWERS_ALDO4) : PMU->disablePowerOutput(XPOWERS_ALDO4);
-        } else if (HW_VENDOR == meshtastic_HardwareModel_T_WATCH_S3) {
-            // t-watch-s3-plus GNSS power channel
+        } else if (HW_VENDOR == meshtastic_HardwareModel_T_WATCH_ULTRA || HW_VENDOR == meshtastic_HardwareModel_T_WATCH_S3) {
+            // t-watch-ultra / t-watch-s3-plus GNSS power channel
             on ? PMU->enablePowerOutput(XPOWERS_BLDO1) : PMU->disablePowerOutput(XPOWERS_BLDO1);
         }
     } else if (model == XPOWERS_AXP192) {

src/gps/GPSUpdateScheduling.cpp

@@ -70,25 +70,20 @@ bool GPSUpdateScheduling::isUpdateDue()
 // Have we been searching for a GPS position for too long?
 bool GPSUpdateScheduling::searchedTooLong()
 {
-    constexpr uint32_t oneMinuteMs = 60UL * 1000UL;
-    constexpr uint32_t maxSearchClampMs = 15UL * oneMinuteMs; // Hard cap: 15 minutes is always too long
-    uint32_t elapsed = elapsedSearchMs();
-
-    // Anything over 15 minutes is too long, regardless of the broadcast interval.
-    // TODO: Make a smarter algorithm that backs off the search dwell time when not getting a lock.
-    if (elapsed > maxSearchClampMs)
-        return true;
-
     uint32_t minimumOrConfiguredSecs =
         Default::getConfiguredOrMinimumValue(config.position.position_broadcast_secs, default_broadcast_interval_secs);
     uint32_t maxSearchMs = Default::getConfiguredOrDefaultMs(minimumOrConfiguredSecs, default_broadcast_interval_secs);
+    // If broadcast interval set to max, no such thing as "too long"
+    if (maxSearchMs == UINT32_MAX)
+        return false;
 
     // If we've been searching longer than our position broadcast interval: that's too long
-    if (elapsed > maxSearchMs)
+    else if (elapsedSearchMs() > maxSearchMs)
         return true;
 
     // Otherwise, not too long yet!
-    return false;
+    else
+        return false;
 }
 
 // Updates the predicted time-to-get-lock, by exponentially smoothing the latest observation

src/graphics/Screen.cpp

@@ -434,7 +434,8 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
         LOG_INFO("SSD1306 init success");
     }
 #elif defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7789_CS) ||    \
-    defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(HACKADAY_COMMUNICATOR)
+    defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(CO5300_CS) ||                \
+    defined(HACKADAY_COMMUNICATOR)
     dispdev = new TFTDisplay(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
 #elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY) && !defined(USE_EINK_PARALLELDISPLAY)
@@ -508,12 +509,12 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
         if (on) {
             LOG_INFO("Turn on screen");
             powerMon->setState(meshtastic_PowerMon_State_Screen_On);
-#ifdef T_WATCH_S3
+#if defined(T_WATCH_S3) || defined(T_WATCH_ULTRA)
             PMU->enablePowerOutput(XPOWERS_ALDO2);
 #endif
 
 // some screens seem to need a kick in the pants to turn back on
-#if defined(MUZI_BASE) || defined(M5STACK_CARDPUTER_ADV)
+#if defined(MUZI_BASE) || defined(M5STACK_CARDPUTER_ADV) || defined(TFT_RESET_AFTER_SLEEP)
             dispdev->init();
             dispdev->setBrightness(brightness);
             dispdev->flipScreenVertically();
@@ -524,11 +525,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             delay(100);
 #endif
 #if !ARCH_PORTDUINO
-#if defined(USE_ST7789) && defined(VTFT_CTRL)
-            // Ensure panel power rail is enabled before sending wake commands.
-            pinMode(VTFT_CTRL, OUTPUT);
-            digitalWrite(VTFT_CTRL, LOW);
-#endif
             dispdev->displayOn();
 #endif
 
@@ -550,6 +546,10 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             ui->init();
 #endif
 #if defined(USE_ST7789) && defined(VTFT_LEDA)
+#ifdef VTFT_CTRL
+            pinMode(VTFT_CTRL, OUTPUT);
+            digitalWrite(VTFT_CTRL, LOW);
+#endif
             ui->init();
 #ifdef ESP_PLATFORM
             analogWrite(VTFT_LEDA, BRIGHTNESS_DEFAULT);
@@ -590,22 +590,23 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 #ifdef USE_ST7789
             SPI1.end();
-            // Keep TFT control pins in deterministic states while timed-off.
-            // Floating/default pin states can corrupt panel edge rows on wake.
+#if defined(ARCH_ESP32)
 #ifdef VTFT_LEDA
-            pinMode(VTFT_LEDA, OUTPUT);
-            digitalWrite(VTFT_LEDA, !TFT_BACKLIGHT_ON);
+            pinMode(VTFT_LEDA, ANALOG);
 #endif
 #ifdef VTFT_CTRL
-            pinMode(VTFT_CTRL, OUTPUT);
-            digitalWrite(VTFT_CTRL, HIGH);
+            pinMode(VTFT_CTRL, ANALOG);
+#endif
+            pinMode(ST7789_RESET, ANALOG);
+            pinMode(ST7789_RS, ANALOG);
+            pinMode(ST7789_NSS, ANALOG);
+#else
+            nrf_gpio_cfg_default(VTFT_LEDA);
+            nrf_gpio_cfg_default(VTFT_CTRL);
+            nrf_gpio_cfg_default(ST7789_RESET);
+            nrf_gpio_cfg_default(ST7789_RS);
+            nrf_gpio_cfg_default(ST7789_NSS);
 #endif
-            pinMode(ST7789_RESET, OUTPUT);
-            digitalWrite(ST7789_RESET, HIGH);
-            pinMode(ST7789_RS, OUTPUT);
-            digitalWrite(ST7789_RS, HIGH);
-            pinMode(ST7789_NSS, OUTPUT);
-            digitalWrite(ST7789_NSS, HIGH);
 #endif
 #ifdef USE_ST7796
             SPI1.end();
@@ -623,7 +624,7 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 #endif
 
-#ifdef T_WATCH_S3
+#if defined(T_WATCH_S3) || defined(T_WATCH_ULTRA)
             PMU->disablePowerOutput(XPOWERS_ALDO2);
 #endif
             enabled = false;
@@ -730,7 +731,8 @@ void Screen::setup()
 #else
     if (!config.display.flip_screen) {
 #if defined(ST7701_CS) || defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7789_CS) ||      \
-    defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(HACKADAY_COMMUNICATOR)
+    defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(CO5300_CS) ||                \
+    defined(HACKADAY_COMMUNICATOR)
         static_cast<TFTDisplay *>(dispdev)->flipScreenVertically();
 #elif defined(USE_ST7789)
         static_cast<ST7789Spi *>(dispdev)->flipScreenVertically();

src/graphics/ScreenFonts.h

@@ -90,7 +90,7 @@
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) ||             \
-     defined(USE_ST7796) || defined(HACKADAY_COMMUNICATOR)) &&                                                                   \
+     defined(CO5300_CS) || defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                             \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 // The screen is bigger so use bigger fonts
 #define FONT_SMALL FONT_MEDIUM_LOCAL // Height: 19

src/graphics/TFTDisplay.cpp

@@ -16,6 +16,92 @@
 extern SX1509 gpioExtender;
 #endif
 
+#ifdef TFT_MESH_OVERRIDE
+uint16_t TFT_MESH = TFT_MESH_OVERRIDE;
+#else
+uint16_t TFT_MESH = COLOR565(0x67, 0xEA, 0x94);
+#endif
+
+#if defined(CO5300_CS)
+#include <LovyanGFX.hpp> // Graphics and font library for AMOLED driver chip
+class LGFX : public lgfx::LGFX_Device
+{
+    lgfx::Panel_CO5300 _panel_instance;
+    lgfx::Bus_SPI _bus_instance;
+
+  public:
+    LGFX(void)
+    {
+        {
+            auto cfg = _bus_instance.config();
+
+            // configure SPI
+            cfg.spi_host = CO5300_SPI_HOST; // ESP32-S2,S3,C3 : SPI2_HOST or SPI3_HOST / ESP32 : VSPI_HOST or HSPI_HOST
+            cfg.spi_mode = SPI_MODE0;
+            cfg.freq_write = SPI_FREQUENCY; // SPI clock for transmission (up to 80MHz, rounded to the value obtained by dividing
+                                            // 80MHz by an integer)
+            cfg.freq_read = SPI_READ_FREQUENCY; // SPI clock when receiving
+            cfg.spi_3wire = false;              // Set to true if reception is done on the MOSI pin
+            cfg.use_lock = true;                // Set to true to use transaction locking
+            cfg.dma_channel = SPI_DMA_CH_AUTO;  // SPI_DMA_CH_AUTO; // Set DMA channel to use (0=not use DMA / 1=1ch / 2=ch /
+                                                // SPI_DMA_CH_AUTO=auto setting)
+            cfg.pin_sclk = CO5300_SCK;          // Set SPI SCLK pin number
+            cfg.pin_io0 = CO5300_IO0;
+            cfg.pin_io1 = CO5300_IO1;
+            cfg.pin_io2 = CO5300_IO2;
+            cfg.pin_io3 = CO5300_IO3;
+
+            _bus_instance.config(cfg);              // applies the set value to the bus.
+            _panel_instance.setBus(&_bus_instance); // set the bus on the panel.
+        }
+
+        {                                        // Set the display panel control.
+            auto cfg = _panel_instance.config(); // Gets a structure for display panel settings.
+
+            cfg.pin_cs = CO5300_CS;                    // Pin number where CS is connected (-1 = disable)
+            cfg.pin_rst = CO5300_RESET;                // Pin number where RST is connected  (-1 = disable)
+            cfg.panel_width = TFT_WIDTH;               // actual displayable width
+            cfg.panel_height = TFT_HEIGHT;             // actual displayable height
+            cfg.offset_rotation = TFT_OFFSET_ROTATION; // Rotation direction value offset 0~7 (4~7 is upside down)
+            cfg.offset_x = TFT_OFFSET_X;
+            cfg.offset_y = TFT_OFFSET_Y;
+            cfg.dummy_read_pixel = 8; // Number of bits for dummy read before pixel readout
+            cfg.dummy_read_bits = 1;  // Number of bits for dummy read before non-pixel data read
+            cfg.readable = true;      // Set to true if data can be read
+            cfg.invert = false;       // Set to true if the light/darkness of the panel is reversed
+            cfg.rgb_order = false;    // Set to true if the panel's red and blue are swapped
+            cfg.dlen_16bit = false;   // Set to true for panels that transmit data length in 16-bit units
+            cfg.bus_shared = true;    // If the bus is shared with the SD card, set to true (bus control with drawJpgFile etc.)
+
+            // Set the following only when the display is shifted with a driver with a variable number of pixels
+            cfg.memory_width = TFT_WIDTH;   // Maximum width supported by the driver IC
+            cfg.memory_height = TFT_HEIGHT; // Maximum height supported by the driver IC
+            _panel_instance.config(cfg);
+        }
+
+        setPanel(&_panel_instance);
+    }
+
+    bool init()
+    {
+#ifdef CO5300_RESET
+        LOG_DEBUG("LGFX_Panel_CO5300::init()");
+        lgfx::pinMode(CO5300_RESET, lgfx::pin_mode_t::output);
+        lgfx::gpio_hi(CO5300_RESET);
+        delay(20);
+        lgfx::gpio_lo(CO5300_RESET);
+        delay(30);
+        lgfx::gpio_hi(CO5300_RESET);
+        delay(20);
+#endif
+        return lgfx::LGFX_Device::init();
+    }
+};
+
+static LGFX *tft = nullptr;
+
+#endif
+
 #if defined(ST7735S)
 #include <LovyanGFX.hpp> // Graphics and font library for ST7735 driver chip
 
@@ -422,7 +508,7 @@ static LGFX *tft = nullptr;
 
 #elif defined(ST7789_CS)
 #include <LovyanGFX.hpp> // Graphics and font library for ST7735 driver chip
-#if defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)
+#ifdef HELTEC_V4_TFT
 #include "chsc6x.h"
 #include "lgfx/v1/Touch.hpp"
 namespace lgfx
@@ -444,11 +530,7 @@ class TOUCH_CHSC6X : public ITouch
     bool init(void) override
     {
         if (chsc6xTouch == nullptr) {
-#if (TOUCH_I2C_PORT == 1)
             chsc6xTouch = new chsc6x(&Wire1, TOUCH_SDA_PIN, TOUCH_SCL_PIN, TOUCH_INT_PIN, TOUCH_RST_PIN);
-#else
-            chsc6xTouch = new chsc6x(&Wire, TOUCH_SDA_PIN, TOUCH_SCL_PIN, TOUCH_INT_PIN, TOUCH_RST_PIN);
-#endif
         }
         chsc6xTouch->chsc6x_init();
         return true;
@@ -485,7 +567,7 @@ class LGFX : public lgfx::LGFX_Device
 #if HAS_TOUCHSCREEN
 #if defined(T_WATCH_S3) || defined(ELECROW)
     lgfx::Touch_FT5x06 _touch_instance;
-#elif defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)
+#elif defined(HELTEC_V4_TFT)
     lgfx::TOUCH_CHSC6X _touch_instance;
 #else
     lgfx::Touch_GT911 _touch_instance;
@@ -504,11 +586,7 @@ class LGFX : public lgfx::LGFX_Device
             cfg.freq_write = SPI_FREQUENCY; // SPI clock for transmission (up to 80MHz, rounded to the value obtained by dividing
                                             // 80MHz by an integer)
             cfg.freq_read = SPI_READ_FREQUENCY; // SPI clock when receiving
-#ifdef SPI_3_WIRE
-            cfg.spi_3wire = SPI_3_WIRE;
-#else
-            cfg.spi_3wire = true;                      // Set to true if reception is done on the MOSI pin
-#endif
+            cfg.spi_3wire = false;
             cfg.use_lock = true;               // Set to true to use transaction locking
             cfg.dma_channel = SPI_DMA_CH_AUTO; // SPI_DMA_CH_AUTO; // Set DMA channel to use (0=not use DMA / 1=1ch / 2=ch /
                                                // SPI_DMA_CH_AUTO=auto setting)
@@ -558,11 +636,8 @@ class LGFX : public lgfx::LGFX_Device
             cfg.rgb_order = false;                        // Set to true if the panel's red and blue are swapped
             cfg.dlen_16bit =
                 false;             // Set to true for panels that transmit data length in 16-bit units with 16-bit parallel or SPI
-#if defined(HAS_SDCARD)
             cfg.bus_shared = true; // If the bus is shared with the SD card, set to true (bus control with drawJpgFile etc.)
-#else
-            cfg.bus_shared = false;
-#endif
+
             // Set the following only when the display is shifted with a driver with a variable number of pixels, such as the
             // ST7735 or ILI9163.
             // cfg.memory_width = TFT_WIDTH;   // Maximum width supported by the driver IC
@@ -1362,6 +1437,7 @@ void TFTDisplay::display(bool fromBlank)
                 x_LastPixelUpdate = displayWidth - 1;
             }
 
+            int y_offset = 0;
             // Step 3: Copy only the changed span into the pixel line buffer.
             for (x = x_FirstPixelUpdate; x <= x_LastPixelUpdate; x++) {
                 isset = buffer[x + y_byteIndex] & y_byteMask;
@@ -1376,13 +1452,58 @@ void TFTDisplay::display(bool fromBlank)
                 linePixelBuffer[x] = isset ? colorTftWhite : colorTftBlack;
 #endif
             }
+
+#if defined(CO5300_CS)
+            uint8_t lines_updated = 2;
+            if (y % 2 == 0) {
+                y_byteIndex = ((y + 1) / 8) * displayWidth;
+                y_byteMask = (1 << ((y + 1) & 7));
+                uint32_t bufferIndex = 1;
+                for (x = x_FirstPixelUpdate; x < x_LastPixelUpdate; x++) {
+                    isset = buffer[x + y_byteIndex] & y_byteMask;
+#if GRAPHICS_TFT_COLORING_ENABLED
+                    if (hasColorRegions) {
+                        linePixelBuffer[x] = graphics::resolveTFTColorPixel(static_cast<int16_t>(x), static_cast<int16_t>(y),
+                                                                            isset, colorTftWhite, colorTftBlack);
+                    } else {
+                        linePixelBuffer[x] = isset ? colorTftWhite : colorTftBlack;
+                    }
+#else
+                    linePixelBuffer[x] = isset ? colorTftWhite : colorTftBlack;
+#endif
+                }
+            } else {
+                y_offset = -1;
+                memcpy(&linePixelBuffer[x_LastPixelUpdate + 1], &linePixelBuffer[x_FirstPixelUpdate],
+                       2 * (x_LastPixelUpdate - x_FirstPixelUpdate + 1));
+                y_byteIndex = ((y - 1) / 8) * displayWidth;
+                y_byteMask = (1 << ((y - 1) & 7));
+                uint32_t bufferIndex = 0;
+                for (x = x_FirstPixelUpdate; x < x_LastPixelUpdate; x++) {
+                    isset = buffer[x + y_byteIndex] & y_byteMask;
+#if GRAPHICS_TFT_COLORING_ENABLED
+                    if (hasColorRegions) {
+                        linePixelBuffer[x] = graphics::resolveTFTColorPixel(static_cast<int16_t>(x), static_cast<int16_t>(y),
+                                                                            isset, colorTftWhite, colorTftBlack);
+                    } else {
+                        linePixelBuffer[x] = isset ? colorTftWhite : colorTftBlack;
+                    }
+#else
+                    linePixelBuffer[x] = isset ? colorTftWhite : colorTftBlack;
+#endif
+                }
+            }
+#else
+            uint8_t lines_updated = 1;
+#endif
+
 #if defined(HACKADAY_COMMUNICATOR)
             tft->draw16bitBeRGBBitmap(x_FirstPixelUpdate, y, &linePixelBuffer[x_FirstPixelUpdate],
                                       (x_LastPixelUpdate - x_FirstPixelUpdate + 1), 1);
 #else
             // Step 4: Send the changed pixels on this line to the screen as a single block transfer.
             // This function accepts pixel data MSB first so it can dump the memory straight out the SPI port.
-            tft->pushImage(x_FirstPixelUpdate, y, (x_LastPixelUpdate - x_FirstPixelUpdate + 1), 1,
+            tft->pushImage(x_FirstPixelUpdate, y + y_offset, (x_LastPixelUpdate - x_FirstPixelUpdate + 1), lines_updated,
                            &linePixelBuffer[x_FirstPixelUpdate]);
 #endif
             somethingChanged = true;
@@ -1450,7 +1571,7 @@ void TFTDisplay::sendCommand(uint8_t com)
     // handle display on/off directly
     switch (com) {
     case DISPLAYON: {
-        // LOG_DEBUG("Display on");
+        LOG_DEBUG("Display on");
         backlightEnable->set(true);
 #if ARCH_PORTDUINO
         display(true);
@@ -1477,7 +1598,7 @@ void TFTDisplay::sendCommand(uint8_t com)
         break;
     }
     case DISPLAYOFF: {
-        // LOG_DEBUG("Display off");
+        LOG_DEBUG("Display off");
         backlightEnable->set(false);
 #if ARCH_PORTDUINO
         tft->clear();
@@ -1579,8 +1700,8 @@ bool TFTDisplay::connect()
     tft = new LGFX;
 #endif
 
-    backlightEnable->set(true);
     LOG_INFO("Power to TFT Backlight");
+    backlightEnable->set(true);
 
 #ifdef UNPHONE
     unphone.backlight(true); // using unPhone library
@@ -1608,7 +1729,7 @@ bool TFTDisplay::connect()
     tft->setRotation(1); // T-Deck has the TFT in landscape
 #elif defined(T_WATCH_S3)
     tft->setRotation(2); // T-Watch S3 left-handed orientation
-#elif ARCH_PORTDUINO || defined(SENSECAP_INDICATOR) || defined(T_LORA_PAGER)
+#elif ARCH_PORTDUINO || defined(SENSECAP_INDICATOR) || defined(T_LORA_PAGER) || defined(T_WATCH_ULTRA)
     tft->setRotation(0); // use config.yaml to set rotation
 #else
     tft->setRotation(3); // Orient horizontal and wide underneath the silkscreen name label
@@ -1616,7 +1737,11 @@ bool TFTDisplay::connect()
     tft->fillScreen(getThemeDefaultOffColor());
 
     if (this->linePixelBuffer == NULL) {
+#if defined(CO5300_CS)
+        this->linePixelBuffer = (uint16_t *)malloc(sizeof(uint16_t) * displayWidth * 2);
+#else
         this->linePixelBuffer = (uint16_t *)malloc(sizeof(uint16_t) * displayWidth);
+#endif
 
         if (!this->linePixelBuffer) {
             LOG_ERROR("Not enough memory to create TFT line buffer\n");

src/graphics/draw/DebugRenderer.cpp

@@ -99,7 +99,7 @@ void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16
                                           (storeForwardModule->heartbeatInterval * 1200))) { // no heartbeat, overlap a bit
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS) ||             \
-     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796) || ARCH_PORTDUINO) &&                                                 \
+     defined(CO5300_CS) || defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796) || ARCH_PORTDUINO) &&                           \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
             display->drawFastImage(x + SCREEN_WIDTH - 14 - display->getStringWidth(screen->ourId), y + 3 + FONT_HEIGHT_SMALL, 12,
                                    8, imgQuestionL1);
@@ -112,7 +112,7 @@ void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16
         } else {
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS) ||             \
-     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                                                   \
+     defined(CO5300_CS) || defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                             \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
             display->drawFastImage(x + SCREEN_WIDTH - 18 - display->getStringWidth(screen->ourId), y + 3 + FONT_HEIGHT_SMALL, 16,
                                    8, imgSFL1);
@@ -128,7 +128,7 @@ void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16
         // TODO: Raspberry Pi supports more than just the one screen size
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS) ||             \
-     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796) || ARCH_PORTDUINO) &&                                                 \
+     defined(CO5300_CS) || defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796) || ARCH_PORTDUINO) &&                           \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
         display->drawFastImage(x + SCREEN_WIDTH - 14 - display->getStringWidth(screen->ourId), y + 3 + FONT_HEIGHT_SMALL, 12, 8,
                                imgInfoL1);

src/graphics/draw/UIRenderer.cpp

@@ -716,7 +716,7 @@ void UIRenderer::drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const mes
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(HX8357_CS) || defined(ST7796_CS) ||             \
-     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                                                   \
+     defined(CO5300_CS) || defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                             \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 
     if (currentResolution == ScreenResolution::High) {

src/graphics/images.h

@@ -28,7 +28,7 @@ const uint8_t bluetoothConnectedIcon[36] PROGMEM = {0xfe, 0x01, 0xff, 0x03, 0x03
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) ||             \
-     defined(USE_ST7796) || defined(HACKADAY_COMMUNICATOR) || ARCH_PORTDUINO) &&                                                 \
+     defined(USE_ST7796) || defined(CO5300_CS) || defined(HACKADAY_COMMUNICATOR) || ARCH_PORTDUINO) &&                           \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 const uint8_t imgQuestionL1[] PROGMEM = {0xff, 0x01, 0x01, 0x32, 0x7b, 0x49, 0x49, 0x6f, 0x26, 0x01, 0x01, 0xff};
 const uint8_t imgQuestionL2[] PROGMEM = {0x0f, 0x08, 0x08, 0x08, 0x06, 0x0f, 0x0f, 0x06, 0x08, 0x08, 0x08, 0x0f};

src/input/TouchScreenBase.cpp

@@ -186,7 +186,7 @@ int32_t TouchScreenBase::runOnce()
 
 void TouchScreenBase::hapticFeedback()
 {
-#ifdef T_WATCH_S3
+#if defined(T_WATCH_S3) || defined(T_WATCH_ULTRA)
     drv.setWaveform(0, 75);
     drv.setWaveform(1, 0); // end waveform
     drv.go();

src/main.cpp

@@ -811,7 +811,7 @@ void setup()
 
 #if defined(ST7701_CS) || defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) ||       \
     defined(ST7789_CS) || defined(HX8357_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(ST7796_CS) ||              \
-    defined(USE_SPISSD1306) || defined(USE_ST7796) || defined(HACKADAY_COMMUNICATOR)
+    defined(USE_SPISSD1306) || defined(USE_ST7796) || defined(CO5300_CS) || defined(HACKADAY_COMMUNICATOR)
         screen = new graphics::Screen(screen_found, screen_model, screen_geometry);
 #elif defined(ARCH_PORTDUINO)
         if ((screen_found.port != ScanI2C::I2CPort::NO_I2C || portduino_config.displayPanel) &&
@@ -937,7 +937,7 @@ void setup()
 // the current region name)
 #if defined(ST7701_CS) || defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) ||       \
     defined(ST7789_CS) || defined(HX8357_CS) || defined(USE_ST7789) || defined(ILI9488_CS) || defined(ST7796_CS) ||              \
-    defined(USE_ST7796) || defined(USE_SPISSD1306) || defined(HACKADAY_COMMUNICATOR)
+    defined(USE_ST7796) || defined(USE_SPISSD1306) || defined(CO5300_CS) || defined(HACKADAY_COMMUNICATOR)
     if (screen)
         screen->setup();
 #elif defined(ARCH_PORTDUINO)

src/mesh/Default.cpp

@@ -2,21 +2,18 @@
 
 #include "meshUtils.h"
 
-// Convert seconds to ms, clamping at INT32_MAX (~24.86 days)
-static inline uint32_t secondsToMsClamped(uint32_t secs)
-{
-    constexpr uint32_t MAX_MS = static_cast<uint32_t>(INT32_MAX);
-    return (secs > MAX_MS / 1000U) ? MAX_MS : secs * 1000U;
-}
-
 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval)
 {
-    return secondsToMsClamped(configuredInterval > 0 ? configuredInterval : defaultInterval);
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return defaultInterval * 1000;
 }
 
 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
 {
-    return secondsToMsClamped(configuredInterval > 0 ? configuredInterval : default_broadcast_interval_secs);
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return default_broadcast_interval_secs * 1000;
 }
 
 uint32_t Default::getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue)
@@ -50,14 +47,7 @@ uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t d
                   meshtastic_Config_DeviceConfig_Role_TAK_TRACKER))
         return getConfiguredOrDefaultMs(configured, defaultValue);
 
-    // Saturate at INT32_MAX to match secondsToMsClamped: float→uint32_t when
-    // out of range is UB, and the result is consumed as an int32_t downstream.
-    constexpr uint32_t MAX_MS = static_cast<uint32_t>(INT32_MAX);
-    uint32_t base = getConfiguredOrDefaultMs(configured, defaultValue);
-    float coef = congestionScalingCoefficient(numOnlineNodes);
-    if (static_cast<double>(base) * static_cast<double>(coef) >= static_cast<double>(MAX_MS))
-        return MAX_MS;
-    return base * coef;
+    return getConfiguredOrDefaultMs(configured, defaultValue) * congestionScalingCoefficient(numOnlineNodes);
 }
 
 uint32_t Default::getConfiguredOrMinimumValue(uint32_t configured, uint32_t minValue)
@@ -76,4 +66,4 @@ uint8_t Default::getConfiguredOrDefaultHopLimit(uint8_t configured)
 #else
     return (configured >= HOP_MAX) ? HOP_MAX : config.lora.hop_limit;
 #endif
-}
+}

src/mesh/NodeDB.cpp

@@ -688,7 +688,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
     strncpy(config.network.ntp_server, "meshtastic.pool.ntp.org", 32);
 
 #if (defined(T_DECK) || defined(T_WATCH_S3) || defined(UNPHONE) || defined(PICOMPUTER_S3) || defined(SENSECAP_INDICATOR) ||      \
-     defined(ELECROW_PANEL) || defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)) &&                                           \
+     defined(ELECROW_PANEL) || defined(HELTEC_V4_TFT) || defined(T_WATCH_ULTRA)) &&                                              \
     HAS_TFT
     // switch BT off by default; use TFT programming mode or hotkey to enable
     config.bluetooth.enabled = false;
@@ -766,7 +766,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #ifdef RAK4630
     config.display.wake_on_tap_or_motion = true;
 #endif
-#if defined(T_WATCH_S3) || defined(SENSECAP_INDICATOR)
+#if defined(T_WATCH_S3) || defined(SENSECAP_INDICATOR) || defined(T_WATCH_ULTRA)
     config.display.screen_on_secs = 30;
     config.display.wake_on_tap_or_motion = true;
 #endif
@@ -1205,11 +1205,11 @@ void NodeDB::loadFromDisk()
     spiLock->unlock();
 #endif
 #ifdef FSCom
-#if defined(FACTORY_INSTALL) && !defined(ARCH_PORTDUINO)
+#ifdef FACTORY_INSTALL
     spiLock->lock();
     if (!FSCom.exists("/prefs/" xstr(BUILD_EPOCH))) {
         LOG_WARN("Factory Install Reset!");
-        rmDir("/prefs");
+        FSCom.format();
         FSCom.mkdir("/prefs");
         File f2 = FSCom.open("/prefs/" xstr(BUILD_EPOCH), FILE_O_WRITE);
         if (f2) {

src/mesh/RadioLibInterface.h

@@ -179,8 +179,6 @@ 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/generated/meshtastic/apponly.pb.h

@@ -55,7 +55,7 @@ extern const pb_msgdesc_t meshtastic_ChannelSet_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_APPONLY_PB_H_MAX_SIZE meshtastic_ChannelSet_size
-#define meshtastic_ChannelSet_size               685
+#define meshtastic_ChannelSet_size               682
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/config.pb.h

@@ -618,8 +618,6 @@ typedef struct _meshtastic_Config_LoRaConfig {
     bool config_ok_to_mqtt;
     /* Set where LORA FEM is enabled, disabled, or not present */
     meshtastic_Config_LoRaConfig_FEM_LNA_Mode fem_lna_mode;
-    /* Don't use radiolib to initialize the radio, instead listen for a serialHal connection */
-    bool serial_hal_only;
 } meshtastic_Config_LoRaConfig;
 
 typedef struct _meshtastic_Config_BluetoothConfig {
@@ -781,7 +779,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, "", 0, 0}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0, 0, 0}
-#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN, 0}
+#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_default {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
 #define meshtastic_Config_SessionkeyConfig_init_default {0}
@@ -792,7 +790,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, "", 0, 0}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0, 0, 0}
-#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN, 0}
+#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_zero {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
 #define meshtastic_Config_SessionkeyConfig_init_zero {0}
@@ -879,7 +877,6 @@ extern "C" {
 #define meshtastic_Config_LoRaConfig_ignore_mqtt_tag 104
 #define meshtastic_Config_LoRaConfig_config_ok_to_mqtt_tag 105
 #define meshtastic_Config_LoRaConfig_fem_lna_mode_tag 106
-#define meshtastic_Config_LoRaConfig_serial_hal_only_tag 107
 #define meshtastic_Config_BluetoothConfig_enabled_tag 1
 #define meshtastic_Config_BluetoothConfig_mode_tag 2
 #define meshtastic_Config_BluetoothConfig_fixed_pin_tag 3
@@ -1032,8 +1029,7 @@ X(a, STATIC,   SINGULAR, BOOL,     pa_fan_disabled,  15) \
 X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
 X(a, STATIC,   SINGULAR, BOOL,     ignore_mqtt,     104) \
 X(a, STATIC,   SINGULAR, BOOL,     config_ok_to_mqtt, 105) \
-X(a, STATIC,   SINGULAR, UENUM,    fem_lna_mode,    106) \
-X(a, STATIC,   SINGULAR, BOOL,     serial_hal_only, 107)
+X(a, STATIC,   SINGULAR, UENUM,    fem_lna_mode,    106)
 #define meshtastic_Config_LoRaConfig_CALLBACK NULL
 #define meshtastic_Config_LoRaConfig_DEFAULT NULL
 
@@ -1090,7 +1086,7 @@ extern const pb_msgdesc_t meshtastic_Config_SessionkeyConfig_msg;
 #define meshtastic_Config_BluetoothConfig_size   10
 #define meshtastic_Config_DeviceConfig_size      100
 #define meshtastic_Config_DisplayConfig_size     36
-#define meshtastic_Config_LoRaConfig_size        91
+#define meshtastic_Config_LoRaConfig_size        88
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     204
 #define meshtastic_Config_PositionConfig_size    62

src/mesh/generated/meshtastic/deviceonly.pb.h

@@ -361,7 +361,7 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 /* Maximum encoded size of messages (where known) */
 /* meshtastic_NodeDatabase_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
-#define meshtastic_BackupPreferences_size        2432
+#define meshtastic_BackupPreferences_size        2429
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_DeviceState_size              1737
 #define meshtastic_NodeInfoLite_size             196

src/mesh/generated/meshtastic/localonly.pb.h

@@ -205,7 +205,7 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalModuleConfig_size
-#define meshtastic_LocalConfig_size              757
+#define meshtastic_LocalConfig_size              754
 #define meshtastic_LocalModuleConfig_size        820
 
 #ifdef __cplusplus

src/mesh/generated/meshtastic/serial_hal.pb.cpp

@@ -1,19 +0,0 @@
-/* Automatically generated nanopb constant definitions */
-/* Generated by nanopb-0.4.9.1 */
-
-#include "meshtastic/serial_hal.pb.h"
-#if PB_PROTO_HEADER_VERSION != 40
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
-PB_BIND(meshtastic_SerialHalCommand, meshtastic_SerialHalCommand, 2)
-
-
-PB_BIND(meshtastic_SerialHalResponse, meshtastic_SerialHalResponse, 2)
-
-
-
-
-
-
-

src/mesh/generated/meshtastic/serial_hal.pb.h

@@ -1,135 +0,0 @@
-/* Automatically generated nanopb header */
-/* Generated by nanopb-0.4.9.1 */
-
-#ifndef PB_MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_INCLUDED
-#define PB_MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_INCLUDED
-#include <pb.h>
-
-#if PB_PROTO_HEADER_VERSION != 40
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
-/* Enum definitions */
-typedef enum _meshtastic_SerialHalCommand_Type {
-    meshtastic_SerialHalCommand_Type_UNSET = 0,
-    meshtastic_SerialHalCommand_Type_PIN_MODE = 1,
-    meshtastic_SerialHalCommand_Type_DIGITAL_WRITE = 2,
-    meshtastic_SerialHalCommand_Type_DIGITAL_READ = 3,
-    meshtastic_SerialHalCommand_Type_ATTACH_INTERRUPT = 4,
-    meshtastic_SerialHalCommand_Type_DETACH_INTERRUPT = 5,
-    meshtastic_SerialHalCommand_Type_SPI_TRANSFER = 6,
-    meshtastic_SerialHalCommand_Type_NOOP = 7
-} meshtastic_SerialHalCommand_Type;
-
-typedef enum _meshtastic_SerialHalResponse_Result {
-    meshtastic_SerialHalResponse_Result_OK = 0,
-    meshtastic_SerialHalResponse_Result_ERROR = 1,
-    meshtastic_SerialHalResponse_Result_BAD_REQUEST = 2,
-    meshtastic_SerialHalResponse_Result_UNSUPPORTED = 3
-} meshtastic_SerialHalResponse_Result;
-
-/* Struct definitions */
-typedef PB_BYTES_ARRAY_T(512) meshtastic_SerialHalCommand_data_t;
-typedef struct _meshtastic_SerialHalCommand {
-    /* Host-assigned request id. Replies echo this id back in
- SerialHalResponse.transaction_id. */
-    uint32_t transaction_id;
-    meshtastic_SerialHalCommand_Type type;
-    uint32_t pin;
-    uint32_t value;
-    uint32_t mode;
-    meshtastic_SerialHalCommand_data_t data;
-} meshtastic_SerialHalCommand;
-
-typedef PB_BYTES_ARRAY_T(512) meshtastic_SerialHalResponse_data_t;
-typedef struct _meshtastic_SerialHalResponse {
-    /* Matches the originating SerialHalCommand.transaction_id for normal
- request/response traffic.
-
- A value of 0 indicates an unsolicited interrupt notification generated by
- the device. In that case, the host should interpret value as the GPIO pin
- that triggered. */
-    uint32_t transaction_id;
-    meshtastic_SerialHalResponse_Result result;
-    /* Used by DIGITAL_READ replies and interrupt notifications. For interrupt
- notifications (transaction_id == 0), this carries the pin number. */
-    uint32_t value;
-    meshtastic_SerialHalResponse_data_t data;
-    char error[80];
-} meshtastic_SerialHalResponse;
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Helper constants for enums */
-#define _meshtastic_SerialHalCommand_Type_MIN meshtastic_SerialHalCommand_Type_UNSET
-#define _meshtastic_SerialHalCommand_Type_MAX meshtastic_SerialHalCommand_Type_NOOP
-#define _meshtastic_SerialHalCommand_Type_ARRAYSIZE ((meshtastic_SerialHalCommand_Type)(meshtastic_SerialHalCommand_Type_NOOP+1))
-
-#define _meshtastic_SerialHalResponse_Result_MIN meshtastic_SerialHalResponse_Result_OK
-#define _meshtastic_SerialHalResponse_Result_MAX meshtastic_SerialHalResponse_Result_UNSUPPORTED
-#define _meshtastic_SerialHalResponse_Result_ARRAYSIZE ((meshtastic_SerialHalResponse_Result)(meshtastic_SerialHalResponse_Result_UNSUPPORTED+1))
-
-#define meshtastic_SerialHalCommand_type_ENUMTYPE meshtastic_SerialHalCommand_Type
-
-#define meshtastic_SerialHalResponse_result_ENUMTYPE meshtastic_SerialHalResponse_Result
-
-
-/* Initializer values for message structs */
-#define meshtastic_SerialHalCommand_init_default {0, _meshtastic_SerialHalCommand_Type_MIN, 0, 0, 0, {0, {0}}}
-#define meshtastic_SerialHalResponse_init_default {0, _meshtastic_SerialHalResponse_Result_MIN, 0, {0, {0}}, ""}
-#define meshtastic_SerialHalCommand_init_zero    {0, _meshtastic_SerialHalCommand_Type_MIN, 0, 0, 0, {0, {0}}}
-#define meshtastic_SerialHalResponse_init_zero   {0, _meshtastic_SerialHalResponse_Result_MIN, 0, {0, {0}}, ""}
-
-/* Field tags (for use in manual encoding/decoding) */
-#define meshtastic_SerialHalCommand_transaction_id_tag 1
-#define meshtastic_SerialHalCommand_type_tag     2
-#define meshtastic_SerialHalCommand_pin_tag      3
-#define meshtastic_SerialHalCommand_value_tag    4
-#define meshtastic_SerialHalCommand_mode_tag     5
-#define meshtastic_SerialHalCommand_data_tag     6
-#define meshtastic_SerialHalResponse_transaction_id_tag 1
-#define meshtastic_SerialHalResponse_result_tag  2
-#define meshtastic_SerialHalResponse_value_tag   3
-#define meshtastic_SerialHalResponse_data_tag    4
-#define meshtastic_SerialHalResponse_error_tag   5
-
-/* Struct field encoding specification for nanopb */
-#define meshtastic_SerialHalCommand_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   transaction_id,    1) \
-X(a, STATIC,   SINGULAR, UENUM,    type,              2) \
-X(a, STATIC,   SINGULAR, UINT32,   pin,               3) \
-X(a, STATIC,   SINGULAR, UINT32,   value,             4) \
-X(a, STATIC,   SINGULAR, UINT32,   mode,              5) \
-X(a, STATIC,   SINGULAR, BYTES,    data,              6)
-#define meshtastic_SerialHalCommand_CALLBACK NULL
-#define meshtastic_SerialHalCommand_DEFAULT NULL
-
-#define meshtastic_SerialHalResponse_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   transaction_id,    1) \
-X(a, STATIC,   SINGULAR, UENUM,    result,            2) \
-X(a, STATIC,   SINGULAR, UINT32,   value,             3) \
-X(a, STATIC,   SINGULAR, BYTES,    data,              4) \
-X(a, STATIC,   SINGULAR, STRING,   error,             5)
-#define meshtastic_SerialHalResponse_CALLBACK NULL
-#define meshtastic_SerialHalResponse_DEFAULT NULL
-
-extern const pb_msgdesc_t meshtastic_SerialHalCommand_msg;
-extern const pb_msgdesc_t meshtastic_SerialHalResponse_msg;
-
-/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
-#define meshtastic_SerialHalCommand_fields &meshtastic_SerialHalCommand_msg
-#define meshtastic_SerialHalResponse_fields &meshtastic_SerialHalResponse_msg
-
-/* Maximum encoded size of messages (where known) */
-#define MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_MAX_SIZE meshtastic_SerialHalResponse_size
-#define meshtastic_SerialHalCommand_size         541
-#define meshtastic_SerialHalResponse_size        610
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif

src/modules/DMShell.cpp

@@ -1,604 +0,0 @@
-#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

@@ -1,77 +0,0 @@
-#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,7 +49,6 @@
 #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"
@@ -196,7 +195,6 @@ void setupModules()
 #endif
 #if ARCH_PORTDUINO
     new HostMetricsModule();
-    dmShellModule = new DMShellModule();
 #endif
 #if HAS_TELEMETRY
     new DeviceTelemetryModule();

src/modules/PositionModule.cpp

@@ -70,7 +70,7 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
         if (config.position.fixed_position) {
             LOG_DEBUG("Ignore incoming position update from myself except for time, because position.fixed_position is true");
 
-#ifdef T_WATCH_S3
+#if defined(T_WATCH_S3) || defined(T_WATCH_ULTRA)
             // Since we return early if position.fixed_position is true, set the T-Watch's RTC to the time received from the
             // client device here
             if (p.time && channels.getByIndex(mp.channel).role == meshtastic_Channel_Role_PRIMARY) {

src/mqtt/MQTT.cpp

@@ -350,8 +350,6 @@ inline bool isConnectedToNetwork()
     return WiFi.isConnected();
 #elif HAS_ETHERNET
     return Ethernet.linkStatus() == LinkON;
-#elif defined(ARCH_PORTDUINO)
-    return true;
 #else
     return false;
 #endif

src/platform/esp32/architecture.h

@@ -202,6 +202,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_M5STACK_C6L
 #elif defined(HELTEC_WIRELESS_TRACKER_V2)
 #define HW_VENDOR meshtastic_HardwareModel_HELTEC_WIRELESS_TRACKER_V2
+#elif defined(T_WATCH_ULTRA)
+#define HW_VENDOR meshtastic_HardwareModel_T_WATCH_ULTRA
 #elif defined(M5STACK_CARDPUTER_ADV)
 #define HW_VENDOR meshtastic_HardwareModel_M5STACK_CARDPUTER_ADV
 #else

src/platform/portduino/PortduinoGlue.cpp

@@ -494,17 +494,10 @@ void portduinoSetup()
             exit(EXIT_FAILURE);
         }
         char serial[9] = {0};
-        // Pass the full buffer size (9 = 8 chars + null) to getSerialString,
-        // not 8. The function treats `len` as buffer size and reserves one
-        // slot for the null terminator, so passing 8 produced a 7-char serial
-        // and broke the `strlen(serial) == 8` check below — masked on Linux
-        // by the BlueZ HCI MAC fallback in getMacAddr(), but on macOS (where
-        // the BlueZ path is __linux__-guarded) it left mac_address empty and
-        // meshtasticd refused to start.
-        ch341Hal->getSerialString(serial, sizeof(serial));
+        ch341Hal->getSerialString(serial, 8);
         std::cout << "CH341 Serial " << serial << std::endl;
         char product_string[96] = {0};
-        ch341Hal->getProductString(product_string, sizeof(product_string));
+        ch341Hal->getProductString(product_string, 95);
         std::cout << "CH341 Product " << product_string << std::endl;
         if (strlen(serial) == 8 && portduino_config.mac_address.length() < 12) {
             std::cout << "Deriving MAC address from Serial and Product String" << std::endl;

src/sleep.cpp

@@ -347,7 +347,7 @@ void doDeepSleep(uint32_t msecToWake, bool skipPreflight = false, bool skipSaveN
                 // t-beam v1.2 radio power channel
                 PMU->disablePowerOutput(XPOWERS_ALDO2); // lora radio power channel
             } else if (HW_VENDOR == meshtastic_HardwareModel_LILYGO_TBEAM_S3_CORE ||
-                       HW_VENDOR == meshtastic_HardwareModel_T_WATCH_S3) {
+                       HW_VENDOR == meshtastic_HardwareModel_T_WATCH_S3 || HW_VENDOR == meshtastic_HardwareModel_T_WATCH_ULTRA) {
                 PMU->disablePowerOutput(XPOWERS_ALDO3); // lora radio power channel
             }
         } else if (model == XPOWERS_AXP192) {

test/test_default/test_main.cpp

@@ -127,60 +127,6 @@ void test_client_uses_public_channel_minimums()
     TEST_ASSERT_EQUAL_UINT32(60 * 60, position);
 }
 
-// --- Saturation/clamp tests for getConfiguredOrDefaultMs[Scaled] ---
-// These guard the INT32_MAX clamp added to avoid uint32 wrap of secs*1000 and
-// to keep results safe to cast to int32_t for OSThread runOnce returns.
-
-void test_ms_below_threshold()
-{
-    // Ordinary value passes through unchanged.
-    TEST_ASSERT_EQUAL_UINT32(60000U, Default::getConfiguredOrDefaultMs(60, 0));
-}
-
-void test_ms_at_threshold()
-{
-    // INT32_MAX / 1000 = 2,147,483 — largest secs that does not clamp.
-    TEST_ASSERT_EQUAL_UINT32(2147483000U, Default::getConfiguredOrDefaultMs(2147483U, 0));
-}
-
-void test_ms_just_above_threshold()
-{
-    // One second over the boundary must saturate, not wrap.
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(2147484U, 0));
-}
-
-void test_ms_uint32_max()
-{
-    // default_sds_secs == UINT32_MAX on non-routers must not wrap.
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(UINT32_MAX, 0));
-}
-
-void test_ms_default_clamps()
-{
-    // Clamp also applies when the default-arg path is taken (configured == 0).
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(0, UINT32_MAX));
-}
-
-void test_ms_result_is_int32_safe()
-{
-    // Regression guard for runOnce returns: cast to int32_t must not go negative.
-    int32_t result = static_cast<int32_t>(Default::getConfiguredOrDefaultMs(UINT32_MAX, 0));
-    TEST_ASSERT_GREATER_OR_EQUAL_INT32(0, result);
-}
-
-void test_scaled_overflow_saturates()
-{
-    // long_fast (SF11/BW250) with a 24h base and heavy congestion overflows
-    // the uint32 result without the double-precision guard. Must saturate.
-    config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
-    config.lora.use_preset = false;
-    config.lora.spread_factor = 11;
-    config.lora.bandwidth = 250;
-
-    uint32_t res = Default::getConfiguredOrDefaultMsScaled(0, ONE_DAY, 1000);
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), res);
-}
-
 void setup()
 {
     // Small delay to match other test mains
@@ -194,13 +140,6 @@ void setup()
     RUN_TEST(test_router_uses_router_minimums);
     RUN_TEST(test_router_late_uses_router_minimums);
     RUN_TEST(test_client_uses_public_channel_minimums);
-    RUN_TEST(test_ms_below_threshold);
-    RUN_TEST(test_ms_at_threshold);
-    RUN_TEST(test_ms_just_above_threshold);
-    RUN_TEST(test_ms_uint32_max);
-    RUN_TEST(test_ms_default_clamps);
-    RUN_TEST(test_ms_result_is_int32_safe);
-    RUN_TEST(test_scaled_overflow_saturates);
     exit(UNITY_END());
 }
 

test/test_meshpacket_serializer/ports/test_dmshell.cpp

@@ -1,97 +0,0 @@
-#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,10 +19,6 @@ 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()
 {
@@ -56,12 +52,6 @@ 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/esp32s3/heltec_v4/platformio.ini

@@ -89,10 +89,8 @@ build_flags =
   -D VIEW_240x320
   -D DISPLAY_SET_RESOLUTION
   -D DISPLAY_SIZE=240x320 ; portrait mode
-  -D LGFX_SPI_3WIRE=true
   -D LGFX_PIN_SCK=17
   -D LGFX_PIN_MOSI=33
-  -D LGFX_PIN_MISO=-1
   -D LGFX_PIN_DC=16
   -D LGFX_PIN_CS=15
   -D LGFX_PIN_BL=21
@@ -125,7 +123,7 @@ build_flags =
   -D SCREEN_TRANSITION_FRAMERATE=30
   -D BRIGHTNESS_DEFAULT=130 ; Medium Low Brightness
   -D HAS_TOUCHSCREEN=1
-  -D TOUCH_I2C_PORT=1
+  -D TOUCH_I2C_PORT=0
   -D TOUCH_SLAVE_ADDRESS=0x2E
   -D SCREEN_TOUCH_INT=TOUCH_INT_PIN
   -D SCREEN_TOUCH_RST=TOUCH_RST_PIN

variants/esp32s3/heltec_v4_r8/pins_arduino.h

@@ -1,56 +0,0 @@
-#ifndef Pins_Arduino_h
-#define Pins_Arduino_h
-
-#include <stdint.h>
-
-#define USB_VID 0x303a
-#define USB_PID 0x1001
-
-static const uint8_t TX = 43;
-static const uint8_t RX = 44;
-
-static const uint8_t SDA = 17;
-static const uint8_t SCL = 18;
-
-static const uint8_t SS = 8;
-static const uint8_t MOSI = 10;
-static const uint8_t MISO = 11;
-static const uint8_t SCK = 9;
-
-static const uint8_t A0 = 1;
-static const uint8_t A1 = 2;
-static const uint8_t A2 = 3;
-static const uint8_t A3 = 4;
-static const uint8_t A4 = 5;
-static const uint8_t A5 = 6;
-static const uint8_t A6 = 7;
-static const uint8_t A7 = 8;
-static const uint8_t A8 = 9;
-static const uint8_t A9 = 10;
-static const uint8_t A10 = 11;
-static const uint8_t A11 = 12;
-static const uint8_t A12 = 13;
-static const uint8_t A13 = 14;
-static const uint8_t A14 = 15;
-static const uint8_t A15 = 16;
-static const uint8_t A16 = 17;
-static const uint8_t A17 = 18;
-static const uint8_t A18 = 19;
-static const uint8_t A19 = 20;
-
-static const uint8_t T1 = 1;
-static const uint8_t T2 = 2;
-static const uint8_t T3 = 3;
-static const uint8_t T4 = 4;
-static const uint8_t T5 = 5;
-static const uint8_t T6 = 6;
-static const uint8_t T7 = 7;
-static const uint8_t T8 = 8;
-static const uint8_t T9 = 9;
-static const uint8_t T10 = 10;
-static const uint8_t T11 = 11;
-static const uint8_t T12 = 12;
-static const uint8_t T13 = 13;
-static const uint8_t T14 = 14;
-
-#endif /* Pins_Arduino_h */

variants/esp32s3/heltec_v4_r8/platformio.ini

@@ -1,145 +0,0 @@
-[heltec_v4_r8_base] 
-extends = esp32s3_base
-board = heltec_v4_r8
-board_check = true
-board_build.partitions = default_16MB.csv
-build_flags = 
-  ${esp32s3_base.build_flags}
-  -D HELTEC_V4_R8
-  -D HAS_LORA_FEM=1
-  -D BOARD_HAS_PSRAM
-  -I variants/esp32s3/heltec_v4_r8
-  -ULED_BUILTIN
-
-[env:heltec-v4-r8-oled]
-custom_meshtastic_hw_model = 132
-custom_meshtastic_hw_model_slug = HELTEC_V4_R8
-custom_meshtastic_architecture = esp32-s3
-custom_meshtastic_actively_supported = true
-custom_meshtastic_support_level = 1
-custom_meshtastic_display_name = Heltec V4 R8
-custom_meshtastic_images = heltec_v4_r8.svg
-custom_meshtastic_tags = Heltec
-custom_meshtastic_requires_dfu = true
-custom_meshtastic_partition_scheme = 16MB
-
-extends = heltec_v4_r8_base
-build_flags = 
-  ${heltec_v4_r8_base.build_flags}
-  -D HELTEC_V4_R8_OLED
-  -D USE_SSD1306 ; Heltec_v4_R8 has an SSD1315 display (compatible with SSD1306 driver)
-  -D LED_POWER=46
-  -D RESET_OLED=21
-  -D I2C_SDA=17
-  -D I2C_SCL=18
-
-[env:heltec-v4-r8-tft]
-custom_meshtastic_hw_model = 132
-custom_meshtastic_hw_model_slug = HELTEC_V4_R8
-custom_meshtastic_architecture = esp32-s3
-custom_meshtastic_actively_supported = true
-custom_meshtastic_support_level = 1
-custom_meshtastic_display_name = Heltec V4 R8 TFT
-custom_meshtastic_images = heltec_v4_r8_tft.svg
-custom_meshtastic_tags = Heltec
-custom_meshtastic_requires_dfu = true
-custom_meshtastic_partition_scheme = 16MB
-
-extends = heltec_v4_r8_base
-build_flags = 
-  ${heltec_v4_r8_base.build_flags} ;-Os
-  -D HELTEC_V4_R8_TFT
-  -D I2C_SDA=17
-  -D I2C_SCL=18
-  -D PIN_BUTTON2=46
-  -D ALT_BUTTON_PIN=PIN_BUTTON2
-  -D ALT_BUTTON_ACTIVE_LOW=false
-  -D PIN_BUZZER=4
-  -D USE_PIN_BUZZER=PIN_BUZZER
-  -D CONFIG_ARDUHAL_LOG_COLORS
-  -D RADIOLIB_DEBUG_SPI=0
-  -D RADIOLIB_DEBUG_PROTOCOL=0
-  -D RADIOLIB_DEBUG_BASIC=0
-  -D RADIOLIB_VERBOSE_ASSERT=0
-  -D RADIOLIB_SPI_PARANOID=0
-  -D CONFIG_DISABLE_HAL_LOCKS=1
-  -D INPUTDRIVER_BUTTON_TYPE=0
-  -D HAS_SCREEN=1
-  -D HAS_TFT=1
-  -D RAM_SIZE=5120
-  -D LV_LVGL_H_INCLUDE_SIMPLE
-  -D LV_CONF_INCLUDE_SIMPLE
-  -D LV_COMP_CONF_INCLUDE_SIMPLE
-  -D LV_USE_SYSMON=0
-  -D LV_USE_PROFILER=0
-  -D LV_USE_PERF_MONITOR=0
-  -D LV_USE_MEM_MONITOR=0
-  -D LV_USE_LOG=0
-  -D LV_BUILD_TEST=0
-  -D USE_LOG_DEBUG
-  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
-  -D USE_PACKET_API
-  -D LGFX_DRIVER=LGFX_HELTEC_V4_TFT
-  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_HELTEC_V4_TFT.h\"
-  -D VIEW_240x320
-  -D DISPLAY_SET_RESOLUTION
-  -D DISPLAY_SIZE=240x320 ; portrait mode
-  -D LGFX_SPI_3WIRE=false
-  -D LGFX_PIN_SCK=16
-  -D LGFX_PIN_MOSI=15
-  -D LGFX_PIN_MISO=45
-  -D LGFX_PIN_DC=48
-  -D LGFX_PIN_CS=47
-  -D LGFX_PIN_BL=44
-  -D LGFX_PIN_RST=21
-  -D CUSTOM_TOUCH_DRIVER
-  -D TOUCH_SDA_PIN=I2C_SDA
-  -D TOUCH_SCL_PIN=I2C_SCL
-  -D TOUCH_INT_PIN=-1
-  -D TOUCH_RST_PIN=-1
-;base UI
-  -D TFT_CS=LGFX_PIN_CS
-  -D ST7789_CS=TFT_CS
-  -D ST7789_RS=LGFX_PIN_DC
-  -D ST7789_SDA=LGFX_PIN_MOSI
-  -D ST7789_SCK=LGFX_PIN_SCK
-  -D ST7789_RESET=LGFX_PIN_RST
-  -D ST7789_MISO=LGFX_PIN_MISO
-  -D ST7789_BUSY=-1
-  -D ST7789_BL=LGFX_PIN_BL
-  -D ST7789_SPI_HOST=SPI3_HOST
-  -D TFT_BL=ST7789_BL
-  -D SPI_FREQUENCY=75000000
-  -D SPI_READ_FREQUENCY=SPI_FREQUENCY
-  -D SPI_3_WIRE=false
-  -D TFT_HEIGHT=320
-  -D TFT_WIDTH=240
-  -D TFT_OFFSET_X=0
-  -D TFT_OFFSET_Y=0
-  -D TFT_OFFSET_ROTATION=0
-  -D SCREEN_ROTATE
-  -D SCREEN_TRANSITION_FRAMERATE=5
-  -D BRIGHTNESS_DEFAULT=130 ; Medium Low Brightness
-  -D HAS_TOUCHSCREEN=1
-  -D TOUCH_I2C_PORT=0
-  -D TOUCH_SLAVE_ADDRESS=0x2E
-  -D SCREEN_TOUCH_INT=TOUCH_INT_PIN
-  -D SCREEN_TOUCH_RST=TOUCH_RST_PIN
-
-; Have SPI interface SD card slot
-  -D HAS_SDCARD
-  -D SDCARD_USE_SPI1
-  -D SDCARD_USER_SPI_BEGIN
-  -D SPI_MOSI=LGFX_PIN_MOSI
-  -D SPI_SCK=LGFX_PIN_SCK
-  -D SPI_MISO=LGFX_PIN_MISO
-  -D SPI_CS=3
-  -D SDCARD_CS=SPI_CS
-  -D SD_SPI_FREQUENCY=SPI_FREQUENCY
-
-lib_deps = ${heltec_v4_r8_base.lib_deps}
-  ${device-ui_base.lib_deps}
-  # renovate: datasource=custom.pio depName=LovyanGFX packageName=lovyan03/library/LovyanGFX
-  lovyan03/LovyanGFX@1.2.19
-  # renovate: datasource=git-refs depName=Quency-D_chsc6x packageName=https://github.com/Quency-D/chsc6x gitBranch=master
-  https://github.com/Quency-D/chsc6x/archive/3b2b6cebf3177b3e2c33d06e07909b0b10159516.zip

variants/esp32s3/heltec_v4_r8/variant.h

@@ -1,72 +0,0 @@
-#define VEXT_ENABLE 40 // active low, powers the oled display and the lora antenna boost
-#define VEXT_ON_VALUE LOW
-#define BUTTON_PIN 0
-
-#define BATTERY_PIN 1 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
-#define ADC_ATTENUATION ADC_ATTEN_DB_2_5 // lower dB for high resistance voltage divider
-#define ADC_MULTIPLIER 4.9 * 1.035
-
-#define USE_SX1262
-#define LORA_DIO0 -1 // a No connect on the SX1262 module
-#define LORA_RESET 12
-#define LORA_DIO1 14 // SX1262 IRQ
-#define LORA_DIO2 13 // SX1262 BUSY
-#define LORA_DIO3    // Not connected on PCB, but internally on the TTGO SX1262, if DIO3 is high the TCXO is enabled
-
-#define LORA_SCK 9
-#define LORA_MISO 11
-#define LORA_MOSI 10
-#define LORA_CS 8
-
-#define SX126X_CS LORA_CS
-#define SX126X_DIO1 LORA_DIO1
-#define SX126X_BUSY LORA_DIO2
-#define SX126X_RESET LORA_RESET
-
-#define SX126X_DIO2_AS_RF_SWITCH
-#define SX126X_DIO3_TCXO_VOLTAGE 1.8
-
-// Enable Traffic Management Module for Heltec V4
-#ifndef HAS_TRAFFIC_MANAGEMENT
-#define HAS_TRAFFIC_MANAGEMENT 1
-#endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif
-
-// ---- KCT8103L RF FRONT END CONFIGURATION ----
-// The Heltec V4.3 uses a KCT8103L FEM chip with integrated PA and LNA
-// RF path: SX1262 -> Pi attenuator -> KCT8103L PA -> Antenna
-// Control logic (from KCT8103L datasheet):
-//   Transmit PA:     CSD=1, CTX=1, CPS=1
-//   Receive LNA:     CSD=1, CTX=0, CPS=X  (21dB gain, 1.9dB NF)
-//   Receive bypass:  CSD=1, CTX=1, CPS=0
-//   Shutdown:        CSD=0, CTX=X, CPS=X
-// Pin mapping:
-//   CPS (pin 5)  -> SX1262 DIO2: TX/RX path select (automatic via SX126X_DIO2_AS_RF_SWITCH)
-//   CSD (pin 4)  -> GPIO2: Chip enable (HIGH=on, LOW=shutdown)
-//   CTX (pin 6)  -> GPIO5: Switch between Receive LNA Mode and Receive Bypass Mode. (HIGH=RX bypass, LOW=RX LNA)
-//   VCC0/VCC1    -> Vfem via U3 LDO, controlled by GPIO7
-// KCT8103L FEM: TX/RX path switching is handled by DIO2 -> CPS pin (via SX126X_DIO2_AS_RF_SWITCH)
-
-#define USE_KCT8103L_PA
-#define LORA_PA_POWER 7        // VFEM_Ctrl - KCT8103L LDO power enable
-#define LORA_KCT8103L_PA_CSD 2 // CSD - KCT8103L chip enable (HIGH=on)
-#define LORA_KCT8103L_PA_CTX 5 // CTX - Switch between Receive LNA Mode and Receive Bypass Mode. (HIGH=RX bypass, LOW=RX LNA)
-
-#if HAS_TFT
-#define USE_TFTDISPLAY 1
-#endif
-/*
- * GPS pins
- */
-#define GPS_L76K
-#define PIN_GPS_EN (42)
-#define GPS_EN_ACTIVE LOW
-#define PERIPHERAL_WARMUP_MS 1000 // Make sure I2C QuickLink has stable power before continuing
-#define PIN_GPS_PPS (41)
-// Seems to be missing on this new board
-#define GPS_TX_PIN (38) // This is for bits going TOWARDS the CPU
-#define GPS_RX_PIN (39) // This is for bits going TOWARDS the GPS
-#define GPS_THREAD_INTERVAL 50

variants/esp32s3/t-deck-pro/variant.h

@@ -30,6 +30,7 @@
 
 // vibration motor
 #define PIN_VIBRATION 2
+#define HAS_DRV2605 1
 
 // Have SPI interface SD card slot
 #define HAS_SDCARD

variants/esp32s3/t-watch-ultra/pins_arduino.h

@@ -0,0 +1,94 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+
+// #ifndef digitalPinToInterrupt
+// #define digitalPinToInterrupt(p) (((p) < 48) ? (p) : -1)
+// #endif
+
+#define USB_VID 0x303a
+#define USB_PID 0x8227
+#define USB_MANUFACTURER "LILYGO"
+#define USB_PRODUCT "T-Watch-Ultra"
+
+#define DISP_WIDTH 502
+#define DISP_HEIGHT 410
+
+// QSPI interface display
+#define DISP_D0 (38)
+#define DISP_D1 (39)
+#define DISP_D2 (42)
+#define DISP_D3 (45)
+#define DISP_SCK (40)
+#define DISP_CS (41)
+#define DISP_RST (37)
+#define DISP_TE (6)
+
+// Interrupt IO port
+#define TP_INT (12)
+#define RTC_INT (1)
+#define PMU_INT (7)
+#define NFC_INT (5)
+#define SENSOR_INT (8)
+#define NFC_CS (4)
+
+// PDM microphone
+#define MIC_SCK (17)
+#define MIC_DAT (18)
+
+// MAX98357A
+#define I2S_BCLK (9)
+#define I2S_WCLK (10)
+#define I2S_DOUT (11)
+
+#define SD_CS (21)
+
+// TX, RX pin connected to GPS
+static const uint8_t TX = 43;
+static const uint8_t RX = 44;
+
+// BHI260,PCF85063,AXP2101,DRV2605L share I2C Bus
+static const uint8_t SDA = 3;
+static const uint8_t SCL = 2;
+
+// Default sd cs pin
+static const uint8_t SS = SD_CS;
+static const uint8_t MOSI = 34;
+static const uint8_t MISO = 33;
+static const uint8_t SCK = 35;
+
+#define GPS_TX (TX)
+#define GPS_RX (RX)
+#define GPS_PPS (13)
+
+#define TP_SDA (SDA)
+#define TP_SCL (SCL)
+
+// LoRa and SD card share SPI bus -> variant.h
+// #define LORA_SCK  (SCK)   // share spi bus
+// #define LORA_MISO (MISO)  // share spi bus
+// #define LORA_MOSI (MOSI)  // share spi bus
+// #define LORA_CS   (36)
+// #define LORA_RST  (47)
+// #define LORA_BUSY (48)
+// #define LORA_IRQ  (14)
+
+// External expansion chip IO definition
+#define EXPANDS_DRV_EN (6)
+#define EXPANDS_DISP_EN (7)
+#define EXPANDS_TOUCH_RST (8)
+#define EXPANDS_SD_DET (10)
+#define EXPANDS_LORA_RF_SW (11)
+
+// Peripheral definition exists
+#define USING_XL9555_EXPANDS
+#define USING_PCM_AMPLIFIER
+#define USING_PDM_MICROPHONE
+#define USING_PMU_MANAGE
+#define USING_INPUT_DEV_TOUCHPAD
+#define USING_ST25R3916
+#define USING_BHI260_SENSOR
+#define HAS_SD_CARD_SOCKET
+
+#endif /* Pins_Arduino_h */

variants/esp32s3/t-watch-ultra/platformio.ini

@@ -0,0 +1,67 @@
+; LilyGo T-Watch S3
+[env:t-watch-ultra]
+extends = esp32s3_base
+board = t-watch-ultra
+board_check = true
+board_build.partitions = default_16MB.csv
+upload_protocol = esptool
+
+build_flags = ${esp32_base.build_flags} -Ivariants/esp32s3/t-watch-ultra
+  -D T_WATCH_ULTRA
+  -D RADIOLIB_EXCLUDE_SX128X=1
+  -D RADIOLIB_EXCLUDE_SX127X=1
+  -D RADIOLIB_EXCLUDE_LR11X0=1
+;  -D HAS_SDCARD
+  -D SDCARD_CS=21
+;  -DHAS_BMA423=1
+
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+  +<../variants/esp32s3/t-watch-ultra>
+
+lib_deps = ${esp32s3_base.lib_deps}
+  https://github.com/lovyan03/LovyanGFX/archive/tags/1.2.19.zip
+  adafruit/Adafruit DRV2605 Library@^1.2.4
+  earlephilhower/ESP8266Audio@^1.9.9
+  earlephilhower/ESP8266SAM@^1.0.1
+  lewisxhe/SensorLib@0.3.1
+
+[env:t-watch-ultra-tft]
+board_level = extra
+extends = env:t-watch-ultra
+build_flags =
+  ${env:t-watch-ultra.build_flags}
+  -D CONFIG_DISABLE_HAL_LOCKS=1
+  -D INPUTDRIVER_BUTTON_TYPE=0
+  -D HAS_SCREEN=1
+  -D HAS_TFT=1
+  -D USE_I2S_BUZZER
+  -D RAM_SIZE=5120
+  -D LV_LVGL_H_INCLUDE_SIMPLE
+  -D LV_CONF_INCLUDE_SIMPLE
+  -D LV_COMP_CONF_INCLUDE_SIMPLE
+  -D LV_USE_SYSMON=0
+  -D LV_USE_PROFILER=0
+  -D LV_USE_PERF_MONITOR=0
+  -D LV_USE_MEM_MONITOR=0
+  -D LV_USE_LOG=0
+  -D USE_LOG_DEBUG
+  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
+  -D RADIOLIB_SPI_PARANOID=0
+  -D LGFX_SCREEN_WIDTH=410
+  -D LGFX_SCREEN_HEIGHT=502
+  -D LGFX_AMOLED_ROUNDER=1
+  -D LGFX_BUFSIZE=308732
+  -D DISPLAY_SIZE=410x502 ; portrait mode
+  -D DISPLAY_SET_RESOLUTION
+  -D LGFX_DRIVER=LGFX_TWATCH_ULTRA
+  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_T_WATCH_ULTRA.h\"
+;  -D LVGL_DRIVER=LVGL_T_WATCH_ULTRA
+  -D VIEW_320x240
+  -D USE_PACKET_API
+  -D MAP_FULL_REDRAW
+  -D CUSTOM_TOUCH_DRIVER
+
+lib_deps =
+  ${env:t-watch-ultra.lib_deps}
+  ${device-ui_base.lib_deps}

variants/esp32s3/t-watch-ultra/variant.cpp

@@ -0,0 +1,59 @@
+#include "variant.h"
+#include "Arduino.h"
+#include "TouchDrvCSTXXX.hpp"
+#include "input/TouchScreenImpl1.h"
+#include <ExtensionIOXL9555.hpp>
+#include <Wire.h>
+
+static ExtensionIOXL9555 io;
+static TouchDrvCST92xx touchDrv;
+
+void earlyInitVariant()
+{
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(DISP_CS, OUTPUT);
+    digitalWrite(DISP_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(NFC_CS, OUTPUT);
+    digitalWrite(NFC_CS, HIGH);
+
+    if (io.begin(Wire, XL9555_SLAVE_ADDRESS0)) {
+        io.pinMode(EXPANDS_DRV_EN, OUTPUT);
+        io.digitalWrite(EXPANDS_DRV_EN, HIGH);
+        delay(1);
+        io.pinMode(EXPANDS_DISP_EN, OUTPUT);
+        io.digitalWrite(EXPANDS_DISP_EN, HIGH);
+        delay(1);
+        io.pinMode(EXPANDS_TOUCH_RST, OUTPUT);
+        io.digitalWrite(EXPANDS_TOUCH_RST, LOW);
+        delay(20);
+        io.digitalWrite(EXPANDS_TOUCH_RST, HIGH);
+        delay(60);
+        io.pinMode(EXPANDS_LORA_RF_SW, OUTPUT);
+        io.digitalWrite(EXPANDS_LORA_RF_SW, HIGH); // set RF switch to built-in LoRa antenna
+        // io.pinMode(EXPANDS_SD_DET, INPUT);
+    } else {
+        LOG_ERROR("io expander initialisation failed!");
+    }
+}
+
+static bool readTouch(int16_t *x, int16_t *y)
+{
+    return touchDrv.isPressed() && touchDrv.getPoint(x, y, 1);
+}
+
+void lateInitVariant()
+{
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        pinMode(SCREEN_TOUCH_INT, INPUT_PULLUP);
+        touchDrv.setPins(-1, SCREEN_TOUCH_INT);
+        if (touchDrv.begin(Wire, TOUCH_SLAVE_ADDRESS, I2C_SDA, I2C_SCL)) {
+            touchScreenImpl1 = new TouchScreenImpl1(TFT_WIDTH, TFT_HEIGHT, readTouch);
+            touchScreenImpl1->init();
+        } else {
+            LOG_ERROR("failed to initialize CST92xx");
+        }
+    }
+}

variants/esp32s3/t-watch-ultra/variant.h

@@ -0,0 +1,93 @@
+
+// CO5300 TFT AMOLED
+#define CO5300_CS 41
+#define CO5300_SCK 40
+#define CO5300_RESET 37
+#define CO5300_TE 6
+#define CO5300_IO0 38
+#define CO5300_IO1 39
+#define CO5300_IO2 42
+#define CO5300_IO3 45
+#define CO5300_SPI_HOST SPI2_HOST
+#define SPI_FREQUENCY 75000000
+#define SPI_READ_FREQUENCY 16000000 // irrelevant
+#define TFT_HEIGHT 502
+#define TFT_WIDTH 410
+#define TFT_OFFSET_X 22
+#define TFT_OFFSET_Y 0
+#define TFT_OFFSET_ROTATION 0
+#define SCREEN_TRANSITION_FRAMERATE 5 // fps
+#define USE_TFTDISPLAY 1
+#define HAS_SCREEN 1
+#define TFT_RESET_AFTER_SLEEP
+
+#define HAS_TOUCHSCREEN 1
+#define SCREEN_TOUCH_INT 12
+#define TOUCH_I2C_PORT 0
+#define TOUCH_SLAVE_ADDRESS 0x1A
+#define WAKE_ON_TOUCH
+
+#define BUTTON_PIN 0
+
+#define USE_POWERSAVE
+#define SLEEP_TIME 120
+
+// External expansion chip XL9555
+#define USE_XL9555
+
+// PCF85063 RTC Module
+#define PCF85063_RTC 0x51
+#define HAS_RTC 1
+
+// MAX98357A
+#define HAS_I2S
+#define DAC_I2S_BCK 9
+#define DAC_I2S_WS 10
+#define DAC_I2S_DOUT 11
+#define DAC_I2S_MCLK -1 // TODO
+
+#define HAS_AXP2101
+// #define PMU_IRQ 7
+#define HAS_DRV2605 1
+
+#define I2C_SDA 3
+#define I2C_SCL 2
+#define I2C_NO_RESCAN
+
+#define HAS_GPS 1
+#define GPS_BAUDRATE 38400
+#define GPS_RX_PIN 44
+#define GPS_TX_PIN 43
+#define PIN_GPS_PPS 13
+
+// SPI interface SD card slot
+#define SPI_MOSI MOSI
+#define SPI_SCK SCK
+#define SPI_MISO MISO
+#define SPI_CS 21
+#define SD_SPI_FREQUENCY 75000000U
+
+#define USE_SX1262
+// #define USE_SX1280
+#define HW_SPI1_DEVICE
+
+#define LORA_SCK 35
+#define LORA_MISO 33
+#define LORA_MOSI 34
+#define LORA_CS 36
+
+#define LORA_DIO0 -1 // a No connect on the SX1262 module
+#define LORA_RESET 47
+#define LORA_DIO1 14 // SX1262 IRQ
+#define LORA_DIO2 48 // SX1262 BUSY
+#define LORA_DIO3
+
+#define SX126X_CS LORA_CS
+#define SX126X_DIO1 LORA_DIO1
+#define SX126X_BUSY LORA_DIO2
+#define SX126X_RESET LORA_RESET
+#define SX126X_DIO2_AS_RF_SWITCH
+#define SX126X_DIO3_TCXO_VOLTAGE 1.8
+
+#define USE_VIRTUAL_KEYBOARD 1
+#define DISPLAY_CLOCK_FRAME 1

variants/esp32s3/tlora-pager/variant.h

@@ -69,6 +69,9 @@
 #define DAC_I2S_DIN 17
 #define DAC_I2S_MCLK 10
 
+// haptic driver
+#define HAS_DRV2605 1
+
 // gyroscope BHI260AP
 #define HAS_BHI260AP
 

variants/native/portduino/platformio.ini

@@ -133,39 +133,6 @@ test_testing_command =
 ;     SOCK_NONBLOCK fallback, Common.h __APPLE__ guard, WiFiServer.cpp extern-C
 ;     fix, package.json URL refresh. Pulled by platform-native at its pinned commit.
 ; This env therefore only carries the firmware-side build flags and src filter.
-;
-; Real LoRa hardware on macOS:
-;   The same lib_dep `pine64/libch341-spi-userspace` used on Linux works on
-;   macOS as-is — its `libusb_detach_kernel_driver()` call is `__linux__`-
-;   guarded, but on macOS the kernel doesn't bind a driver to a CH341A SPI
-;   bridge (PID 0x5512; bDeviceClass=0xff vendor-specific) by default, so
-;   no detach is needed. Apple's bundled CH34x driver targets the CH340
-;   *UART* variant (PID 0x7523) — different product. libusb opens the device
-;   and claims interface 0 directly via IOUSBHostInterface.
-;
-;   To use, point `meshtasticd` at any of the existing `bin/config.d/lora-*.yaml`
-;   files that specify `spidev: ch341` — they're platform-agnostic. Example:
-;     pio run -e native-macos
-;     mkdir -p ~/.meshtasticd && cp bin/config-dist.yaml ~/.meshtasticd/config.yaml
-;     # Edit ~/.meshtasticd/config.yaml: ConfigDirectory: ./config.d/
-;     mkdir ~/.meshtasticd/config.d && cp bin/config.d/lora-meshstick-1262.yaml ~/.meshtasticd/config.d/
-;     cd ~/.meshtasticd && /path/to/firmware/.pio/build/native-macos/meshtasticd
-;
-;   The MAC address auto-derives from the CH341's USB serial + product string
-;   (PortduinoGlue.cpp ~497-518); on Linux a BlueZ HCI socket is the fallback
-;   when that path isn't taken, but BlueZ is `__linux__`-guarded so the
-;   serial-derivation path is mandatory on macOS. Override with
-;   `MACAddress: AA:BB:CC:DD:EE:FF` in config.yaml's `General:` section if
-;   the device's serial isn't 8 hex chars.
-;
-;   Diagnosing CH341 issues on macOS:
-;     ioreg -p IOUSB -l -w 0 | grep -B2 -A30 0x5512
-;       Children should be `IOUSBHostInterface`. If a vendor driver class
-;       (e.g. `com.wch.CH34xVCPDriver` from a third-party WCH installer)
-;       claims interface 0, libusb will fail with LIBUSB_ERROR_BUSY.
-;       Workaround: `sudo kmutil unload -b <bundleID>`.
-;     LIBUSB_DEBUG=4 .pio/build/native-macos/meshtasticd
-;       Verbose libusb trace — useful when claim_interface fails.
 ; ---------------------------------------------------------------------------
 [env:native-macos]
 extends = native_base