Merge branch 'master' into lora-led-rx

* Use standard GPS enable pin, for smarter power control on M3

* Enable GPS pin in variant.cpp initialization

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

.clusterfuzzlite/Dockerfile

@@ -18,7 +18,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 # trunk-ignore(hadolint/DL3008): apt packages are not pinned.
 # trunk-ignore(terrascan/AC_DOCKER_0002): apt packages are not pinned.
 RUN apt-get update && apt-get install --no-install-recommends -y \
-        cmake git zip libgpiod-dev libjsoncpp-dev libbluetooth-dev libi2c-dev \
+        cmake git zip libgpiod-dev libbluetooth-dev libi2c-dev \
         libunistring-dev libmicrohttpd-dev libgnutls28-dev libgcrypt20-dev \
         libusb-1.0-0-dev libssl-dev pkg-config libsqlite3-dev libsdl2-dev && \
     apt-get clean && rm -rf /var/lib/apt/lists/* && \

.clusterfuzzlite/build.sh

@@ -31,7 +31,7 @@ cmake --install "$WORK/ulfius/$SANITIZER" --prefix /usr
 cd "$SRC/firmware"
 
 PLATFORMIO_EXTRA_SCRIPTS=$(echo -e "pre:.clusterfuzzlite/platformio-clusterfuzzlite-pre.py\npost:.clusterfuzzlite/platformio-clusterfuzzlite-post.py")
-STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp jsoncpp bluez --silence-errors)
+STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp bluez --silence-errors)
 export PLATFORMIO_EXTRA_SCRIPTS
 export STATIC_LIBS
 export PLATFORMIO_WORKSPACE_DIR="$WORK/pio/$SANITIZER"

.devcontainer/Dockerfile

@@ -16,7 +16,6 @@ RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
     libssl-dev \
     libulfius-dev \
     libyaml-cpp-dev \
-    libjsoncpp-dev \
     pipx \
     pkg-config \
     python3 \

.github/actions/setup-base/action.yml

@@ -13,7 +13,7 @@ runs:
       shell: bash
       run: |
         sudo apt-get -y update --fix-missing
-        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev libjsoncpp-dev lsb-release
+        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev lsb-release
 
     - name: Setup Python
       uses: actions/setup-python@v6

.github/actions/setup-native/action.yml

@@ -11,4 +11,4 @@ runs:
     - name: Install libs needed for native build
       shell: bash
       run: |
-        sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev libjsoncpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev
+        sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev

.github/copilot-instructions.md

@@ -135,99 +135,6 @@ On top of authorization, any remote admin message that **mutates** state (not a
 - **Channel 0 PSK change** → every peer must re-learn the channel hash; cached NodeInfo becomes temporarily unreachable until the next broadcast.
 - **`security.private_key` blanked via admin** → regenerates both halves (unless in Ham mode) and propagates the new public key via NodeInfo.
 
-## NodeDB Layout (v25)
-
-`DEVICESTATE_CUR_VER = 25`, `DEVICESTATE_MIN_VER = 24`. The on-device NodeDB was split in v25 into a slim header table plus four optional satellite stores. Older v24 saves auto-migrate at boot. Old training-data instincts (`node->user.long_name`, `node->position.latitude_i`, `node->is_favorite`, `node->device_metrics.battery_level`) are wrong now — the fields aren't there. Read this section before touching anything that walks `nodeDB->meshNodes`.
-
-### Slim `NodeInfoLite`
-
-`UserLite` is flattened onto `NodeInfoLite` (no nested sub-message); `position` and `device_metrics` are removed entirely (tags reserved). MAC address is dropped. Long names are capped at 25 chars (`max_size:25` in `deviceonly.options`); `hw_model` and `role` are `int_size:8`. Encoded size dropped from ~166 B → ~105 B per node.
-
-Booleans are bit-packed into `NodeInfoLite.bitfield`. **Do not read or write the bits directly** — use the inline helpers in `src/mesh/NodeDB.h`:
-
-```cpp
-nodeInfoLiteHasUser(n)                  // bit 5 — user fields populated
-nodeInfoLiteIsFavorite(n)               // bit 3
-nodeInfoLiteIsIgnored(n)                // bit 4
-nodeInfoLiteIsMuted(n)                  // bit 1
-nodeInfoLiteIsLicensed(n)               // bit 6 — Ham mode peer
-nodeInfoLiteIsKeyManuallyVerified(n)    // bit 0
-nodeInfoLiteHasIsUnmessagable(n)        // bit 8 — "is_unmessagable was sent"
-nodeInfoLiteIsUnmessagable(n)           // bit 7
-// via_mqtt is bit 2 (mask exposed; predicate uses the mask directly)
-
-nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_FAVORITE_MASK, true);  // setter
-```
-
-### Satellite stores
-
-Four `std::unordered_map<NodeNum, …>` members on `NodeDB`, each gated by its own build flag:
-
-| Map               | Value type                      | Build flag                         |
-| ----------------- | ------------------------------- | ---------------------------------- |
-| `nodePositions`   | `meshtastic_PositionLite`       | `MESHTASTIC_EXCLUDE_POSITIONDB`    |
-| `nodeTelemetry`   | `meshtastic_DeviceMetrics`      | `MESHTASTIC_EXCLUDE_TELEMETRYDB`   |
-| `nodeEnvironment` | `meshtastic_EnvironmentMetrics` | `MESHTASTIC_EXCLUDE_ENVIRONMENTDB` |
-| `nodeStatus`      | `meshtastic_StatusMessage`      | `MESHTASTIC_EXCLUDE_STATUSDB`      |
-
-Defaults are ON (i.e., maps **excluded**) for STM32WL only — see `src/mesh/mesh-pb-constants.h`. On every other arch all four maps are present. When excluded, the map member is absent and the corresponding accessors return `false`.
-
-All four maps are guarded by **`mutable concurrency::Lock satelliteMutex`** — concurrent access from receive threads, the phone API state machine, and the renderer is the rule, not the exception.
-
-### Accessor convention
-
-**Never hand out pointers into the maps.** Use the copy-out accessors on `NodeDB`:
-
-```cpp
-bool copyNodePosition(NodeNum, meshtastic_PositionLite &out)       const;
-bool copyNodeTelemetry(NodeNum, meshtastic_DeviceMetrics &out)     const;
-bool copyNodeEnvironment(NodeNum, meshtastic_EnvironmentMetrics &out) const;
-bool copyNodeStatus(NodeNum, meshtastic_StatusMessage &out)        const;
-```
-
-Each takes the lock, copies the value if present, returns `false` if the entry is absent or the DB is excluded. Pass-by-out-param is deliberate — pointer-style accessors would invite UAF and lock-leak bugs across the renderer. The "has any X" convenience predicates (`hasValidPosition` etc.) are implemented in terms of these.
-
-Writers go through `setNodeStatus`, `updatePosition`, `updateTelemetry` (which dispatches on `which_variant` for device vs environment metrics) — these own the lock and the eviction hooks.
-
-### Eviction
-
-Every code path that drops a node from the header table must also evict the satellites. The single chokepoint is `eraseNodeSatellites(NodeNum)`; it's already called from `getOrCreateMeshNode`'s oldest-boring eviction, `removeNodeByNum`, both branches of `resetNodes`, `cleanupMeshDB`, `addFromContact`'s ignored-branch, and `AdminModule`'s `set_ignored_node`. Add new eviction sites here, not by calling `.erase()` directly.
-
-### Sync flow: thin NodeInfo + post-COMPLETE_ID replay (no opt-in)
-
-There is no capability flag and no special "gradient" nonce. The **default** sync flow is:
-
-1. Config / module-config / channel / metadata segments (same as before).
-2. `STATE_SEND_OWN_NODEINFO` — **our own** NodeInfo, still bundled with our position and device_metrics (because the replay snapshot excludes our own NodeNum). Emitted via `ConvertToNodeInfo(lite)`.
-3. `STATE_SEND_OTHER_NODEINFOS` — every other peer's NodeInfo, **always thin** (no `position`, no `device_metrics`). Emitted via `ConvertToNodeInfoThin(lite)`.
-4. `STATE_SEND_FILEMANIFEST` → `STATE_SEND_COMPLETE_ID` — the phone sees `config_complete_id` and treats sync as done.
-5. `STATE_SEND_PACKETS` — live mesh packets, with a trailing replay drain interleaved. The replay drain walks four cached satellite stores in order (positions → telemetry → environment → status) and emits each cached entry as an ordinary `MeshPacket` on the matching portnum (`POSITION_APP`, `TELEMETRY_APP` device + environment variants, `NODE_STATUS_APP`). These are indistinguishable on the wire from live mesh traffic, so clients need no special handling — any code that already updates UI on `POSITION_APP` etc. works.
-
-`PhoneAPI::sendConfigComplete()` arms `replayPhase = REPLAY_PHASE_POSITIONS` for default/full sync and `SPECIAL_NONCE_ONLY_NODES`, while `SPECIAL_NONCE_ONLY_CONFIG` skips replay. The drain runs inside `STATE_SEND_PACKETS` via `popReplayPacket()`, lower priority than live traffic. When all four phases drain, `replayPhase` flips back to `REPLAY_PHASE_IDLE` and the snapshot vectors get `shrink_to_fit`ed.
-
-STM32WL and any other build with all four `MESHTASTIC_EXCLUDE_*DB` flags set produces zero replay packets — `popReplayPacket` advances through each phase in microseconds without emitting anything.
-
-Special nonces that still mean something:
-
-- `SPECIAL_NONCE_ONLY_CONFIG` (69420) — skip node sync entirely, just config.
-- `SPECIAL_NONCE_ONLY_NODES` (69421) — skip config segments, jump straight to `STATE_SEND_OWN_NODEINFO`. Still gets the post-COMPLETE_ID replay drain.
-
-There are no other reserved nonces; everything else is a fresh random `want_config_id` from the client.
-
-### v24 → v25 migration
-
-The legacy migration code lives in **`src/mesh/NodeDBLegacyMigration.cpp`**, not in `NodeDB.cpp`. It owns the `meshtastic_NodeDatabase_Legacy` callback and `NodeDB::migrateLegacyNodeDatabase()`. The legacy proto descriptor is `protobufs/meshtastic/deviceonly_legacy.proto` (only included by the migration TU). The boot path peeks the file's leading version tag, runs the migration if `version < 25`, then re-saves in v25 layout. The legacy descriptor is scheduled for removal once `DEVICESTATE_MIN_VER` is bumped.
-
-### Read-site rules of thumb
-
-- Never `node->position.X` / `node->device_metrics.X` — those fields no longer exist. Pull from the satellite map via `copyNodePosition` / `copyNodeTelemetry`.
-- Never `node->user.long_name` — `long_name`, `short_name`, `public_key`, `hw_model`, `role`, `macaddr` (gone), `is_licensed`, `is_unmessagable` are flat on `NodeInfoLite`.
-- Never `node->is_favorite` / `node->is_ignored` / `node->via_mqtt` / `node->is_key_manually_verified` — use the bitfield helpers.
-- Never assume `nodeDB->getMeshNode(num)->position.time` — call `copyNodePosition` and check the return.
-- Don't lock `satelliteMutex` yourself in renderer code; the copy-out accessors already do.
-
-Unit tests for the conversion layer live in `test/test_type_conversions/test_main.cpp` (Unity) — bitfield round-trips, `long_name` truncation, thin-vs-full conversions. Add cases there when extending the schema.
-
 ## Project Structure
 
 ```
@@ -376,14 +283,14 @@ Multiple display driver families in `src/graphics/`:
 
 - **OLED**: SSD1306, SH1106, ST7567
 - **TFT**: TFTDisplay (LovyanGFX-based)
-- **E-Ink**: `src/graphics/BaseUIEInkDisplay.*` is the OLEDDisplay-compatible adapter (peer of `TFTDisplay`). The hardware layer it drives lives in `src/graphics/eink/` — chipset drivers in `Drivers/`, panel profiles in `Panels/`, optional `Backlight/`. Shared by both BaseUI-on-eink and InkHUD builds.
+- **E-Ink**: EInkDisplay2, EInkDynamicDisplay, EInkParallelDisplay
 
-**InkHUD** (`src/graphics/niche/`) is an event-driven e-ink UI framework that sits on top of the `graphics/eink/` layer:
+**InkHUD** (`src/graphics/niche/InkHUD/`) is an event-driven e-ink UI framework:
 
 - Applet-based architecture — modular display tiles
 - Read-only, static display optimized for minimal refreshes and low power
 - Configured per-variant via `nicheGraphics.h`
-- Build helpers in top-level `platformio.ini` — `[niche]` pulls `graphics/eink/` only (BaseUI path), `[inkhud]` extends it with `graphics/niche/`
+- Separate PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
 
 ### Input System
 
@@ -609,35 +516,20 @@ Most workflows can be triggered manually via `workflow_dispatch` for testing.
 
 ### Native unit tests (C++)
 
-Unit tests in `test/` directory with 17 test suites:
+Unit tests in `test/` directory with 12 test suites:
 
-- `test_admin_radio/` - LoRa region/config validation and AdminModule dispatch
-- `test_atak/` - ATAK integration
 - `test_crypto/` - Cryptography
-- `test_default/` - Default configuration
-- `test_http_content_handler/` - HTTP handling
-- `test_mac_from_string/` - MAC address parsing
+- `test_mqtt/` - MQTT integration
+- `test_radio/` - Radio interface
 - `test_mesh_module/` - Module framework
 - `test_meshpacket_serializer/` - Packet serialization
-- `test_mqtt/` - MQTT integration
-- `test_packet_history/` - Packet history tracking
-- `test_position_precision/` - Position precision helpers
-- `test_radio/` - Radio interface
-- `test_serial/` - Serial communication
-- `test_traffic_management/` - Traffic management
 - `test_transmit_history/` - Retransmission tracking
-- `test_type_conversions/` - NodeDB v25 type conversion (bitfield round-trips, NodeInfoLite)
-- `test_utf8/` - UTF-8 utilities
+- `test_atak/` - ATAK integration
+- `test_default/` - Default configuration
+- `test_http_content_handler/` - HTTP handling
+- `test_serial/` - Serial communication
 
-Run command (preferred — avoids pipe-buffering and the Ubuntu externally-managed-environment error):
-
-```bash
-~/.platformio/penv/bin/python -m platformio test -e native -f test_your_suite > /tmp/test_out.txt 2>&1
-grep -E 'error:|PASS|FAIL|succeeded|failed' /tmp/test_out.txt
-tail -15 /tmp/test_out.txt
-```
-
-Do **not** use `pio test … | tail -N` — it discards build errors and shows stale cached results. Do **not** use `pio test … | grep` — line-buffering makes the terminal appear hung until the process exits. Redirect to a file first, then grep.
+Run with: `pio test -e native`
 
 Simulation testing: `bin/test-simulator.sh`
 

.github/prompts/new-variant.prompt.md

@@ -132,7 +132,7 @@ For e-ink display variants using the InkHUD framework, add `nicheGraphics.h`:
 // Configure display, applets, and refresh behavior per device
 ```
 
-InkHUD and the shared E-Ink layer are wired up via the top-level `platformio.ini` `[niche]` (BaseUI + driver/panel layer in `src/graphics/eink/`) and `[inkhud]` (adds the InkHUD UI in `src/graphics/niche/`). Variants opt in with `extends = ..., niche` or `extends = ..., inkhud`.
+InkHUD has its own PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
 
 ## I2C Device Detection
 

.github/workflows/build_one_target.yml

@@ -4,14 +4,9 @@ on:
   workflow_dispatch:
     inputs:
       # trunk-ignore(checkov/CKV_GHA_7)
-      target:
-        type: string
-        required: false
-        description: Choose the target board, e.g. nrf52_promicro_diy_tcxo. If blank, will find available targets.
       arch:
         type: choice
         options:
-          - all
           - esp32
           - esp32s3
           - esp32c3
@@ -20,18 +15,32 @@ on:
           - rp2040
           - rp2350
           - stm32
-        description: Choose an arch to limit the search, or 'all' to search all architectures.
-        default: all
+      target:
+        type: string
+        required: false
+        description: Choose the target board, e.g. nrf52_promicro_diy_tcxo. If blank, will find available targets.
+      # find-target:
+      #   type: boolean
+      #   default: true
+      #   description: 'Find the available targets'
 
 permissions: read-all
 
 jobs:
   find-targets:
+    if: ${{ inputs.target == '' }}
     strategy:
       fail-fast: false
       matrix:
         arch:
-          - all
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v6
@@ -42,37 +51,14 @@ jobs:
       - run: pip install -U platformio
       - name: Generate matrix
         id: jsonStep
-        env:
-          BUILDTARGET: ${{ inputs.target }}
-          MATRIXARCH: ${{ inputs.arch }}
         run: |
           TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level extra)
-          if [ "$BUILDTARGET" = "" ]; then
-            echo "Name: $GITHUB_REF_NAME" >> $GITHUB_STEP_SUMMARY
-            echo "Base: $GITHUB_BASE_REF" >> $GITHUB_STEP_SUMMARY
-            echo "Arch: $MATRIXARCH" >> $GITHUB_STEP_SUMMARY
-            echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
-            echo "## 🎯 The following target boards are available to build:" >> $GITHUB_STEP_SUMMARY
-            echo "| Platform | Board |" >> $GITHUB_STEP_SUMMARY
-            echo "| -------- | ----- |" >> $GITHUB_STEP_SUMMARY
-            echo $TARGETS | jq -r 'sort_by(.board) | sort_by(.platform) |.[] | "| " + .platform + " | " + .board + " |" ' >> $GITHUB_STEP_SUMMARY
-          else
-            echo "We build this one:" >> $GITHUB_STEP_SUMMARY
-            ARCH=$(echo "$TARGETS" | jq --arg BUILDTARGET "$BUILDTARGET" -r '.[] | select(.board==$BUILDTARGET) | .platform')
-            echo "| Platform | Board |" >> $GITHUB_STEP_SUMMARY
-            echo "| -------- | ----- |" >> $GITHUB_STEP_SUMMARY
-            echo "| $ARCH | "$BUILDTARGET" |" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            if [[ "$ARCH" == "" ]]; then
-              echo "## ❌ Error: Target "$BUILDTARGET" not found!" >> $GITHUB_STEP_SUMMARY
-            else
-              echo "## ✅ Target "$BUILDTARGET" found, proceeding to build." >> $GITHUB_STEP_SUMMARY
-            fi
-            echo "You may need to refresh this page to make the built firmware appear below." >> $GITHUB_STEP_SUMMARY
-            echo "arch=$ARCH" >> $GITHUB_OUTPUT
-          fi
-    outputs:
-      arch: ${{ steps.jsonStep.outputs.arch }}
+          echo "Name: $GITHUB_REF_NAME" >> $GITHUB_STEP_SUMMARY
+          echo "Base: $GITHUB_BASE_REF" >> $GITHUB_STEP_SUMMARY
+          echo "Arch: ${{matrix.arch}}" >> $GITHUB_STEP_SUMMARY
+          echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
+          echo "Targets:" >> $GITHUB_STEP_SUMMARY
+          echo $TARGETS | jq -r 'sort_by(.board) |.[] | "- " + .board' >> $GITHUB_STEP_SUMMARY
 
   version:
     if: ${{ inputs.target != '' }}
@@ -92,12 +78,12 @@ jobs:
 
   build:
     if: ${{ inputs.target != '' && inputs.arch != 'native' }}
-    needs: [version, find-targets]
+    needs: [version]
     uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
       pio_env: ${{ inputs.target }}
-      platform: ${{ needs.find-targets.outputs.arch }}
+      platform: ${{ inputs.arch }}
 
   gather-artifacts:
     permissions:

.github/workflows/firmware-size-comment.yml

@@ -1,62 +0,0 @@
-name: Post Firmware Size Comment
-
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-
-permissions:
-  pull-requests: write
-  actions: read
-
-jobs:
-  post-size-comment:
-    if: >
-      github.event.workflow_run.event == 'pull_request' &&
-      github.event.workflow_run.conclusion != 'cancelled' &&
-      github.repository == 'meshtastic/firmware'
-    continue-on-error: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download size report
-        id: download
-        uses: actions/download-artifact@v8
-        continue-on-error: true
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          run-id: ${{ github.event.workflow_run.id }}
-          name: size-report
-          path: ./
-
-      - name: Post or update PR comment
-        if: steps.download.outcome == 'success'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const fs = require('fs');
-            const marker = '<!-- firmware-size-report -->';
-            const body = fs.readFileSync('./size-report.md', 'utf8');
-            const prNumber = parseInt(fs.readFileSync('./pr-number.txt', 'utf8').trim(), 10);
-
-            const { data: comments } = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: prNumber,
-            });
-
-            const existing = comments.find(c => c.body.includes(marker));
-            if (existing) {
-              await github.rest.issues.updateComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                comment_id: existing.id,
-                body,
-              });
-            } else {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: prNumber,
-                body,
-              });
-            }

.github/workflows/flasher-link-comment.yml

@@ -0,0 +1,190 @@
+name: Post Web Flasher Link Comment
+
+on:
+  workflow_run:
+    workflows: [CI]
+    types: [completed]
+
+permissions:
+  pull-requests: write
+  actions: read
+
+jobs:
+  post-flasher-link:
+    if: >
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.conclusion != 'cancelled' &&
+      github.repository == 'meshtastic/firmware'
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    steps:
+      # Per-board manifests carry the firmware's own metadata (activelySupported,
+      # displayName, ...) generated from each target's custom_meshtastic_* config.
+      - name: Download board manifests
+        uses: actions/download-artifact@v8
+        continue-on-error: true
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+          pattern: manifest-*
+          path: ./manifests
+          merge-multiple: true
+
+      - name: Post or update web flasher link comment
+        uses: actions/github-script@v9
+        with:
+          script: |
+            const marker = '<!-- web-flasher-link -->';
+            const run = context.payload.workflow_run;
+            const { owner, repo } = context.repo;
+
+            // Resolve the PR number (run.pull_requests is empty for fork PRs)
+            let prNumber = run.pull_requests?.[0]?.number;
+            if (!prNumber) {
+              const { data: prs } = await github.rest.repos.listPullRequestsAssociatedWithCommit({
+                owner, repo, commit_sha: run.head_sha,
+              });
+              prNumber = (prs.find((pr) => pr.head.sha === run.head_sha) ?? prs[0])?.number;
+            }
+            if (!prNumber) {
+              core.info('No pull request associated with this run; skipping.');
+              return;
+            }
+
+            const { data: pr } = await github.rest.pulls.get({ owner, repo, pull_number: prNumber });
+
+            // Only comment on PRs authored by members of the organization.
+            // author_association MEMBER is computed by GitHub and reflects org
+            // membership (including concealed members); OWNER covers a repo owner.
+            const allowedAssociations = ['OWNER', 'MEMBER'];
+            if (!allowedAssociations.includes(pr.author_association)) {
+              core.info(`Author association ${pr.author_association} is not an org member; skipping.`);
+              return;
+            }
+            if (pr.state !== 'open') {
+              core.info('Pull request is not open; skipping.');
+              return;
+            }
+            if (pr.head.sha !== run.head_sha) {
+              core.info('Run is for an outdated commit; skipping.');
+              return;
+            }
+
+            // Require at least one per-arch firmware artifact from gather-artifacts
+            const artifacts = await github.paginate(github.rest.actions.listWorkflowRunArtifacts, {
+              owner, repo, run_id: run.id, per_page: 100,
+            });
+            const archRe = /^firmware-(esp32|esp32s3|esp32c3|esp32c6|nrf52840|rp2040|rp2350|stm32)-(\d+\.\d+\.\d+\.[0-9a-f]+)$/;
+            const archArtifacts = artifacts.filter((a) => archRe.test(a.name) && !a.expired);
+            if (archArtifacts.length === 0) {
+              core.info('No per-arch firmware artifacts found; skipping.');
+              return;
+            }
+
+            const version = archRe.exec(archArtifacts[0].name)[2];
+            const expiresAt = archArtifacts[0].expires_at
+              ? new Date(archArtifacts[0].expires_at).toISOString().slice(0, 10)
+              : null;
+
+            // Read each built board's manifest (.mt.json). activelySupported,
+            // displayName and architecture come straight from the board's
+            // custom_meshtastic_* platformio config, so the list is in sync with
+            // the firmware itself — no external device database needed.
+            const fs = require('fs');
+            let boards = [];
+            try {
+              boards = fs.readdirSync('./manifests')
+                .filter((f) => f.endsWith('.mt.json'))
+                .map((f) => {
+                  try { return JSON.parse(fs.readFileSync(`./manifests/${f}`, 'utf8')); }
+                  catch { return null; }
+                })
+                .filter((m) => m && m.activelySupported === true && m.platformioTarget)
+                .map((m) => ({
+                  board: m.platformioTarget,
+                  platform: m.architecture || '',
+                  // displayName is maintainer-authored text; escape table-breaking pipes
+                  displayName: String(m.displayName || m.platformioTarget).replace(/\|/g, '\\|'),
+                  image: Array.isArray(m.images) && m.images[0] ? String(m.images[0]) : '',
+                }))
+                .sort((a, b) => a.board.localeCompare(b.board));
+            } catch (e) {
+              core.warning(`Could not read board manifests: ${e.message}`);
+            }
+
+            const flasherUrl = `https://flasher.meshtastic.org/?pr=${prNumber}`;
+            // Device illustrations are served by the flasher from the same image
+            // names the manifest declares (custom_meshtastic_images). The flasher
+            // serves its SPA shell (HTML, 200) for unknown paths, so confirm each
+            // image really resolves to an image before linking it.
+            const imageBase = 'https://flasher.meshtastic.org/img/devices/';
+            await Promise.all(boards.map(async (b) => {
+              if (!b.image) return;
+              try {
+                const res = await fetch(`${imageBase}${encodeURIComponent(b.image)}`);
+                const type = res.headers.get('content-type') || '';
+                if (!res.ok || !type.startsWith('image/')) b.image = '';
+              } catch { b.image = ''; }
+            }));
+
+            const boardLines = boards
+              .map((b) => {
+                const img = b.image ? `<img src="${imageBase}${encodeURIComponent(b.image)}" alt="" height="34">` : '';
+                return `| ${img} | ${b.displayName} | [\`${b.board}\`](${flasherUrl}&device=${encodeURIComponent(b.board)}) | ${b.platform} |`;
+              })
+              .join('\n');
+
+            // Shields.io badges. Only non-user-controlled, charset-constrained values
+            // (version, commit sha, counts, dates) go into badge URLs — never board
+            // names or the PR title — so the rendered comment cannot be spoofed.
+            const shieldText = (s) =>
+              encodeURIComponent(String(s).replace(/-/g, '--').replace(/_/g, '__').replace(/ /g, '_'));
+            const shield = (label, message, color) =>
+              `https://img.shields.io/badge/${shieldText(label)}-${shieldText(message)}-${color}`;
+            const buttonUrl =
+              `https://img.shields.io/badge/${shieldText('Flash this PR in the Web Flasher')}-2C2D3C?style=for-the-badge`;
+            const badges = [
+              `![firmware](${shield('firmware', version, '67EA94')})`,
+              `![commit](${shield('commit', run.head_sha.slice(0, 7), '2C2D3C')})`,
+              `![boards](${shield('boards', boards.length, '5C6BC0')})`,
+            ];
+            if (expiresAt) badges.push(`![expires](${shield('expires', expiresAt, '9A4E00')})`);
+
+            // Only render the board table when there are supported boards to list
+            const boardTable = boards.length > 0 ? [
+              `<details><summary>Supported boards built by this PR (${boards.length})</summary>`,
+              '',
+              '| | Device | Board | Platform |',
+              '| --- | --- | --- | --- |',
+              boardLines,
+              '',
+              '</details>',
+              '',
+            ] : [];
+
+            const body = [
+              marker,
+              '## ⚡ Try this PR in the Web Flasher',
+              '',
+              `[![Flash this PR in the Web Flasher](${buttonUrl})](${flasherUrl})`,
+              '',
+              badges.join(' '),
+              '',
+              '> [!WARNING]',
+              '> This is an automated, unreviewed CI test build. Back up your device configuration',
+              '> before flashing, and only flash devices you are able to recover.',
+              '',
+              ...boardTable,
+              `*Build artifacts expire${expiresAt ? ` on ${expiresAt}` : ' after 30 days'}. Updated for \`${run.head_sha.slice(0, 7)}\`.*`,
+            ].join('\n');
+
+            // Sticky comment: update in place when the marker is found
+            const comments = await github.paginate(github.rest.issues.listComments, {
+              owner, repo, issue_number: prNumber, per_page: 100,
+            });
+            const existing = comments.find((c) => c.body?.includes(marker));
+            if (existing) {
+              await github.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body });
+            } else {
+              await github.rest.issues.createComment({ owner, repo, issue_number: prNumber, body });
+            }

.github/workflows/flasher-link-placeholder.yml

@@ -0,0 +1,60 @@
+name: Post Web Flasher Build Placeholder
+
+# Drops an immediate "build in progress" comment when a PR opens, so the web
+# flasher entry shows up right away. The real CI-driven workflow
+# (flasher-link-comment.yml) later replaces it in place via the shared marker.
+#
+# SECURITY: this uses pull_request_target (write token, runs for fork PRs) but is
+# safe because it never checks out or runs PR code and posts a fully static body
+# — no PR title, branch name, or other untrusted input is used anywhere.
+
+on:
+  pull_request_target:
+    types: [opened, reopened]
+
+permissions:
+  pull-requests: write
+
+jobs:
+  post-placeholder:
+    if: github.repository == 'meshtastic/firmware'
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    steps:
+      - name: Post web flasher build-in-progress placeholder
+        uses: actions/github-script@v9
+        with:
+          script: |
+            const marker = '<!-- web-flasher-link -->';
+            const { owner, repo } = context.repo;
+            const pr = context.payload.pull_request;
+
+            // Only org members get the flasher comment (matches the real workflow)
+            const allowedAssociations = ['OWNER', 'MEMBER'];
+            if (!allowedAssociations.includes(pr.author_association)) {
+              core.info(`Author association ${pr.author_association} is not an org member; skipping.`);
+              return;
+            }
+
+            // Only seed a placeholder when no flasher comment exists yet — never
+            // overwrite a real (or existing placeholder) comment.
+            const comments = await github.paginate(github.rest.issues.listComments, {
+              owner, repo, issue_number: pr.number, per_page: 100,
+            });
+            if (comments.some((c) => c.body?.includes(marker))) {
+              core.info('Flasher comment already exists; nothing to do.');
+              return;
+            }
+
+            const body = [
+              marker,
+              '## ⚡ Try this PR in the Web Flasher',
+              '',
+              '> [!NOTE]',
+              '> Building this pull request… the flash button, badges and supported-board',
+              '> list will appear here automatically once CI finishes.',
+            ].join('\n');
+
+            await github.rest.issues.createComment({
+              owner, repo, issue_number: pr.number, body,
+            });

.github/workflows/main_matrix.yml

@@ -245,127 +245,6 @@ jobs:
           path: ./*.elf
           retention-days: 30
 
-  firmware-size-report:
-    if: github.repository == 'meshtastic/firmware'
-    continue-on-error: true
-    permissions:
-      contents: read
-      actions: read
-    runs-on: ubuntu-latest
-    needs: [build]
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Download current manifests
-        uses: actions/download-artifact@v8
-        with:
-          path: ./manifests/
-          pattern: manifest-*
-          merge-multiple: true
-
-      - name: Collect current firmware sizes
-        run: python3 bin/collect_sizes.py ./manifests/ ./current-sizes.json
-
-      - name: Upload size report artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: firmware-sizes-${{ github.sha }}
-          overwrite: true
-          path: ./current-sizes.json
-          retention-days: 90
-
-      - name: Download baseline sizes from develop
-        if: github.event_name == 'pull_request'
-        continue-on-error: true
-        id: baseline-develop
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          RUN_ID=$(gh run list -R "${{ github.repository }}" \
-            --workflow CI --branch develop --status success \
-            --limit 1 --json databaseId --jq '.[0].databaseId // empty')
-          if [ -n "$RUN_ID" ]; then
-            ARTIFACT_NAME=$(gh api "repos/${{ github.repository }}/actions/runs/${RUN_ID}/artifacts" \
-              --jq '.artifacts[] | select(.name | startswith("firmware-sizes-")) | .name' | head -1)
-            if [ -n "$ARTIFACT_NAME" ]; then
-              gh run download "$RUN_ID" -R "${{ github.repository }}" \
-                --name "$ARTIFACT_NAME" --dir ./baseline-develop/
-              cp "./baseline-develop/${ARTIFACT_NAME}/current-sizes.json" ./develop-sizes.json
-              echo "found=true" >> "$GITHUB_OUTPUT"
-            else
-              echo "found=false" >> "$GITHUB_OUTPUT"
-            fi
-          else
-            echo "found=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Download baseline sizes from master
-        if: github.event_name == 'pull_request'
-        continue-on-error: true
-        id: baseline-master
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          RUN_ID=$(gh run list -R "${{ github.repository }}" \
-            --workflow CI --branch master --status success \
-            --limit 1 --json databaseId --jq '.[0].databaseId // empty')
-          if [ -n "$RUN_ID" ]; then
-            ARTIFACT_NAME=$(gh api "repos/${{ github.repository }}/actions/runs/${RUN_ID}/artifacts" \
-              --jq '.artifacts[] | select(.name | startswith("firmware-sizes-")) | .name' | head -1)
-            if [ -n "$ARTIFACT_NAME" ]; then
-              gh run download "$RUN_ID" -R "${{ github.repository }}" \
-                --name "$ARTIFACT_NAME" --dir ./baseline-master/
-              cp "./baseline-master/${ARTIFACT_NAME}/current-sizes.json" ./master-sizes.json
-              echo "found=true" >> "$GITHUB_OUTPUT"
-            else
-              echo "found=false" >> "$GITHUB_OUTPUT"
-            fi
-          else
-            echo "found=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Generate size comparison report
-        if: github.event_name == 'pull_request'
-        id: report
-        run: |
-          ARGS="./current-sizes.json"
-          if [ -f ./develop-sizes.json ]; then
-            ARGS="$ARGS --baseline develop:./develop-sizes.json"
-          fi
-          if [ -f ./master-sizes.json ]; then
-            ARGS="$ARGS --baseline master:./master-sizes.json"
-          fi
-          REPORT=$(python3 bin/size_report.py $ARGS)
-          if [ -z "$REPORT" ]; then
-            echo "has_report=false" >> "$GITHUB_OUTPUT"
-          else
-            echo "has_report=true" >> "$GITHUB_OUTPUT"
-            {
-              echo '<!-- firmware-size-report -->'
-              echo '# Firmware Size Report'
-              echo ''
-              echo "$REPORT"
-              echo ''
-              echo '---'
-              echo "*Updated for ${{ github.sha }}*"
-            } > ./size-report.md
-            cat ./size-report.md >> "$GITHUB_STEP_SUMMARY"
-          fi
-
-      - name: Save PR number
-        if: github.event_name == 'pull_request' && steps.report.outputs.has_report == 'true'
-        run: echo "${{ github.event.pull_request.number }}" > ./pr-number.txt
-
-      - name: Upload size report
-        if: github.event_name == 'pull_request' && steps.report.outputs.has_report == 'true'
-        uses: actions/upload-artifact@v7
-        with:
-          name: size-report
-          path: |
-            ./size-report.md
-            ./pr-number.txt
-          retention-days: 5
-
   release-artifacts:
     permissions: # Needed for 'gh release upload'.
       contents: write

.github/workflows/nightly.yml

@@ -17,13 +17,13 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Trunk Check
-        uses: trunk-io/trunk-action@v1
+        uses: trunk-io/trunk-action@v1.3.1
         with:
           trunk-token: ${{ secrets.TRUNK_TOKEN }}
 
   trunk_upgrade:
     if: github.repository == 'meshtastic/firmware'
-    # See: https://github.com/trunk-io/trunk-action/blob/v1/readme.md#automatic-upgrades
+    # See: https://github.com/trunk-io/trunk-action/blob/main/readme.md#automatic-upgrades
     name: Trunk Upgrade (PR)
     runs-on: ubuntu-24.04
     permissions:
@@ -34,6 +34,6 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Trunk Upgrade
-        uses: trunk-io/trunk-action/upgrade@v1
+        uses: trunk-io/trunk-action/upgrade@v1.3.1
         with:
           base: master

.github/workflows/stale_bot.yml

@@ -17,7 +17,7 @@ jobs:
 
     steps:
       - name: Stale PR+Issues
-        uses: actions/stale@v10.2.0
+        uses: actions/stale@v10.3.0
         with:
           days-before-stale: 45
           stale-issue-message: This issue has not had any comment or update in the last month. If it is still relevant, please post update comments. If no comments are made, this issue will be closed automagically in 7 days.

.github/workflows/test_native.yml

@@ -86,13 +86,7 @@ jobs:
         run: sed -i 's/-DBUILD_EPOCH=$UNIX_TIME/#-DBUILD_EPOCH=$UNIX_TIME/' platformio.ini
 
       - name: PlatformIO Tests
-        run: |
-          set -o pipefail
-          # Filter out SKIPPED summary rows for hardware variants that can't run on the
-          # native host. They flood the log and make it harder to spot real failures.
-          # The JUnit XML is written directly to testreport.xml before the pipe, so
-          # the test artifact is unaffected.
-          platformio test -e coverage -v --junit-output-path testreport.xml 2>&1 | grep -v "[[:space:]]SKIPPED$"
+        run: platformio test -e coverage -v --junit-output-path testreport.xml
 
       - name: Save test results
         if: always() # run this step even if previous step failed

.github/workflows/trunk_annotate_pr.yml

@@ -1,5 +1,5 @@
 name: Annotate PR with trunk issues
-# See: https://github.com/trunk-io/trunk-action/blob/v1/readme.md#getting-inline-annotations-for-fork-prs
+# See: https://github.com/trunk-io/trunk-action/blob/main/readme.md#getting-inline-annotations-for-fork-prs
 
 on:
   workflow_run:
@@ -21,6 +21,6 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Trunk Check
-        uses: trunk-io/trunk-action@v1
+        uses: trunk-io/trunk-action@v1.3.1
         with:
           post-annotations: true

.github/workflows/trunk_check.yml

@@ -19,6 +19,6 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Trunk Check
-        uses: trunk-io/trunk-action@v1
+        uses: trunk-io/trunk-action@v1.3.1
         with:
           save-annotations: true

.github/workflows/update_protobufs.yml

@@ -16,13 +16,18 @@ jobs:
           submodules: true
 
       - name: Update submodule
-        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop' }}
+        if: ${{ github.ref_name == 'master' || github.ref_name == 'develop' }}
+        working-directory: protobufs
+        env:
+          # Use the branch that triggered the workflow as the protobuf branch.
+          GIT_BRANCH: ${{ github.ref_name }}
         run: |
-          git submodule update --remote protobufs
+          git fetch --prune origin $GIT_BRANCH
+          git checkout origin/$GIT_BRANCH
 
       - name: Download nanopb
         run: |
-          wget https://jpa.kapsi.fi/nanopb/download/nanopb-0.4.9.1-linux-x86.tar.gz
+          wget https://github.com/nanopb/nanopb/releases/download/nanopb-0.4.9.1/nanopb-0.4.9.1-linux-x86.tar.gz
           tar xvzf nanopb-0.4.9.1-linux-x86.tar.gz
           mv nanopb-0.4.9.1-linux-x86 nanopb-0.4.9
 
@@ -33,7 +38,7 @@ jobs:
       - name: Create pull request
         uses: peter-evans/create-pull-request@v8
         with:
-          branch: create-pull-request/update-protobufs
+          branch: create-pull-request/update-protobufs-${{ github.ref_name }}
           labels: submodules
           title: Update protobufs and classes
           commit-message: Update protobufs

.gitignore

@@ -47,10 +47,6 @@ data/boot/logo.*
 managed_components/*
 arduino-lib-builder*
 dependencies.lock
-
-# JLink / RTT debug artifacts (nRF SoCs)
-flash.jlink
-rtt_*.txt
 idf_component.yml
 CMakeLists.txt
 /sdkconfig.*
@@ -60,9 +56,3 @@ CMakeLists.txt
 .python3
 .claude/scheduled_tasks.lock
 userPrefs.jsonc.mcp-session-bak
-
-# Fake-NodeDB fixture pipeline (bin/regen-fake-nodedbs.sh)
-# JSONL seeds are committed (test/fixtures/nodedb/seed_v25_*.jsonl);
-# compiled .proto outputs are ephemeral build artifacts.
-build/fixtures/
-bin/_generated/

.trunk/trunk.yaml

@@ -4,19 +4,19 @@ cli:
 plugins:
   sources:
     - id: trunk
-      ref: v1.10.0
+      ref: v1.10.2
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.529
-    - renovate@43.150.0
-    - prettier@3.8.3
-    - trufflehog@3.95.3
+    - checkov@3.3.1
+    - renovate@43.220.0
+    - prettier@3.8.4
+    - trufflehog@3.95.5
     - yamllint@1.38.0
     - bandit@1.9.4
-    - trivy@0.70.0
+    - trivy@0.71.0
     - taplo@0.10.0
-    - ruff@0.15.13
+    - ruff@0.15.17
     - isort@8.0.1
     - markdownlint@0.48.0
     - oxipng@10.1.1
@@ -34,13 +34,6 @@ lint:
     - linters: [ALL]
       paths:
         - bin/**
-    # Fake-NodeDB fixture JSONL files contain deterministic synthetic
-    # public_key_hex (64-char hex) values that gitleaks misidentifies as
-    # generic-api-key. These are not secrets — they're test fixtures
-    # produced by bin/gen-fake-nodedb-seed.py with a fixed RNG seed.
-    - linters: [gitleaks]
-      paths:
-        - test/fixtures/nodedb/seed_v25_*.jsonl
 runtimes:
   enabled:
     - python@3.14.4

AGENTS.md

@@ -10,18 +10,18 @@ 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) | `~/.platformio/penv/bin/python -m platformio test -e native > /tmp/test_out.txt 2>&1` then `grep -E 'error:\|PASS\|FAIL\|succeeded\|failed' /tmp/test_out.txt` (redirect first — piping causes line-buffering) |
-| 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`)                                        |
+| 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]`                                                                |
 
 ## MCP server (device + test automation)
 
@@ -108,7 +108,7 @@ Sequence these; don't parallelize on the same port.
 | `src/modules/`                    | Feature modules; `Telemetry/Sensor/` has 50+ I2C sensor drivers                                                          |
 | `variants/`                       | 200+ hardware variant definitions (`variant.h` + `platformio.ini` per board)                                             |
 | `protobufs/`                      | `.proto` definitions; regenerate with `bin/regen-protos.sh`                                                              |
-| `test/`                           | Firmware unit tests (17 suites; `pio test -e native`)                                                                    |
+| `test/`                           | Firmware unit tests (12 suites; `pio test -e native`)                                                                    |
 | `mcp-server/`                     | Python MCP server + pytest hardware integration tests                                                                    |
 | `mcp-server/tests/`               | Tiered pytest suite: `unit/`, `mesh/`, `telemetry/`, `monitor/`, `recovery/`, `ui/`, `fleet/`, `admin/`, `provisioning/` |
 | `.claude/commands/`               | Claude Code slash command bodies                                                                                         |

Dockerfile

@@ -14,7 +14,7 @@ ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apt-get update && apt-get install --no-install-recommends -y \
         curl wget g++ zip git ca-certificates pkg-config \
         python3-pip python3-grpc-tools \
-        libgpiod-dev libyaml-cpp-dev libjsoncpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
         libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \
@@ -53,7 +53,7 @@ ENV TZ=Etc/UTC
 USER root
 
 RUN apt-get update && apt-get --no-install-recommends -y install \
-        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libjsoncpp26 libi2c0 libuv1t64 libusb-1.0-0-dev \
+        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libi2c0 libuv1t64 libusb-1.0-0-dev \
         liborcania2.3 libulfius2.7t64 libssl3t64 \
         libx11-6 libinput10 libxkbcommon-x11-0 libsdl2-2.0-0 \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \

Dockerfile.test

@@ -7,7 +7,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 # hadolint ignore=DL3008
 RUN apt-get update && apt-get install --no-install-recommends -y \
         g++ git ca-certificates pkg-config \
-        libgpiod-dev libyaml-cpp-dev libjsoncpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
         libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \

alpine.Dockerfile

@@ -4,7 +4,7 @@
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
 # Ensure the Alpine version is updated in both stages of the container!
-FROM alpine:3.23 AS builder
+FROM alpine:3.24 AS builder
 ARG PIO_ENV=native
 
 # Enable Alpine community repository (for 'py3-grpcio-tools')
@@ -16,7 +16,7 @@ ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apk --no-cache add \
         bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
         py3-pip py3-grpcio-tools \
-        libgpiod-dev yaml-cpp-dev jsoncpp-dev bluez-dev \
+        libgpiod-dev yaml-cpp-dev bluez-dev \
         libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
         libx11-dev libinput-dev libxkbcommon-dev sqlite-dev sdl2-dev \
     && rm -rf /var/cache/apk/* \
@@ -35,7 +35,7 @@ RUN bash ./bin/build-native.sh "$PIO_ENV" && \
 
 # ##### PRODUCTION BUILD #############
 
-FROM alpine:3.23
+FROM alpine:3.24
 LABEL org.opencontainers.image.title="Meshtastic" \
       org.opencontainers.image.description="Alpine Meshtastic daemon" \
       org.opencontainers.image.url="https://meshtastic.org" \
@@ -48,7 +48,7 @@ LABEL org.opencontainers.image.title="Meshtastic" \
 USER root
 
 RUN apk --no-cache add \
-        shadow libstdc++ libbsd libgpiod yaml-cpp jsoncpp libusb \
+        shadow libstdc++ libbsd libgpiod yaml-cpp libusb \
         i2c-tools libuv libx11 libinput libxkbcommon sdl2 \
     && rm -rf /var/cache/apk/* \
     && mkdir -p /var/lib/meshtasticd \

bin/_rewrite_proto_namespace.py

@@ -1,64 +0,0 @@
-#!/usr/bin/env python3
-"""Post-process protoc-generated Python files to live under a local namespace.
-
-Called by bin/regen-py-protos.sh. Walks the generated *_pb2.py files in the
-target directory and rewrites every `meshtastic` reference (imports, dotted
-attribute access) to use the new namespace (e.g., `meshtastic_v25`).
-
-Why: the .proto files declare `package meshtastic;`, so protoc emits
-`from meshtastic import mesh_pb2 as ...` lines. That would shadow the PyPI
-`meshtastic` package which other parts of the mcp-server depend on. Renaming
-to a local namespace keeps both available.
-
-Usage:
-    _rewrite_proto_namespace.py <generated_dir> <new_namespace>
-"""
-
-from __future__ import annotations
-
-import pathlib
-import re
-import sys
-
-
-def rewrite(dir_path: pathlib.Path, new_ns: str) -> int:
-    # Standard protoc import forms:
-    #   from meshtastic.X_pb2 import ...     (rare, for direct symbol pulls)
-    #   from meshtastic import X_pb2 as ...  (common, the cross-file ref)
-    #   import meshtastic.X_pb2              (also possible)
-    pattern_dotted_from = re.compile(r"^from meshtastic\.", re.MULTILINE)
-    pattern_bare_from = re.compile(r"^from meshtastic import ", re.MULTILINE)
-    pattern_dotted_import = re.compile(r"^import meshtastic\.", re.MULTILINE)
-
-    count = 0
-    for p in dir_path.glob("*.py"):
-        text = p.read_text(encoding="utf-8")
-        new = pattern_dotted_from.sub(f"from {new_ns}.", text)
-        new = pattern_bare_from.sub(f"from {new_ns} import ", new)
-        new = pattern_dotted_import.sub(f"import {new_ns}.", new)
-        # NOTE: we deliberately leave `meshtastic/X.proto` source-filename
-        # references inside descriptor strings alone. The descriptor pool is
-        # keyed by source filename (independent of Python package layout), so
-        # those don't collide with the PyPI package's descriptors.
-        if new != text:
-            p.write_text(new, encoding="utf-8")
-            count += 1
-    return count
-
-
-def main(argv: list[str]) -> int:
-    if len(argv) != 2:
-        print("usage: _rewrite_proto_namespace.py <generated_dir> <new_namespace>", file=sys.stderr)
-        return 2
-    dir_path = pathlib.Path(argv[0])
-    new_ns = argv[1]
-    if not dir_path.is_dir():
-        print(f"directory not found: {dir_path}", file=sys.stderr)
-        return 2
-    n = rewrite(dir_path, new_ns)
-    print(f"rewrote {n} file(s) in {dir_path} → namespace {new_ns}", file=sys.stderr)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))

bin/build-esp32.sh

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

bin/collect_sizes.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-
-"""Collect firmware binary sizes from manifest (.mt.json) files into a single report."""
-
-import json
-import os
-import sys
-
-
-def collect_sizes(manifest_dir):
-    """Scan manifest_dir for .mt.json files and return {board: size_bytes} dict."""
-    sizes = {}
-    for fname in sorted(os.listdir(manifest_dir)):
-        if not fname.endswith(".mt.json"):
-            continue
-        path = os.path.join(manifest_dir, fname)
-        with open(path) as f:
-            data = json.load(f)
-        board = data.get("platformioTarget", fname.replace(".mt.json", ""))
-        # Find the main firmware .bin size (largest .bin, excluding OTA/littlefs/bleota)
-        bin_size = None
-        for entry in data.get("files", []):
-            name = entry.get("name", "")
-            if name.startswith("firmware-") and name.endswith(".bin"):
-                bin_size = entry["bytes"]
-                break
-        # Fallback: any .bin that isn't ota/littlefs/bleota
-        if bin_size is None:
-            for entry in data.get("files", []):
-                name = entry.get("name", "")
-                if name.endswith(".bin") and not any(
-                    x in name for x in ["littlefs", "bleota", "ota"]
-                ):
-                    bin_size = entry["bytes"]
-                    break
-        if bin_size is not None:
-            sizes[board] = bin_size
-    return sizes
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 3:
-        print(f"Usage: {sys.argv[0]} <manifest_dir> <output.json>", file=sys.stderr)
-        sys.exit(1)
-
-    manifest_dir = sys.argv[1]
-    output_path = sys.argv[2]
-
-    sizes = collect_sizes(manifest_dir)
-    with open(output_path, "w") as f:
-        json.dump(sizes, f, indent=2, sort_keys=True)
-
-    print(f"Collected sizes for {len(sizes)} targets -> {output_path}")

bin/config.d/femtofox/femtofox_E80-900M2213S.yaml

@@ -1,30 +0,0 @@
----
-Lora:
-## Ebyte E80-900M22S
-## This is a bit experimental
-## 
-##
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23  #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-  
-rfswitch_table:
-  pins: [DIO5, DIO6, DIO7]
-  MODE_STBY: [LOW, LOW, LOW]
-  MODE_RX: [LOW, HIGH, LOW]
-  MODE_TX: [HIGH, HIGH, LOW]
-  MODE_TX_HP: [HIGH, LOW, LOW]
-  MODE_TX_HF: [LOW, LOW, LOW]
-  MODE_GNSS: [LOW, LOW, HIGH]
-  MODE_WIFI: [LOW, LOW, LOW]
-
-General:
-  MACAddressSource: eth0

bin/config.d/femtofox/femtofox_LR1121 generic.yaml

@@ -1,46 +0,0 @@
----
-Lora:
-## Ebyte E80-900M22S
-## This is a bit experimental
-## 
-##
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23  #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-  
-rfswitch_table:
-  pins:
-    - DIO5
-    - DIO6
-  MODE_STBY:
-    - LOW
-    - LOW
-  MODE_RX:
-    - HIGH
-    - LOW
-  MODE_TX:
-    - HIGH
-    - HIGH
-  MODE_TX_HP:
-    - LOW
-    - HIGH
-  MODE_TX_HF:
-    - LOW
-    - LOW
-  MODE_GNSS:
-    - LOW
-    - LOW
-  MODE_WIFI:
-    - LOW
-    - LOW
-
-General:
-  MACAddressSource: eth0

bin/config.d/femtofox/femtofox_WIO-LR1121.yaml

@@ -1,30 +0,0 @@
----
-Lora:
-## Ebyte E80-900M22S
-## This is a bit experimental
-## 
-##
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23  #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-  
-rfswitch_table:
-  pins: [DIO5, DIO6, DIO7]
-  MODE_STBY: [LOW, LOW, LOW]
-  MODE_RX: [LOW, LOW, LOW]
-  MODE_TX: [LOW, HIGH, LOW]
-  MODE_TX_HP: [HIGH, LOW, LOW]
-  # MODE_TX_HF: []
-  # MODE_GNSS: []
-  MODE_WIFI: [LOW, LOW, LOW]
-
-General:
-  MACAddressSource: eth0

bin/config.d/lora-lyra-zero-BQ-SG3-BQ35LORA900V1M-slot1.yaml

@@ -0,0 +1,29 @@
+# Station G3 + BQ35LORA900V1M Primary Slot
+# Board Doc: https://wiki.bqvoy.com/en/devkits/station-g3
+Meta:
+  name: B&Q Station G3 + BQ35LORA900V1M Primary Slot
+  support: official
+  compatible:
+    - luckfox-lyra-zero-w # Armbian
+
+Lora:
+  Module: sx1262
+  IRQ: # GPIO0_A5 (physical 15)
+    pin: 5
+    gpiochip: 0
+    line: 5
+  Reset: # GPIO1_D1 (physical 36)
+    pin: 57
+    gpiochip: 1
+    line: 25
+  Busy: # GPIO0_B4 (physical 18)
+    pin: 12
+    gpiochip: 0
+    line: 12
+  DIO3_TCXO_VOLTAGE: true
+  DIO2_AS_RF_SWITCH: true
+  spidev: spidev0.0
+  # CS: # GPIO0_B2 (physical 24)
+  #   pin: 10
+  #   gpiochip: 0
+  #   line: 10

bin/config.d/lora-rpi-BQ-SG3-BQ35LORA900V1M-slot1.yaml

@@ -0,0 +1,17 @@
+# Station G3 + BQ35LORA900V1M Primary Slot
+# Board Doc: https://wiki.bqvoy.com/en/devkits/station-g3
+Meta:
+  name: B&Q Station G3 + BQ35LORA900V1M Primary Slot
+  support: official
+  compatible:
+    - raspberry-pi
+
+Lora:
+  Module: sx1262
+  IRQ: 22
+  Reset: 16
+  Busy: 24
+  DIO3_TCXO_VOLTAGE: true
+  DIO2_AS_RF_SWITCH: true
+  spidev: spidev0.0
+  #CS: 8

bin/gen-fake-nodedb-seed.py

@@ -1,439 +0,0 @@
-#!/usr/bin/env python3
-"""Deterministic seed-data generator for the fake NodeDB fixture pipeline.
-
-Writes a JSONL file describing N fake-but-realistic Meshtastic peers.
-The output is hand-editable and committed; a sibling compile step
-(bin/seed-json-to-proto.py) turns it into a binary `meshtastic_NodeDatabase`
-v25 protobuf with fresh "now-relative" timestamps.
-
-Determinism contract:
-  Same --seed -> byte-identical JSONL output, regardless of wall clock.
-  All timestamps are stored as `*_offset_sec` (seconds before "now"); the
-  compile step resolves them to absolute epochs at compile time.
-
-Structural fields covered:
-  * NodeInfoLite header: num, long_name, short_name, hw_model, role,
-    public_key, snr, channel, hops_away, next_hop, bitfield flags
-  * PositionLite: lat/long Gaussian around --centroid, altitude, source
-  * DeviceMetrics: battery/voltage/util/uptime
-  * EnvironmentMetrics: temp/humidity/pressure/iaq
-  * StatusMessage: error_code (usually zero)
-
-Active-board allow-list:
-  hw_model values are restricted to the intersection of
-    (a) variants with `custom_meshtastic_support_level = 1` in
-        variants/*/*/platformio.ini, AND
-    (b) values present in the `HardwareModel` enum in mesh.proto.
-  See HW_MODEL_WEIGHTS below. Deprecated boards (legacy TLORA / Heltec V1-2 /
-  classic TBEAM / TBEAM_V0P7 / Nano G1 / etc.) and fuzzer-only sentinels
-  (PORTDUINO, ANDROID_SIM, DIY_V1, ...) are excluded.
-
-Active-role allow-list:
-  Excludes ROUTER_CLIENT (deprecated v2.3.15) and REPEATER (deprecated v2.7.11).
-"""
-
-from __future__ import annotations
-
-import argparse
-import datetime as _dt
-import json
-import math
-import pathlib
-import random
-import sys
-
-# --------------------------------------------------------------------------
-# Active-board allow-list (intersection of tier-1 variants + HardwareModel enum).
-# Refresh by running:
-#   for f in $(find variants -name 'platformio.ini' | xargs grep -lE 'custom_meshtastic_support_level = 1'); do
-#       grep custom_meshtastic_hw_model_slug $f | awk -F= '{print $2}' | tr -d ' ';
-#   done | sort -u | comm -12 - <(python3 -c "from meshtastic.protobuf.mesh_pb2 import HardwareModel; print('\\n'.join(HardwareModel.keys()))" | sort)
-# --------------------------------------------------------------------------
-HW_MODEL_WEIGHTS: dict[str, float] = {
-    "HELTEC_V3": 14.0,
-    "T_DECK": 9.0,
-    "HELTEC_V4": 8.0,
-    "RAK4631": 8.0,
-    "HELTEC_MESH_POCKET": 6.0,
-    "TRACKER_T1000_E": 5.0,
-    "HELTEC_MESH_NODE_T114": 5.0,
-    "T_DECK_PRO": 5.0,
-    "LILYGO_TBEAM_S3_CORE": 4.0,
-    "HELTEC_WIRELESS_PAPER": 4.0,
-    "HELTEC_WSL_V3": 3.0,
-    "T_ECHO": 3.0,
-    "HELTEC_WIRELESS_TRACKER": 3.0,
-    "HELTEC_WIRELESS_TRACKER_V2": 2.0,
-    "HELTEC_VISION_MASTER_E290": 2.0,
-    "HELTEC_MESH_SOLAR": 2.0,
-    "SEEED_WIO_TRACKER_L1": 2.0,
-    "T_LORA_PAGER": 1.5,
-    "HELTEC_VISION_MASTER_E213": 1.5,
-    "T_ECHO_PLUS": 1.0,
-    "MUZI_BASE": 1.0,
-    "WISMESH_TAP_V2": 1.0,
-    "THINKNODE_M2": 1.0,
-    "THINKNODE_M5": 1.0,
-    "TLORA_T3_S3": 1.0,
-    # Long tail (uniform low weight across remaining tier-1 boards):
-    "HELTEC_V4_R8": 0.3,
-    "HELTEC_VISION_MASTER_T190": 0.3,
-    "HELTEC_HT62": 0.3,
-    "HELTEC_MESH_NODE_T096": 0.3,
-    "M5STACK_C6L": 0.3,
-    "MINI_EPAPER_S3": 0.3,
-    "MUZI_R1_NEO": 0.3,
-    "NOMADSTAR_METEOR_PRO": 0.3,
-    "RAK3312": 0.3,
-    "RAK3401": 0.3,
-    "SEEED_SOLAR_NODE": 0.3,
-    "SEEED_WIO_TRACKER_L1_EINK": 0.3,
-    "SENSECAP_INDICATOR": 0.3,
-    "TBEAM_1_WATT": 0.3,
-    "THINKNODE_M1": 0.3,
-    "THINKNODE_M3": 0.3,
-    "THINKNODE_M6": 0.3,
-    "T_ECHO_LITE": 0.3,
-    "WISMESH_TAG": 0.3,
-    "WISMESH_TAP": 0.3,
-    "XIAO_NRF52_KIT": 0.3,
-    "CROWPANEL": 0.3,
-}
-
-# Non-deprecated roles only.
-ROLE_WEIGHTS: dict[str, float] = {
-    "CLIENT": 75.0,
-    "CLIENT_MUTE": 5.0,
-    "ROUTER": 7.0,
-    "TRACKER": 3.0,
-    "SENSOR": 2.0,
-    "CLIENT_HIDDEN": 2.0,
-    "ROUTER_LATE": 2.0,
-    "CLIENT_BASE": 2.0,
-    "TAK": 1.0,
-    "TAK_TRACKER": 0.5,
-    "LOST_AND_FOUND": 0.5,
-}
-
-# Name pools — 60 firsts × 60 lasts = 3600 combinations.
-FIRSTS = [
-    "Quick", "Brave", "Silent", "Wild", "Lone", "Bright", "Red", "Blue",
-    "Green", "Black", "White", "Iron", "Steel", "Copper", "Silver", "Gold",
-    "Stone", "River", "Forest", "Mountain", "Canyon", "Desert", "Storm", "Sky",
-    "Solar", "Lunar", "Dawn", "Dusk", "Misty", "Frosty", "Sunny", "Shady",
-    "Happy", "Sleepy", "Drowsy", "Sneaky", "Sharp", "Smooth", "Rough", "Loud",
-    "Soft", "Slow", "Fast", "Tall", "Short", "Old", "New", "Tiny",
-    "Giant", "Hidden", "Lost", "Found", "Wandering", "Roving", "Drifting", "Floating",
-    "Burning", "Frozen", "Whispering", "Howling",
-]
-LASTS = [
-    "Phoenix", "Lion", "Bear", "Wolf", "Hawk", "Eagle", "Fox", "Lynx",
-    "Cougar", "Coyote", "Raven", "Owl", "Crow", "Falcon", "Heron", "Crane",
-    "Otter", "Badger", "Bison", "Elk", "Moose", "Stag", "Doe", "Hare",
-    "Marmot", "Mole", "Beaver", "Squirrel", "Mustang", "Bronco", "Pony", "Colt",
-    "Cobra", "Viper", "Mamba", "Adder", "Gecko", "Iguana", "Tortoise", "Turtle",
-    "Salmon", "Trout", "Bass", "Pike", "Shark", "Whale", "Dolphin", "Seal",
-    "Cactus", "Yucca", "Sage", "Juniper", "Pine", "Cedar", "Aspen", "Oak",
-    "Bluff", "Mesa", "Arroyo", "Ridge",
-]
-
-# Brief callsign pool for licensed-looking suffixes.
-CALLSIGN_PREFIXES = ["KX", "WD", "N5", "KE", "AB", "W5", "K1", "KQ", "AE", "NM"]
-
-# Only emojis that fit in 4 UTF-8 bytes (no variation selectors). short_name's
-# nanopb max_size:5 (incl. NUL) limits content to 4 bytes. ❄️ / ☀️ would be
-# 6 bytes due to U+FE0F variation selector — explicitly excluded.
-EMOJI_SHORTNAMES = ["🦊", "🐺", "🦅", "🐢", "🌵", "🔥", "🌙",
-                    "🌊", "🗻", "🌲", "🦌", "🐝", "🦂", "🦉",
-                    "🦇", "🦋"]
-
-# --------------------------------------------------------------------------
-# Helpers
-# --------------------------------------------------------------------------
-
-NUM_RESERVED = 4         # firmware reserves 0..3 (per NodeDB constants)
-NUM_MAX_EXCLUSIVE = 0x80000000  # restrict to positive int32 range for readability
-
-
-def _weighted_choice(rng: random.Random, weights: dict[str, float]) -> str:
-    """Deterministic weighted pick. Uses sorted keys so dict order is fixed."""
-    keys = sorted(weights.keys())
-    totals = [weights[k] for k in keys]
-    return rng.choices(keys, weights=totals, k=1)[0]
-
-
-def _gen_long_name(rng: random.Random, is_licensed: bool) -> str:
-    base = f"{rng.choice(FIRSTS)} {rng.choice(LASTS)}"
-    if is_licensed:
-        prefix = rng.choice(CALLSIGN_PREFIXES)
-        # Two trailing alpha chars after the digit; keep within 25 - len(base) - 1
-        suffix = f" {prefix}{rng.randint(0,9)}{rng.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ')}{rng.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ')}"
-        # nanopb max_size:25 means C string fits 24 bytes + NUL.
-        if len(base) + len(suffix) <= 24:
-            base = base + suffix
-    # Hard cap to 24 chars (nanopb max_size:25 minus NUL).
-    return base[:24]
-
-
-def _gen_short_name(rng: random.Random, long_name: str) -> str:
-    # 10% emoji-only short_name
-    if rng.random() < 0.10:
-        return rng.choice(EMOJI_SHORTNAMES)
-    first_char = long_name[0].upper() if long_name else "X"
-    alphanums = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-    return first_char + "".join(rng.choices(alphanums, k=3))
-
-
-def _gen_hops_away(rng: random.Random) -> int:
-    # Geometric-ish: 0→55%, 1→25%, 2→12%, 3→5%, 4→2%, 5+→1%
-    r = rng.random()
-    if r < 0.55:
-        return 0
-    if r < 0.80:
-        return 1
-    if r < 0.92:
-        return 2
-    if r < 0.97:
-        return 3
-    if r < 0.99:
-        return 4
-    return rng.randint(5, 7)
-
-
-def _gen_position(
-    rng: random.Random,
-    centroid_lat: float,
-    centroid_lon: float,
-    spread_km: float,
-    last_heard_offset_sec: int,
-) -> dict:
-    # 1 deg ≈ 111 km at the equator; we use this as a flat approximation.
-    lat = centroid_lat + rng.gauss(0.0, spread_km / 111.0)
-    lon = centroid_lon + rng.gauss(0.0, spread_km / 111.0)
-    altitude = max(0, round(rng.gauss(1376.0, 250.0)))  # T or C valley floor + relief
-    # Position was reported up to 300s before last_heard.
-    time_offset_sec = last_heard_offset_sec + rng.randint(0, 300)
-    return {
-        "latitude": round(lat, 6),
-        "longitude": round(lon, 6),
-        "altitude": altitude,
-        "time_offset_sec": time_offset_sec,
-        "location_source": "LOC_INTERNAL",
-    }
-
-
-def _gen_telemetry(rng: random.Random) -> dict:
-    # 5% plugged-in (battery_level == 101); rest uniform [10..100].
-    if rng.random() < 0.05:
-        battery_level = 101
-        voltage = 4.20
-    else:
-        battery_level = rng.randint(10, 100)
-        voltage = round(3.3 + (battery_level / 100.0) * 0.9, 3)
-    # Beta distributions for low/right-skewed metrics; randomly draw via gammavariate.
-    def _beta(a: float, b: float) -> float:
-        x = rng.gammavariate(a, 1.0)
-        y = rng.gammavariate(b, 1.0)
-        return x / (x + y)
-    channel_utilization = round(_beta(2.0, 15.0) * 100.0, 2)
-    air_util_tx = round(_beta(1.5, 20.0) * 10.0, 3)
-    uptime_seconds = int(rng.expovariate(1.0 / 86400.0))
-    return {
-        "battery_level": battery_level,
-        "voltage": voltage,
-        "channel_utilization": channel_utilization,
-        "air_util_tx": air_util_tx,
-        "uptime_seconds": uptime_seconds,
-    }
-
-
-def _gen_environment(rng: random.Random) -> dict:
-    return {
-        "temperature": round(rng.gauss(22.0, 8.0), 2),
-        "relative_humidity": round(min(100.0, max(0.0, rng.gauss(55.0, 20.0))), 2),
-        "barometric_pressure": round(rng.gauss(1013.0, 8.0), 2),
-        "iaq": int(min(500, max(0, round(rng.gauss(50.0, 30.0))))),
-    }
-
-
-def _gen_status(rng: random.Random) -> dict:
-    # `StatusMessage` (mesh.proto:1445) has a single free-form `string status`.
-    # Most peers report a healthy short status; occasional alert string.
-    healthy = ["OK", "online", "active", "running", "ready", "nominal"]
-    alert = ["low-batt", "no-gps", "weak-signal", "rebooted", "offline-soon"]
-    if rng.random() < 0.92:
-        return {"status": rng.choice(healthy)}
-    return {"status": rng.choice(alert)}
-
-
-def _gen_node(
-    rng: random.Random,
-    num: int,
-    centroid_lat: float,
-    centroid_lon: float,
-    spread_km: float,
-    coverage: dict[str, float],
-    last_heard_mean_sec: int,
-    last_heard_max_sec: int,
-) -> dict:
-    is_licensed = rng.random() < 0.05
-    long_name = _gen_long_name(rng, is_licensed)
-    short_name = _gen_short_name(rng, long_name)
-    hw_model = _weighted_choice(rng, HW_MODEL_WEIGHTS)
-    role = _weighted_choice(rng, ROLE_WEIGHTS)
-    has_public_key = rng.random() < 0.92
-    public_key_hex = (
-        "".join(f"{rng.randint(0,255):02x}" for _ in range(32)) if has_public_key else ""
-    )
-    snr = round(max(-20.0, min(12.0, rng.gauss(6.0, 4.0))), 2)
-    channel = 0 if rng.random() < 0.90 else rng.randint(1, 7)
-    hops_away = _gen_hops_away(rng)
-    next_hop = rng.randint(0, 255) if hops_away > 0 else 0
-    last_heard_offset_sec = int(min(rng.expovariate(1.0 / last_heard_mean_sec), last_heard_max_sec))
-
-    bitfield = {
-        "has_user": True,
-        "is_favorite": rng.random() < 0.08,
-        "is_muted": rng.random() < 0.03,
-        "via_mqtt": rng.random() < 0.12,
-        "is_ignored": rng.random() < 0.01,
-        "is_licensed": is_licensed,
-        "has_is_unmessagable": True,
-        "is_unmessagable": rng.random() < 0.02,
-        "is_key_manually_verified": rng.random() < 0.04,
-    }
-
-    node: dict = {
-        "num": f"0x{num:08x}",
-        "long_name": long_name,
-        "short_name": short_name,
-        "hw_model": hw_model,
-        "role": role,
-        "public_key_hex": public_key_hex,
-        "snr": snr,
-        "channel": channel,
-        "hops_away": hops_away,
-        "next_hop": next_hop,
-        "last_heard_offset_sec": last_heard_offset_sec,
-        "bitfield": bitfield,
-        "position": (
-            _gen_position(rng, centroid_lat, centroid_lon, spread_km, last_heard_offset_sec)
-            if rng.random() < coverage["position"]
-            else None
-        ),
-        "telemetry": _gen_telemetry(rng) if rng.random() < coverage["telemetry"] else None,
-        "environment": _gen_environment(rng) if rng.random() < coverage["environment"] else None,
-        "status": _gen_status(rng) if rng.random() < coverage["status"] else None,
-    }
-    return node
-
-
-def _parse_my_node_num(s: str | None) -> int | None:
-    if s is None:
-        return None
-    s = s.strip()
-    if s.startswith("0x") or s.startswith("0X"):
-        return int(s, 16)
-    return int(s)
-
-
-def main(argv: list[str]) -> int:
-    p = argparse.ArgumentParser(
-        description="Deterministic JSONL seed for the fake NodeDB fixture.",
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-    )
-    p.add_argument("--count", type=int, required=True, help="Number of fake nodes to emit.")
-    p.add_argument("--seed", type=int, required=True, help="Deterministic seed.")
-    p.add_argument("--out", required=True, help="Output JSONL path.")
-    p.add_argument(
-        "--centroid",
-        default="33.1284,-107.2528",
-        help="LAT,LON centroid (default: Truth or Consequences, NM).",
-    )
-    p.add_argument("--spread-km", type=float, default=60.0, help="Gaussian std-dev in km.")
-    p.add_argument("--position-coverage", type=float, default=0.85)
-    p.add_argument("--telemetry-coverage", type=float, default=0.70)
-    p.add_argument("--environment-coverage", type=float, default=0.25)
-    p.add_argument("--status-coverage", type=float, default=0.40)
-    p.add_argument("--my-node-num", default=None, help="Exclude this NodeNum from generated set (hex or dec).")
-    p.add_argument("--last-heard-mean-sec", type=int, default=3600)
-    p.add_argument("--last-heard-max-sec", type=int, default=7 * 86400)
-    args = p.parse_args(argv)
-
-    if args.count <= 0:
-        print("--count must be positive", file=sys.stderr)
-        return 2
-
-    try:
-        centroid_lat, centroid_lon = (float(s) for s in args.centroid.split(","))
-    except ValueError:
-        print(f"--centroid must be LAT,LON; got {args.centroid!r}", file=sys.stderr)
-        return 2
-
-    my_node_num = _parse_my_node_num(args.my_node_num)
-
-    rng = random.Random(args.seed)
-
-    # 1) Generate a unique deterministic set of NodeNums.
-    nums: set[int] = set()
-    while len(nums) < args.count:
-        n = rng.randrange(NUM_RESERVED, NUM_MAX_EXCLUSIVE)
-        if my_node_num is not None and n == my_node_num:
-            continue
-        nums.add(n)
-    ordered_nums = sorted(nums)  # sort to fix output order independent of set hash
-
-    # 2) Per-node generation (in num order, single RNG continues).
-    coverage = {
-        "position": args.position_coverage,
-        "telemetry": args.telemetry_coverage,
-        "environment": args.environment_coverage,
-        "status": args.status_coverage,
-    }
-    nodes = [
-        _gen_node(
-            rng,
-            n,
-            centroid_lat,
-            centroid_lon,
-            args.spread_km,
-            coverage,
-            args.last_heard_mean_sec,
-            args.last_heard_max_sec,
-        )
-        for n in ordered_nums
-    ]
-
-    # 3) Write JSONL.
-    out_path = pathlib.Path(args.out)
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    # `generated_at_iso` is informational; it does NOT affect determinism because
-    # we derive it from the seed, not from wall clock. (Same seed -> same string.)
-    generated_at = _dt.datetime.fromtimestamp(args.seed, tz=_dt.timezone.utc).isoformat().replace("+00:00", "Z")
-    meta = {
-        "_meta": {
-            "version": 25,
-            "seed": args.seed,
-            "count": args.count,
-            "centroid": [centroid_lat, centroid_lon],
-            "spread_km": args.spread_km,
-            "generated_at_iso": generated_at,
-            "my_node_num_excluded": (None if my_node_num is None else f"0x{my_node_num:08x}"),
-            "coverage": coverage,
-            "last_heard_mean_sec": args.last_heard_mean_sec,
-            "last_heard_max_sec": args.last_heard_max_sec,
-        }
-    }
-    with out_path.open("w", encoding="utf-8") as f:
-        # `ensure_ascii=False` so emoji short_names survive. `sort_keys=True` for
-        # determinism (insertion order varies by Python version otherwise).
-        f.write(json.dumps(meta, ensure_ascii=False, sort_keys=True) + "\n")
-        for node in nodes:
-            f.write(json.dumps(node, ensure_ascii=False, sort_keys=True) + "\n")
-
-    print(f"wrote {args.count} nodes to {out_path} ({out_path.stat().st_size} bytes)", file=sys.stderr)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))

bin/org.meshtastic.meshtasticd.metainfo.xml

@@ -87,6 +87,12 @@
   </screenshots>
 
   <releases>
+    <release version="2.7.26" date="2026-06-10">
+      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.26</url>
+    </release>
+    <release version="2.7.25" date="2026-05-23">
+      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.25</url>
+    </release>
     <release version="2.7.24" date="2026-05-08">
       <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.24</url>
     </release>

bin/platformio-custom.py

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

bin/regen-fake-nodedbs.sh

@@ -1,73 +0,0 @@
-#!/usr/bin/env bash
-# Regenerate the fake-NodeDB fixtures: produces 250 / 500 / 1000 / 2000-node
-# JSONL seed files + their compiled v25 protobufs.
-#
-# Layout:
-#   test/fixtures/nodedb/seed_v25_<N>.jsonl   — COMMITTED, hand-editable.
-#   build/fixtures/nodedb/nodes_v25_<N>.proto — .gitignored, build artifact.
-#                                               Drop into /prefs/nodes.proto.
-#
-# Daily use:  ./bin/regen-fake-nodedbs.sh
-#   - Recompiles protos from committed seeds (fresh wall-clock timestamps).
-# Intentional seed bump:  REGEN_SEEDS=yes ./bin/regen-fake-nodedbs.sh
-#   - Overwrites the committed JSONL files with freshly-seeded data.
-
-set -euo pipefail
-cd "$(dirname "$0")/.."
-
-# 1) Make sure the Python protobuf bindings exist (in-tree generation; .gitignored).
-if [[ ! -d bin/_generated/meshtastic ]]; then
-    echo "regenerating Python protobuf bindings (one-time)..."
-    ./bin/regen-py-protos.sh
-fi
-
-# 2) Pick a Python interpreter that has the meshtastic deps installed.
-#    Prefer the mcp-server venv (most likely to be set up by the operator).
-PY="python3"
-for cand in mcp-server/.venv/bin/python3 .venv/bin/python3; do
-    if [[ -x "$cand" ]]; then
-        PY="$cand"
-        break
-    fi
-done
-
-# 3) Pinned seeds per size — bump only when you intentionally want different
-#    structural data committed. Parallel arrays so the script works on
-#    macOS bash 3.2 (no `declare -A`).
-SIZES=(250 500 1000 2000)
-SEEDS=(20260511 20260512 20260513 20260514)
-
-REGEN_SEEDS="${REGEN_SEEDS:-no}"
-
-mkdir -p build/fixtures/nodedb test/fixtures/nodedb
-
-for i in 0 1 2 3; do
-    n="${SIZES[$i]}"
-    seed="${SEEDS[$i]}"
-    jsonl=$(printf "test/fixtures/nodedb/seed_v25_%04d.jsonl" "$n")
-    proto=$(printf "build/fixtures/nodedb/nodes_v25_%04d.proto" "$n")
-
-    if [[ "$REGEN_SEEDS" == "yes" || ! -f "$jsonl" ]]; then
-        $PY bin/gen-fake-nodedb-seed.py \
-            --count "$n" \
-            --seed "$seed" \
-            --out "$jsonl" \
-            --centroid 33.1284,-107.2528 \
-            --spread-km 60 \
-            --position-coverage 0.85 \
-            --telemetry-coverage 0.70 \
-            --environment-coverage 0.25 \
-            --status-coverage 0.40
-        echo "  seed:   $jsonl ($(wc -c < "$jsonl") bytes)"
-    fi
-
-    $PY bin/seed-json-to-proto.py --in "$jsonl" --out "$proto"
-    echo "  proto:  $proto ($(wc -c < "$proto") bytes)"
-done
-
-echo ""
-echo "Done. To load on Portduino native:"
-echo "  cp build/fixtures/nodedb/nodes_v25_1000.proto ~/.portduino/default/prefs/nodes.proto"
-echo ""
-echo "To push to a hardware device:"
-echo "  Use the mcp-server tool: push_fake_nodedb(size=1000, target=\"hardware\", port=\"/dev/cu.usbmodemXXXX\", confirm=True)"

bin/regen-py-protos.sh

@@ -1,51 +0,0 @@
-#!/usr/bin/env bash
-# Regenerate Python protobuf bindings from the in-tree `protobufs/` submodule
-# into `bin/_generated/`. Called by bin/regen-fake-nodedbs.sh; also useful as
-# a standalone refresh after any change to a .proto file.
-#
-# Output is .gitignored — bindings are a build artifact.
-#
-# Namespace rewrite:
-# The .proto files declare `package meshtastic;`, which makes protoc emit
-# imports like `from meshtastic import mesh_pb2`. That conflicts with the
-# PyPI `meshtastic` package (which the mcp-server relies on for its
-# SerialInterface/BLEInterface transport). We post-process the generated
-# files to live under `meshtastic_v25` instead — both the directory layout
-# and all internal imports — so they coexist cleanly with the PyPI package.
-
-set -euo pipefail
-cd "$(dirname "$0")/.."
-
-if ! command -v protoc >/dev/null 2>&1; then
-    echo "ERROR: protoc not found in PATH." >&2
-    echo "  macOS: brew install protobuf" >&2
-    echo "  Ubuntu/Debian: apt install protobuf-compiler" >&2
-    exit 1
-fi
-
-OUT=bin/_generated
-LOCAL_NS=meshtastic_v25
-
-rm -rf "$OUT"
-mkdir -p "$OUT"
-
-# 1) Generate from the in-tree protos. nanopb.proto first so its descriptor
-#    is available for the [(nanopb).*] options on other messages.
-protoc \
-    --proto_path=protobufs \
-    --python_out="$OUT" \
-    protobufs/nanopb.proto \
-    protobufs/meshtastic/*.proto
-
-# 2) Move the generated `meshtastic/` directory to `meshtastic_v25/`.
-mv "$OUT/meshtastic" "$OUT/$LOCAL_NS"
-
-# 3) Rewrite internal imports: any reference to `meshtastic.X_pb2` or
-#    `from meshtastic import X_pb2` becomes `meshtastic_v25.*`.
-python3 bin/_rewrite_proto_namespace.py "$OUT/$LOCAL_NS" "$LOCAL_NS"
-
-# 4) Make the package importable.
-touch "$OUT/__init__.py"
-touch "$OUT/$LOCAL_NS/__init__.py"
-
-echo "regenerated Python protobuf bindings -> $OUT/$LOCAL_NS/ (namespace: $LOCAL_NS)" >&2

bin/seed-json-to-proto.py

@@ -1,342 +0,0 @@
-#!/usr/bin/env python3
-"""Compile a committed seed JSONL into a binary meshtastic_NodeDatabase v25 proto.
-
-The input is produced by `bin/gen-fake-nodedb-seed.py`. Timestamps in the JSONL
-are stored as `*_offset_sec` (seconds before "now"); this script resolves them
-to absolute epochs using `--now-epoch` (default: current wall clock).
-
-Output is a raw `pb_encode`-compatible binary that can be dropped at
-`/prefs/nodes.proto` on the device (Portduino prefs dir or hardware via
-XModem) and loaded by `NodeDB::loadFromDisk` at boot.
-
-Wire format reference:
-  protobufs/meshtastic/deviceonly.proto  (NodeDatabase, NodeInfoLite, sat entries)
-  src/mesh/NodeDB.h:467-484              (bitfield bit positions)
-  src/mesh/NodeDB.cpp:1523-1524          (pb_decode entry point)
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import pathlib
-import sys
-import time
-from typing import Any
-
-# Prefer the in-tree generated Python protobuf bindings (bin/_generated/meshtastic_v25/)
-# because the firmware branch's protos (v25 NodeDatabase satellite arrays, slim
-# NodeInfoLite) are typically newer than what the PyPI `meshtastic` package
-# ships. Run `bin/regen-py-protos.sh` to (re)generate.
-#
-# Namespace note: the local bindings live under `meshtastic_v25` (NOT `meshtastic`)
-# to avoid shadowing the PyPI `meshtastic` package — bin/regen-py-protos.sh
-# post-processes the protoc output to rename the package.
-_HERE = pathlib.Path(__file__).resolve().parent
-_LOCAL_PROTO_DIR = _HERE / "_generated"
-if _LOCAL_PROTO_DIR.is_dir():
-    sys.path.insert(0, str(_LOCAL_PROTO_DIR))
-
-try:
-    from meshtastic_v25.deviceonly_pb2 import (  # type: ignore[import-not-found]
-        NodeDatabase,
-        NodeInfoLite,
-        NodePositionEntry,
-        NodeTelemetryEntry,
-        NodeEnvironmentEntry,
-        NodeStatusEntry,
-        PositionLite,
-    )
-    from meshtastic_v25.mesh_pb2 import HardwareModel, Position, StatusMessage  # type: ignore[import-not-found]
-    from meshtastic_v25.config_pb2 import Config  # type: ignore[import-not-found]
-    from meshtastic_v25.telemetry_pb2 import DeviceMetrics, EnvironmentMetrics  # type: ignore[import-not-found]
-except ImportError as local_err:
-    # Fall back to the PyPI package if in-tree bindings haven't been generated.
-    # Will fail the v25 assertion below if the PyPI package predates the
-    # satellite-DB schema, but at least gives a clear "run regen-py-protos.sh"
-    # error message instead of an opaque ImportError.
-    try:
-        from meshtastic.protobuf.deviceonly_pb2 import (
-            NodeDatabase,
-            NodeInfoLite,
-            NodePositionEntry,
-            NodeTelemetryEntry,
-            NodeEnvironmentEntry,
-            NodeStatusEntry,
-            PositionLite,
-        )
-        from meshtastic.protobuf.mesh_pb2 import HardwareModel, Position, StatusMessage
-        from meshtastic.protobuf.config_pb2 import Config
-        from meshtastic.protobuf.telemetry_pb2 import DeviceMetrics, EnvironmentMetrics
-    except ImportError as pypi_err:
-        print(
-            "ERROR: could not import meshtastic protobuf bindings.\n"
-            "  In-tree generation: run `bin/regen-py-protos.sh` (requires protoc).\n"
-            "  PyPI fallback: `pip install meshtastic` (may lag firmware branch).\n"
-            f"  local error (meshtastic_v25): {local_err}\n"
-            f"  pypi error  (meshtastic.protobuf): {pypi_err}",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-# Fail loudly if bindings predate v25 (no satellite arrays).
-assert (
-    hasattr(NodeDatabase, "DESCRIPTOR")
-    and "positions" in NodeDatabase.DESCRIPTOR.fields_by_name
-), (
-    "Loaded meshtastic bindings are older than v25 (NodeDatabase.positions missing). "
-    "Run `bin/regen-py-protos.sh` against the in-tree protobufs/ submodule."
-)
-
-# ---------------------------------------------------------------------------
-# Bitfield bit positions (mirror src/mesh/NodeDB.h:467-484).
-# ---------------------------------------------------------------------------
-BIT_IS_KEY_MANUALLY_VERIFIED = 0
-BIT_IS_MUTED = 1
-BIT_VIA_MQTT = 2
-BIT_IS_FAVORITE = 3
-BIT_IS_IGNORED = 4
-BIT_HAS_USER = 5
-BIT_IS_LICENSED = 6
-BIT_IS_UNMESSAGABLE = 7
-BIT_HAS_IS_UNMESSAGABLE = 8
-
-BITFIELD_LAYOUT = (
-    # JSON key            bit position
-    ("is_key_manually_verified", BIT_IS_KEY_MANUALLY_VERIFIED),
-    ("is_muted", BIT_IS_MUTED),
-    ("via_mqtt", BIT_VIA_MQTT),
-    ("is_favorite", BIT_IS_FAVORITE),
-    ("is_ignored", BIT_IS_IGNORED),
-    ("has_user", BIT_HAS_USER),
-    ("is_licensed", BIT_IS_LICENSED),
-    ("is_unmessagable", BIT_IS_UNMESSAGABLE),
-    ("has_is_unmessagable", BIT_HAS_IS_UNMESSAGABLE),
-)
-
-
-def _pack_bitfield(bf: dict[str, bool]) -> int:
-    out = 0
-    for key, shift in BITFIELD_LAYOUT:
-        if bf.get(key, False):
-            out |= (1 << shift)
-    return out
-
-
-def _validate_node(node: dict[str, Any]) -> None:
-    """Friendly errors so hand-editors get clear feedback."""
-    if "num" not in node or not isinstance(node["num"], str):
-        raise ValueError(f"node missing/invalid 'num' (must be hex string): {node!r}")
-    if "long_name" not in node:
-        raise ValueError(f"node {node['num']}: missing 'long_name'")
-    if len(node["long_name"]) > 24:
-        raise ValueError(
-            f"node {node['num']}: long_name {node['long_name']!r} is "
-            f"{len(node['long_name'])} chars; max 24 (nanopb max_size:25 minus NUL)"
-        )
-    if "short_name" in node:
-        # short_name max_size:5 (incl. NUL) → 4 bytes of content.
-        # Char count is irrelevant — emojis with variation selectors (e.g. ❄️ = 6 B)
-        # would slip past a `len(str) > 4` check. Always measure bytes.
-        b = node["short_name"].encode("utf-8")
-        if len(b) > 4:
-            raise ValueError(
-                f"node {node['num']}: short_name {node['short_name']!r} is "
-                f"{len(b)} bytes UTF-8; max 4 (nanopb max_size:5 minus NUL)"
-            )
-    pk = node.get("public_key_hex", "")
-    if pk and len(pk) != 64:
-        raise ValueError(
-            f"node {node['num']}: public_key_hex must be 64 hex chars or empty; "
-            f"got {len(pk)} chars"
-        )
-    if pk:
-        try:
-            bytes.fromhex(pk)
-        except ValueError as e:
-            raise ValueError(f"node {node['num']}: public_key_hex is not valid hex: {e}")
-
-
-def _resolve_time(
-    node: dict[str, Any],
-    field_absolute: str,
-    field_offset: str,
-    now_epoch: int,
-) -> int:
-    """If `field_absolute` is set, use it; else compute `now_epoch - offset`."""
-    if field_absolute in node and node[field_absolute] is not None:
-        return int(node[field_absolute])
-    offset = node.get(field_offset, 0)
-    return max(0, int(now_epoch) - int(offset))
-
-
-def _build_node_info_lite(node: dict[str, Any], now_epoch: int) -> NodeInfoLite:
-    _validate_node(node)
-    info = NodeInfoLite()
-    info.num = int(node["num"], 16) if isinstance(node["num"], str) else int(node["num"])
-    info.long_name = node.get("long_name", "")
-    info.short_name = node.get("short_name", "")
-    # Enum lookups will raise ValueError on unknown names — that's exactly what we want.
-    info.hw_model = HardwareModel.Value(node.get("hw_model", "UNSET"))
-    info.role = Config.DeviceConfig.Role.Value(node.get("role", "CLIENT"))
-    pk_hex = node.get("public_key_hex", "")
-    if pk_hex:
-        info.public_key = bytes.fromhex(pk_hex)
-    info.snr = float(node.get("snr", 0.0))
-    info.channel = int(node.get("channel", 0))
-    if "hops_away" in node:
-        # `optional uint32 hops_away = 9;` — in Python protobuf, assigning the
-        # field implicitly sets HasField("hops_away") to True. No has_hops_away
-        # setter exists (unlike the C++ nanopb-generated header).
-        info.hops_away = int(node["hops_away"])
-    info.next_hop = int(node.get("next_hop", 0))
-    info.last_heard = _resolve_time(node, "last_heard", "last_heard_offset_sec", now_epoch)
-    info.bitfield = _pack_bitfield(node.get("bitfield", {}))
-    return info
-
-
-def _build_position_entry(num: int, pos: dict[str, Any], now_epoch: int) -> NodePositionEntry:
-    entry = NodePositionEntry()
-    entry.num = num
-    pl = PositionLite()
-    # Firmware stores lat/long as int32 in 1e-7 degrees.
-    pl.latitude_i = int(round(float(pos["latitude"]) * 1e7))
-    pl.longitude_i = int(round(float(pos["longitude"]) * 1e7))
-    pl.altitude = int(pos.get("altitude", 0))
-    pl.time = _resolve_time(pos, "time", "time_offset_sec", now_epoch)
-    pl.location_source = Position.LocSource.Value(pos.get("location_source", "LOC_UNSET"))
-    entry.position.CopyFrom(pl)
-    return entry
-
-
-def _build_telemetry_entry(num: int, tel: dict[str, Any]) -> NodeTelemetryEntry:
-    entry = NodeTelemetryEntry()
-    entry.num = num
-    dm = DeviceMetrics()
-    if "battery_level" in tel:
-        dm.battery_level = int(tel["battery_level"])
-    if "voltage" in tel:
-        dm.voltage = float(tel["voltage"])
-    if "channel_utilization" in tel:
-        dm.channel_utilization = float(tel["channel_utilization"])
-    if "air_util_tx" in tel:
-        dm.air_util_tx = float(tel["air_util_tx"])
-    if "uptime_seconds" in tel:
-        dm.uptime_seconds = int(tel["uptime_seconds"])
-    entry.device_metrics.CopyFrom(dm)
-    return entry
-
-
-def _build_environment_entry(num: int, env: dict[str, Any]) -> NodeEnvironmentEntry:
-    entry = NodeEnvironmentEntry()
-    entry.num = num
-    em = EnvironmentMetrics()
-    if "temperature" in env:
-        em.temperature = float(env["temperature"])
-    if "relative_humidity" in env:
-        em.relative_humidity = float(env["relative_humidity"])
-    if "barometric_pressure" in env:
-        em.barometric_pressure = float(env["barometric_pressure"])
-    if "iaq" in env:
-        em.iaq = int(env["iaq"])
-    entry.environment_metrics.CopyFrom(em)
-    return entry
-
-
-def _build_status_entry(num: int, status: dict[str, Any]) -> NodeStatusEntry:
-    # `StatusMessage` (mesh.proto:1445) has a single `string status` field.
-    entry = NodeStatusEntry()
-    entry.num = num
-    sm = StatusMessage()
-    if "status" in status:
-        sm.status = str(status["status"])
-    entry.status.CopyFrom(sm)
-    return entry
-
-
-def compile_jsonl_to_proto(jsonl_path: pathlib.Path, now_epoch: int) -> bytes:
-    """Read a seed JSONL and return the encoded NodeDatabase bytes."""
-    lines = jsonl_path.read_text(encoding="utf-8").splitlines()
-    if not lines:
-        raise ValueError(f"{jsonl_path} is empty")
-    meta_line = lines[0]
-    meta_obj = json.loads(meta_line)
-    meta = meta_obj.get("_meta", {})
-    version = meta.get("version")
-    if version != 25:
-        raise ValueError(
-            f"{jsonl_path}: meta version is {version!r}; this compiler "
-            f"requires version=25. Regenerate the seed with the matching tooling."
-        )
-
-    db = NodeDatabase()
-    db.version = 25
-
-    for ln, raw in enumerate(lines[1:], start=2):
-        raw = raw.strip()
-        if not raw:
-            continue
-        try:
-            node = json.loads(raw)
-        except json.JSONDecodeError as e:
-            raise ValueError(f"{jsonl_path}:{ln} JSON parse error: {e}")
-
-        num = int(node["num"], 16) if isinstance(node["num"], str) else int(node["num"])
-
-        # Header
-        info = _build_node_info_lite(node, now_epoch)
-        db.nodes.append(info)
-
-        # Satellites (nullable)
-        if node.get("position"):
-            db.positions.append(_build_position_entry(num, node["position"], now_epoch))
-        if node.get("telemetry"):
-            db.telemetry.append(_build_telemetry_entry(num, node["telemetry"]))
-        if node.get("environment"):
-            db.environment.append(_build_environment_entry(num, node["environment"]))
-        if node.get("status"):
-            db.status.append(_build_status_entry(num, node["status"]))
-
-    return db.SerializeToString()
-
-
-def main(argv: list[str]) -> int:
-    p = argparse.ArgumentParser(
-        description="Compile a seed JSONL into a binary v25 NodeDatabase proto.",
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-    )
-    p.add_argument("--in", dest="in_path", required=True, help="Input seed JSONL.")
-    p.add_argument("--out", required=True, help="Output binary .proto path.")
-    p.add_argument(
-        "--now-epoch",
-        type=int,
-        default=None,
-        help="Pin 'now' to this Unix epoch (for byte-identical CI). Default: time.time().",
-    )
-    args = p.parse_args(argv)
-
-    in_path = pathlib.Path(args.in_path)
-    if not in_path.is_file():
-        print(f"input not found: {in_path}", file=sys.stderr)
-        return 2
-
-    now_epoch = args.now_epoch if args.now_epoch is not None else int(time.time())
-
-    try:
-        encoded = compile_jsonl_to_proto(in_path, now_epoch)
-    except ValueError as e:
-        print(f"ERROR: {e}", file=sys.stderr)
-        return 3
-
-    out_path = pathlib.Path(args.out)
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    out_path.write_bytes(encoded)
-    print(
-        f"compiled {in_path} -> {out_path} ({len(encoded)} bytes, now_epoch={now_epoch})",
-        file=sys.stderr,
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))

bin/shame.py

@@ -0,0 +1,95 @@
+import sys
+import os
+import json
+from github import Github
+
+def parseFile(path):
+    with open(path, "r") as f:
+        data = json.loads(f)
+    for file in data["files"]:
+        if file["name"].endswith(".bin"):
+            return file["name"], file["bytes"]
+
+if len(sys.argv) != 4:
+    print(f"expected usage: {sys.argv[0]} <PR number> <path to old-manifests> <path to new-manifests>")
+    sys.exit(1)
+
+pr_number = int(sys.argv[1])
+
+token = os.getenv("GITHUB_TOKEN")
+if not token:
+    raise EnvironmentError("GITHUB_TOKEN not found in environment.")
+
+repo_name = os.getenv("GITHUB_REPOSITORY")  # "owner/repo"
+if not repo_name:
+    raise EnvironmentError("GITHUB_REPOSITORY not found in environment.")
+
+oldFiles = sys.argv[2]
+old = set(os.path.join(oldFiles, f) for f in os.listdir(oldFiles) if os.path.isfile(f))
+newFiles = sys.argv[3]
+new = set(os.path.join(newFiles, f) for f in os.listdir(newFiles) if os.path.isfile(f))
+
+startMarkdown = "# Target Size Changes\n\n"
+markdown = ""
+
+newlyIntroduced = new - old
+if len(newlyIntroduced) > 0:
+    markdown += "## Newly Introduced Targets\n\n"
+    # create a table
+    markdown += "| File | Size |\n"
+    markdown += "| ---- | ---- |\n"
+    for f in newlyIntroduced:
+        name, size = parseFile(f)
+        markdown += f"| `{name}` | {size}b |\n"
+
+# do not log removed targets
+# PRs only run a small subset of builds, so removed targets are not meaningful
+# since they are very likely to just be not ran in PR CI
+
+both = old & new
+degradations = []
+improvements = []
+for f in both:
+    oldName, oldSize = parseFile(f)
+    _, newSize = parseFile(f)
+    if oldSize != newSize:
+        if newSize < oldSize:
+            improvements.append((oldName, oldSize, newSize))
+        else:
+            degradations.append((oldName, oldSize, newSize))
+
+if len(degradations) > 0:
+    markdown += "\n## Degradation\n\n"
+    # create a table
+    markdown += "| File | Difference | Old Size | New Size |\n"
+    markdown += "| ---- | ---------- | -------- | -------- |\n"
+    for oldName, oldSize, newSize in degradations:
+        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
+
+if len(improvements) > 0:
+    markdown += "\n## Improvement\n\n"
+    # create a table
+    markdown += "| File | Difference | Old Size | New Size |\n"
+    markdown += "| ---- | ---------- | -------- | -------- |\n"
+    for oldName, oldSize, newSize in improvements:
+        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
+
+if len(markdown) == 0:
+    markdown = "No changes in target sizes detected."
+
+g = Github(token)
+repo = g.get_repo(repo_name)
+pr = repo.get_pull(pr_number)
+
+existing_comment = None
+for comment in pr.get_issue_comments():
+    if comment.body.startswith(startMarkdown):
+        existing_comment = comment
+        break
+
+final_markdown = startMarkdown + markdown
+
+if existing_comment:
+    existing_comment.edit(body=final_markdown)
+else:
+    pr.create_issue_comment(body=final_markdown)

bin/size_report.py

@@ -1,171 +0,0 @@
-#!/usr/bin/env python3
-
-"""Compare firmware size reports and generate a markdown summary.
-
-Usage:
-    size_report.py <new_sizes.json> [--baseline <label>:<old_sizes.json>]...
-
-Examples:
-    # Compare PR against develop and master baselines
-    size_report.py pr.json --baseline develop:develop.json --baseline master:master.json
-
-    # Single baseline comparison
-    size_report.py pr.json --baseline develop:develop.json
-
-    # No baselines — shows sizes with blank delta columns
-    size_report.py pr.json
-"""
-
-import argparse
-import json
-import sys
-
-
-def load_sizes(path):
-    with open(path) as f:
-        return json.load(f)
-
-
-def format_delta(n):
-    """Format byte delta with sign and human-friendly suffix."""
-    sign = "+" if n > 0 else ""
-    if abs(n) >= 1024:
-        return f"{sign}{n:,} ({sign}{n / 1024:.1f} KB)"
-    return f"{sign}{n:,}"
-
-
-def generate_markdown(new_sizes, baselines, top_n=5):
-    """Generate a single table with current size and delta columns per baseline.
-
-    baselines: list of (label, old_sizes_dict), may be empty
-    """
-    labels = [label for label, _ in baselines]
-
-    # Build rows: (board, current_size, [(delta, abs_delta) per baseline])
-    rows = []
-    for board in sorted(new_sizes):
-        current = new_sizes[board]
-        deltas = []
-        for _, old_sizes in baselines:
-            old = old_sizes.get(board)
-            if old is not None:
-                d = current - old
-                deltas.append((d, abs(d)))
-            else:
-                deltas.append((None, 0))
-        # Sort key: max abs delta across baselines (biggest changes first)
-        max_abs = max((ad for _, ad in deltas), default=0)
-        rows.append((board, current, deltas, max_abs))
-
-    rows.sort(key=lambda r: r[3], reverse=True)
-
-    # Summary line
-    sections = []
-    summary_parts = [f"{len(new_sizes)} targets"]
-    for i, (label, old_sizes) in enumerate(baselines):
-        increases = sum(
-            1 for _, _, deltas, _ in rows if deltas[i][0] is not None and deltas[i][0] > 0
-        )
-        decreases = sum(
-            1 for _, _, deltas, _ in rows if deltas[i][0] is not None and deltas[i][0] < 0
-        )
-        net = sum(
-            deltas[i][0] for _, _, deltas, _ in rows if deltas[i][0] is not None
-        )
-        parts = []
-        if increases:
-            parts.append(f"{increases} increased")
-        if decreases:
-            parts.append(f"{decreases} decreased")
-        if parts:
-            parts.append(f"net {format_delta(net)}")
-            summary_parts.append(f"vs `{label}`: {', '.join(parts)}")
-        else:
-            summary_parts.append(f"vs `{label}`: no changes")
-
-    if not baselines:
-        summary_parts.append("no baseline available yet")
-
-    sections.append(f"**{' | '.join(summary_parts)}**\n")
-
-    # Table header
-    header = "| Target | Size |"
-    separator = "|--------|-----:|"
-    for label in labels:
-        header += f" vs `{label}` |"
-        separator += "----------:|"
-    sections.append(header)
-    sections.append(separator)
-
-    def format_row(board, current, deltas):
-        row = f"| `{board}` | {current:,} |"
-        for d, _ in deltas:
-            if d is None:
-                row += " |"
-            elif d == 0:
-                row += " 0 |"
-            else:
-                icon = "📈" if d > 0 else "📉"
-                row += f" {icon} {format_delta(d)} |"
-        return row
-
-    # Top N rows always visible
-    top = rows[:top_n]
-    for board, current, deltas, _ in top:
-        sections.append(format_row(board, current, deltas))
-
-    # Remaining rows in expandable section
-    rest = rows[top_n:]
-    if rest:
-        sections.append("")
-        sections.append(
-            f"<details><summary>Show {len(rest)} more target(s)</summary>\n"
-        )
-        sections.append(header)
-        sections.append(separator)
-        for board, current, deltas, _ in rest:
-            sections.append(format_row(board, current, deltas))
-        sections.append("\n</details>")
-
-    sections.append("")
-    return "\n".join(sections)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Compare firmware size reports")
-    parser.add_argument("new_sizes", help="Path to new sizes JSON")
-    parser.add_argument(
-        "--baseline",
-        action="append",
-        default=[],
-        metavar="LABEL:PATH",
-        help="Baseline to compare against (e.g. develop:develop.json)",
-    )
-    parser.add_argument(
-        "--top",
-        type=int,
-        default=5,
-        help="Number of top changes to show before collapsing (default: 5)",
-    )
-    args = parser.parse_args()
-
-    new_sizes = load_sizes(args.new_sizes)
-
-    # Silence output when no targets were built — repo maintainer choice
-    if not new_sizes:
-        return
-
-    baselines = []
-    for b in args.baseline:
-        if ":" not in b:
-            print(f"Error: baseline must be LABEL:PATH, got '{b}'", file=sys.stderr)
-            sys.exit(1)
-        label, path = b.split(":", 1)
-        baselines.append((label, load_sizes(path)))
-
-    md = generate_markdown(new_sizes, baselines, top_n=args.top)
-    print(md)
-
-
-if __name__ == "__main__":
-    main()

bin/test_size_scripts.py

@@ -1,262 +0,0 @@
-#!/usr/bin/env python3
-
-"""Tests for bin/collect_sizes.py and bin/size_report.py."""
-
-import json
-import os
-import subprocess
-import sys
-import tempfile
-
-SCRIPTS_DIR = os.path.join(os.path.dirname(__file__), "..", "bin")
-
-
-def make_manifest(target, firmware_bytes, extra_files=None):
-    """Create a minimal .mt.json manifest dict."""
-    files = [{"name": f"firmware-{target}-2.6.0.bin", "bytes": firmware_bytes}]
-    if extra_files:
-        files.extend(extra_files)
-    return {
-        "platformioTarget": target,
-        "version": "2.6.0.test",
-        "files": files,
-    }
-
-
-def write_manifests(tmpdir, manifests):
-    """Write manifest dicts as .mt.json files into tmpdir."""
-    for target, data in manifests.items():
-        path = os.path.join(tmpdir, f"firmware-{target}.mt.json")
-        with open(path, "w") as f:
-            json.dump(data, f)
-
-
-def run_script(script, args):
-    """Run a Python script and return (returncode, stdout, stderr)."""
-    result = subprocess.run(
-        [sys.executable, os.path.join(SCRIPTS_DIR, script)] + args,
-        capture_output=True,
-        text=True,
-    )
-    return result.returncode, result.stdout, result.stderr
-
-
-def test_collect_sizes_basic():
-    """collect_sizes picks up firmware-*.bin entries from manifests."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        outfile = os.path.join(tmpdir, "sizes.json")
-        manifests = {
-            "heltec-v3": make_manifest("heltec-v3", 1048576),
-            "rak4631": make_manifest("rak4631", 524288),
-            "tbeam": make_manifest("tbeam", 786432),
-        }
-        write_manifests(tmpdir, manifests)
-
-        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
-        assert rc == 0, f"collect_sizes failed: {stderr}"
-        assert "3 targets" in stdout
-
-        with open(outfile) as f:
-            sizes = json.load(f)
-        assert sizes == {"heltec-v3": 1048576, "rak4631": 524288, "tbeam": 786432}
-
-
-def test_collect_sizes_fallback_bin():
-    """collect_sizes falls back to non-firmware-prefixed .bin if no firmware-*.bin."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        outfile = os.path.join(tmpdir, "sizes.json")
-        # Manifest with only a generic .bin (no firmware- prefix)
-        data = {
-            "platformioTarget": "custom-board",
-            "files": [
-                {"name": "littlefs-custom-board.bin", "bytes": 100000},
-                {"name": "custom-board.bin", "bytes": 500000},
-            ],
-        }
-        path = os.path.join(tmpdir, "firmware-custom-board.mt.json")
-        with open(path, "w") as f:
-            json.dump(data, f)
-
-        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
-        assert rc == 0, f"collect_sizes failed: {stderr}"
-
-        with open(outfile) as f:
-            sizes = json.load(f)
-        assert sizes == {"custom-board": 500000}
-
-
-def test_collect_sizes_skips_ota_littlefs():
-    """collect_sizes ignores ota/littlefs/bleota .bin files in fallback."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        outfile = os.path.join(tmpdir, "sizes.json")
-        data = {
-            "platformioTarget": "board-x",
-            "files": [
-                {"name": "littlefs-board-x.bin", "bytes": 100000},
-                {"name": "bleota-board-x.bin", "bytes": 50000},
-                {"name": "mt-board-x-ota.bin", "bytes": 60000},
-            ],
-        }
-        path = os.path.join(tmpdir, "firmware-board-x.mt.json")
-        with open(path, "w") as f:
-            json.dump(data, f)
-
-        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
-        assert rc == 0
-        with open(outfile) as f:
-            sizes = json.load(f)
-        # No valid firmware .bin found, board should be absent
-        assert sizes == {}
-
-
-def test_collect_sizes_ignores_non_mt_json():
-    """collect_sizes skips non .mt.json files."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        outfile = os.path.join(tmpdir, "sizes.json")
-        # Write a valid manifest
-        manifests = {"rak4631": make_manifest("rak4631", 500000)}
-        write_manifests(tmpdir, manifests)
-        # Write a decoy file
-        with open(os.path.join(tmpdir, "readme.txt"), "w") as f:
-            f.write("not a manifest")
-
-        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
-        assert rc == 0
-        with open(outfile) as f:
-            sizes = json.load(f)
-        assert list(sizes.keys()) == ["rak4631"]
-
-
-def test_size_report_no_baseline():
-    """size_report with no baselines shows sizes only."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sizes_file = os.path.join(tmpdir, "new.json")
-        with open(sizes_file, "w") as f:
-            json.dump({"heltec-v3": 1000000, "rak4631": 500000}, f)
-
-        rc, stdout, stderr = run_script("size_report.py", [sizes_file])
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "2 targets" in stdout
-        assert "no baseline available yet" in stdout
-        assert "`heltec-v3`" in stdout
-        assert "`rak4631`" in stdout
-
-
-def test_size_report_with_baseline():
-    """size_report shows deltas against a baseline."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        new_file = os.path.join(tmpdir, "new.json")
-        old_file = os.path.join(tmpdir, "old.json")
-        with open(new_file, "w") as f:
-            json.dump({"heltec-v3": 1050000, "rak4631": 500000, "tbeam": 800000}, f)
-        with open(old_file, "w") as f:
-            json.dump({"heltec-v3": 1000000, "rak4631": 500000, "tbeam": 810000}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py", [new_file, "--baseline", f"develop:{old_file}"]
-        )
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "3 targets" in stdout
-        assert "1 increased" in stdout
-        assert "1 decreased" in stdout
-        # heltec-v3 grew by 50000
-        assert "📈" in stdout
-        # tbeam shrank by 10000
-        assert "📉" in stdout
-        # rak4631 unchanged
-        assert "vs `develop`" in stdout
-
-
-def test_size_report_multiple_baselines():
-    """size_report handles multiple baselines."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        new_file = os.path.join(tmpdir, "new.json")
-        dev_file = os.path.join(tmpdir, "develop.json")
-        master_file = os.path.join(tmpdir, "master.json")
-        with open(new_file, "w") as f:
-            json.dump({"board-a": 100000}, f)
-        with open(dev_file, "w") as f:
-            json.dump({"board-a": 95000}, f)
-        with open(master_file, "w") as f:
-            json.dump({"board-a": 90000}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py",
-            [new_file, "--baseline", f"develop:{dev_file}", "--baseline", f"master:{master_file}"],
-        )
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "vs `develop`" in stdout
-        assert "vs `master`" in stdout
-
-
-def test_size_report_new_target_no_baseline_entry():
-    """size_report handles targets not present in baseline (new boards)."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        new_file = os.path.join(tmpdir, "new.json")
-        old_file = os.path.join(tmpdir, "old.json")
-        with open(new_file, "w") as f:
-            json.dump({"new-board": 300000, "existing": 500000}, f)
-        with open(old_file, "w") as f:
-            json.dump({"existing": 500000}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py", [new_file, "--baseline", f"develop:{old_file}"]
-        )
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "`new-board`" in stdout
-        assert "no changes" in stdout  # only existing is compared, delta=0
-
-
-def test_size_report_all_unchanged():
-    """size_report shows 'no changes' when all sizes match."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sizes_file = os.path.join(tmpdir, "sizes.json")
-        with open(sizes_file, "w") as f:
-            json.dump({"board-a": 100000, "board-b": 200000}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py", [sizes_file, "--baseline", f"develop:{sizes_file}"]
-        )
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "no changes" in stdout
-
-
-def test_collect_sizes_bad_args():
-    """collect_sizes exits with error on wrong arg count."""
-    rc, stdout, stderr = run_script("collect_sizes.py", [])
-    assert rc == 1
-    assert "Usage" in stderr
-
-
-def test_size_report_bad_baseline_format():
-    """size_report exits with error on malformed --baseline."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sizes_file = os.path.join(tmpdir, "sizes.json")
-        with open(sizes_file, "w") as f:
-            json.dump({"x": 1}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py", [sizes_file, "--baseline", "no-colon-here"]
-        )
-        assert rc == 1
-        assert "LABEL:PATH" in stderr
-
-
-if __name__ == "__main__":
-    tests = [v for k, v in globals().items() if k.startswith("test_")]
-    passed = 0
-    failed = 0
-    for test in tests:
-        try:
-            test()
-            print(f"  PASS: {test.__name__}")
-            passed += 1
-        except AssertionError as e:
-            print(f"  FAIL: {test.__name__}: {e}")
-            failed += 1
-        except Exception as e:
-            print(f"  ERROR: {test.__name__}: {type(e).__name__}: {e}")
-            failed += 1
-
-    print(f"\n{passed} passed, {failed} failed out of {passed + failed}")
-    sys.exit(1 if failed else 0)

boards/CDEBYTE_EoRa-S3.json

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

boards/bpi_picow_esp32_s3.json

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

boards/hackaday-communicator.json

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

boards/heltec_vision_master_e213.json

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

boards/heltec_vision_master_e290.json

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

boards/heltec_vision_master_t190.json

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

boards/heltec_wireless_tracker.json

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

boards/heltec_wireless_tracker_v2.json

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

boards/nrf54l15dk.json

@@ -1,26 +0,0 @@
-{
-  "build": {
-    "cpu": "cortex-m33",
-    "f_cpu": "128000000L",
-    "mcu": "nrf54l15",
-    "zephyr": {
-      "variant": "nrf54l15dk/nrf54l15/cpuapp"
-    }
-  },
-  "connectivity": ["bluetooth"],
-  "debug": {
-    "default_tools": ["jlink"],
-    "jlink_device": "nRF54L15_M33",
-    "svd_path": "nrf54l15.svd"
-  },
-  "frameworks": ["zephyr"],
-  "name": "Nordic nRF54L15-DK (PCA10156)",
-  "upload": {
-    "maximum_ram_size": 262144,
-    "maximum_size": 1572864,
-    "protocol": "jlink",
-    "protocols": ["jlink"]
-  },
-  "url": "https://www.nordicsemi.com/Products/nRF54L15",
-  "vendor": "Nordic Semiconductor"
-}

boards/seeed-xiao-s3.json

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

boards/t-beam-1w.json

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

boards/t-deck.json

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

boards/t-impulse-plus.json

@@ -0,0 +1,53 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_T_IMPULSE_PLUS -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [["0x239A", "0x8029"]],
+    "usb_product": "T-Impulse-Plus-nRF52840",
+    "mcu": "nrf52840",
+    "variant": "t-impulse-plus",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "Lilygo T-Impulse-Plus-nRF52840",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": [
+      "jlink",
+      "nrfjprog",
+      "nrfutil",
+      "stlink",
+      "cmsis-dap",
+      "blackmagic"
+    ]
+  },
+  "url": "https://www.lilygo.cc/",
+  "vendor": "Lilygo"
+}

boards/tbeam-s3-core.json

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

boards/tlora-t3s3-v1.json

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

boards/unphone.json

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

debian/changelog

@@ -1,3 +1,15 @@
+meshtasticd (2.7.26.0) unstable; urgency=medium
+
+  * Version 2.7.26
+
+ -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Wed, 10 Jun 2026 00:19:23 +0000
+
+meshtasticd (2.7.25.0) unstable; urgency=medium
+
+  * Version 2.7.25
+
+ -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Sat, 23 May 2026 01:16:20 +0000
+
 meshtasticd (2.7.24.0) unstable; urgency=medium
 
   * Version 2.7.24

debian/ci_pack_sdeb.sh

@@ -33,5 +33,5 @@ if [[ -n $GPG_KEY_ID ]]; then
 	debuild -S -nc -k"$GPG_KEY_ID"
 else
 	# Build the source deb without signing (forks)
-	debuild -S -nc
+	debuild -S -nc -us -uc
 fi

debian/control

@@ -14,7 +14,6 @@ Build-Depends: debhelper-compat (= 13),
                g++,
                pkg-config,
                libyaml-cpp-dev,
-               libjsoncpp-dev,
                libgpiod-dev,
                libbluetooth-dev,
                libusb-1.0-0-dev,

default_16MB.csv

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

default_8MB.csv

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

extra_scripts/esp32_extra.py

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

extra_scripts/ld_response_file.py

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

extra_scripts/nrf54l15_linker.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python3
-# trunk-ignore-all(ruff/F821)
-# trunk-ignore-all(flake8/F821): For SConstruct imports
-#
-# post:extra_scripts/nrf54l15_linker.py
-#
-# Fix for Zephyr two-pass link on nRF54L15:
-# platformio-build.py registers env.Depends("$PROG_PATH", final_ld_script) but
-# the SCons dependency chain is broken (final_ld_script Command never runs).
-# This script adds a PreAction on the final firmware binary that runs the gcc
-# preprocessing command directly (extracted from build.ninja) to generate
-# zephyr/linker.cmd before the link step.
-#
-# PlatformIO bundles an old Ninja that can't handle multi-output depslog rules,
-# so we parse the COMMAND line from build.ninja and run just the gcc -E part,
-# skipping the cmake_transform_depfile step (only needed for Ninja deps tracking).
-
-import os
-import re
-import subprocess
-
-Import("env")
-
-if env.get("PIOENV") != "nrf54l15dk":
-    pass  # Only for the nrf54l15dk environment
-else:
-
-    def _extract_gcc_command(ninja_build):
-        """Parse build.ninja to find the gcc -E command that generates linker.cmd.
-
-        The rule format depends on the host:
-          Windows (CMake's RunCMake wraps every command):
-            COMMAND = cmd.exe /C "cd /D DIR && arm-none-eabi-gcc.exe ... -o linker.cmd && cmake.exe -E cmake_transform_depfile ..."
-          POSIX (Linux/macOS — no wrapper):
-            COMMAND = cd DIR && arm-none-eabi-gcc ... -o linker.cmd && cmake -E cmake_transform_depfile ...
-
-        Returns (gcc_cmd_string, cwd_path) or raises RuntimeError.
-        """
-        in_rule = False
-        with open(ninja_build, "r", encoding="utf-8", errors="replace") as f:
-            for line in f:
-                # Detect start of the linker.cmd custom command rule
-                if not in_rule:
-                    if "build zephyr/linker.cmd" in line and "CUSTOM_COMMAND" in line:
-                        in_rule = True
-                    continue
-
-                stripped = line.strip()
-                if not stripped.startswith("COMMAND = "):
-                    continue
-
-                command_val = stripped[len("COMMAND = ") :]
-
-                # On Windows the value is wrapped in `cmd.exe /C "..."` — strip
-                # the wrapper. On POSIX hosts the inner sequence is the value
-                # itself (no quoting layer).
-                m = re.search(r'/C\s+"(.*)"\s*$', command_val)
-                inner = m.group(1) if m else command_val
-                parts = inner.split(" && ")
-
-                cwd = None
-                gcc_cmd = None
-                for part in parts:
-                    part = part.strip()
-                    if part.startswith("cd /D "):  # Windows form
-                        cwd = part[len("cd /D ") :]
-                    elif part.startswith("cd "):  # POSIX form
-                        cwd = part[len("cd ") :]
-                    elif "arm-none-eabi-gcc" in part:
-                        gcc_cmd = part
-
-                if not gcc_cmd:
-                    raise RuntimeError(
-                        "nRF54L15 linker fix: arm-none-eabi-gcc command not found in:\n%s"
-                        % inner[:400]
-                    )
-
-                return gcc_cmd, cwd
-
-        raise RuntimeError(
-            "nRF54L15 linker fix: 'build zephyr/linker.cmd' rule not found in build.ninja"
-        )
-
-    def _generate_linker_cmd(target, source, env):
-        """Generate zephyr/linker.cmd via direct gcc invocation before the final link."""
-        build_dir = env.subst("$BUILD_DIR")
-        zephyr_dir = os.path.join(build_dir, "zephyr")
-        linker_cmd = os.path.join(zephyr_dir, "linker.cmd")
-
-        if os.path.exists(linker_cmd):
-            return  # Already present — nothing to do
-
-        ninja_build = os.path.join(build_dir, "build.ninja")
-        if not os.path.exists(ninja_build):
-            raise RuntimeError(
-                "nRF54L15 linker fix: build.ninja not found at %s\n"
-                "Run a full build first so CMake generates the Ninja files."
-                % ninja_build
-            )
-
-        gcc_cmd, cwd = _extract_gcc_command(ninja_build)
-        run_cwd = cwd if cwd else zephyr_dir
-
-        print(
-            "==> nRF54L15: Generating zephyr/linker.cmd (LINKER_ZEPHYR_FINAL) via GCC"
-        )
-        # gcc_cmd comes verbatim from our own build.ninja (never user input) and
-        # contains Windows-style paths with spaces that cannot be safely argv-split
-        # with shlex, so we run it via the platform shell. nosec/nosemgrep below
-        # acknowledge this deliberate, scoped use of shell=True.
-        result = subprocess.run(  # nosec B602
-            gcc_cmd,
-            shell=True,  # nosemgrep: python.lang.security.audit.subprocess-shell-true.subprocess-shell-true
-            cwd=run_cwd,
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode != 0:
-            print("GCC stdout:", result.stdout[:2000])
-            print("GCC stderr:", result.stderr[:2000])
-            raise RuntimeError(
-                "nRF54L15 linker fix: GCC failed to generate linker.cmd (rc=%d)"
-                % result.returncode
-            )
-        if not os.path.exists(linker_cmd):
-            raise RuntimeError(
-                "nRF54L15 linker fix: GCC returned 0 but linker.cmd was not created at %s"
-                % linker_cmd
-            )
-        print("==> linker.cmd generated successfully")
-
-    # Use PIOMAINPROG (set by ZephyrBuildProgram) to get the exact SCons node
-    prog = env.get("PIOMAINPROG")
-    if prog:
-        env.AddPreAction(prog, _generate_linker_cmd)
-    else:
-        print(
-            "[nrf54l15_linker] WARNING: PIOMAINPROG not set, falling back to $PROG_PATH"
-        )
-        env.AddPreAction(env.subst("$PROG_PATH"), _generate_linker_cmd)

mcp-server/run-tests.sh

@@ -191,12 +191,10 @@ echo
 # PASS/FAIL — every hardware test would SKIP with "role not present". We
 # narrow to tests/unit explicitly so the summary reads as "no hardware,
 # unit suite only" instead of "big skip count looks suspicious".
-# Keep terminal output condensed (`-q -r fE`) so skip-heavy runs do not print
-# each skipped test in full; skip counts still appear in pytest's summary.
 if [[ -z $DETECTED && $# -eq 0 ]]; then
 	echo "[pre-flight] no supported devices detected; running unit tier only."
 	echo
-	exec "$VENV_PY" -m pytest tests/unit -q -r fE --report-log=tests/reportlog.jsonl
+	exec "$VENV_PY" -m pytest tests/unit -v --report-log=tests/reportlog.jsonl
 fi
 
 # Default pytest args when the user passed none. Power users can invoke
@@ -212,13 +210,11 @@ fi
 # skipping half the hardware tests with "not baked with session profile"
 # errors. Power users who know their hardware is current and want to shave
 # those seconds can pass `--assume-baked` explicitly.
-# Defaults also use condensed reporting (`-q -r fE`) to avoid listing every
-# skipped test verbatim while still surfacing failures/errors and summary data.
 if [[ $# -eq 0 ]]; then
 	set -- tests/ \
 		--html=tests/report.html --self-contained-html \
 		--junitxml=tests/junit.xml \
-		-q -r fE --tb=short
+		-v --tb=short
 fi
 
 # UI tier requires opencv-python-headless (and ideally easyocr). If it's

mcp-server/src/meshtastic_mcp/fixtures.py

@@ -1,382 +0,0 @@
-"""Fake NodeDB fixture push — Portduino file copy + hardware XModem upload.
-
-The fixture pipeline is two-stage:
-  1. `bin/gen-fake-nodedb-seed.py` produces a deterministic JSONL describing N
-     fake-but-realistic peers. Committed under `test/fixtures/nodedb/`.
-  2. `bin/seed-json-to-proto.py` compiles JSONL → binary v25 NodeDatabase
-     protobuf with fresh wall-clock timestamps.
-
-This module exposes `push_fake_nodedb(...)`, the MCP tool that:
-  - target="portduino": compiles the JSONL into the device's prefs dir on
-    the local filesystem (`~/.portduino/<config>/prefs/nodes.proto`).
-  - target="hardware":  compiles to a temp file, then streams it over the
-    XModem protocol (via the meshtastic SerialInterface/BLEInterface +
-    `meshtastic.xmodempacket` pubsub topic) to `/prefs/nodes.proto` on the
-    device. Triggers a reboot so the firmware loads the new state on next
-    boot.
-
-XModem wire details (mirrors firmware impl at src/xmodem.cpp:115-260):
-  * 128-byte chunks; final chunk padded to 128 B with 0x1A (SUB) bytes.
-  * CRC16-CCITT (poly 0x1021, init 0x0000).
-  * SOH/seq=0 carries the destination filename in `buffer.bytes`. ACK if
-    `FSCom.open(filename, FILE_O_WRITE)` succeeds; NAK otherwise.
-  * SOH/seq≥1 carries a 128-byte chunk. ACK = advance; NAK = retransmit.
-  * EOT after the last chunk flushes + closes the file on-device.
-
-Hardware push requires `confirm=True` (mirrors factory_reset / erase_and_flash
-in the .github/copilot-instructions.md "never do these without asking" list).
-"""
-
-from __future__ import annotations
-
-import dataclasses
-import hashlib
-import pathlib
-import queue
-import shutil
-import subprocess
-import sys
-import tempfile
-import time
-from typing import Any, Literal
-
-from .connection import connect, is_tcp_port
-
-# Resolve repo root so the tool works regardless of mcp-server cwd.
-_REPO_ROOT = pathlib.Path(__file__).resolve().parents[3]
-_SEED_DIR = _REPO_ROOT / "test" / "fixtures" / "nodedb"
-_COMPILE_SCRIPT = _REPO_ROOT / "bin" / "seed-json-to-proto.py"
-
-_DEFAULT_NODES_FILENAME = "/prefs/nodes.proto"
-_XMODEM_CHUNK = 128
-_XMODEM_SUB = 0x1A
-_ACK_TIMEOUT_INIT_S = 5.0
-_ACK_TIMEOUT_CHUNK_S = 2.0
-_MAX_CHUNK_RETRIES = 5
-
-_VALID_SIZES = (250, 500, 1000, 2000)
-
-
-class FixtureError(RuntimeError):
-    """Raised for any fixture-push failure (compile, transport, ack timeout, …)."""
-
-
-# ---------------------------------------------------------------------------
-# CRC16-CCITT (poly 0x1021, init 0x0000). Matches the firmware's `crc16_ccitt`.
-# Hand-rolled to avoid the optional `crcmod` dep.
-# ---------------------------------------------------------------------------
-def _crc16_ccitt(data: bytes, *, init: int = 0x0000) -> int:
-    crc = init
-    for b in data:
-        crc ^= b << 8
-        for _ in range(8):
-            if crc & 0x8000:
-                crc = ((crc << 1) ^ 0x1021) & 0xFFFF
-            else:
-                crc = (crc << 1) & 0xFFFF
-    return crc
-
-
-# ---------------------------------------------------------------------------
-# Compile step — shells out to bin/seed-json-to-proto.py so the MCP module
-# doesn't have to duplicate the proto-encoding logic.
-# ---------------------------------------------------------------------------
-def _compile_proto(jsonl_path: pathlib.Path, out_path: pathlib.Path) -> None:
-    if not _COMPILE_SCRIPT.is_file():
-        raise FixtureError(f"compile script missing at {_COMPILE_SCRIPT}")
-    cmd = [
-        sys.executable,
-        str(_COMPILE_SCRIPT),
-        "--in",
-        str(jsonl_path),
-        "--out",
-        str(out_path),
-    ]
-    try:
-        subprocess.run(cmd, check=True, capture_output=True, text=True)
-    except subprocess.CalledProcessError as exc:
-        raise FixtureError(
-            f"seed-json-to-proto.py failed (exit {exc.returncode}):\n"
-            f"  stdout: {exc.stdout}\n  stderr: {exc.stderr}"
-        ) from exc
-
-
-def _resolve_seed_jsonl(size: int, custom: str | None) -> pathlib.Path:
-    if custom is not None:
-        p = pathlib.Path(custom).expanduser().resolve()
-        if not p.is_file():
-            raise FixtureError(f"custom_seed_jsonl not found: {p}")
-        return p
-    p = _SEED_DIR / f"seed_v25_{size:04d}.jsonl"
-    if not p.is_file():
-        raise FixtureError(
-            f"missing committed seed at {p}. "
-            f"Run `./bin/regen-fake-nodedbs.sh` to generate it."
-        )
-    return p
-
-
-# ---------------------------------------------------------------------------
-# Portduino push — file copy into ~/.portduino/<config>/prefs/
-# ---------------------------------------------------------------------------
-def _portduino_prefs_dir(config_name: str) -> pathlib.Path:
-    home = pathlib.Path.home()
-    return home / ".portduino" / config_name / "prefs"
-
-
-def _push_portduino(
-    size: int,
-    jsonl: pathlib.Path,
-    portduino_config: str,
-    backup_existing: bool,
-) -> dict[str, Any]:
-    prefs = _portduino_prefs_dir(portduino_config)
-    prefs.mkdir(parents=True, exist_ok=True)
-    target = prefs / "nodes.proto"
-    backed_up_to: str | None = None
-    if backup_existing and target.is_file():
-        ts = int(time.time())
-        backup = prefs / f"nodes.proto.bak.{ts}"
-        shutil.move(str(target), str(backup))
-        backed_up_to = str(backup)
-    _compile_proto(jsonl, target)
-    raw = target.read_bytes()
-    return {
-        "transport": "portduino",
-        "path": str(target),
-        "bytes": len(raw),
-        "sha256": hashlib.sha256(raw).hexdigest(),
-        "jsonl_source": str(jsonl),
-        "backed_up_to": backed_up_to,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Hardware push — XModem over BLE/serial via the meshtastic Python interface.
-# ---------------------------------------------------------------------------
-@dataclasses.dataclass
-class _AckEvent:
-    control: int
-    seq: int
-
-
-def _wait_for_response(q: "queue.Queue[_AckEvent]", timeout_s: float) -> _AckEvent:
-    try:
-        return q.get(timeout=timeout_s)
-    except queue.Empty as exc:
-        raise FixtureError(
-            f"XModem response timeout after {timeout_s:.1f}s — device not responding"
-        ) from exc
-
-
-def _push_hardware(
-    size: int,
-    jsonl: pathlib.Path,
-    port: str | None,
-    reboot_after: bool,
-) -> dict[str, Any]:
-    # Lazy imports so the module loads even when the meshtastic deps aren't
-    # available (e.g. CI in a Python env without the package installed).
-    try:
-        from meshtastic.protobuf import mesh_pb2, xmodem_pb2
-        from pubsub import pub
-    except ImportError as exc:  # pragma: no cover — dep missing
-        raise FixtureError(
-            f"hardware push requires the meshtastic + pypubsub packages: {exc}"
-        ) from exc
-
-    if is_tcp_port(port):
-        raise FixtureError(
-            "hardware push over TCP/portduino is not supported — use "
-            "target='portduino' to drop the fixture directly into the prefs dir."
-        )
-
-    # Compile the fixture to a temp file with fresh timestamps.
-    with tempfile.NamedTemporaryFile(suffix=".proto", delete=False) as tf:
-        proto_path = pathlib.Path(tf.name)
-    try:
-        _compile_proto(jsonl, proto_path)
-        payload = proto_path.read_bytes()
-    finally:
-        proto_path.unlink(missing_ok=True)
-
-    sha256 = hashlib.sha256(payload).hexdigest()
-    total_bytes = len(payload)
-
-    # Subscribe to XModem responses BEFORE we open the interface, so we don't
-    # race the first ACK that arrives during the SOH/seq=0 handshake.
-    #
-    # NB: the signature MUST declare every kwarg pypubsub will see for this
-    # topic, or pubsub locks the topic spec to a smaller set (whichever
-    # subscribe arrives first) and then *rejects* the meshtastic library's
-    # publish call with `SenderUnknownMsgDataError: unknown ... interface`.
-    # The meshtastic lib publishes both `packet=` and `interface=`
-    # (mesh_interface.py:1389-1395), so both must appear here.
-    response_q: "queue.Queue[_AckEvent]" = queue.Queue()
-
-    def _on_xmodem(packet: Any = None, interface: Any = None, **_kw: Any) -> None:
-        if packet is None:
-            return
-        response_q.put(_AckEvent(control=int(packet.control), seq=int(packet.seq)))
-
-    pub.subscribe(_on_xmodem, "meshtastic.xmodempacket")
-
-    chunks_sent = 0
-    retried = 0
-    rebooted = False
-
-    XMC = xmodem_pb2.XModem.Control
-    try:
-        with connect(port=port) as iface:
-            # 1) Send the filename (SOH, seq=0).
-            init_pkt = xmodem_pb2.XModem(
-                control=XMC.Value("SOH"),
-                seq=0,
-                buffer=_DEFAULT_NODES_FILENAME.encode("utf-8"),
-            )
-            iface._sendToRadio(mesh_pb2.ToRadio(xmodemPacket=init_pkt))
-            ack = _wait_for_response(response_q, _ACK_TIMEOUT_INIT_S)
-            if ack.control != XMC.Value("ACK"):
-                raise FixtureError(
-                    f"device refused filename {_DEFAULT_NODES_FILENAME!r} "
-                    f"(got control={ack.control}, expected ACK). "
-                    f"Filesystem full or permissions issue?"
-                )
-
-            # 2) Stream the payload in 128 B chunks.
-            for offset in range(0, total_bytes, _XMODEM_CHUNK):
-                chunk = payload[offset : offset + _XMODEM_CHUNK]
-                if len(chunk) < _XMODEM_CHUNK:
-                    # Pad final chunk to 128 B with SUB. The trailing 0x1A bytes
-                    # become part of the file on-device, but nanopb ignores
-                    # bytes past the end of the top-level message.
-                    chunk = chunk + bytes([_XMODEM_SUB] * (_XMODEM_CHUNK - len(chunk)))
-                seq = ((offset // _XMODEM_CHUNK) + 1) % 256
-                # Retry loop on NAK / timeout.
-                attempts = 0
-                while True:
-                    pkt = xmodem_pb2.XModem(
-                        control=XMC.Value("SOH"),
-                        seq=seq,
-                        buffer=chunk,
-                        crc16=_crc16_ccitt(chunk),
-                    )
-                    iface._sendToRadio(mesh_pb2.ToRadio(xmodemPacket=pkt))
-                    ack = _wait_for_response(response_q, _ACK_TIMEOUT_CHUNK_S)
-                    if ack.control == XMC.Value("ACK"):
-                        chunks_sent += 1
-                        break
-                    if ack.control == XMC.Value("NAK"):
-                        attempts += 1
-                        retried += 1
-                        if attempts >= _MAX_CHUNK_RETRIES:
-                            # Abort: send CAN so the firmware removes the half-
-                            # written file via FSCom.remove(filename).
-                            iface._sendToRadio(
-                                mesh_pb2.ToRadio(
-                                    xmodemPacket=xmodem_pb2.XModem(
-                                        control=XMC.Value("CAN")
-                                    )
-                                )
-                            )
-                            raise FixtureError(
-                                f"chunk seq={seq} NAK'd {attempts} times; "
-                                f"aborted transfer (file removed on-device)."
-                            )
-                        continue  # retry the same chunk
-                    raise FixtureError(
-                        f"unexpected XModem control={ack.control} on seq={seq}"
-                    )
-
-            # 3) Tell the device we're done.
-            iface._sendToRadio(
-                mesh_pb2.ToRadio(
-                    xmodemPacket=xmodem_pb2.XModem(control=XMC.Value("EOT"))
-                )
-            )
-            ack = _wait_for_response(response_q, _ACK_TIMEOUT_CHUNK_S)
-            if ack.control != XMC.Value("ACK"):
-                raise FixtureError(f"EOT not ACKed (got control={ack.control})")
-
-            # 4) Reboot so loadFromDisk picks up the new file.
-            if reboot_after:
-                iface.localNode.reboot(secs=1)
-                rebooted = True
-    finally:
-        try:
-            pub.unsubscribe(_on_xmodem, "meshtastic.xmodempacket")
-        except Exception:
-            pass
-
-    return {
-        "transport": "hardware",
-        "port": port,
-        "filename_on_device": _DEFAULT_NODES_FILENAME,
-        "bytes": total_bytes,
-        "chunks_sent": chunks_sent,
-        "retried": retried,
-        "sha256": sha256,
-        "jsonl_source": str(jsonl),
-        "rebooted": rebooted,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Public entry point — registered as an MCP tool in server.py.
-# ---------------------------------------------------------------------------
-def push_fake_nodedb(
-    size: int,
-    target: Literal["portduino", "hardware"] = "portduino",
-    *,
-    port: str | None = None,
-    portduino_config: str = "default",
-    backup_existing: bool = True,
-    confirm: bool = False,
-    reboot_after: bool = True,
-    custom_seed_jsonl: str | None = None,
-) -> dict[str, Any]:
-    """Compile a fresh-timestamp NodeDatabase fixture and push it to a device.
-
-    Args:
-      size: 250, 500, 1000, or 2000 — selects which committed seed JSONL to use.
-      target: "portduino" (file copy to ~/.portduino/<config>/prefs/) or
-              "hardware" (XModem upload to /prefs/nodes.proto + reboot).
-      port: required for target="hardware". Serial path (e.g. /dev/cu.usbmodemXXXX)
-            or BLE identifier. TCP endpoints are rejected — use target="portduino"
-            instead.
-      portduino_config: which Portduino instance dir under ~/.portduino/. Default "default".
-      backup_existing: portduino only. Move nodes.proto -> nodes.proto.bak.<ts>
-                        if present, so you can roll back.
-      confirm: required True for target="hardware" (writes flash + reboots).
-      reboot_after: hardware only. If True, send a 1-second reboot after the
-                    final ACK so loadFromDisk picks up the new file at next boot.
-      custom_seed_jsonl: override the committed JSONL. Use to push a hand-edited
-                         test scenario.
-
-    Returns:
-        dict with transport, bytes, sha256, etc. — depends on target.
-
-    """
-    if size not in _VALID_SIZES:
-        raise FixtureError(
-            f"size must be one of {_VALID_SIZES}; got {size!r}. "
-            f"Add a new committed seed if you need a different cardinality."
-        )
-
-    jsonl = _resolve_seed_jsonl(size, custom_seed_jsonl)
-
-    if target == "portduino":
-        return _push_portduino(size, jsonl, portduino_config, backup_existing)
-
-    if target == "hardware":
-        if not confirm:
-            raise FixtureError(
-                "hardware push writes flash and triggers a reboot — pass confirm=True."
-            )
-        if not port:
-            raise FixtureError(
-                "target='hardware' requires a port (e.g. /dev/cu.usbmodemXXXX)."
-            )
-        return _push_hardware(size, jsonl, port, reboot_after)
-
-    raise FixtureError(f"unknown target {target!r}; expected 'portduino' or 'hardware'")

mcp-server/src/meshtastic_mcp/server.py

@@ -15,7 +15,6 @@ from . import (
     admin,
     boards,
     devices,
-    fixtures,
     flash,
     hw_tools,
     info,
@@ -964,45 +963,3 @@ def recorder_export(
         dest_dir=dest_dir,
         streams=streams,
     )
-
-
-# ---------- Fixture / test-data push --------------------------------------
-
-
-@app.tool()
-def push_fake_nodedb(
-    size: int,
-    target: str = "portduino",
-    port: str | None = None,
-    portduino_config: str = "default",
-    backup_existing: bool = True,
-    confirm: bool = False,
-    reboot_after: bool = True,
-    custom_seed_jsonl: str | None = None,
-) -> dict[str, Any]:
-    """Push a fake-NodeDB v25 fixture (250/500/1000/2000 nodes) onto a device.
-
-    Two transports:
-      target="portduino" — file copy to ~/.portduino/<portduino_config>/prefs/nodes.proto.
-                            Fast, no device connection needed.
-      target="hardware"  — XModem upload over serial/BLE to /prefs/nodes.proto.
-                            Requires `port` + `confirm=True`. Triggers a reboot
-                            so loadFromDisk picks up the new file at next boot.
-
-    Compiles a fresh-timestamp proto from the committed JSONL seed under
-    test/fixtures/nodedb/seed_v25_<N>.jsonl each invocation, so the loaded
-    NodeDB always looks "recent" to the connecting phone. Structural data
-    (names, IDs, positions, telemetries) is deterministic per the seed.
-
-    Override the JSONL via `custom_seed_jsonl` to push a hand-edited scenario.
-    """
-    return fixtures.push_fake_nodedb(
-        size=size,
-        target=target,  # type: ignore[arg-type]
-        port=port,
-        portduino_config=portduino_config,
-        backup_existing=backup_existing,
-        confirm=confirm,
-        reboot_after=reboot_after,
-        custom_seed_jsonl=custom_seed_jsonl,
-    )

mcp-server/tests/unit/test_fake_nodedb_generator.py

@@ -1,364 +0,0 @@
-"""Tests for the fake-NodeDB fixture pipeline (bin/gen-fake-nodedb-seed.py
-+ bin/seed-json-to-proto.py + mcp-server fixtures.push_fake_nodedb).
-
-Lives under tests/unit/ because none of these touch real hardware — they
-shell out to the bin/ scripts and decode the resulting protobufs in-process.
-"""
-
-from __future__ import annotations
-
-import json
-import pathlib
-import subprocess
-import sys
-import time
-
-import pytest
-
-REPO_ROOT = pathlib.Path(__file__).resolve().parents[3]
-SEED_GEN = REPO_ROOT / "bin" / "gen-fake-nodedb-seed.py"
-COMPILE = REPO_ROOT / "bin" / "seed-json-to-proto.py"
-FIXTURES_DIR = REPO_ROOT / "test" / "fixtures" / "nodedb"
-
-# Ensure the locally-generated Python protobuf bindings are importable.
-# These live under `meshtastic_v25` (not `meshtastic`) so they don't shadow
-# the PyPI `meshtastic` package that the rest of the mcp-server depends on.
-_BINDINGS_DIR = REPO_ROOT / "bin" / "_generated"
-if _BINDINGS_DIR.is_dir() and str(_BINDINGS_DIR) not in sys.path:
-    sys.path.insert(0, str(_BINDINGS_DIR))
-
-try:
-    from meshtastic_v25.deviceonly_pb2 import (
-        NodeDatabase,  # type: ignore[import-not-found]
-    )
-except ImportError:
-    NodeDatabase = None  # type: ignore[assignment]
-
-
-def _require_v25_bindings() -> None:
-    if NodeDatabase is None:
-        pytest.skip(
-            "v25 Python protobuf bindings missing; run `./bin/regen-py-protos.sh`."
-        )
-    if "positions" not in NodeDatabase.DESCRIPTOR.fields_by_name:
-        pytest.skip(
-            "Loaded NodeDatabase predates v25 — run `./bin/regen-py-protos.sh`."
-        )
-
-
-def _run(cmd: list[str]) -> None:
-    subprocess.check_call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-
-
-# ---------------------------------------------------------------------------
-# Seed generator: deterministic for given --seed (no wall-clock dependence).
-# ---------------------------------------------------------------------------
-def test_seed_generator_is_deterministic(tmp_path: pathlib.Path) -> None:
-    a = tmp_path / "a.jsonl"
-    b = tmp_path / "b.jsonl"
-    _run(
-        [
-            sys.executable,
-            str(SEED_GEN),
-            "--count",
-            "100",
-            "--seed",
-            "42",
-            "--out",
-            str(a),
-        ]
-    )
-    # Sleep so any sneaky wall-clock leak in the generator would surface as
-    # a byte diff between the two runs.
-    time.sleep(0.8)
-    _run(
-        [
-            sys.executable,
-            str(SEED_GEN),
-            "--count",
-            "100",
-            "--seed",
-            "42",
-            "--out",
-            str(b),
-        ]
-    )
-    assert a.read_bytes() == b.read_bytes()
-
-
-def test_seed_generator_meta_line(tmp_path: pathlib.Path) -> None:
-    out = tmp_path / "seed.jsonl"
-    _run(
-        [
-            sys.executable,
-            str(SEED_GEN),
-            "--count",
-            "50",
-            "--seed",
-            "1",
-            "--out",
-            str(out),
-        ]
-    )
-    lines = out.read_text(encoding="utf-8").splitlines()
-    assert len(lines) == 51  # 1 meta + 50 nodes
-    meta = json.loads(lines[0])
-    assert "_meta" in meta
-    assert meta["_meta"]["version"] == 25
-    assert meta["_meta"]["count"] == 50
-    assert meta["_meta"]["seed"] == 1
-
-
-def test_seed_only_uses_active_hardware_and_roles(tmp_path: pathlib.Path) -> None:
-    """Confirm no deprecated roles + no off-list HW models leak through."""
-    out = tmp_path / "seed.jsonl"
-    _run(
-        [
-            sys.executable,
-            str(SEED_GEN),
-            "--count",
-            "500",
-            "--seed",
-            "7",
-            "--out",
-            str(out),
-        ]
-    )
-    forbidden_roles = {"ROUTER_CLIENT", "REPEATER"}
-    forbidden_hw = {
-        "TLORA_V1",
-        "TLORA_V2",
-        "TLORA_V1_1P3",
-        "TLORA_V2_1_1P6",
-        "TLORA_V2_1_1P8",
-        "HELTEC_V1",
-        "HELTEC_V2_0",
-        "HELTEC_V2_1",
-        "TBEAM",
-        "TBEAM_V0P7",
-        "NANO_G1",
-        "NANO_G1_EXPLORER",
-        "NANO_G2_ULTRA",
-        "STATION_G1",
-        "STATION_G2",
-        "PORTDUINO",
-        "ANDROID_SIM",
-        "DIY_V1",
-        "LORA_RELAY_V1",
-        "NRF52840_PCA10059",
-        "NRF52_UNKNOWN",
-        "DR_DEV",
-        "GENIEBLOCKS",
-        "M5STACK",
-        "RP2040_LORA",
-        "PPR",
-    }
-    for raw in out.read_text(encoding="utf-8").splitlines()[1:]:
-        node = json.loads(raw)
-        assert node["role"] not in forbidden_roles, f"deprecated role: {node['role']}"
-        assert (
-            node["hw_model"] not in forbidden_hw
-        ), f"non-tier-1 HW: {node['hw_model']}"
-
-
-# ---------------------------------------------------------------------------
-# Compile step + committed seeds.
-# ---------------------------------------------------------------------------
-@pytest.mark.parametrize("size", [250, 500, 1000, 2000])
-def test_committed_seed_compiles_and_decodes(size: int, tmp_path: pathlib.Path) -> None:
-    _require_v25_bindings()
-    proto = tmp_path / "out.proto"
-    jsonl = FIXTURES_DIR / f"seed_v25_{size:04d}.jsonl"
-    if not jsonl.is_file():
-        pytest.skip(f"{jsonl} not present — run ./bin/regen-fake-nodedbs.sh")
-    _run([sys.executable, str(COMPILE), "--in", str(jsonl), "--out", str(proto)])
-
-    db = NodeDatabase()
-    db.ParseFromString(proto.read_bytes())
-    assert db.version == 25
-    assert len(db.nodes) == size
-    nums = {n.num for n in db.nodes}
-    assert len(nums) == size, "node numbers must be unique"
-    assert all(n.long_name and n.short_name for n in db.nodes)
-    assert all(len(n.long_name) <= 24 for n in db.nodes)  # max_size:25 - NUL
-
-    # Coverage sanity (±10pp tolerance for binomial fluctuation).
-    def in_range(actual: int, expected_ratio: float, tol_pp: float = 0.10) -> bool:
-        lo = max(0, int((expected_ratio - tol_pp) * size))
-        hi = min(size, int((expected_ratio + tol_pp) * size))
-        return lo <= actual <= hi
-
-    assert in_range(len(db.positions), 0.85)
-    assert in_range(len(db.telemetry), 0.70)
-    assert in_range(len(db.environment), 0.25)
-    assert in_range(len(db.status), 0.40)
-
-
-def test_compile_freshens_timestamps(tmp_path: pathlib.Path) -> None:
-    """Same JSONL compiled twice → identical structure, different timestamps."""
-    _require_v25_bindings()
-    jsonl = FIXTURES_DIR / "seed_v25_0250.jsonl"
-    if not jsonl.is_file():
-        pytest.skip("250-node seed not present — run ./bin/regen-fake-nodedbs.sh")
-    a = tmp_path / "a.proto"
-    b = tmp_path / "b.proto"
-    _run([sys.executable, str(COMPILE), "--in", str(jsonl), "--out", str(a)])
-    time.sleep(1.2)
-    _run([sys.executable, str(COMPILE), "--in", str(jsonl), "--out", str(b)])
-
-    da = NodeDatabase()
-    db_ = NodeDatabase()
-    da.ParseFromString(a.read_bytes())
-    db_.ParseFromString(b.read_bytes())
-
-    # Zero out timestamp fields and confirm everything else is byte-identical.
-    for d in (da, db_):
-        for n in d.nodes:
-            n.last_heard = 0
-        for p in d.positions:
-            p.position.time = 0
-    assert da.SerializeToString() == db_.SerializeToString()
-
-    # Re-load fresh copies to confirm timestamps actually moved.
-    aa = NodeDatabase()
-    bb = NodeDatabase()
-    aa.ParseFromString(a.read_bytes())
-    bb.ParseFromString(b.read_bytes())
-    aa_max = max(n.last_heard for n in aa.nodes if n.last_heard)
-    bb_max = max(n.last_heard for n in bb.nodes if n.last_heard)
-    assert bb_max >= aa_max
-    assert bb_max - aa_max < 5  # within a few seconds
-
-
-def test_compile_pinned_now_epoch_is_byte_identical(tmp_path: pathlib.Path) -> None:
-    """With --now-epoch pinned, two compiles produce identical bytes."""
-    _require_v25_bindings()
-    jsonl = FIXTURES_DIR / "seed_v25_0250.jsonl"
-    if not jsonl.is_file():
-        pytest.skip("250-node seed not present")
-    a = tmp_path / "a.proto"
-    b = tmp_path / "b.proto"
-    for o in (a, b):
-        _run(
-            [
-                sys.executable,
-                str(COMPILE),
-                "--in",
-                str(jsonl),
-                "--now-epoch",
-                "1700000000",
-                "--out",
-                str(o),
-            ]
-        )
-    assert a.read_bytes() == b.read_bytes()
-
-
-def test_compile_timestamps_are_recent(tmp_path: pathlib.Path) -> None:
-    _require_v25_bindings()
-    jsonl = FIXTURES_DIR / "seed_v25_0250.jsonl"
-    if not jsonl.is_file():
-        pytest.skip("250-node seed not present")
-    out = tmp_path / "out.proto"
-    _run([sys.executable, str(COMPILE), "--in", str(jsonl), "--out", str(out)])
-    db = NodeDatabase()
-    db.ParseFromString(out.read_bytes())
-    now = int(time.time())
-    # No timestamp older than 7 days, none in the future.
-    for n in db.nodes:
-        if n.last_heard:
-            assert now - 7 * 86400 <= n.last_heard <= now
-    # At least half should be within the last hour
-    # (matches expovariate(mean=3600s)).
-    recent = sum(1 for n in db.nodes if n.last_heard and n.last_heard >= now - 3600)
-    assert recent >= 0.4 * len(db.nodes)
-
-
-def test_compile_hand_edit_round_trip(tmp_path: pathlib.Path) -> None:
-    """Edit one JSONL line, recompile, confirm edit appears in the proto."""
-    _require_v25_bindings()
-    src = FIXTURES_DIR / "seed_v25_0250.jsonl"
-    if not src.is_file():
-        pytest.skip("250-node seed not present")
-    dst = tmp_path / "edited.jsonl"
-    lines = src.read_text(encoding="utf-8").splitlines()
-
-    # Find a node that already has telemetry so the index relationship is
-    # easy to assert on the other side.
-    edit_idx = None
-    for i, raw in enumerate(lines[1:], start=1):
-        node = json.loads(raw)
-        if node.get("telemetry") is not None:
-            edit_idx = i
-            break
-    assert edit_idx is not None, "expected at least one node with telemetry"
-
-    node = json.loads(lines[edit_idx])
-    target_num = int(node["num"], 16)
-    node["long_name"] = "Hand Edited Node"
-    node["telemetry"] = {
-        "battery_level": 42,
-        "voltage": 3.71,
-        "channel_utilization": 0.0,
-        "air_util_tx": 0.0,
-        "uptime_seconds": 1,
-    }
-    lines[edit_idx] = json.dumps(node, ensure_ascii=False, sort_keys=True)
-    dst.write_text("\n".join(lines) + "\n", encoding="utf-8")
-
-    out = tmp_path / "out.proto"
-    _run([sys.executable, str(COMPILE), "--in", str(dst), "--out", str(out)])
-    db = NodeDatabase()
-    db.ParseFromString(out.read_bytes())
-    edited = next((n for n in db.nodes if n.num == target_num), None)
-    assert edited is not None
-    assert edited.long_name == "Hand Edited Node"
-    tel = next((t for t in db.telemetry if t.num == target_num), None)
-    assert tel is not None
-    assert tel.device_metrics.battery_level == 42
-
-
-# ---------------------------------------------------------------------------
-# Misc smoke checks on the module surface.
-# ---------------------------------------------------------------------------
-def test_crc16_ccitt_matches_known_vectors() -> None:
-    """Sanity-check the hand-rolled CRC16-CCITT matches well-known vectors.
-
-    Test vectors from the XModem-CRC spec (init=0, poly=0x1021):
-      crc16("123456789") = 0x31C3
-      crc16("")          = 0x0000
-    """
-    from meshtastic_mcp.fixtures import _crc16_ccitt
-
-    assert _crc16_ccitt(b"") == 0x0000
-    assert _crc16_ccitt(b"123456789") == 0x31C3
-
-
-def test_push_fake_nodedb_rejects_invalid_size() -> None:
-    from meshtastic_mcp.fixtures import FixtureError, push_fake_nodedb
-
-    with pytest.raises(FixtureError, match="size must be one of"):
-        push_fake_nodedb(size=999, target="portduino")  # type: ignore[arg-type]
-
-
-def test_push_fake_nodedb_hardware_requires_confirm() -> None:
-    from meshtastic_mcp.fixtures import FixtureError, push_fake_nodedb
-
-    with pytest.raises(FixtureError, match="confirm=True"):
-        push_fake_nodedb(size=250, target="hardware", port="/dev/cu.fake")
-
-
-def test_push_fake_nodedb_hardware_requires_port() -> None:
-    from meshtastic_mcp.fixtures import FixtureError, push_fake_nodedb
-
-    with pytest.raises(FixtureError, match="requires a port"):
-        push_fake_nodedb(size=250, target="hardware", confirm=True)
-
-
-def test_push_fake_nodedb_hardware_rejects_tcp_port() -> None:
-    from meshtastic_mcp.fixtures import FixtureError, push_fake_nodedb
-
-    with pytest.raises(FixtureError, match="not supported"):
-        push_fake_nodedb(
-            size=250, target="hardware", confirm=True, port="tcp://localhost:4403"
-        )

meshtasticd.spec.rpkg

@@ -34,7 +34,6 @@ BuildRequires: python3dist(grpcio-tools)
 BuildRequires: git-core
 BuildRequires: gcc-c++
 BuildRequires: pkgconfig(yaml-cpp)
-BuildRequires: pkgconfig(jsoncpp)
 BuildRequires: pkgconfig(libgpiod)
 BuildRequires: pkgconfig(bluez)
 BuildRequires: pkgconfig(libusb-1.0)

platformio.ini

@@ -2,42 +2,21 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = heltec-v3
+default_envs = tbeam
 
 extra_configs =
 	variants/*/*.ini
 	variants/*/*/platformio.ini
 	variants/*/diy/*/platformio.ini
+	src/graphics/niche/InkHUD/PlatformioConfig.ini
 
 description = Meshtastic
 
-; E-Ink / NicheGraphics build helpers.
-[niche]
-build_src_filter =
-  +<graphics/eink/>
-build_flags =
-  -D MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-[inkhud]
-build_src_filter =
-  ${niche.build_src_filter}
-  +<graphics/niche/>
-build_flags =
-  ${niche.build_flags}
-  -D MESHTASTIC_INCLUDE_INKHUD ; Use InkHUD as the UI
-  -D MESHTASTIC_EXCLUDE_SCREEN ; Suppress default Screen class
-  -D MESHTASTIC_EXCLUDE_INPUTBROKER ; Suppress default input handling
-  -D HAS_BUTTON=0 ; Suppress default ButtonThread
-lib_deps =
-  # renovate: datasource=github-tags depName=GFX_Root packageName=ZinggJM/GFX_Root
-  https://github.com/ZinggJM/GFX_Root/archive/3195764e352a0d2567c8d277ac408ca7293a99b0.zip ; Used by InkHUD as a "slimmer" version of AdafruitGFX
-
 [env]
 test_build_src = true
 extra_scripts =
 	pre:bin/platformio-pre.py
 	bin/platformio-custom.py
-	post:extra_scripts/nrf54l15_linker.py
 ; note: we add src to our include search path so that lmic_project_config can override
 ; note: TINYGPS_OPTION_NO_CUSTOM_FIELDS is VERY important.  We don't use custom fields and somewhere in that pile
 ; of code is a heap corruption bug!
@@ -70,7 +49,6 @@ build_flags = -Wno-missing-field-initializers
 	-DRADIOLIB_EXCLUDE_PAGER=1
 	-DRADIOLIB_EXCLUDE_FSK4=1
 	-DRADIOLIB_EXCLUDE_APRS=1
-	-DRADIOLIB_EXCLUDE_ADSB=1
 	-DRADIOLIB_EXCLUDE_LORAWAN=1
 	-DMESHTASTIC_EXCLUDE_DROPZONE=1
 	-DMESHTASTIC_EXCLUDE_REPLYBOT=1
@@ -79,6 +57,7 @@ build_flags = -Wno-missing-field-initializers
 	-DMESHTASTIC_EXCLUDE_POWERSTRESS=1 ; exclude power stress test module from main firmware
 	-DMESHTASTIC_EXCLUDE_GENERIC_THREAD_MODULE=1
 	-DMESHTASTIC_EXCLUDE_POWERMON=1
+	-DMESHTASTIC_EXCLUDE_STATUS=1
 	-D MAX_THREADS=40 ; As we've split modules, we have more threads to manage
 	#-DBUILD_EPOCH=$UNIX_TIME ; set in platformio-custom.py now
 	#-D OLED_PL=1
@@ -89,7 +68,7 @@ monitor_speed = 115200
 monitor_filters = direct
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-esp8266-oled-ssd1306 packageName=https://github.com/meshtastic/esp8266-oled-ssd1306 gitBranch=master
-	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/6bfd1f135e1ebe37afd6050bb4b9964cea3fcfda.zip
+	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/2e26010040e028baee72e2093402fa7b3c59e430.zip
 	# renovate: datasource=git-refs depName=meshtastic-OneButton packageName=https://github.com/meshtastic/OneButton gitBranch=master
 	https://github.com/meshtastic/OneButton/archive/fa352d668c53f290cfa480a5f79ad422cd828c70.zip
 	# renovate: datasource=git-refs depName=meshtastic-arduino-fsm packageName=https://github.com/meshtastic/arduino-fsm gitBranch=master
@@ -123,7 +102,7 @@ build_unflags =
 	-std=gnu++11
 build_flags = ${env.build_flags} -Os
 	-std=gnu++17
-build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/> -<graphics/eink/>
+build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT
 [networking_base]
@@ -142,12 +121,12 @@ lib_deps =
 [radiolib_base]
 lib_deps =
 	# renovate: datasource=github-tags depName=RadioLib packageName=jgromes/RadioLib
-	https://github.com/jgromes/RadioLib/archive/afe72ae46a343e15e3cac7f26ac585c7f98bffe5.zip
+	https://github.com/jgromes/RadioLib/archive/refs/tags/7.6.0.zip
 
 [device-ui_base]
 lib_deps =
 	# 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/502ba30dbccc6a323f1d4f7ca961131c27f60672.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -161,7 +140,7 @@ lib_deps =
 	# renovate: datasource=github-tags depName=NeoPixel packageName=adafruit/Adafruit_NeoPixel
 	https://github.com/adafruit/Adafruit_NeoPixel/archive/1.15.5.zip
 	# renovate: datasource=github-tags depName=Adafruit SSD1306 packageName=adafruit/Adafruit_SSD1306
-	https://github.com/adafruit/Adafruit_SSD1306/archive/refs/tags/2.5.16.zip
+	https://github.com/adafruit/Adafruit_SSD1306/archive/2.5.17.zip
 	# renovate: datasource=github-tags depName=Adafruit BMP280 packageName=adafruit/Adafruit_BMP280_Library
 	https://github.com/adafruit/Adafruit_BMP280_Library/archive/refs/tags/3.0.0.zip
 	# renovate: datasource=github-tags depName=Adafruit BMP085 packageName=adafruit/Adafruit-BMP085-Library
@@ -192,8 +171,8 @@ lib_deps =
 	https://github.com/EmotiBit/EmotiBit_MLX90632/archive/refs/tags/v1.0.8.zip
 	# renovate: datasource=github-tags depName=Adafruit MLX90614 packageName=adafruit/Adafruit_MLX90614
 	https://github.com/adafruit/Adafruit-MLX90614-Library/archive/refs/tags/2.1.6.zip
-	# renovate: datasource=github-tags depName=INA3221_RT packageName=RobTillaart/INA3221_RT
-	https://github.com/RobTillaart/INA3221_RT/archive/refs/tags/0.4.2.zip
+	# renovate: datasource=git-refs depName=INA3221 packageName=https://github.com/sgtwilko/INA3221 gitBranch=FixOverflow
+	https://github.com/sgtwilko/INA3221/archive/bb03d7e9bfcc74fc798838a54f4f99738f29fc6a.zip
 	# renovate: datasource=github-tags depName=QMC5883L Compass packageName=mprograms/QMC5883LCompass
 	https://github.com/mprograms/QMC5883LCompass/archive/refs/tags/v1.2.3.zip
 	# renovate: datasource=github-tags depName=DFRobot_RTU packageName=dfrobot/DFRobot_RTU
@@ -215,7 +194,7 @@ lib_deps =
 	# renovate: datasource=github-tags depName=DFRobot_BMM150 packageName=dfrobot/DFRobot_BMM150
 	https://github.com/DFRobot/DFRobot_BMM150/archive/refs/tags/V1.0.0.zip
 	# renovate: datasource=github-tags depName=SparkFun MMC5983MA Magnetometer packageName=sparkfun/SparkFun_MMC5983MA_Magnetometer_Arduino_Library
-	https://github.com/sparkfun/SparkFun_MMC5983MA_Magnetometer_Arduino_Library/archive/refs/tags/v1.1.4.zip
+	https://github.com/sparkfun/SparkFun_MMC5983MA_Magnetometer_Arduino_Library/archive/v1.1.5.zip
 	# renovate: datasource=github-tags depName=Adafruit_TSL2561 packageName=adafruit/Adafruit_TSL2561
 	https://github.com/adafruit/Adafruit_TSL2561/archive/refs/tags/1.1.3.zip
 	# renovate: datasource=github-tags depName=BH1750_WE packageName=wollewald/BH1750_WE
@@ -228,10 +207,16 @@ lib_deps =
 	https://github.com/adafruit/Adafruit_BMP3XX/archive/refs/tags/2.1.6.zip
 	# renovate: datasource=github-tags depName=Adafruit MAX1704X packageName=adafruit/Adafruit_MAX1704X
 	https://github.com/adafruit/Adafruit_MAX1704X/archive/refs/tags/1.0.3.zip
+	# renovate: datasource=github-tags depName=Adafruit SHTC3 packageName=adafruit/Adafruit_SHTC3
+	https://github.com/adafruit/Adafruit_SHTC3/archive/refs/tags/1.0.2.zip
 	# renovate: datasource=github-tags depName=Adafruit LPS2X packageName=adafruit/Adafruit_LPS2X
 	https://github.com/adafruit/Adafruit_LPS2X/archive/refs/tags/2.0.6.zip
+	# renovate: datasource=github-tags depName=Adafruit SHT31 packageName=adafruit/Adafruit_SHT31
+	https://github.com/adafruit/Adafruit_SHT31/archive/refs/tags/2.2.2.zip
 	# renovate: datasource=github-tags depName=Adafruit VEML7700 packageName=adafruit/Adafruit_VEML7700
 	https://github.com/adafruit/Adafruit_VEML7700/archive/refs/tags/2.1.6.zip
+	# renovate: datasource=github-tags depName=Adafruit SHT4x packageName=adafruit/Adafruit_SHT4X
+	https://github.com/adafruit/Adafruit_SHT4X/archive/refs/tags/1.0.5.zip
 	# renovate: datasource=github-tags depName=SparkFun Qwiic Scale NAU7802 packageName=sparkfun/SparkFun_Qwiic_Scale_NAU7802_Arduino_Library
 	https://github.com/sparkfun/SparkFun_Qwiic_Scale_NAU7802_Arduino_Library/archive/refs/tags/v1.0.6.zip
 	# renovate: datasource=custom.pio depName=ClosedCube OPT3001 packageName=closedcube/library/ClosedCube OPT3001
@@ -246,8 +231,6 @@ lib_deps =
 	https://github.com/Sensirion/arduino-i2c-sfa3x/archive/refs/tags/1.0.0.zip
 	# renovate: datasource=github-tags depName=Sensirion I2C SCD30 packageName=sensirion/arduino-i2c-scd30
 	https://github.com/Sensirion/arduino-i2c-scd30/archive/refs/tags/1.0.0.zip
-	# renovate: datasource=github-tags depName=arduino-sht packageName=sensirion/arduino-sht
-	https://github.com/Sensirion/arduino-sht/archive/refs/tags/v1.2.6.zip
 
 ; Environmental sensors with BSEC2 (Bosch proprietary IAQ)
 [environmental_extra]

src/DebugConfiguration.h

@@ -152,16 +152,15 @@ extern "C" void logLegacy(const char *level, const char *fmt, ...);
 // Default Bluetooth PIN
 #define defaultBLEPin 123456
 
-#if HAS_ETHERNET && defined(USE_ARDUINO_ETHERNET)
-#include <Ethernet.h> // arduino-libraries/Ethernet — supports W5500 auto-detect
-#elif HAS_ETHERNET && defined(USE_CH390D)
+#if HAS_ETHERNET && defined(USE_CH390D)
 #include <ESP32_CH390.h>
 #elif HAS_ETHERNET && !defined(USE_WS5500)
 #include <RAK13800_W5100S.h>
 #endif // HAS_ETHERNET
 
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 
 #if HAS_WIFI

src/DisplayFormatters.cpp

@@ -1,62 +1,42 @@
 #include "DisplayFormatters.h"
-#include "MeshRadio.h"
 
 const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName,
                                                          bool usePreset)
 {
 
-    // If use_preset is false, always return "Custom" — callers such as RadioInterface and Channels
-    // rely on this being a stable literal for channel-name hashing and default-channel detection.
+    // If use_preset is false, always return "Custom"
     if (!usePreset) {
         return "Custom";
     }
 
     switch (preset) {
-    case PRESET(SHORT_TURBO):
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
         return useShortName ? "ShortT" : "ShortTurbo";
         break;
-    case PRESET(SHORT_SLOW):
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
         return useShortName ? "ShortS" : "ShortSlow";
         break;
-    case PRESET(SHORT_FAST):
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
         return useShortName ? "ShortF" : "ShortFast";
         break;
-    case PRESET(MEDIUM_SLOW):
+    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
         return useShortName ? "MedS" : "MediumSlow";
         break;
-    case PRESET(MEDIUM_FAST):
+    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
         return useShortName ? "MedF" : "MediumFast";
         break;
-    case PRESET(LONG_SLOW):
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
         return useShortName ? "LongS" : "LongSlow";
         break;
-    case PRESET(LONG_FAST):
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
         return useShortName ? "LongF" : "LongFast";
         break;
-    case PRESET(LONG_TURBO):
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
         return useShortName ? "LongT" : "LongTurbo";
         break;
-    case PRESET(LONG_MODERATE):
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
         return useShortName ? "LongM" : "LongMod";
         break;
-    case PRESET(LITE_FAST):
-        return useShortName ? "LiteF" : "LiteFast";
-        break;
-    case PRESET(LITE_SLOW):
-        return useShortName ? "LiteS" : "LiteSlow";
-        break;
-    case PRESET(NARROW_FAST):
-        return useShortName ? "NarF" : "NarrowFast";
-        break;
-    case PRESET(NARROW_SLOW):
-        return useShortName ? "NarS" : "NarrowSlow";
-        break;
-    case PRESET(TINY_FAST):
-        return useShortName ? "TinyF" : "TinyFast";
-        break;
-    case PRESET(TINY_SLOW):
-        return useShortName ? "TinyS" : "TinySlow";
-        break;
     default:
         return useShortName ? "Custom" : "Invalid";
         break;

src/FSCommon.cpp

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

src/FSCommon.h

@@ -48,19 +48,10 @@ using namespace STM32_LittleFS_Namespace;
 using namespace Adafruit_LittleFS_Namespace;
 #endif
 
-#if defined(ARCH_NRF54L15)
-// nRF54L15 — Zephyr LittleFS on 36 KB storage_partition (internal RRAM)
-#include "InternalFileSystem.h"
-#define FSCom InternalFS
-#define FSBegin() FSCom.begin()
-using namespace Adafruit_LittleFS_Namespace;
-#endif
-
 void fsInit();
 void fsListFiles();
 bool copyFile(const char *from, const char *to);
 bool renameFile(const char *pathFrom, const char *pathTo);
-bool fsFormat();
 std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels);
 void listDir(const char *dirname, uint8_t levels, bool del = false);
 void rmDir(const char *dirname);

src/GPSStatus.h

@@ -53,7 +53,8 @@ class GPSStatus : public Status
     int32_t getLatitude() const
     {
         if (config.position.fixed_position) {
-            return localPosition.latitude_i;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.latitude_i;
         } else {
             return p.latitude_i;
         }
@@ -62,7 +63,8 @@ class GPSStatus : public Status
     int32_t getLongitude() const
     {
         if (config.position.fixed_position) {
-            return localPosition.longitude_i;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.longitude_i;
         } else {
             return p.longitude_i;
         }
@@ -71,7 +73,8 @@ class GPSStatus : public Status
     int32_t getAltitude() const
     {
         if (config.position.fixed_position) {
-            return localPosition.altitude;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.altitude;
         } else {
             return p.altitude;
         }

src/MessageStore.cpp

@@ -1,11 +1,12 @@
 #include "configuration.h"
-#if HAS_SCREEN || defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
+#if HAS_SCREEN
 #include "FSCommon.h"
 #include "MessageStore.h"
 #include "NodeDB.h"
 #include "SPILock.h"
 #include "SafeFile.h"
 #include "gps/RTC.h"
+#include "graphics/draw/MessageRenderer.h"
 #include <cstring> // memcpy
 
 #ifndef MESSAGE_TEXT_POOL_SIZE
@@ -180,8 +181,13 @@ const StoredMessage &MessageStore::addFromPacket(const meshtastic_MeshPacket &pa
 
     bool isDM = (sm.dest != 0 && sm.dest != NODENUM_BROADCAST);
 
-    sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
-    sm.ackStatus = (packet.from == 0) ? AckStatus::NONE : AckStatus::ACKED;
+    if (packet.from == 0) {
+        sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+        sm.ackStatus = AckStatus::NONE;
+    } else {
+        sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+        sm.ackStatus = AckStatus::ACKED;
+    }
 
     addLiveMessage(sm);
 
@@ -366,25 +372,26 @@ void MessageStore::clearAllMessages()
 #endif
 }
 
-// Internal helpers for targeted erasure.
-template <typename Predicate> static bool eraseFirstMatch(std::deque<StoredMessage> &deque, Predicate pred)
+// Internal helper: erase first or last message matching a predicate
+template <typename Predicate> static void eraseIf(std::deque<StoredMessage> &deque, Predicate pred, bool fromBack = false)
 {
-    for (auto it = deque.begin(); it != deque.end(); ++it) {
-        if (pred(*it)) {
-            deque.erase(it);
-            return true;
+    if (fromBack) {
+        // Iterate from the back and erase all matches from the end
+        for (auto it = deque.rbegin(); it != deque.rend();) {
+            if (pred(*it)) {
+                it = std::deque<StoredMessage>::reverse_iterator(deque.erase(std::next(it).base()));
+            } else {
+                ++it;
+            }
         }
-    }
-    return false;
-}
-
-template <typename Predicate> static void eraseAllMatches(std::deque<StoredMessage> &deque, Predicate pred)
-{
-    for (auto it = deque.begin(); it != deque.end();) {
-        if (pred(*it)) {
-            it = deque.erase(it);
-        } else {
-            ++it;
+    } else {
+        // Manual forward search to erase all matches
+        for (auto it = deque.begin(); it != deque.end();) {
+            if (pred(*it)) {
+                it = deque.erase(it);
+            } else {
+                ++it;
+            }
         }
     }
 }
@@ -392,9 +399,7 @@ template <typename Predicate> static void eraseAllMatches(std::deque<StoredMessa
 // Delete oldest message (RAM + persisted queue)
 void MessageStore::deleteOldestMessage()
 {
-    if (!liveMessages.empty()) {
-        liveMessages.pop_front();
-    }
+    eraseIf(liveMessages, [](StoredMessage &) { return true; });
     saveToFlash();
 }
 
@@ -402,14 +407,14 @@ void MessageStore::deleteOldestMessage()
 void MessageStore::deleteOldestMessageInChannel(uint8_t channel)
 {
     auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
-    eraseFirstMatch(liveMessages, pred);
+    eraseIf(liveMessages, pred);
     saveToFlash();
 }
 
 void MessageStore::deleteAllMessagesInChannel(uint8_t channel)
 {
     auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
-    eraseAllMatches(liveMessages, pred);
+    eraseIf(liveMessages, pred, false /* delete ALL, not just first */);
     saveToFlash();
 }
 
@@ -422,7 +427,7 @@ void MessageStore::deleteAllMessagesWithPeer(uint32_t peer)
         uint32_t other = (m.sender == local) ? m.dest : m.sender;
         return other == peer;
     };
-    eraseAllMatches(liveMessages, pred);
+    eraseIf(liveMessages, pred, false);
     saveToFlash();
 }
 
@@ -435,7 +440,7 @@ void MessageStore::deleteOldestMessageWithPeer(uint32_t peer)
         uint32_t other = (m.sender == nodeDB->getNodeNum()) ? m.dest : m.sender;
         return other == peer;
     };
-    eraseFirstMatch(liveMessages, pred);
+    eraseIf(liveMessages, pred);
     saveToFlash();
 }
 

src/MessageStore.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if HAS_SCREEN || defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
+#if HAS_SCREEN
 
 // Disable debug logging entirely on release builds of HELTEC_MESH_SOLAR for space constraints
 #if defined(HELTEC_MESH_SOLAR)
@@ -124,6 +124,9 @@ class MessageStore
     // Allocate text into pool (used by sender-side code)
     static uint16_t storeText(const char *src, size_t len);
 
+    // Used when loading from flash to rebuild the text pool
+    static uint16_t rebuildTextFromFlash(const char *src, size_t len);
+
   private:
     std::deque<StoredMessage> liveMessages; // Single in-RAM message buffer (also used for persistence)
     std::string filename;                   // Flash filename for persistence

src/Power.cpp

@@ -23,14 +23,8 @@
 #include "main.h"
 #include "meshUtils.h"
 #include "power/PowerHAL.h"
+#include "power/SGM41562.h"
 #include "sleep.h"
-#ifdef ARCH_ESP32
-// #include <driver/adc.h>
-#include <esp_adc/adc_cali.h>
-#include <esp_adc/adc_cali_scheme.h>
-#include <esp_adc/adc_oneshot.h>
-#include <esp_err.h>
-#endif
 
 #if defined(ARCH_PORTDUINO)
 #include "api/WiFiServerAPI.h"
@@ -47,22 +41,6 @@
 #include "concurrency/LockGuard.h"
 #endif
 
-#if defined(ARCH_STM32WL) && defined(BATTERY_PIN)
-#include "stm32yyxx_ll_adc.h"
-
-/* Analog read resolution */
-#if defined(LL_ADC_RESOLUTION_12B)
-#define LL_ADC_RESOLUTION LL_ADC_RESOLUTION_12B
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#elif defined(LL_ADC_DS_DATA_WIDTH_12_BIT)
-#define LL_ADC_RESOLUTION LL_ADC_DS_DATA_WIDTH_12_BIT
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#else
-#error "ADC resolution could not be defined!"
-#endif
-#define ADC_RANGE (1 << BATTERY_SENSE_RESOLUTION_BITS)
-#endif
-
 #if defined(DEBUG_HEAP_MQTT) && !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #include "target_specific.h"
@@ -70,8 +48,9 @@
 #include <WiFi.h>
 #endif
 
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 
 #endif
@@ -83,113 +62,33 @@
 #if defined(BATTERY_PIN) && defined(ARCH_ESP32)
 
 #ifndef BAT_MEASURE_ADC_UNIT // ADC1 is default
-static const adc_channel_t adc_channel = ADC_CHANNEL;
+static const adc1_channel_t adc_channel = ADC_CHANNEL;
 static const adc_unit_t unit = ADC_UNIT_1;
-#else  // ADC2
-static const adc_channel_t adc_channel = ADC_CHANNEL;
+#else // ADC2
+static const adc2_channel_t adc_channel = ADC_CHANNEL;
 static const adc_unit_t unit = ADC_UNIT_2;
+RTC_NOINIT_ATTR uint64_t RTC_reg_b;
+
 #endif // BAT_MEASURE_ADC_UNIT
 
-static adc_oneshot_unit_handle_t adc_handle = nullptr;
-static adc_cali_handle_t adc_cali_handle = nullptr;
-static bool adc_calibrated = false;
+esp_adc_cal_characteristics_t *adc_characs = (esp_adc_cal_characteristics_t *)calloc(1, sizeof(esp_adc_cal_characteristics_t));
 #ifndef ADC_ATTENUATION
 static const adc_atten_t atten = ADC_ATTEN_DB_12;
 #else
 static const adc_atten_t atten = ADC_ATTENUATION;
 #endif
-#ifdef ADC_BITWIDTH
-static const adc_bitwidth_t adc_width = ADC_BITWIDTH;
-#else
-static const adc_bitwidth_t adc_width = ADC_BITWIDTH_DEFAULT;
-#endif
-
-static int adcBitWidthToBits(adc_bitwidth_t width)
-{
-    switch (width) {
-    case ADC_BITWIDTH_9:
-        return 9;
-    case ADC_BITWIDTH_10:
-        return 10;
-    case ADC_BITWIDTH_11:
-        return 11;
-    case ADC_BITWIDTH_12:
-        return 12;
-#ifdef ADC_BITWIDTH_13
-    case ADC_BITWIDTH_13:
-        return 13;
-#endif
-    default:
-        return 12;
-    }
-}
-
-static bool initAdcCalibration()
-{
-#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
-    adc_cali_curve_fitting_config_t cali_config = {
-        .unit_id = unit,
-        .atten = atten,
-        .bitwidth = adc_width,
-    };
-    esp_err_t ret = adc_cali_create_scheme_curve_fitting(&cali_config, &adc_cali_handle);
-    if (ret == ESP_OK) {
-        LOG_INFO("ADC calibration: curve fitting enabled");
-        return true;
-    }
-    if (ret != ESP_ERR_NOT_SUPPORTED) {
-        LOG_WARN("ADC calibration: curve fitting failed: %s", esp_err_to_name(ret));
-    }
-#endif
-
-#if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
-    adc_cali_line_fitting_config_t cali_config = {
-        .unit_id = unit,
-        .atten = atten,
-        .bitwidth = adc_width,
-        .default_vref = DEFAULT_VREF,
-    };
-    esp_err_t ret = adc_cali_create_scheme_line_fitting(&cali_config, &adc_cali_handle);
-    if (ret == ESP_OK) {
-        LOG_INFO("ADC calibration: line fitting enabled");
-        return true;
-    }
-    if (ret != ESP_ERR_NOT_SUPPORTED) {
-        LOG_WARN("ADC calibration: line fitting failed: %s", esp_err_to_name(ret));
-    }
-#endif
-
-    LOG_INFO("ADC calibration not supported; using approximate scaling");
-    return false;
-}
-
 #endif // BATTERY_PIN && ARCH_ESP32
 
-#ifdef EXT_PWR_DETECT
-#ifndef EXT_PWR_DETECT_MODE
-#define EXT_PWR_DETECT_MODE INPUT
-// If using internal pull resistors, we can infer EXT_PWR_DETECT_VALUE
-#elif EXT_PWR_DETECT_MODE == INPUT_PULLUP
-#define EXT_PWR_DETECT_VALUE LOW
-#elif EXT_PWR_DETECT_MODE == INPUT_PULLDOWN
-#define EXT_PWR_DETECT_VALUE HIGH
-#endif
-#ifndef EXT_PWR_DETECT_VALUE
-#define EXT_PWR_DETECT_VALUE HIGH
-#endif
-#endif
-
 #ifdef EXT_CHRG_DETECT
 #ifndef EXT_CHRG_DETECT_MODE
-#define EXT_CHRG_DETECT_MODE INPUT
-// If using internal pull resistors, we can infer EXT_CHRG_DETECT_VALUE
-#elif EXT_CHRG_DETECT_MODE == INPUT_PULLUP
-#define EXT_CHRG_DETECT_VALUE LOW
-#elif EXT_CHRG_DETECT_MODE == INPUT_PULLDOWN
-#define EXT_CHRG_DETECT_VALUE HIGH
+static const uint8_t ext_chrg_detect_mode = INPUT;
+#else
+static const uint8_t ext_chrg_detect_mode = EXT_CHRG_DETECT_MODE;
 #endif
 #ifndef EXT_CHRG_DETECT_VALUE
-#define EXT_CHRG_DETECT_VALUE HIGH
+static const uint8_t ext_chrg_detect_value = HIGH;
+#else
+static const uint8_t ext_chrg_detect_value = EXT_CHRG_DETECT_VALUE;
 #endif
 #endif
 
@@ -430,29 +329,11 @@ class AnalogBatteryLevel : public HasBatteryLevel
             float scaled = 0;
 
             battery_adcEnable();
-#ifdef ARCH_STM32WL
-            // STM32 ADC with VREFINT runtime calibration
-            Vref = __LL_ADC_CALC_VREFANALOG_VOLTAGE(analogRead(AVREF), LL_ADC_RESOLUTION);
-            raw = analogRead(BATTERY_PIN);
-            scaled = __LL_ADC_CALC_DATA_TO_VOLTAGE(Vref, raw, LL_ADC_RESOLUTION);
-            scaled *= operativeAdcMultiplier;
-#elif defined(ARCH_ESP32) // ADC block for espressif platforms
+#ifdef ARCH_ESP32 // ADC block for espressif platforms
             raw = espAdcRead();
-            int voltage_mv = 0;
-            if (adc_calibrated && adc_cali_handle) {
-                if (adc_cali_raw_to_voltage(adc_cali_handle, raw, &voltage_mv) != ESP_OK) {
-                    LOG_WARN("ADC calibration read failed; using raw value");
-                    voltage_mv = 0;
-                }
-            }
-            if (voltage_mv == 0) {
-                // Fallback approximate conversion without calibration
-                const int bits = adcBitWidthToBits(adc_width);
-                const float max_code = powf(2.0f, bits) - 1.0f;
-                voltage_mv = (int)((raw / max_code) * DEFAULT_VREF);
-            }
-            scaled = voltage_mv * operativeAdcMultiplier;
-#else                     // block for all other platforms
+            scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
+            scaled *= operativeAdcMultiplier;
+#else // block for all other platforms
 #ifdef ARCH_NRF52
             concurrency::LockGuard saadcGuard(concurrency::nrf52SaadcLock);
 #endif
@@ -493,22 +374,51 @@ class AnalogBatteryLevel : public HasBatteryLevel
         uint32_t raw = 0;
         uint8_t raw_c = 0; // raw reading counter
 
-        if (!adc_handle) {
-            LOG_ERROR("ADC oneshot handle not initialized");
-            return 0;
-        }
-
+#ifndef BAT_MEASURE_ADC_UNIT // ADC1
         for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-            int val = 0;
-            esp_err_t err = adc_oneshot_read(adc_handle, adc_channel, &val);
-            if (err == ESP_OK) {
-                raw += val;
+            int val_ = adc1_get_raw(adc_channel);
+            if (val_ >= 0) { // save only valid readings
+                raw += val_;
                 raw_c++;
+            }
+            // delayMicroseconds(100);
+        }
+#else                            // ADC2
+#ifdef CONFIG_IDF_TARGET_ESP32S3 // ESP32S3
+        // ADC2 wifi bug workaround not required, breaks compile
+        // On ESP32S3, ADC2 can take turns with Wifi (?)
+
+        int32_t adc_buf;
+        esp_err_t read_result;
+
+        // Multiple samples
+        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
+            adc_buf = 0;
+            read_result = -1;
+
+            read_result = adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
+            if (read_result == ESP_OK) {
+                raw += adc_buf;
+                raw_c++; // Count valid samples
             } else {
-                LOG_DEBUG("ADC read failed: %s", esp_err_to_name(err));
+                LOG_DEBUG("An attempt to sample ADC2 failed");
             }
         }
 
+#else  // Other ESP32
+        int32_t adc_buf = 0;
+        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
+            // ADC2 wifi bug workaround, see
+            // https://github.com/espressif/arduino-esp32/issues/102
+            WRITE_PERI_REG(SENS_SAR_READ_CTRL2_REG, RTC_reg_b);
+            SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
+            adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
+            raw += adc_buf;
+            raw_c++;
+        }
+#endif // BAT_MEASURE_ADC_UNIT
+
+#endif // End BAT_MEASURE_ADC_UNIT
         return (raw / (raw_c < 1 ? 1 : raw_c));
     }
 #endif
@@ -538,14 +448,32 @@ class AnalogBatteryLevel : public HasBatteryLevel
     virtual bool isBatteryConnect() override { return getBatteryPercent() != -1; }
 #endif
 
-    // Detect if an external power source is connected if we don’t have a PMIC;
-    // Firstly prefer EXT_PWR_DETECT GPIO if available,
-    // secondly try an nRF52-specific routine on some variants,
-    // lastly provide a fallback to indicate external power when fully charged.
+    /// If we see a battery voltage higher than physics allows - assume charger is
+    /// pumping in power On some boards we don't have the power management chip
+    /// (like AXPxxxx) so we use EXT_PWR_DETECT GPIO pin to detect external power
+    /// source
     virtual bool isVbusIn() override
     {
+#ifdef HAS_SGM41562
+        if (sgm41562 && sgm41562->refresh())
+            return sgm41562->isInputPowerGood();
+#endif
 #ifdef EXT_PWR_DETECT
-        return digitalRead(EXT_PWR_DETECT) == EXT_PWR_DETECT_VALUE;
+#if defined(HELTEC_CAPSULE_SENSOR_V3) || defined(HELTEC_SENSOR_HUB)
+        // if external powered that pin will be pulled down
+        if (digitalRead(EXT_PWR_DETECT) == LOW) {
+            return true;
+        }
+        // if it's not LOW - check the battery
+#else
+        // if external powered that pin will be pulled up
+        if (digitalRead(EXT_PWR_DETECT) == HIGH) {
+            return true;
+        }
+        // if it's not HIGH - check the battery
+#endif
+        // If we have an EXT_PWR_DETECT pin and it indicates no external power, believe it.
+        return false;
 
 // technically speaking this should work for all(?) NRF52 boards
 // but needs testing across multiple devices. NRF52 USB would not even work if
@@ -560,15 +488,19 @@ class AnalogBatteryLevel : public HasBatteryLevel
     /// we can't be smart enough to say 'full'?
     virtual bool isCharging() override
     {
+#ifdef HAS_SGM41562
+        if (sgm41562 && sgm41562->refresh())
+            return sgm41562->isCharging();
+#endif
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT) && !defined(HAS_PMU)
         if (hasRAK()) {
             return (rak9154Sensor.isCharging()) ? OptTrue : OptFalse;
         }
 #endif
 #if defined(ELECROW_ThinkNode_M6)
-        return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE || isVbusIn();
+        return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value || isVbusIn();
 #elif EXT_CHRG_DETECT
-        return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
+        return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value;
 #elif defined(BATTERY_CHARGING_INV)
         return !digitalRead(BATTERY_CHARGING_INV);
 #else
@@ -607,11 +539,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
     bool initial_read_done = false;
     float last_read_value = (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS);
     uint32_t last_read_time_ms = 0;
-#ifdef ARCH_STM32WL
-    // 3300mV placeholder for STM32 errata where VREFINT factory calibration may be missing
-    // (e.g. STM32U0, see DS14756 Rev 3 §2.4.1 "VREFINT offset")
-    uint32_t Vref = 3300;
-#endif
 
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT)
 
@@ -701,10 +628,14 @@ Power::Power() : OSThread("Power")
 bool Power::analogInit()
 {
 #ifdef EXT_PWR_DETECT
-    pinMode(EXT_PWR_DETECT, EXT_PWR_DETECT_MODE);
+#if defined(HELTEC_CAPSULE_SENSOR_V3) || defined(HELTEC_SENSOR_HUB)
+    pinMode(EXT_PWR_DETECT, INPUT_PULLUP);
+#else
+    pinMode(EXT_PWR_DETECT, INPUT);
+#endif
 #endif
 #ifdef EXT_CHRG_DETECT
-    pinMode(EXT_CHRG_DETECT, EXT_CHRG_DETECT_MODE);
+    pinMode(EXT_CHRG_DETECT, ext_chrg_detect_mode);
 #endif
 
 #ifdef BATTERY_PIN
@@ -717,38 +648,47 @@ bool Power::analogInit()
 #define BATTERY_SENSE_RESOLUTION_BITS 10
 #endif
 
-#ifdef ARCH_STM32WL
-    analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
-#elif defined(ARCH_ESP32) // ESP32 needs special analog stuff
-    adc_oneshot_unit_init_cfg_t init_config = {
-        .unit_id = unit,
-    };
+#ifdef ARCH_ESP32 // ESP32 needs special analog stuff
 
-    if (!adc_handle) {
-        esp_err_t err = adc_oneshot_new_unit(&init_config, &adc_handle);
-        if (err != ESP_OK) {
-            LOG_ERROR("ADC oneshot init failed: %s", esp_err_to_name(err));
-            return false;
-        }
+#ifndef ADC_WIDTH // max resolution by default
+    static const adc_bits_width_t width = ADC_WIDTH_BIT_12;
+#else
+    static const adc_bits_width_t width = ADC_WIDTH;
+#endif
+#ifndef BAT_MEASURE_ADC_UNIT // ADC1
+    adc1_config_width(width);
+    adc1_config_channel_atten(adc_channel, atten);
+#else // ADC2
+    adc2_config_channel_atten(adc_channel, atten);
+#ifndef CONFIG_IDF_TARGET_ESP32S3
+    // ADC2 wifi bug workaround
+    // Not required with ESP32S3, breaks compile
+    RTC_reg_b = READ_PERI_REG(SENS_SAR_READ_CTRL2_REG);
+#endif
+#endif
+    // calibrate ADC
+    esp_adc_cal_value_t val_type = esp_adc_cal_characterize(unit, atten, width, DEFAULT_VREF, adc_characs);
+    // show ADC characterization base
+    if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) {
+        LOG_INFO("ADC config based on Two Point values stored in eFuse");
+    } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) {
+        LOG_INFO("ADC config based on reference voltage stored in eFuse");
     }
-
-    adc_oneshot_chan_cfg_t chan_cfg = {
-        .atten = atten,
-        .bitwidth = adc_width,
-    };
-
-    esp_err_t err = adc_oneshot_config_channel(adc_handle, adc_channel, &chan_cfg);
-    if (err != ESP_OK) {
-        LOG_ERROR("ADC channel config failed: %s", esp_err_to_name(err));
-        return false;
+#ifdef CONFIG_IDF_TARGET_ESP32S3
+    // ESP32S3
+    else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP_FIT) {
+        LOG_INFO("ADC config based on Two Point values and fitting curve "
+                 "coefficients stored in eFuse");
     }
-
-    adc_calibrated = initAdcCalibration();
-#endif                    // ARCH_ESP32
+#endif
+    else {
+        LOG_INFO("ADC config based on default reference voltage");
+    }
+#endif // ARCH_ESP32
 
     // NRF52 ADC init moved to powerHAL_init in nrf52 platform
 
-#if !defined(ARCH_ESP32) && !defined(ARCH_STM32WL)
+#ifndef ARCH_ESP32
     analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
 #endif
 
@@ -766,6 +706,12 @@ bool Power::analogInit()
  */
 bool Power::setup()
 {
+#ifdef HAS_SGM41562
+    // Initialize the charger early so AnalogBatteryLevel can read charging
+    // state from it. The charger does not provide battery voltage / percent —
+    // those still come from the platform ADC via analogInit() below.
+    initSGM41562(SGM41562_WIRE);
+#endif
     bool found = false;
     if (axpChipInit()) {
         found = true;
@@ -1054,14 +1000,6 @@ int32_t Power::runOnce()
             powerFSM.trigger(EVENT_POWER_CONNECTED);
         }
 
-#ifdef PMU_POWER_BUTTON_IS_CANCEL
-        // cancel action also turns the screen on and off.
-        if (PMU->isPekeyShortPressIrq()) {
-            LOG_INFO("Input: Corona Button Click");
-            InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_CANCEL, .kbchar = 0, .touchX = 0, .touchY = 0};
-            inputBroker->injectInputEvent(&event);
-        }
-#endif
         /*
         Other things we could check if we cared...
 
@@ -1078,6 +1016,13 @@ int32_t Power::runOnce()
             LOG_DEBUG("Battery removed");
         }
         */
+#ifndef T_WATCH_S3 // FIXME - why is this triggering on the T-Watch S3?
+        if (PMU->isPekeyLongPressIrq()) {
+            LOG_DEBUG("PEK long button press");
+            if (screen)
+                screen->setOn(false);
+        }
+#endif
 
         PMU->clearIrqStatus();
     }
@@ -1146,7 +1091,7 @@ void Power::attachPowerInterrupts()
     if (PMU) {
         attachInterrupt(
             PMU_IRQ,
-            []() {
+            [] {
                 pmu_irq = true;
                 power->setIntervalFromNow(0);
                 runASAP = true;
@@ -1449,16 +1394,19 @@ bool Power::axpChipInit()
     uint64_t pmuIrqMask = 0;
 
     if (PMU->getChipModel() == XPOWERS_AXP192) {
-        pmuIrqMask = XPOWERS_AXP192_VBUS_INSERT_IRQ | XPOWERS_AXP192_VBUS_REMOVE_IRQ | XPOWERS_AXP192_PKEY_SHORT_IRQ;
+        pmuIrqMask = XPOWERS_AXP192_VBUS_INSERT_IRQ | XPOWERS_AXP192_BAT_INSERT_IRQ | XPOWERS_AXP192_PKEY_SHORT_IRQ;
     } else if (PMU->getChipModel() == XPOWERS_AXP2101) {
-        pmuIrqMask = XPOWERS_AXP2101_VBUS_INSERT_IRQ | XPOWERS_AXP2101_VBUS_REMOVE_IRQ | XPOWERS_AXP2101_PKEY_SHORT_IRQ;
+        pmuIrqMask = XPOWERS_AXP2101_VBUS_INSERT_IRQ | XPOWERS_AXP2101_BAT_INSERT_IRQ | XPOWERS_AXP2101_PKEY_SHORT_IRQ;
     }
 
     pinMode(PMU_IRQ, INPUT);
 
-    // We wake on IRQ, so only enable the IRQs that we care about.
-    // we want USB plug and unplug to update the screen and LED status,
-    // and short press on the power button to trigger the "cancel" action in the UI (which also turns the screen on and off).
+    // we do not look for AXPXXX_CHARGING_FINISHED_IRQ & AXPXXX_CHARGING_IRQ
+    // because it occurs repeatedly while there is no battery also it could cause
+    // inadvertent waking from light sleep just because the battery filled we
+    // don't look for AXPXXX_BATT_REMOVED_IRQ because it occurs repeatedly while
+    // no battery installed we don't look at AXPXXX_VBUS_REMOVED_IRQ because we
+    // don't have anything hooked to vbus
     PMU->enableIRQ(pmuIrqMask);
 
     PMU->clearIrqStatus();
@@ -1924,7 +1872,7 @@ class SerialBatteryLevel : public HasBatteryLevel
     {
 #if defined(EXT_CHRG_DETECT)
 
-        return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
+        return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value;
 
 #endif
         return false;
@@ -1933,7 +1881,7 @@ class SerialBatteryLevel : public HasBatteryLevel
     virtual bool isCharging() override
     {
 #ifdef EXT_CHRG_DETECT
-        return digitalRead(EXT_CHRG_DETECT) == EXT_CHRG_DETECT_VALUE;
+        return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value;
 
 #endif
         // by default, we check the battery voltage only
@@ -1955,10 +1903,10 @@ SerialBatteryLevel serialBatteryLevel;
 bool Power::serialBatteryInit()
 {
 #ifdef EXT_PWR_DETECT
-    pinMode(EXT_PWR_DETECT, EXT_PWR_DETECT_MODE);
+    pinMode(EXT_PWR_DETECT, INPUT);
 #endif
 #ifdef EXT_CHRG_DETECT
-    pinMode(EXT_CHRG_DETECT, EXT_CHRG_DETECT_MODE);
+    pinMode(EXT_CHRG_DETECT, ext_chrg_detect_mode);
 #endif
 
     bool result = serialBatteryLevel.runOnce();

src/PowerFSM.cpp

@@ -58,35 +58,6 @@ static bool isPowered()
     return !isPowerSavingMode && powerStatus && (!powerStatus->getHasBattery() || powerStatus->getHasUSB());
 }
 
-#if defined(T5_S3_EPAPER_PRO)
-static void t5BacklightOffForSleep()
-{
-    t5BacklightSetForcedBySleep(true);
-}
-
-static void t5BacklightWakeFromSleep()
-{
-    t5BacklightSetForcedBySleep(false);
-}
-
-static void t5BacklightOffForTimeout()
-{
-    t5BacklightSetForcedByTimeout(true);
-    t5TouchSetForcedByTimeout(true);
-}
-
-static void t5BacklightOnFromUserInput()
-{
-    t5BacklightHandleUserInput();
-    t5TouchHandleUserInput();
-}
-#else
-static void t5BacklightOffForSleep() {}
-static void t5BacklightWakeFromSleep() {}
-static void t5BacklightOffForTimeout() {}
-static void t5BacklightOnFromUserInput() {}
-#endif
-
 static void sdsEnter()
 {
     LOG_POWERFSM("State: SDS");
@@ -116,7 +87,6 @@ static void lsEnter()
     LOG_POWERFSM("lsEnter begin, ls_secs=%u", config.power.ls_secs);
     if (screen)
         screen->setOn(false);
-    t5BacklightOffForSleep();
     secsSlept = 0; // How long have we been sleeping this time
 
     // LOG_INFO("lsEnter end");
@@ -189,8 +159,6 @@ static void lsIdle()
 static void lsExit()
 {
     LOG_POWERFSM("State: lsExit");
-    // Lift the light-sleep force-off gate when leaving LS.
-    t5BacklightWakeFromSleep();
 }
 
 static void nbEnter()
@@ -212,8 +180,6 @@ static void darkEnter()
     setBluetoothEnable(true);
     if (screen)
         screen->setOn(false);
-    // Screen timeout enters DARK; ensure backlight also turns off.
-    t5BacklightOffForTimeout();
 }
 
 static void serialEnter()
@@ -323,13 +289,12 @@ void PowerFSM_setup()
     powerFSM.add_transition(&stateNB, &stateNB, EVENT_PACKET_FOR_PHONE, NULL, "Received packet, resetting win wake");
 
     // Handle press events - note: we ignore button presses when in API mode
-    powerFSM.add_transition(&stateLS, &stateON, EVENT_PRESS, t5BacklightOnFromUserInput, "Press");
-    powerFSM.add_transition(&stateNB, &stateON, EVENT_PRESS, t5BacklightOnFromUserInput, "Press");
-    powerFSM.add_transition(&stateDARK, isPowered() ? &statePOWER : &stateON, EVENT_PRESS, t5BacklightOnFromUserInput, "Press");
-    powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_PRESS, t5BacklightOnFromUserInput, "Press");
-    powerFSM.add_transition(&stateON, &stateON, EVENT_PRESS, t5BacklightOnFromUserInput,
-                            "Press"); // reenter On to restart our timers
-    powerFSM.add_transition(&stateSERIAL, &stateSERIAL, EVENT_PRESS, t5BacklightOnFromUserInput,
+    powerFSM.add_transition(&stateLS, &stateON, EVENT_PRESS, NULL, "Press");
+    powerFSM.add_transition(&stateNB, &stateON, EVENT_PRESS, NULL, "Press");
+    powerFSM.add_transition(&stateDARK, isPowered() ? &statePOWER : &stateON, EVENT_PRESS, NULL, "Press");
+    powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_PRESS, NULL, "Press");
+    powerFSM.add_transition(&stateON, &stateON, EVENT_PRESS, NULL, "Press"); // reenter On to restart our timers
+    powerFSM.add_transition(&stateSERIAL, &stateSERIAL, EVENT_PRESS, NULL,
                             "Press"); // Allow button to work while in serial API
 
     // Handle critically low power battery by forcing deep sleep
@@ -349,13 +314,11 @@ void PowerFSM_setup()
     powerFSM.add_transition(&stateSERIAL, &stateSHUTDOWN, EVENT_SHUTDOWN, NULL, "Shutdown");
 
     // Inputbroker
-    powerFSM.add_transition(&stateLS, &stateON, EVENT_INPUT, t5BacklightOnFromUserInput, "Input Device");
-    powerFSM.add_transition(&stateNB, &stateON, EVENT_INPUT, t5BacklightOnFromUserInput, "Input Device");
-    powerFSM.add_transition(&stateDARK, &stateON, EVENT_INPUT, t5BacklightOnFromUserInput, "Input Device");
-    powerFSM.add_transition(&stateON, &stateON, EVENT_INPUT, t5BacklightOnFromUserInput,
-                            "Input Device"); // restarts the sleep timer
-    powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_INPUT, t5BacklightOnFromUserInput,
-                            "Input Device"); // restarts the sleep timer
+    powerFSM.add_transition(&stateLS, &stateON, EVENT_INPUT, NULL, "Input Device");
+    powerFSM.add_transition(&stateNB, &stateON, EVENT_INPUT, NULL, "Input Device");
+    powerFSM.add_transition(&stateDARK, &stateON, EVENT_INPUT, NULL, "Input Device");
+    powerFSM.add_transition(&stateON, &stateON, EVENT_INPUT, NULL, "Input Device");       // restarts the sleep timer
+    powerFSM.add_transition(&statePOWER, &statePOWER, EVENT_INPUT, NULL, "Input Device"); // restarts the sleep timer
 
     powerFSM.add_transition(&stateDARK, &stateON, EVENT_BLUETOOTH_PAIR, NULL, "Bluetooth pairing");
     powerFSM.add_transition(&stateON, &stateON, EVENT_BLUETOOTH_PAIR, NULL, "Bluetooth pairing");

src/RF95Configuration.h

@@ -1,16 +1,6 @@
 // TODO refactor this out with better radio configuration system
 #ifdef USE_RF95
-
-#ifndef RF95_RESET
 #define RF95_RESET LORA_RESET
-#endif
-
-#ifndef RF95_IRQ
-#define RF95_IRQ LORA_DIO0 // on SX1262 version this is a no connect DIO0
-#endif
-
-#ifndef RF95_DIO1
+#define RF95_IRQ LORA_DIO0  // on SX1262 version this is a no connect DIO0
 #define RF95_DIO1 LORA_DIO1 // Note: not really used for RF95, but used for pure SX127x
 #endif
-
-#endif

src/RedirectablePrint.cpp

@@ -51,7 +51,7 @@ size_t RedirectablePrint::write(uint8_t c)
 size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_list arg)
 {
     va_list copy;
-#if ARCH_PORTDUINO
+#if ENABLE_JSON_LOGGING || ARCH_PORTDUINO
     static char printBuf[512];
 #else
     static char printBuf[160];
@@ -137,7 +137,7 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
         if (color) {
             ::printf("\u001b[0m");
         }
-        ::printf("| %02d:%02d:%02d %u.%03u ", hour, min, sec, millis() / 1000, millis() % 1000);
+        ::printf("| %02d:%02d:%02d %u ", hour, min, sec, millis() / 1000);
 #else
         printf("%s ", logLevel);
         if (color) {
@@ -151,7 +151,7 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
         if (color) {
             ::printf("\u001b[0m");
         }
-        ::printf("| ??:??:?? %u.%03u ", millis() / 1000, millis() % 1000);
+        ::printf("| ??:??:?? %u ", millis() / 1000);
 #else
         printf("%s ", logLevel);
         if (color) {
@@ -225,16 +225,14 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
         isBleConnected = nimbleBluetooth && nimbleBluetooth->isActive() && nimbleBluetooth->isConnected();
 #elif defined(ARCH_NRF52)
         isBleConnected = nrf52Bluetooth != nullptr && nrf52Bluetooth->isConnected();
-#elif defined(ARCH_NRF54L15)
-        isBleConnected = nrf54l15Bluetooth != nullptr && nrf54l15Bluetooth->isConnected();
 #endif
         if (isBleConnected) {
             auto thread = concurrency::OSThread::currentThread;
             meshtastic_LogRecord logRecord = meshtastic_LogRecord_init_zero;
             logRecord.level = getLogLevel(logLevel);
-            vsnprintf(logRecord.message, sizeof(logRecord.message), format, arg);
+            vsprintf(logRecord.message, format, arg);
             if (thread)
-                strlcpy(logRecord.source, thread->ThreadName.c_str(), sizeof(logRecord.source));
+                strcpy(logRecord.source, thread->ThreadName.c_str());
             logRecord.time = getValidTime(RTCQuality::RTCQualityDevice, true);
 
             auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[meshtastic_LogRecord_size]);
@@ -243,8 +241,6 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
             nimbleBluetooth->sendLog(buffer.get(), size);
 #elif defined(ARCH_NRF52)
             nrf52Bluetooth->sendLog(buffer.get(), size);
-#elif defined(ARCH_NRF54L15)
-            nrf54l15Bluetooth->sendLog(buffer.get(), size);
 #endif
         }
     }

src/SafeFile.cpp

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

src/SerialConsole.cpp

@@ -30,9 +30,6 @@ SerialConsole *console;
 
 void consoleInit()
 {
-    if (console) {
-        return;
-    }
     auto sc = new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
 
 #if defined(SERIAL_HAS_ON_RECEIVE)

src/airtime.cpp

@@ -133,12 +133,11 @@ bool AirTime::isTxAllowedChannelUtil(bool polite)
 
 bool AirTime::isTxAllowedAirUtil()
 {
-    float effectiveDutyCycle = getEffectiveDutyCycle();
-    if (!config.lora.override_duty_cycle && effectiveDutyCycle < 100) {
-        if (utilizationTXPercent() < effectiveDutyCycle * polite_duty_cycle_percent / 100) {
+    if (!config.lora.override_duty_cycle && myRegion->dutyCycle < 100) {
+        if (utilizationTXPercent() < myRegion->dutyCycle * polite_duty_cycle_percent / 100) {
             return true;
         } else {
-            LOG_WARN("TX air util. >%f%%. Skip send", effectiveDutyCycle * polite_duty_cycle_percent / 100);
+            LOG_WARN("TX air util. >%f%%. Skip send", myRegion->dutyCycle * polite_duty_cycle_percent / 100);
             return false;
         }
     }

src/airtime.h

@@ -19,8 +19,8 @@
 
   TX_LOG + RX_LOG = Total air time for a particular meshtastic channel.
 
-  TX_LOG + RX_ALL_LOG = Total air time for a particular meshtastic channel, including
-                        other lora radios.
+  TX_LOG + RX_LOG = Total air time for a particular meshtastic channel, including
+                    other lora radios.
 
   RX_ALL_LOG - RX_LOG = Other lora radios on our frequency channel.
 */

src/configuration.h

@@ -83,11 +83,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // Configuration
 // -----------------------------------------------------------------------------
 
-// Pre-hop drop handling (compile-time flag).
-#ifndef MESHTASTIC_PREHOP_DROP
-#define MESHTASTIC_PREHOP_DROP 1
-#endif
-
 /// Convert a preprocessor name into a quoted string
 #define xstr(s) ystr(s)
 #define ystr(s) #s
@@ -239,7 +234,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define BME_ADDR 0x76
 #define BME_ADDR_ALTERNATE 0x77
 #define MCP9808_ADDR 0x18
-#define INA_ADDR 0x40 // same as SHT2X
+#define INA_ADDR 0x40
 #define INA_ADDR_ALTERNATE 0x41
 #define INA_ADDR_WAVESHARE_UPS 0x43
 #define INA3221_ADDR 0x42
@@ -253,8 +248,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LPS22HB_ADDR 0x5C
 #define LPS22HB_ADDR_ALT 0x5D
 #define SFA30_ADDR 0x5D
-#define SHTXX_ADDR 0x44
-#define SHTXX_ADDR_ALT 0x45
+#define SHT31_4x_ADDR 0x44
+#define SHT31_4x_ADDR_ALT 0x45
 #define PMSA003I_ADDR 0x12
 #define QMA6100P_ADDR 0x12
 #define AHT10_ADDR 0x38
@@ -510,7 +505,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MESHTASTIC_EXCLUDE_PKI 1
 #define MESHTASTIC_EXCLUDE_POWER_FSM 1
 #define MESHTASTIC_EXCLUDE_TZ 1
-#define MESHTASTIC_EXCLUDE_PKT_HISTORY_HASH 1
 #endif
 
 // Turn off all optional modules
@@ -527,7 +521,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MESHTASTIC_EXCLUDE_REMOTEHARDWARE 1
 #define MESHTASTIC_EXCLUDE_STOREFORWARD 1
 #define MESHTASTIC_EXCLUDE_TEXTMESSAGE 1
-#define MESHTASTIC_EXCLUDE_TRAFFIC_MANAGEMENT 1
 #define MESHTASTIC_EXCLUDE_ATAK 1
 #define MESHTASTIC_EXCLUDE_CANNEDMESSAGES 1
 #define MESHTASTIC_EXCLUDE_NEIGHBORINFO 1
@@ -569,9 +562,5 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_SCREEN 0
 #endif
 
-#ifndef USE_ETHERNET_DEFAULT
-#define USE_ETHERNET_DEFAULT 0
-#endif
-
 #include "DebugConfiguration.h"
 #include "RF95Configuration.h"

src/detect/LoRaRadioType.h

@@ -11,8 +11,7 @@ enum LoRaRadioType {
     SX1280_RADIO,
     LR1110_RADIO,
     LR1120_RADIO,
-    LR1121_RADIO,
-    LR2021_RADIO
+    LR1121_RADIO
 };
 
 extern LoRaRadioType radioType;

src/detect/ScanI2C.cpp

@@ -37,8 +37,8 @@ ScanI2C::FoundDevice ScanI2C::firstKeyboard() const
 
 ScanI2C::FoundDevice ScanI2C::firstAccelerometer() const
 {
-    ScanI2C::DeviceType types[] = {MPU6050, LIS3DH, BMA423, LSM6DS3, BMX160, STK8BAXX,
-                                   ICM20948, QMA6100P, BMM150,  BMI270,  ICM42607P};
+    ScanI2C::DeviceType types[] = {MPU6050,  LIS3DH,   BMA423, LSM6DS3, BMX160,   STK8BAXX,
+                                   ICM20948, QMA6100P, BMM150, BMI270,  ICM42607P};
     return firstOfOrNONE(11, types);
 }
 

src/detect/ScanI2CTwoWire.cpp

@@ -85,8 +85,9 @@ ScanI2C::DeviceType ScanI2CTwoWire::probeOLED(ScanI2C::DeviceAddress addr) const
 
     return o_probe;
 }
+
 uint16_t ScanI2CTwoWire::getRegisterValue(const ScanI2CTwoWire::RegisterLocation &registerLocation,
-                                          ScanI2CTwoWire::ResponseWidth responseWidth, bool zeropad = false) const
+                                          ScanI2CTwoWire::ResponseWidth responseWidth, bool zeropad) const
 {
     uint16_t value = 0x00;
     TwoWire *i2cBus = fetchI2CBus(registerLocation.i2cAddress);
@@ -136,9 +137,7 @@ bool ScanI2CTwoWire::i2cCommandResponseLength(ScanI2C::DeviceAddress addr, uint1
     return match;
 }
 
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_AIR_QUALITY_SENSOR
-// FIXME Move to a separate file for detection of sensors that require more complex interactions?
-// For SEN5X detection
+/// for SEN5X detection
 // Note, this code needs to be called before setting the I2C bus speed
 // for the screen at high speed. The speed needs to be at 100kHz, otherwise
 // detection will not work
@@ -176,7 +175,6 @@ String readSEN5xProductName(TwoWire *i2cBus, uint8_t address)
 
     return String(productName);
 }
-#endif
 
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
 static uint8_t crcSHT2X(const uint8_t *data, uint8_t len)
@@ -427,47 +425,27 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 break;
 #endif
 #if !defined(M5STACK_UNITC6L)
-            case INA_ADDR: // Same as SHT2X
+            case INA_ADDR:
             case INA_ADDR_ALTERNATE:
-            case INA_ADDR_WAVESHARE_UPS: {
-                uint16_t mfg = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFE), 2);
+            case INA_ADDR_WAVESHARE_UPS:
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFE), 2);
+                LOG_DEBUG("Register MFG_UID: 0x%x", registerValue);
+                if (registerValue == 0x5449) {
+                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFF), 2);
+                    LOG_DEBUG("Register DIE_UID: 0x%x", registerValue);
 
-                LOG_DEBUG("Register MFG_UID: 0x%x", mfg);
-
-                // Only read DIE_UID for vendors we recognize as INA-compatible to avoid
-                // an extra I2C transaction + delay on other devices sharing this address.
-                if (mfg == 0x5449 || mfg == 0x190F) {
-                    uint16_t die = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFF), 2);
-                    LOG_DEBUG("Register DIE_UID: 0x%x", die);
-
-                    // TI INA226 or fully compatible clones (e.g. TPA626)
-                    if (mfg == 0x5449 && die == 0x2260) {
+                    if (registerValue == 0x2260) {
                         logFoundDevice("INA226", (uint8_t)addr.address);
                         type = INA226;
-                    }
-                    // Silergy SQ52201 (INA226-compatible with different IDs)
-                    else if (mfg == 0x190F && die == 0x0000) {
-                        logFoundDevice("INA226 (SQ52201)", (uint8_t)addr.address);
-                        type = INA226;
-                    }
-                    // TI INA260
-                    else if (mfg == 0x5449) {
+                    } else {
                         logFoundDevice("INA260", (uint8_t)addr.address);
                         type = INA260;
                     }
-                }
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-                if (type == NONE && detectSHT21SerialNumber(i2cBus, (uint8_t)addr.address)) {
-                    logFoundDevice("SHTXX (SHT2X)", (uint8_t)addr.address);
-                    type = SHTXX;
-                }
-#endif
-                else { // Assume INA219 if none of the above ones are found
+                } else { // Assume INA219 if INA260 ID is not found
                     logFoundDevice("INA219", (uint8_t)addr.address);
                     type = INA219;
                 }
                 break;
-            }
             case INA3221_ADDR:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFE), 2);
                 LOG_DEBUG("Register MFG_UID FE: 0x%x", registerValue);
@@ -524,19 +502,22 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                     }
                     break;
                 }
-            case SHTXX_ADDR:     // same as OPT3001_ADDR_ALT
-            case SHTXX_ADDR_ALT: // same as OPT3001_ADDR
+            case SHT31_4x_ADDR:     // same as OPT3001_ADDR_ALT
+            case SHT31_4x_ADDR_ALT: // same as OPT3001_ADDR
                 if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
                     type = OPT3001;
                     logFoundDevice("OPT3001", (uint8_t)addr.address);
-                } else { // SHTXX
-                    type = SHTXX;
-                    logFoundDevice("SHTXX", (uint8_t)addr.address);
+                } else if (i2cCommandResponseLength(addr, 0x89, 6)) { // SHT4x serial number (6 bytes inc. CRC)
+                    type = SHT4X;
+                    logFoundDevice("SHT4X", (uint8_t)addr.address);
+                } else {
+                    type = SHT31;
+                    logFoundDevice("SHT31", (uint8_t)addr.address);
                 }
 
                 break;
 
-                SCAN_SIMPLE_CASE(SHTC3_ADDR, SHTXX, "SHTXX", (uint8_t)addr.address)
+                SCAN_SIMPLE_CASE(SHTC3_ADDR, SHTC3, "SHTC3", (uint8_t)addr.address)
             case RCWL9620_ADDR:
                 // get MAX30102 PARTID
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFF), 1);
@@ -790,7 +771,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                         logFoundDevice("ICM-42607-P", (uint8_t)addr.address);
                         break;
                     }
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_AIR_QUALITY_SENSOR
                     String prod = "";
                     prod = readSEN5xProductName(i2cBus, addr.address);
                     if (prod.startsWith("SEN55")) {
@@ -806,7 +786,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                         logFoundDevice("Sensirion SEN50", addr.address);
                         break;
                     }
-#endif
                     if (addr.address == BMX160_ADDR) {
                         type = BMX160;
                         logFoundDevice("BMX160", (uint8_t)addr.address);

src/detect/ScanI2CTwoWire.h

@@ -53,7 +53,7 @@ class ScanI2CTwoWire : public ScanI2C
 
     concurrency::Lock lock;
 
-    uint16_t getRegisterValue(const RegisterLocation &, ResponseWidth, bool) const;
+    uint16_t getRegisterValue(const RegisterLocation &, ResponseWidth, bool = false) const;
 
     bool i2cCommandResponseLength(DeviceAddress addr, uint16_t command, uint8_t expectedLength) const;
 

src/gps/GPS.cpp

@@ -103,14 +103,6 @@ static int32_t gpsSwitch()
     if (gps) {
         int currentState = digitalRead(PIN_GPS_SWITCH);
 
-        // Respect explicit NOT_PRESENT mode and do not let the hardware switch re-enable GPS.
-        if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT) {
-            gps->disable();
-            lastState = currentState;
-            firstrun = false;
-            return 1000;
-        }
-
         // if the switch is set to zero, disable the GPS Thread
         if (firstrun)
             if (currentState == LOW)

src/gps/RTC.cpp

@@ -31,13 +31,63 @@ static uint32_t
     timeStartMsec; // Once we have a GPS lock, this is where we hold the initial msec clock that corresponds to that time
 static uint64_t zeroOffsetSecs; // GPS based time in secs since 1970 - only updated once on initial lock
 
+#ifdef PIO_UNIT_TESTING
+// Test seam: unit tests can inject a fake system clock (e.g. the uptime seconds that
+// gettimeofday() returns on boards without a real RTC, like RP2040) and force readFromRTC()
+// down the no-hardware-RTC fallback even when a hardware-RTC branch is compiled in.
+static bool hasMockSystemTime = false;
+static bool forceSystemTimeFallback = false;
+static struct timeval mockSystemTime = {};
+#endif
+
+// Reads the platform system clock (or the injected mock during unit tests). Used only by the
+// no-hardware-RTC fallback below, so it may be unused on builds with a hardware RTC.
+[[maybe_unused]] static bool readSystemTime(struct timeval *tv)
+{
+#ifdef PIO_UNIT_TESTING
+    if (hasMockSystemTime) {
+        *tv = mockSystemTime;
+        return true;
+    }
+#endif
+    return gettimeofday(tv, NULL) == 0;
+}
+
+// Seeds the clock from the system time on boards without a hardware RTC. gettimeofday() can
+// return uptime rather than wall-clock time there (e.g. RP2040), so only adopt it when we have
+// nothing better yet -- never clobber a higher-quality GPS/NTP/phone source (issue #9828).
+[[maybe_unused]] static RTCSetResult readFromSystemTimeFallback()
+{
+    struct timeval tv;
+    if (readSystemTime(&tv)) {
+        uint32_t now = millis();
+        uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms
+        if (currentQuality == RTCQualityNone) {
+            LOG_DEBUG("Seed time from system clock: %lu", (unsigned long)printableEpoch);
+            timeStartMsec = now;
+            zeroOffsetSecs = tv.tv_sec;
+        } else {
+            LOG_DEBUG("Ignore system clock fallback (%lu); current RTC quality is %s", (unsigned long)printableEpoch,
+                      RtcName(currentQuality));
+        }
+        return RTCSetResultSuccess;
+    }
+    return RTCSetResultNotSet;
+}
+
 /**
- * Reads the current date and time from the RTC module and updates the system time.
- * @return True if the RTC was successfully read and the system time was updated, false otherwise.
+ * Reads date/time from the RTC module (or system-time fallback) and seeds internal timekeeping.
+ * @return RTCSetResultSuccess if a time source was read successfully (even if an existing higher-quality time is retained).
  */
 RTCSetResult readFromRTC()
 {
-    struct timeval tv; /* btw settimeofday() is helpful here too*/
+#ifdef PIO_UNIT_TESTING
+    if (forceSystemTimeFallback) {
+        return readFromSystemTimeFallback();
+    }
+#endif
+
+    [[maybe_unused]] struct timeval tv; /* btw settimeofday() is helpful here too*/
 #ifdef RV3028_RTC
     if (rtc_found.address == RV3028_RTC) {
         uint32_t now = millis();
@@ -162,14 +212,7 @@ RTCSetResult readFromRTC()
         }
     }
 #else
-    if (!gettimeofday(&tv, NULL)) {
-        uint32_t now = millis();
-        uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms
-        LOG_DEBUG("Read RTC time as %ld", printableEpoch);
-        timeStartMsec = now;
-        zeroOffsetSecs = tv.tv_sec;
-        return RTCSetResultSuccess;
-    }
+    return readFromSystemTimeFallback();
 #endif
     return RTCSetResultNotSet;
 }
@@ -292,7 +335,7 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
                 LOG_WARN("Failed to set time for RX8130CE");
             }
         }
-#elif defined(ARCH_ESP32)
+#elif defined(ARCH_ESP32) || defined(ARCH_RP2040)
         settimeofday(tv, NULL);
 #endif
 
@@ -423,6 +466,38 @@ void setBootRelativeTimeForUnitTest(uint32_t secondsSinceBoot)
     lastSetFromPhoneNtpOrGps = 0;
     lastTimeValidationWarning = 0;
 }
+
+void clearRTCSystemTimeForTests()
+{
+    hasMockSystemTime = false;
+    mockSystemTime = {};
+}
+
+void setRTCSystemTimeForTests(const struct timeval *tv)
+{
+    if (tv == NULL) {
+        clearRTCSystemTimeForTests();
+        return;
+    }
+    mockSystemTime = *tv;
+    hasMockSystemTime = true;
+}
+
+void setReadFromRTCUseSystemTimeForTests(bool enabled)
+{
+    forceSystemTimeFallback = enabled;
+}
+
+void resetRTCStateForTests()
+{
+    currentQuality = RTCQualityNone;
+    timeStartMsec = 0;
+    zeroOffsetSecs = 0;
+    lastSetFromPhoneNtpOrGps = 0;
+    lastTimeValidationWarning = 0;
+    setReadFromRTCUseSystemTimeForTests(false);
+    clearRTCSystemTimeForTests();
+}
 #endif
 
 time_t gm_mktime(const struct tm *tm)

src/gps/RTC.h

@@ -56,6 +56,10 @@ RTCSetResult readFromRTC();
 
 #ifdef PIO_UNIT_TESTING
 void setBootRelativeTimeForUnitTest(uint32_t secondsSinceBoot);
+void resetRTCStateForTests();
+void setRTCSystemTimeForTests(const struct timeval *tv);
+void clearRTCSystemTimeForTests();
+void setReadFromRTCUseSystemTimeForTests(bool enabled);
 #endif
 
 time_t gm_mktime(const struct tm *tm);

src/graphics/BaseUIEInkDisplay.cpp

@@ -1,211 +0,0 @@
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./BaseUIEInkDisplay.h"
-
-#include "configuration.h"
-#include "main.h"
-
-using namespace NicheGraphics;
-
-BaseUIEInkDisplay::BaseUIEInkDisplay(Drivers::EInk *driver, uint8_t rotation) : driver(driver), rotation(rotation & 0x3)
-{
-    this->geometry = GEOMETRY_RAWMODE;
-
-    // BaseUI draws in UI orientation. Physical panel dimensions are swapped for 90°/270°.
-    const bool swap = (this->rotation == 1) || (this->rotation == 3);
-    this->displayWidth = swap ? driver->height : driver->width;
-    this->displayHeight = swap ? driver->width : driver->height;
-
-    uint16_t shortSide = min(displayWidth, displayHeight);
-    uint16_t longSide = max(displayWidth, displayHeight);
-    if (shortSide % 8 != 0)
-        shortSide = (shortSide | 7) + 1;
-    this->displayBufferSize = longSide * (shortSide / 8);
-
-    // Panel-native row-major buffer
-    panelRowBytes = ((driver->width - 1) / 8) + 1;
-    panelBufferSize = panelRowBytes * driver->height;
-    panelBuffer = new uint8_t[panelBufferSize];
-    memset(panelBuffer, 0xFF, panelBufferSize); // All white
-}
-
-BaseUIEInkDisplay::~BaseUIEInkDisplay()
-{
-    delete[] panelBuffer;
-}
-
-bool BaseUIEInkDisplay::connect()
-{
-    LOG_INFO("Init BaseUI E-Ink (%u x %u, rot %u)", driver->width, driver->height, rotation);
-    return true;
-}
-
-void BaseUIEInkDisplay::addFrameFlag(frameFlagTypes flag)
-{
-    frameFlags = (frameFlagTypes)(frameFlags | flag);
-}
-
-void BaseUIEInkDisplay::setDisplayResilience(uint8_t fastPerFull, float stressMultiplier)
-{
-    this->fastPerFull = (fastPerFull == 0) ? 1 : fastPerFull;
-    this->stressMultiplier = stressMultiplier;
-}
-
-void BaseUIEInkDisplay::joinAsyncRefresh()
-{
-    if (driver->busy())
-        driver->await();
-}
-
-// OLEDDisplayUi tick path. Honours rate-limit unless flags demand otherwise.
-void BaseUIEInkDisplay::display()
-{
-    const bool demandFast = frameFlags & DEMAND_FAST;
-    const bool cosmetic = frameFlags & COSMETIC;
-    const bool unlimitedFast = frameFlags & UNLIMITED_FAST;
-
-    if (!demandFast && !cosmetic && !unlimitedFast) {
-        if (!forceDisplay(lastDrawMsec == 0 ? 0 : 1000))
-            return;
-        return;
-    }
-
-    forceDisplay(0);
-}
-
-// Keyframe path. Returns true if a frame was pushed (sets lastDrawMsec).
-bool BaseUIEInkDisplay::forceDisplay(uint32_t msecLimit)
-{
-    const uint32_t now = millis();
-    if (lastDrawMsec != 0 && (now - lastDrawMsec) < msecLimit)
-        return false;
-
-    const bool blocking = frameFlags & BLOCKING;
-    Drivers::EInk::UpdateTypes type = decide();
-
-    // Don't pile frames on top of a running update - wait it out.
-    if (driver->busy())
-        driver->await();
-
-    const bool pushed = commit(type, blocking);
-    if (pushed)
-        lastDrawMsec = now;
-
-    // Reset flags for next frame
-    frameFlags = BACKGROUND;
-    return pushed;
-}
-
-bool BaseUIEInkDisplay::commit(Drivers::EInk::UpdateTypes type, bool blocking)
-{
-    uint32_t hash = repack();
-
-    // Skip if frame unchanged. Exception: caller explicitly wants a refresh (COSMETIC or FULL).
-    if (hash == lastHash && type != Drivers::EInk::UpdateTypes::FULL && lastDrawMsec != 0)
-        return false;
-    lastHash = hash;
-
-    // Fall back to FULL on panels that don't advertise FAST support.
-    if (type == Drivers::EInk::UpdateTypes::FAST && !driver->supports(Drivers::EInk::UpdateTypes::FAST))
-        type = Drivers::EInk::UpdateTypes::FULL;
-
-    driver->update(panelBuffer, type);
-
-    if (blocking)
-        driver->await();
-    return true;
-}
-
-Drivers::EInk::UpdateTypes BaseUIEInkDisplay::decide()
-{
-    typedef Drivers::EInk::UpdateTypes UT;
-
-    const bool unlimitedFast = frameFlags & UNLIMITED_FAST;
-
-    // Explicit flag wins outright
-    if (frameFlags & COSMETIC) {
-        fullRefreshDebt = max(fullRefreshDebt - 1.0f, 0.0f);
-        return UT::FULL;
-    }
-    if (frameFlags & DEMAND_FAST) {
-        if (!unlimitedFast) {
-            fullRefreshDebt += (fullRefreshDebt < 1.0f) ? (1.0f / fastPerFull) : (stressMultiplier * (1.0f / fastPerFull));
-        }
-        return UT::FAST;
-    }
-
-    const bool explicitFast = frameFlags & RESPONSIVE;
-
-    if (explicitFast || unlimitedFast) {
-        if (!unlimitedFast) {
-            fullRefreshDebt += (fullRefreshDebt < 1.0f) ? (1.0f / fastPerFull) : (stressMultiplier * (1.0f / fastPerFull));
-        }
-        return UT::FAST;
-    }
-
-    // BACKGROUND / unspecified: let debt decide
-    if (fullRefreshDebt >= 1.0f) {
-        fullRefreshDebt = max(fullRefreshDebt - 1.0f, 0.0f);
-        return UT::FULL;
-    }
-    fullRefreshDebt += 1.0f / fastPerFull;
-    return UT::FAST;
-}
-
-uint32_t BaseUIEInkDisplay::repack()
-{
-    memset(panelBuffer, 0xFF, panelBufferSize); // start all-white
-
-    const uint16_t pw = driver->width;
-    const uint16_t ph = driver->height;
-
-    // OLEDDisplay buffer: byte = buffer[x + (y/8) * displayWidth]; bit = 1 << (y & 7); 1 = black
-    // Niche buffer:       byte = (y * panelRowBytes) + (x/8);      bit = 1 << (7 - x%8); 1 = white
-    for (uint16_t oy = 0; oy < displayHeight; oy++) {
-        for (uint16_t ox = 0; ox < displayWidth; ox++) {
-            const uint8_t b = buffer[ox + (oy / 8) * displayWidth];
-            const bool isBlack = b & (1 << (oy & 7));
-
-            uint16_t px, py;
-            switch (rotation) {
-            case 1: // 90° CW: OLED (ox,oy) → panel (pw-1-oy, ox)
-                px = pw - 1 - oy;
-                py = ox;
-                break;
-            case 2: // 180°
-                px = pw - 1 - ox;
-                py = ph - 1 - oy;
-                break;
-            case 3: // 270° CW
-                px = oy;
-                py = ph - 1 - ox;
-                break;
-            case 0:
-            default:
-                px = ox;
-                py = oy;
-                break;
-            }
-
-            if (px >= pw || py >= ph)
-                continue;
-
-            const uint32_t byteNum = (py * panelRowBytes) + (px / 8);
-            const uint8_t bitNum = 7 - (px % 8);
-            if (isBlack)
-                panelBuffer[byteNum] &= ~(1 << bitNum);
-            else
-                panelBuffer[byteNum] |= (1 << bitNum);
-        }
-    }
-
-    // FNV-1a
-    uint32_t h = 2166136261u;
-    for (uint32_t i = 0; i < panelBufferSize; i++) {
-        h ^= panelBuffer[i];
-        h *= 16777619u;
-    }
-    return h;
-}
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/BaseUIEInkDisplay.h

@@ -1,98 +0,0 @@
-/*
-
-OLEDDisplay adapter that routes BaseUI pixel output to a NicheGraphics::Drivers::EInk driver.
-
-One adapter serves all E-Ink variants: the panel driver and orientation are injected at construction,
-and FULL/FAST selection is made by the shared DisplayHealth model (same as InkHUD).
-
-Replaces the per-board branching in EInkDisplay2 / EInkDynamicDisplay / EInkParallelDisplay.
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "graphics/eink/Drivers/EInk.h"
-
-#include <OLEDDisplay.h>
-
-namespace NicheGraphics
-{
-
-class BaseUIEInkDisplay : public OLEDDisplay
-{
-  public:
-    // Flags Screen.cpp sets via EINK_ADD_FRAMEFLAG before triggering a draw.
-    // Bits are combined; decided at render time.
-    enum frameFlagTypes : uint8_t {
-        BACKGROUND = (1 << 0),     // Regular OLEDDisplayUi tick - no urgency, UNSPECIFIED
-        RESPONSIVE = (1 << 1),     // User-driven refresh - prefer FAST
-        COSMETIC = (1 << 2),       // Clean splash / wake-from-sleep - force FULL
-        DEMAND_FAST = (1 << 3),    // Menu interaction - force FAST
-        BLOCKING = (1 << 4),       // Wait for update to finish before returning
-        UNLIMITED_FAST = (1 << 5), // Suppress health-driven FULL promotion (typing modes)
-    };
-
-    BaseUIEInkDisplay(Drivers::EInk *driver, uint8_t rotation);
-    ~BaseUIEInkDisplay() override;
-
-    // OLEDDisplay overrides
-    bool connect() override;
-    void display() override;
-    void sendCommand(uint8_t com) override { (void)com; }
-    int getBufferOffset(void) override { return 0; }
-
-    // BaseUI public API (same shape as the old EInkDynamicDisplay)
-    bool forceDisplay(uint32_t msecLimit = 1000);
-    void addFrameFlag(frameFlagTypes flag);
-    void joinAsyncRefresh();
-    void enableUnlimitedFastMode() { addFrameFlag(UNLIMITED_FAST); }
-    void disableUnlimitedFastMode() { frameFlags = (frameFlagTypes)(frameFlags & ~UNLIMITED_FAST); }
-
-    // Tuning, called once per panel profile
-    void setDisplayResilience(uint8_t fastPerFull, float stressMultiplier = 2.0f);
-
-    // Exposed so Screen.cpp / variants can read the rotation passed in at construction
-    uint8_t getRotation() const { return rotation; }
-
-  private:
-    // Perform an update now, unconditionally. Returns true if a frame was pushed to the driver.
-    bool commit(Drivers::EInk::UpdateTypes type, bool blocking);
-
-    // Convert OLEDDisplay's column-major buffer into the panel's row-major MSB-left buffer.
-    // Applies rotation. Returns the hash of the panel buffer for frame-skip comparison.
-    uint32_t repack();
-
-    // Decide FULL vs FAST based on current frame flags + accumulated debt.
-    Drivers::EInk::UpdateTypes decide();
-
-    Drivers::EInk *driver = nullptr;
-    uint8_t rotation = 0; // 0=0°, 1=90°CW, 2=180°, 3=270°CW
-    uint8_t *panelBuffer = nullptr;
-    uint32_t panelBufferSize = 0;
-    uint16_t panelRowBytes = 0;
-
-    frameFlagTypes frameFlags = BACKGROUND;
-    uint32_t lastDrawMsec = 0;
-    uint32_t lastHash = 0;
-
-    // DisplayHealth-style debt tracking
-    float fullRefreshDebt = 0.0f;
-    uint8_t fastPerFull = 7;
-    float stressMultiplier = 2.0f;
-};
-
-} // namespace NicheGraphics
-
-// Compat macros used throughout Screen.cpp - route straight to the adapter.
-#define EINK_ADD_FRAMEFLAG(display, flag)                                                                                        \
-    static_cast<NicheGraphics::BaseUIEInkDisplay *>(display)->addFrameFlag(NicheGraphics::BaseUIEInkDisplay::flag)
-#define EINK_JOIN_ASYNCREFRESH(display) static_cast<NicheGraphics::BaseUIEInkDisplay *>(display)->joinAsyncRefresh()
-
-#else // !MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-#define EINK_ADD_FRAMEFLAG(display, flag)
-#define EINK_JOIN_ASYNCREFRESH(display)
-#endif

src/graphics/EInkDisplay2.cpp

@@ -0,0 +1,298 @@
+#include "configuration.h"
+
+#if defined(USE_EINK) && !defined(USE_EINK_PARALLELDISPLAY)
+#include "EInkDisplay2.h"
+#include "SPILock.h"
+#include "main.h"
+#include <SPI.h>
+
+#ifdef GXEPD2_DRIVER_0
+#include "einkDetect.h"
+#endif
+
+/*
+    The macros EINK_DISPLAY_MODEL, EINK_WIDTH, and EINK_HEIGHT are defined as build_flags in a variant's platformio.ini
+    Previously, these macros were defined at the top of this file.
+
+    For archival reasons, note that the following configurations had also been tested during this period:
+    * ifdef RAK4631
+        - 4.2 inch
+          EINK_DISPLAY_MODEL: GxEPD2_420_M01
+          EINK_WIDTH: 300
+          EINK_WIDTH: 400
+
+        - 2.9 inch
+          EINK_DISPLAY_MODEL: GxEPD2_290_T5D
+          EINK_WIDTH: 296
+          EINK_HEIGHT: 128
+
+        - 1.54 inch
+          EINK_DISPLAY_MODEL: GxEPD2_154_M09
+          EINK_WIDTH: 200
+          EINK_HEIGHT: 200
+*/
+
+// Constructor
+EInkDisplay::EInkDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus)
+{
+    // Set dimensions in OLEDDisplay base class
+    this->geometry = GEOMETRY_RAWMODE;
+    this->displayWidth = EINK_WIDTH;
+    this->displayHeight = EINK_HEIGHT;
+
+    // Round shortest side up to nearest byte, to prevent truncation causing an undersized buffer
+    uint16_t shortSide = min(EINK_WIDTH, EINK_HEIGHT);
+    uint16_t longSide = max(EINK_WIDTH, EINK_HEIGHT);
+    if (shortSide % 8 != 0)
+        shortSide = (shortSide | 7) + 1;
+
+    this->displayBufferSize = longSide * (shortSide / 8);
+}
+
+/**
+ * Force a display update if we haven't drawn within the specified msecLimit
+ */
+bool EInkDisplay::forceDisplay(uint32_t msecLimit)
+{
+    // No need to grab this lock because we are on our own SPI bus
+    // concurrency::LockGuard g(spiLock);
+
+    uint32_t now = millis();
+    uint32_t sinceLast = now - lastDrawMsec;
+
+    if (adafruitDisplay && (sinceLast > msecLimit || lastDrawMsec == 0))
+        lastDrawMsec = now;
+    else
+        return false;
+
+    // FIXME - only draw bits have changed (use backbuf similar to the other displays)
+    const bool flipped = config.display.flip_screen;
+    // HACK for L1 EInk
+#if defined(SEEED_WIO_TRACKER_L1_EINK)
+    // For SEEED_WIO_TRACKER_L1_EINK, setRotation(3) is correct but mirrored; flip both axes
+    for (uint32_t y = 0; y < displayHeight; y++) {
+        for (uint32_t x = 0; x < displayWidth; x++) {
+            auto b = buffer[x + (y / 8) * displayWidth];
+            auto isset = b & (1 << (y & 7));
+            adafruitDisplay->drawPixel((displayWidth - 1) - x, (displayHeight - 1) - y, isset ? GxEPD_BLACK : GxEPD_WHITE);
+        }
+    }
+#else
+    for (uint32_t y = 0; y < displayHeight; y++) {
+        for (uint32_t x = 0; x < displayWidth; x++) {
+            auto b = buffer[x + (y / 8) * displayWidth];
+            auto isset = b & (1 << (y & 7));
+            if (flipped)
+                adafruitDisplay->drawPixel((displayWidth - 1) - x, (displayHeight - 1) - y, isset ? GxEPD_BLACK : GxEPD_WHITE);
+            else
+                adafruitDisplay->drawPixel(x, y, isset ? GxEPD_BLACK : GxEPD_WHITE);
+        }
+    }
+#endif
+
+    // Trigger the refresh in GxEPD2
+    LOG_DEBUG("Update E-Paper");
+    adafruitDisplay->nextPage();
+
+    // End the update process
+    endUpdate();
+
+    LOG_DEBUG("done");
+    return true;
+}
+
+// End the update process - virtual method, overridden in derived class
+void EInkDisplay::endUpdate()
+{
+#ifndef EINK_NOT_HIBERNATE
+    // By default, power off the E-Ink display hardware and enter hibernate().
+    // Boards/panels that define EINK_NOT_HIBERNATE intentionally skip this step.
+    // Skipping hibernate() can help avoid panel-specific wake/refresh or ghosting issues,
+    // but it typically trades lower power savings for that compatibility.
+    adafruitDisplay->hibernate();
+#endif
+}
+
+// Write the buffer to the display memory
+void EInkDisplay::display(void)
+{
+    // We don't allow regular 'dumb' display() calls to draw on eink until we've shown
+    // at least one forceDisplay() keyframe.  This prevents flashing when we should the critical
+    // bootscreen (that we want to look nice)
+
+    if (lastDrawMsec) {
+        forceDisplay(slowUpdateMsec); // Show the first screen a few seconds after boot, then slower
+    }
+}
+
+// Send a command to the display (low level function)
+void EInkDisplay::sendCommand(uint8_t com)
+{
+    (void)com;
+    // Drop all commands to device (we just update the buffer)
+}
+
+void EInkDisplay::setDetected(uint8_t detected)
+{
+    (void)detected;
+}
+
+// Connect to the display - variant specific
+bool EInkDisplay::connect()
+{
+    LOG_INFO("Do EInk init");
+
+#ifdef PIN_EINK_EN
+    // backlight power, HIGH is backlight on, LOW is off
+    pinMode(PIN_EINK_EN, OUTPUT);
+#ifdef ELECROW_ThinkNode_M1
+    // ThinkNode M1 has a hardware dimmable backlight. Start enabled
+    digitalWrite(PIN_EINK_EN, HIGH);
+#elif defined(MINI_EPAPER_S3)
+    // T-Mini Epaper S3 requires panel power rail enabled before SPI transfer.
+    digitalWrite(PIN_EINK_EN, HIGH);
+    delay(10);
+#else
+    digitalWrite(PIN_EINK_EN, LOW);
+#endif
+#endif
+
+#if defined(TTGO_T_ECHO) || defined(ELECROW_ThinkNode_M1) || defined(T_ECHO_LITE) || defined(TTGO_T_ECHO_PLUS)
+    {
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, SPI1);
+
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init();
+#if defined(ELECROW_ThinkNode_M1) || defined(T_ECHO_LITE)
+        adafruitDisplay->setRotation(4);
+#else
+        adafruitDisplay->setRotation(3);
+#endif
+        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+    }
+#elif defined(ELECROW_ThinkNode_M5)
+    {
+        // Start HSPI
+        hspi = new SPIClass(HSPI);
+        hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
+
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *hspi);
+
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init();
+
+        adafruitDisplay->setRotation(4);
+
+        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+    }
+#elif defined(MESHLINK)
+    {
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, SPI1);
+
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init();
+        adafruitDisplay->setRotation(3);
+        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+    }
+#elif defined(RAK4630) || defined(MAKERPYTHON)
+    {
+        if (eink_found) {
+            auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+            adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+            adafruitDisplay->init(115200, true, 10, false, SPI1, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+            // RAK14000 2.13 inch b/w 250x122 does actually now support fast refresh
+            adafruitDisplay->setRotation(3);
+            // Fast refresh support for  1.54, 2.13 RAK14000 b/w , 2.9 and 4.2
+            // adafruitDisplay->setRotation(1);
+            adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+        } else {
+            (void)adafruitDisplay;
+        }
+    }
+
+#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_VISION_MASTER_E290) || defined(TLORA_T3S3_EPAPER) ||                 \
+    defined(CROWPANEL_ESP32S3_5_EPAPER) || defined(CROWPANEL_ESP32S3_4_EPAPER) || defined(CROWPANEL_ESP32S3_2_EPAPER) ||         \
+    defined(MINI_EPAPER_S3)
+    {
+        // Start HSPI
+        hspi = new SPIClass(HSPI);
+        hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
+        // VExt already enabled in setup()
+        // RTC GPIO hold disabled in setup()
+
+        // Create GxEPD2 objects
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *hspi);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+
+        // Init GxEPD2
+        adafruitDisplay->init();
+#if defined(MINI_EPAPER_S3)
+        adafruitDisplay->setRotation(3);
+#else
+        adafruitDisplay->setRotation(3);
+#if defined(CROWPANEL_ESP32S3_5_EPAPER) || defined(CROWPANEL_ESP32S3_4_EPAPER)
+        adafruitDisplay->setRotation(0);
+#endif
+#endif
+    }
+#elif defined(PCA10059) || defined(ME25LS01)
+    {
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init(115200, true, 40, false, SPI1, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+        adafruitDisplay->setRotation(0);
+        adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+    }
+#elif defined(M5_COREINK) || defined(T_DECK_PRO)
+    auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+    adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+    adafruitDisplay->init(115200, true, 40, false, SPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+    adafruitDisplay->setRotation(0);
+    adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+#elif defined(my) || defined(ESP32_S3_PICO)
+    {
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init(115200, true, 40, false, SPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+        adafruitDisplay->setRotation(1);
+        adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+    }
+#elif defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK) || defined(HELTEC_MESH_SOLAR_EINK)
+    {
+        spi1 = &SPI1;
+        spi1->begin();
+        // VExt already enabled in setup()
+        // RTC GPIO hold disabled in setup()
+
+        // Create GxEPD2 objects
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *spi1);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+
+        // Init GxEPD2
+        adafruitDisplay->init();
+        adafruitDisplay->setRotation(3);
+        adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+    }
+#elif defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_VISION_MASTER_E213)
+
+    // Detect display model, before starting SPI
+    EInkDetectionResult displayModel = detectEInk();
+
+    // Start HSPI
+    hspi = new SPIClass(HSPI);
+    hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
+
+    // Create GxEPD2 object
+    adafruitDisplay = new GxEPD2_Multi<GXEPD2_DRIVER_0, GXEPD2_DRIVER_1>((uint8_t)displayModel, PIN_EINK_CS, PIN_EINK_DC,
+                                                                         PIN_EINK_RES, PIN_EINK_BUSY, *hspi);
+
+    // Init GxEPD2
+    adafruitDisplay->init();
+    adafruitDisplay->setRotation(3);
+
+#endif
+
+    return true;
+}
+
+#endif

src/graphics/EInkDisplay2.h

@@ -0,0 +1,106 @@
+#pragma once
+
+#if defined(USE_EINK) && !defined(USE_EINK_PARALLELDISPLAY)
+
+#include "GxEPD2_BW.h"
+#include <OLEDDisplay.h>
+
+#ifdef GXEPD2_DRIVER_0 // If variant has multiple possible display models
+#include "GxEPD2Multi.h"
+#endif
+
+// Limit how often we push a full E-Ink refresh. T-Deck Pro needs faster updates for typing.
+#ifndef EINK_FORCE_DISPLAY_THROTTLE_MS
+#if defined(T_DECK_PRO)
+#define EINK_FORCE_DISPLAY_THROTTLE_MS 200
+#else
+#define EINK_FORCE_DISPLAY_THROTTLE_MS 1000
+#endif
+#endif
+
+/**
+ * An adapter class that allows using the GxEPD2 library as if it was an OLEDDisplay implementation.
+ *
+ * Note: EInkDynamicDisplay derives from this class.
+ *
+ * Remaining TODO:
+ * optimize display() to only draw changed pixels (see other OLED subclasses for examples)
+ * implement displayOn/displayOff to turn off the TFT device (and backlight)
+ * Use the fast NRF52 SPI API rather than the slow standard arduino version
+ *
+ * turn radio back on - currently with both on spi bus is fucked? or are we leaving chip select asserted?
+ * Suggestion: perhaps similar to HELTEC_WIRELESS_PAPER issue, which resolved with rtc_gpio_hold_dis()
+ */
+class EInkDisplay : public OLEDDisplay
+{
+    /// How often should we update the display
+    /// thereafter we do once per 5 minutes
+    uint32_t slowUpdateMsec = 5 * 60 * 1000;
+
+  public:
+    /* constructor
+    FIXME - the parameters are not used, just a temporary hack to keep working like the old displays
+    */
+    EInkDisplay(uint8_t, int, int, OLEDDISPLAY_GEOMETRY, HW_I2C);
+
+    // Write the buffer to the display memory (for eink we only do this occasionally)
+    virtual void display(void) override;
+
+    /**
+     * Force a display update if we haven't drawn within the specified msecLimit
+     *
+     * @return true if we did draw the screen
+     */
+    virtual bool forceDisplay(uint32_t msecLimit = EINK_FORCE_DISPLAY_THROTTLE_MS);
+
+    /**
+     * Run any code needed to complete an update, after the physical refresh has completed.
+     * Split from forceDisplay(), to enable async refresh in derived EInkDynamicDisplay class.
+     *
+     */
+    virtual void endUpdate();
+
+    /**
+     * shim to make the abstraction happy
+     *
+     */
+    void setDetected(uint8_t detected);
+
+  protected:
+    // the header size of the buffer used, e.g. for the SPI command header
+    virtual int getBufferOffset(void) override { return 0; }
+
+    // Send a command to the display (low level function)
+    virtual void sendCommand(uint8_t com) override;
+
+    // Connect to the display
+    virtual bool connect() override;
+
+#ifdef GXEPD2_DRIVER_0
+    // AdafruitGFX display object - wrapper for multiple drivers
+    // Allows runtime detection of multiple displays
+    // Avoid this situation if possible!
+    GxEPD2_Multi<GXEPD2_DRIVER_0, GXEPD2_DRIVER_1> *adafruitDisplay = NULL;
+#else
+    // AdafruitGFX display object (for single display model) - instantiated in connect(), variant specific
+    GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT> *adafruitDisplay = NULL;
+#endif
+
+    // If display uses HSPI
+#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_VISION_MASTER_E213) ||               \
+    defined(HELTEC_VISION_MASTER_E290) || defined(TLORA_T3S3_EPAPER) || defined(CROWPANEL_ESP32S3_5_EPAPER) ||                   \
+    defined(CROWPANEL_ESP32S3_4_EPAPER) || defined(CROWPANEL_ESP32S3_2_EPAPER) || defined(ELECROW_ThinkNode_M5) ||               \
+    defined(MINI_EPAPER_S3)
+    SPIClass *hspi = NULL;
+#endif
+
+#if defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK) || defined(HELTEC_MESH_SOLAR_EINK)
+    SPIClass *spi1 = NULL;
+#endif
+
+  private:
+    // FIXME quick hack to limit drawing to a very slow rate
+    uint32_t lastDrawMsec = 0;
+};
+
+#endif

src/graphics/EInkDynamicDisplay.cpp

@@ -0,0 +1,564 @@
+#include "Throttle.h"
+#include "configuration.h"
+
+#if defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
+#include "EInkDynamicDisplay.h"
+
+// Constructor
+EInkDynamicDisplay::EInkDynamicDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus)
+    : EInkDisplay(address, sda, scl, geometry, i2cBus), NotifiedWorkerThread("EInkDynamicDisplay")
+{
+    // If tracking ghost pixels, grab memory
+#ifdef EINK_LIMIT_GHOSTING_PX
+    dirtyPixels = std::unique_ptr<uint8_t[]>(new uint8_t[EInkDisplay::displayBufferSize]()); // Init with zeros
+#endif
+}
+
+// Destructor
+EInkDynamicDisplay::~EInkDynamicDisplay()
+{
+    // If we were tracking ghost pixels, free the memory
+#ifdef EINK_LIMIT_GHOSTING_PX
+    dirtyPixels = nullptr;
+#endif
+}
+
+// Screen requests a BACKGROUND frame
+void EInkDynamicDisplay::display()
+{
+    addFrameFlag(BACKGROUND);
+    update();
+}
+
+// Screen requests a RESPONSIVE frame
+bool EInkDynamicDisplay::forceDisplay(uint32_t msecLimit)
+{
+    addFrameFlag(RESPONSIVE);
+    return update(); // (Unutilized) Base class promises to return true if update ran
+}
+
+// Add flag for the next frame
+void EInkDynamicDisplay::addFrameFlag(frameFlagTypes flag)
+{
+    // OR the new flag into the existing flags
+    this->frameFlags = (frameFlagTypes)(this->frameFlags | flag);
+}
+
+// GxEPD2 code to set fast refresh
+void EInkDynamicDisplay::configForFastRefresh()
+{
+    // Variant-specific code can go here
+#if defined(PRIVATE_HW)
+#else
+    // Otherwise:
+    adafruitDisplay->setPartialWindow(0, 0, adafruitDisplay->width(), adafruitDisplay->height());
+#endif
+}
+
+// GxEPD2 code to set full refresh
+void EInkDynamicDisplay::configForFullRefresh()
+{
+    // Variant-specific code can go here
+#if defined(PRIVATE_HW)
+#else
+    // Otherwise:
+    adafruitDisplay->setFullWindow();
+#endif
+}
+
+// Run any relevant GxEPD2 code, so next update will use correct refresh type
+void EInkDynamicDisplay::applyRefreshMode()
+{
+    // Change from FULL to FAST
+    if (currentConfig == FULL && refresh == FAST) {
+        configForFastRefresh();
+        currentConfig = FAST;
+    }
+
+    // Change from FAST back to FULL
+    else if (currentConfig == FAST && refresh == FULL) {
+        configForFullRefresh();
+        currentConfig = FULL;
+    }
+}
+
+// Update fastRefreshCount
+void EInkDynamicDisplay::adjustRefreshCounters()
+{
+    if (refresh == FAST)
+        fastRefreshCount++;
+
+    else if (refresh == FULL)
+        fastRefreshCount = 0;
+}
+
+// Trigger the display update by calling base class
+bool EInkDynamicDisplay::update()
+{
+    // Determine the refresh mode to use, and start the update
+    bool refreshApproved = determineMode();
+    if (refreshApproved) {
+        EInkDisplay::forceDisplay(0); // Bypass base class' own rate-limiting system
+        storeAndReset();              // Store the result of this loop for next time. Note: call *before* endOrDetach()
+        endOrDetach();                // endUpdate() right now, or set the async refresh flag (if FULL and HAS_EINK_ASYNCFULL)
+    } else
+        storeAndReset(); // No update, no post-update code, just store the results
+
+    return refreshApproved; // (Unutilized) Base class promises to return true if update ran
+}
+
+// Figure out who runs the post-update code
+void EInkDynamicDisplay::endOrDetach()
+{
+    // If the GxEPD2 version reports that it has the async modifications
+#ifdef HAS_EINK_ASYNCFULL
+    if (previousRefresh == FULL) {
+        asyncRefreshRunning = true; // Set the flag - checked in determineMode(); cleared by onNotify()
+
+        if (previousFrameFlags & BLOCKING)
+            awaitRefresh();
+        else {
+            // Async begins
+            LOG_DEBUG("Async full-refresh begins (drop frames)");
+            notifyLater(intervalPollAsyncRefresh, DUE_POLL_ASYNCREFRESH, true); // Hand-off to NotifiedWorkerThread
+        }
+    }
+
+    // Fast Refresh
+    else if (previousRefresh == FAST)
+        EInkDisplay::endUpdate(); // Still block while updating, but EInkDisplay needs us to call endUpdate() ourselves.
+
+        // Fallback - If using an unmodified version of GxEPD2 for some reason
+#else
+    if (previousRefresh == FULL || previousRefresh == FAST) { // If refresh wasn't skipped (on unspecified..)
+        LOG_WARN(
+            "GxEPD2 version has not been modified to support async refresh; using fallback behavior. Please update lib_deps in "
+            "variant's platformio.ini file");
+        EInkDisplay::endUpdate();
+    }
+#endif
+}
+
+// Assess situation, pick a refresh type
+bool EInkDynamicDisplay::determineMode()
+{
+    checkInitialized();
+    checkForPromotion();
+#if defined(HAS_EINK_ASYNCFULL)
+    checkBusyAsyncRefresh();
+#endif
+    checkRateLimiting();
+
+    // If too soon for a new frame, or display busy, abort early
+    if (refresh == SKIPPED)
+        return false; // No refresh
+
+    // -- New frame is due --
+
+    resetRateLimiting(); // Once determineMode() ends, will have to wait again
+    hashImage();         // Generate here, so we can still copy it to previousImageHash, even if we skip the comparison check
+    LOG_DEBUG("determineMode(): "); // Begin log entry
+
+    // Once mode determined, any remaining checks will bypass
+    checkCosmetic();
+    checkDemandingFast();
+    checkFrameMatchesPrevious();
+    checkConsecutiveFastRefreshes();
+#ifdef EINK_LIMIT_GHOSTING_PX
+    checkExcessiveGhosting();
+#endif
+    checkFastRequested();
+
+    if (refresh == UNSPECIFIED)
+        LOG_WARN("There was a flaw in the determineMode() logic");
+
+    // -- Decision has been reached --
+    applyRefreshMode();
+    adjustRefreshCounters();
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // Full refresh clears any ghosting
+    if (refresh == FULL)
+        resetGhostPixelTracking();
+#endif
+
+    // Return - call a refresh or not?
+    if (refresh == SKIPPED)
+        return false; // Don't trigger a refresh
+    else
+        return true; // Do trigger a refresh
+}
+
+// Is this the very first frame?
+void EInkDynamicDisplay::checkInitialized()
+{
+    if (!initialized) {
+        // Undo GxEPD2_BW::partialWindow(), if set by developer in EInkDisplay::connect()
+        configForFullRefresh();
+
+        // Clear any existing image, so we can draw logo with fast-refresh, but also to set GxEPD2_EPD::_initial_write
+        adafruitDisplay->clearScreen();
+
+        LOG_DEBUG("initialized, ");
+        initialized = true;
+
+        // Use a fast-refresh for the next frame; no skipping or else blank screen when waking from deep sleep
+        addFrameFlag(DEMAND_FAST);
+    }
+}
+
+// Was a frame skipped (rate, display busy) that should have been a FAST refresh?
+void EInkDynamicDisplay::checkForPromotion()
+{
+    // If a frame was skipped (rate, display busy), then promote a BACKGROUND frame
+    // Because we DID want a RESPONSIVE/COSMETIC/DEMAND_FULL frame last time, we just didn't get it
+
+    switch (previousReason) {
+    case ASYNC_REFRESH_BLOCKED_DEMANDFAST:
+        addFrameFlag(DEMAND_FAST);
+        break;
+    case ASYNC_REFRESH_BLOCKED_COSMETIC:
+        addFrameFlag(COSMETIC);
+        break;
+    case ASYNC_REFRESH_BLOCKED_RESPONSIVE:
+    case EXCEEDED_RATELIMIT_FAST:
+        addFrameFlag(RESPONSIVE);
+        break;
+    default:
+        break;
+    }
+}
+
+// Is it too soon for another frame of this type?
+void EInkDynamicDisplay::checkRateLimiting()
+{
+    // Sanity check: millis() overflow - just let the update run..
+    if (previousRunMs > millis())
+        return;
+
+    // Skip update: too soon for BACKGROUND
+    if (frameFlags == BACKGROUND) {
+        if (Throttle::isWithinTimespanMs(previousRunMs, 30000)) {
+            refresh = SKIPPED;
+            reason = EXCEEDED_RATELIMIT_FULL;
+            return;
+        }
+    }
+
+    // No rate-limit for these special cases
+    if (frameFlags & COSMETIC || frameFlags & DEMAND_FAST)
+        return;
+
+    // Skip update: too soon for RESPONSIVE
+    if (frameFlags & RESPONSIVE) {
+        if (Throttle::isWithinTimespanMs(previousRunMs, 1000)) {
+            refresh = SKIPPED;
+            reason = EXCEEDED_RATELIMIT_FAST;
+            LOG_DEBUG("refresh=SKIPPED, reason=EXCEEDED_RATELIMIT_FAST, frameFlags=0x%x", frameFlags);
+            return;
+        }
+    }
+}
+
+// Is this frame COSMETIC (splash screens?)
+void EInkDynamicDisplay::checkCosmetic()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // A full refresh is requested for cosmetic purposes: we have a decision
+    if (frameFlags & COSMETIC) {
+        refresh = FULL;
+        reason = FLAGGED_COSMETIC;
+        LOG_DEBUG("refresh=FULL, reason=FLAGGED_COSMETIC, frameFlags=0x%x", frameFlags);
+    }
+}
+
+// Is this a one-off special circumstance, where we REALLY want a fast refresh?
+void EInkDynamicDisplay::checkDemandingFast()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // A fast refresh is demanded: we have a decision
+    if (frameFlags & DEMAND_FAST) {
+        refresh = FAST;
+        reason = FLAGGED_DEMAND_FAST;
+        LOG_DEBUG("refresh=FAST, reason=FLAGGED_DEMAND_FAST, frameFlags=0x%x", frameFlags);
+    }
+}
+
+// Does the new frame match the currently displayed image?
+void EInkDynamicDisplay::checkFrameMatchesPrevious()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // If frame is *not* a duplicate, abort the check
+    if (imageHash != previousImageHash)
+        return;
+
+#if !defined(EINK_BACKGROUND_USES_FAST)
+    // If BACKGROUND, and last update was FAST: redraw the same image in FULL (for display health + image quality)
+    if (frameFlags == BACKGROUND && fastRefreshCount > 0) {
+        refresh = FULL;
+        reason = REDRAW_WITH_FULL;
+        LOG_DEBUG("refresh=FULL, reason=REDRAW_WITH_FULL, frameFlags=0x%x", frameFlags);
+        return;
+    }
+#endif
+
+    // Not redrawn, not COSMETIC, not DEMAND_FAST
+    refresh = SKIPPED;
+    reason = FRAME_MATCHED_PREVIOUS;
+    LOG_DEBUG("refresh=SKIPPED, reason=FRAME_MATCHED_PREVIOUS, frameFlags=0x%x", frameFlags);
+}
+
+// Have too many fast-refreshes occurred consecutively, since last full refresh?
+void EInkDynamicDisplay::checkConsecutiveFastRefreshes()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // Bypass limit if UNLIMITED_FAST mode is active
+    if (frameFlags & UNLIMITED_FAST) {
+        refresh = FAST;
+        reason = NO_OBJECTIONS;
+        LOG_DEBUG("refresh=FAST, reason=UNLIMITED_FAST_MODE_ACTIVE, frameFlags=0x%x", frameFlags);
+        return;
+    }
+
+    // If too many FAST refreshes consecutively - force a FULL refresh
+    if (fastRefreshCount >= EINK_LIMIT_FASTREFRESH) {
+        refresh = FULL;
+        reason = EXCEEDED_LIMIT_FASTREFRESH;
+        LOG_DEBUG("refresh=FULL, reason=EXCEEDED_LIMIT_FASTREFRESH, frameFlags=0x%x", frameFlags);
+    }
+}
+
+// No objections, we can perform fast-refresh, if desired
+void EInkDynamicDisplay::checkFastRequested()
+{
+    if (refresh != UNSPECIFIED)
+        return;
+
+    if (frameFlags == BACKGROUND) {
+#ifdef EINK_BACKGROUND_USES_FAST
+        // If we want BACKGROUND to use fast. (FULL only when a limit is hit)
+        refresh = FAST;
+        reason = BACKGROUND_USES_FAST;
+        LOG_DEBUG("refresh=FAST, reason=BACKGROUND_USES_FAST, fastRefreshCount=%lu, frameFlags=0x%x", fastRefreshCount,
+                  frameFlags);
+#else
+        // If we do want to use FULL for BACKGROUND updates
+        refresh = FULL;
+        reason = FLAGGED_BACKGROUND;
+        LOG_DEBUG("refresh=FULL, reason=FLAGGED_BACKGROUND");
+#endif
+    }
+
+    // Sanity: confirm that we did ask for a RESPONSIVE frame.
+    if (frameFlags & RESPONSIVE) {
+        refresh = FAST;
+        reason = NO_OBJECTIONS;
+        LOG_DEBUG("refresh=FAST, reason=NO_OBJECTIONS, fastRefreshCount=%lu, frameFlags=0x%x", fastRefreshCount, frameFlags);
+    }
+}
+
+// Reset the timer used for rate-limiting
+void EInkDynamicDisplay::resetRateLimiting()
+{
+    previousRunMs = millis();
+}
+
+// Generate a hash of this frame, to compare against previous update
+void EInkDynamicDisplay::hashImage()
+{
+    imageHash = 0;
+
+    // Sum all bytes of the image buffer together
+    for (uint16_t b = 0; b < (displayWidth / 8) * displayHeight; b++) {
+        imageHash ^= buffer[b] << b;
+    }
+}
+
+// Store the results of determineMode() for future use, and reset for next call
+void EInkDynamicDisplay::storeAndReset()
+{
+    previousFrameFlags = frameFlags;
+    previousRefresh = refresh;
+    previousReason = reason;
+
+    // Only store image hash if the display will update
+    if (refresh != SKIPPED) {
+        previousImageHash = imageHash;
+    }
+
+    frameFlags = BACKGROUND;
+    refresh = UNSPECIFIED;
+}
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+// Count how many ghost pixels the new image will display
+void EInkDynamicDisplay::countGhostPixels()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // Start a new count
+    ghostPixelCount = 0;
+
+    // Check new image, bit by bit, for any white pixels at locations marked "dirty"
+    for (uint16_t i = 0; i < displayBufferSize; i++) {
+        for (uint8_t bit = 0; bit < 7; bit++) {
+
+            const bool dirty = (dirtyPixels[i] >> bit) & 1;       // Has pixel location been drawn to since full-refresh?
+            const bool shouldBeBlank = !((buffer[i] >> bit) & 1); // Is pixel location white in the new image?
+
+            // If pixel is (or has been) black since last full-refresh, and now is white: ghosting
+            if (dirty && shouldBeBlank)
+                ghostPixelCount++;
+
+            // Update the dirty status for this pixel - will this location become a ghost if set white in future?
+            if (!dirty && !shouldBeBlank)
+                dirtyPixels[i] |= (1 << bit);
+        }
+    }
+
+    LOG_DEBUG("ghostPixels=%hu, ", ghostPixelCount);
+}
+
+// Check if ghost pixel count exceeds the defined limit
+void EInkDynamicDisplay::checkExcessiveGhosting()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    countGhostPixels();
+
+    // If too many ghost pixels, select full refresh
+    if (ghostPixelCount > EINK_LIMIT_GHOSTING_PX) {
+        refresh = FULL;
+        reason = EXCEEDED_GHOSTINGLIMIT;
+        LOG_DEBUG("refresh=FULL, reason=EXCEEDED_GHOSTINGLIMIT, frameFlags=0x%x", frameFlags);
+    }
+}
+
+// Clear the dirty pixels array. Call when full-refresh cleans the display.
+void EInkDynamicDisplay::resetGhostPixelTracking()
+{
+    // Copy the current frame into dirtyPixels[] from the display buffer
+    memcpy(dirtyPixels.get(), EInkDisplay::buffer, EInkDisplay::displayBufferSize);
+}
+#endif // EINK_LIMIT_GHOSTING_PX
+
+// Handle any asyc tasks
+void EInkDynamicDisplay::onNotify(uint32_t notification)
+{
+    // Which task
+    switch (notification) {
+    case DUE_POLL_ASYNCREFRESH:
+        pollAsyncRefresh();
+        break;
+    }
+}
+
+#ifdef HAS_EINK_ASYNCFULL
+// Public: wait for an refresh already in progress, then run the post-update code. See Screen::setScreensaverFrames()
+void EInkDynamicDisplay::joinAsyncRefresh()
+{
+    // If no async refresh running, nothing to do
+    if (!asyncRefreshRunning)
+        return;
+
+    LOG_DEBUG("Join an async refresh in progress");
+
+    // Continually poll the BUSY pin
+    while (adafruitDisplay->epd2.isBusy())
+        yield();
+
+    // If asyncRefreshRunning flag is still set, but display's BUSY pin reports the refresh is done
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+    LOG_DEBUG("Refresh complete");
+
+    // Note: this code only works because of a modification to meshtastic/GxEPD2.
+    // It is only equipped to intercept calls to nextPage()
+}
+
+// Called from NotifiedWorkerThread. Run the post-update code if the hardware is ready
+void EInkDynamicDisplay::pollAsyncRefresh()
+{
+    // In theory, this condition should never be met
+    if (!asyncRefreshRunning)
+        return;
+
+    // Still running, check back later
+    if (adafruitDisplay->epd2.isBusy()) {
+        // Schedule next call of pollAsyncRefresh()
+        NotifiedWorkerThread::notifyLater(intervalPollAsyncRefresh, DUE_POLL_ASYNCREFRESH, true);
+        return;
+    }
+
+    // If asyncRefreshRunning flag is still set, but display's BUSY pin reports the refresh is done
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+    LOG_DEBUG("Async full-refresh complete");
+
+    // Note: this code only works because of a modification to meshtastic/GxEPD2.
+    // It is only equipped to intercept calls to nextPage()
+}
+
+// Check the status of "async full-refresh"; skip if running
+void EInkDynamicDisplay::checkBusyAsyncRefresh()
+{
+    // No refresh taking place, continue with determineMode()
+    if (!asyncRefreshRunning)
+        return;
+
+    // Full refresh still running
+    if (adafruitDisplay->epd2.isBusy()) {
+        // No refresh
+        refresh = SKIPPED;
+
+        // Set the reason, marking what type of frame we're skipping
+        if (frameFlags & DEMAND_FAST)
+            reason = ASYNC_REFRESH_BLOCKED_DEMANDFAST;
+        else if (frameFlags & COSMETIC)
+            reason = ASYNC_REFRESH_BLOCKED_COSMETIC;
+        else if (frameFlags & RESPONSIVE)
+            reason = ASYNC_REFRESH_BLOCKED_RESPONSIVE;
+        else
+            reason = ASYNC_REFRESH_BLOCKED_BACKGROUND;
+
+        return;
+    }
+
+    // Async refresh appears to have stopped, but wasn't caught by onNotify()
+    else
+        pollAsyncRefresh(); // Check (and terminate) the async refresh manually
+}
+
+// Hold control while an async refresh runs
+void EInkDynamicDisplay::awaitRefresh()
+{
+    // Continually poll the BUSY pin
+    while (adafruitDisplay->epd2.isBusy())
+        yield();
+
+    // End the full-refresh process
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+}
+#endif // HAS_EINK_ASYNCFULL
+
+#endif // USE_EINK_DYNAMICDISPLAY