Merge branch 'master' into nodenum-consistency

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

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

@@ -5,7 +5,7 @@ runs:
   using: composite
   steps:
     - name: Checkout code
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         submodules: recursive
         ref: ${{github.event.pull_request.head.ref}}

.github/workflows/build_debian_src.yml

@@ -24,7 +24,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           path: meshtasticd

.github/workflows/build_esp32.yml

@@ -1,42 +0,0 @@
-name: Build ESP32
-
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      board:
-        required: true
-        type: string
-
-permissions: read-all
-
-jobs:
-  build-esp32:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Build ESP32
-        id: build
-        uses: meshtastic/gh-action-firmware@main
-        with:
-          pio_platform: esp32
-          pio_env: ${{ inputs.board }}
-          pio_target: build
-          ota_firmware_source: firmware.bin
-          ota_firmware_target: release/bleota.bin
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-esp32-${{ inputs.board }}-${{ inputs.version }}.zip
-          overwrite: true
-          path: |
-            release/*.bin
-            release/*.elf

.github/workflows/build_esp32_c3.yml

@@ -1,42 +0,0 @@
-name: Build ESP32-C3
-
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      board:
-        required: true
-        type: string
-
-permissions: read-all
-
-jobs:
-  build-esp32-c3:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Build ESP32-C3
-        id: build
-        uses: meshtastic/gh-action-firmware@main
-        with:
-          pio_platform: esp32
-          pio_env: ${{ inputs.board }}
-          pio_target: build
-          ota_firmware_source: firmware-c3.bin
-          ota_firmware_target: release/bleota-c3.bin
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-esp32c3-${{ inputs.board }}-${{ inputs.version }}.zip
-          overwrite: true
-          path: |
-            release/*.bin
-            release/*.elf

.github/workflows/build_esp32_c6.yml

@@ -1,42 +0,0 @@
-name: Build ESP32-C6
-
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      board:
-        required: true
-        type: string
-
-permissions: read-all
-
-jobs:
-  build-esp32-c6:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Build ESP32-C6
-        id: build
-        uses: meshtastic/gh-action-firmware@main
-        with:
-          pio_platform: esp32
-          pio_env: ${{ inputs.board }}
-          pio_target: build
-          ota_firmware_source: firmware-c3.bin
-          ota_firmware_target: release/bleota-c3.bin
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-esp32c6-${{ inputs.board }}-${{ inputs.version }}.zip
-          overwrite: true
-          path: |
-            release/*.bin
-            release/*.elf

.github/workflows/build_esp32_s3.yml

@@ -1,42 +0,0 @@
-name: Build ESP32-S3
-
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      board:
-        required: true
-        type: string
-
-permissions: read-all
-
-jobs:
-  build-esp32-s3:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Build ESP32-S3
-        id: build
-        uses: meshtastic/gh-action-firmware@main
-        with:
-          pio_platform: esp32
-          pio_env: ${{ inputs.board }}
-          pio_target: build
-          ota_firmware_source: firmware-s3.bin
-          ota_firmware_target: release/bleota-s3.bin
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-esp32s3-${{ inputs.board }}-${{ inputs.version }}.zip
-          overwrite: true
-          path: |
-            release/*.bin
-            release/*.elf

.github/workflows/build_firmware.yml

@@ -0,0 +1,66 @@
+name: Build
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      platform:
+        required: true
+        type: string
+      pio_env:
+        required: true
+        type: string
+
+permissions: read-all
+
+jobs:
+  pio-build:
+    name: build-${{ inputs.platform }}
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          submodules: recursive
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+      - name: Set OTA firmware source and target
+        if: startsWith(inputs.platform, 'esp32')
+        id: ota_dir
+        env:
+          PIO_PLATFORM: ${{ inputs.platform }}
+        run: |
+          if [ "$PIO_PLATFORM" = "esp32s3" ]; then
+            echo "src=firmware-s3.bin" >> $GITHUB_OUTPUT
+            echo "tgt=release/bleota-s3.bin" >> $GITHUB_OUTPUT
+          elif [ "$PIO_PLATFORM" = "esp32c3" ] || [ "$PIO_PLATFORM" = "esp32c6" ]; then
+            echo "src=firmware-c3.bin" >> $GITHUB_OUTPUT
+            echo "tgt=release/bleota-c3.bin" >> $GITHUB_OUTPUT
+          elif [ "$PIO_PLATFORM" = "esp32" ]; then
+            echo "src=firmware.bin" >> $GITHUB_OUTPUT
+            echo "tgt=release/bleota.bin" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Build ${{ inputs.platform }}
+        id: build
+        uses: meshtastic/gh-action-firmware@main
+        with:
+          pio_platform: ${{ inputs.platform }}
+          pio_env: ${{ inputs.pio_env }}
+          pio_target: build
+          ota_firmware_source: ${{ steps.ota_dir.outputs.src || '' }}
+          ota_firmware_target: ${{ steps.ota_dir.outputs.tgt || '' }}
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: firmware-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}.zip
+          overwrite: true
+          path: |
+            release/*.bin
+            release/*.elf
+            release/*.uf2
+            release/*.hex
+            release/*-ota.zip

.github/workflows/build_nrf52.yml

@@ -1,42 +0,0 @@
-name: Build NRF52
-
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      board:
-        required: true
-        type: string
-
-permissions: read-all
-
-jobs:
-  build-nrf52:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Build NRF52
-        id: build
-        uses: meshtastic/gh-action-firmware@main
-        with:
-          pio_platform: nrf52
-          pio_env: ${{ inputs.board }}
-          pio_target: build
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-nrf52840-${{ inputs.board }}-${{ inputs.version }}.zip
-          overwrite: true
-          path: |
-            release/*.uf2
-            release/*.elf
-            release/*.hex
-            release/*-ota.zip

.github/workflows/build_rpi2040.yml

@@ -1,40 +0,0 @@
-name: Build RPI2040
-
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      board:
-        required: true
-        type: string
-
-permissions: read-all
-
-jobs:
-  build-rpi2040:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Build Raspberry Pi 2040
-        id: build
-        uses: meshtastic/gh-action-firmware@main
-        with:
-          pio_platform: rp2xx0
-          pio_env: ${{ inputs.board }}
-          pio_target: build
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-rp2040-${{ inputs.board }}-${{ inputs.version }}.zip
-          overwrite: true
-          path: |
-            release/*.uf2
-            release/*.elf

.github/workflows/build_stm32.yml

@@ -1,41 +0,0 @@
-name: Build STM32
-
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      board:
-        required: true
-        type: string
-
-permissions: read-all
-
-jobs:
-  build-stm32:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Build STM32WL
-        id: build
-        uses: meshtastic/gh-action-firmware@main
-        with:
-          pio_platform: stm32wl
-          pio_env: ${{ inputs.board }}
-          pio_target: build
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: firmware-stm32-${{ inputs.board }}-${{ inputs.version }}.zip
-          overwrite: true
-          path: |
-            release/*.hex
-            release/*.bin
-            release/*.elf

.github/workflows/docker_build.yml

@@ -47,7 +47,7 @@ jobs:
     runs-on: ${{ inputs.runs-on }}
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           ref: ${{github.event.pull_request.head.ref}}

.github/workflows/docker_manifest.yml

@@ -83,7 +83,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           ref: ${{github.event.pull_request.head.ref}}

.github/workflows/hook_copr.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           ref: ${{ github.ref }}

.github/workflows/main_matrix.yml

@@ -30,10 +30,19 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        arch: [esp32, esp32s3, esp32c3, esp32c6, nrf52840, rp2040, stm32, check]
+        arch:
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
+          - check
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: actions/setup-python@v5
         with:
           python-version: 3.x
@@ -45,7 +54,7 @@ jobs:
           if [[ "$GITHUB_HEAD_REF" == "" ]]; then
             TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
           else  
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} quick)
+            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} pr)
           fi
           echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF Targets: $TARGETS"
           echo "${{matrix.arch}}=$(jq -cn --argjson environments "$TARGETS" '{board: $environments}')" >> $GITHUB_OUTPUT
@@ -56,13 +65,14 @@ jobs:
       esp32c6: ${{ steps.jsonStep.outputs.esp32c6 }}
       nrf52840: ${{ steps.jsonStep.outputs.nrf52840 }}
       rp2040: ${{ steps.jsonStep.outputs.rp2040 }}
+      rp2350: ${{ steps.jsonStep.outputs.rp2350 }}
       stm32: ${{ steps.jsonStep.outputs.stm32 }}
       check: ${{ steps.jsonStep.outputs.check }}
 
   version:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Get release version string
         run: |
           echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
@@ -83,7 +93,7 @@ jobs:
     runs-on: ubuntu-latest
     if: ${{ github.event_name != 'workflow_dispatch' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Build base
         id: base
         uses: ./.github/actions/setup-base
@@ -95,70 +105,88 @@ jobs:
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.setup.outputs.esp32) }}
-    uses: ./.github/workflows/build_esp32.yml
+    uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      board: ${{ matrix.board }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32
 
-  build-esp32-s3:
+  build-esp32s3:
     needs: [setup, version]
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.setup.outputs.esp32s3) }}
-    uses: ./.github/workflows/build_esp32_s3.yml
+    uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      board: ${{ matrix.board }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32s3
 
-  build-esp32-c3:
+  build-esp32c3:
     needs: [setup, version]
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.setup.outputs.esp32c3) }}
-    uses: ./.github/workflows/build_esp32_c3.yml
+    uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      board: ${{ matrix.board }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c3
 
-  build-esp32-c6:
+  build-esp32c6:
     needs: [setup, version]
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.setup.outputs.esp32c6) }}
-    uses: ./.github/workflows/build_esp32_c6.yml
+    uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      board: ${{ matrix.board }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c6
 
-  build-nrf52:
+  build-nrf52840:
     needs: [setup, version]
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.setup.outputs.nrf52840) }}
-    uses: ./.github/workflows/build_nrf52.yml
+    uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      board: ${{ matrix.board }}
+      pio_env: ${{ matrix.board }}
+      platform: nrf52840
 
-  build-rpi2040:
+  build-rp2040:
     needs: [setup, version]
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.setup.outputs.rp2040) }}
-    uses: ./.github/workflows/build_rpi2040.yml
+    uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      board: ${{ matrix.board }}
+      pio_env: ${{ matrix.board }}
+      platform: rp2040
+
+  build-rp2350:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.rp2350) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: rp2350
 
   build-stm32:
     needs: [setup, version]
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.setup.outputs.stm32) }}
-    uses: ./.github/workflows/build_stm32.yml
+    uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      board: ${{ matrix.board }}
+      pio_env: ${{ matrix.board }}
+      platform: stm32
 
   build-debian-src:
     if: github.repository == 'meshtastic/firmware'
@@ -236,22 +264,31 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        arch: [esp32, esp32s3, esp32c3, esp32c6, nrf52840, rp2040, stm32]
+        arch:
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
     runs-on: ubuntu-latest
     needs:
       [
         version,
         build-esp32,
-        build-esp32-s3,
-        build-esp32-c3,
-        build-esp32-c6,
-        build-nrf52,
-        build-rpi2040,
+        build-esp32s3,
+        build-esp32c3,
+        build-esp32c6,
+        build-nrf52840,
+        build-rp2040,
+        build-rp2350,
         build-stm32,
       ]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
@@ -330,7 +367,7 @@ jobs:
       - package-pio-deps-native-tft
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Setup Python
         uses: actions/setup-python@v5
@@ -385,13 +422,21 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        arch: [esp32, esp32s3, esp32c3, esp32c6, nrf52840, rp2040, stm32]
+        arch:
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
     runs-on: ubuntu-latest
     if: ${{ github.event_name == 'workflow_dispatch' }}
     needs: [release-artifacts, version]
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Setup Python
         uses: actions/setup-python@v5
@@ -442,10 +487,11 @@ jobs:
     if: ${{ github.event_name == 'workflow_dispatch' }}
     needs: [release-firmware, version]
     env:
-      targets: esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,stm32
+      targets: |-
+        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Setup Python
         uses: actions/setup-python@v5

.github/workflows/nightly.yml

@@ -14,7 +14,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Trunk Check
         uses: trunk-io/trunk-action@v1
@@ -31,7 +31,7 @@ jobs:
       pull-requests: write # For trunk to create PRs
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Trunk Upgrade
         uses: trunk-io/trunk-action/upgrade@v1

.github/workflows/package_obs.yml

@@ -34,7 +34,7 @@ jobs:
     needs: build-debian-src
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           path: meshtasticd

.github/workflows/package_pio_deps.yml

@@ -24,7 +24,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           ref: ${{github.event.pull_request.head.ref}}

.github/workflows/package_ppa.yml

@@ -32,7 +32,7 @@ jobs:
     needs: build-debian-src
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           path: meshtasticd

.github/workflows/release_channels.yml

@@ -60,7 +60,7 @@ jobs:
         shell: bash
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Setup Python
         uses: actions/setup-python@v5

.github/workflows/sec_sast_semgrep_cron.yml

@@ -21,7 +21,7 @@ jobs:
     steps:
       # step 1
       - name: clone application source code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       # step 2
       - name: full scan

.github/workflows/sec_sast_semgrep_pull.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
       # step 1
       - name: clone application source code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 

.github/workflows/test_native.yml

@@ -14,7 +14,7 @@ jobs:
     name: Native Simulator Tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
@@ -70,7 +70,7 @@ jobs:
     name: Native PlatformIO Tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
@@ -127,7 +127,7 @@ jobs:
       - platformio-tests
     if: always()
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}

.github/workflows/tests.yml

@@ -20,7 +20,7 @@ jobs:
     runs-on: test-runner
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       # - uses: actions/setup-python@v5
       #   with:

.github/workflows/trunk_annotate_pr.yml

@@ -18,7 +18,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Trunk Check
         uses: trunk-io/trunk-action@v1

.github/workflows/trunk_check.yml

@@ -16,7 +16,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Trunk Check
         uses: trunk-io/trunk-action@v1

.github/workflows/trunk_format_pr.yml

@@ -15,7 +15,7 @@ jobs:
       pull-requests: write
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}

.github/workflows/update_protobufs.yml

@@ -11,7 +11,7 @@ jobs:
       pull-requests: write
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           submodules: true
 

arch/stm32/stm32.ini

@@ -2,7 +2,7 @@
 extends = arduino_base
 platform =
   # renovate: datasource=custom.pio depName=platformio/ststm32 packageName=platformio/platform/ststm32
-  platformio/ststm32@19.2.0
+  platformio/ststm32@19.3.0
 platform_packages =
   # TODO renovate
   platformio/framework-arduinoststm32@https://github.com/stm32duino/Arduino_Core_STM32/archive/2.10.1.zip

bin/build-firmware.sh

@@ -11,7 +11,7 @@ elif (echo $2 | grep -q "nrf52"); then
 elif (echo $2 | grep -q "stm32"); then
   bin/build-stm32.sh $1
 elif (echo $2 | grep -q "rpi2040"); then
-  bin/build-rpi2040.sh $1
+  bin/build-rp2xx0.sh $1
 else
   echo "Unknown target $2"
   exit 1

bin/device-update.sh

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 
 PYTHON=${PYTHON:-$(which python3 python|head -n 1)}
 CHANGE_MODE=false

bin/generate_ci_matrix.py

@@ -45,24 +45,28 @@ for pio_env in pio_envs:
   all_envs.append(env)
 
 # Filter outputs based on options
-# Check is currently mutually exclusive with other options
+# Check is mutually exclusive with other options (except 'pr')
 if "check" in options:
   for env in all_envs:
     if env['board_check']:
-      outlist.append(env['name'])
+      if "pr" in options:
+        if env['board_level'] == 'pr':
+          outlist.append(env['name'])
+      else:
+        outlist.append(env['name'])
 # Filter (non-check) builds by platform
 else:
   for env in all_envs:
     if options[0] == env['platform']:
-      # If no board level is specified, always include it
-      if not env['board_level']:
+      # Always include board_level = 'pr'
+      if env['board_level'] == 'pr':
         outlist.append(env['name'])
-      # Include `extra` boards when requested
+      # Include board_level = 'extra' when requested
       elif "extra" in options and env['board_level'] == "extra":
         outlist.append(env['name'])
+      # If no board level is specified, include in release builds (not PR)
+      elif "pr" not in options and not env['board_level']:
+        outlist.append(env['name'])
 
 # Return as a JSON list
-if ("quick" in options) and (len(outlist) > 3):
-    print(json.dumps(random.sample(outlist, 3)))
-else:
-    print(json.dumps(outlist))
+print(json.dumps(outlist))

bin/org.meshtastic.meshtasticd.metainfo.xml

@@ -87,6 +87,9 @@
   </screenshots>
 
   <releases>
+    <release version="2.7.5" date="2025-08-09">
+      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.5</url>
+    </release>
     <release version="2.7.4" date="2025-07-19">
       <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.4</url>
     </release>

debian/changelog

@@ -1,4 +1,4 @@
-meshtasticd (2.7.4.0) UNRELEASED; urgency=medium
+meshtasticd (2.7.5.0) UNRELEASED; urgency=medium
 
   [ Austin Lane ]
   * Initial packaging
@@ -34,4 +34,7 @@ meshtasticd (2.7.4.0) UNRELEASED; urgency=medium
   [  ]
   * GitHub Actions Automatic version bump
 
- --  <github-actions[bot]@users.noreply.github.com>  Sat, 19 Jul 2025 11:36:55 +0000
+  [  ]
+  * GitHub Actions Automatic version bump
+
+ --  <github-actions[bot]@users.noreply.github.com>  Sat, 09 Aug 2025 12:46:53 +0000

debian/meshtasticd.postinst

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 # postinst script for meshtasticd
 #
 # see: dh_installdeb(1)

debian/meshtasticd.postrm

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 # postrm script for meshtasticd
 #
 # see: dh_installdeb(1)

platformio.ini

@@ -110,7 +110,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/86a09a7360f92d10053fbbf8d74f67f85b0ceb09.zip
+	https://github.com/meshtastic/device-ui/archive/0cd108ff783539e41ef38258ba2784ab3b1bdc97.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -178,7 +178,7 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit MAX1704X packageName=adafruit/library/Adafruit MAX1704X
 	adafruit/Adafruit MAX1704X@1.0.3
 	# renovate: datasource=custom.pio depName=Adafruit SHTC3 packageName=adafruit/library/Adafruit SHTC3 Library
-	adafruit/Adafruit SHTC3 Library@1.0.1
+	adafruit/Adafruit SHTC3 Library@1.0.2
 	# renovate: datasource=custom.pio depName=Adafruit LPS2X packageName=adafruit/library/Adafruit LPS2X
 	adafruit/Adafruit LPS2X@2.0.6
 	# renovate: datasource=custom.pio depName=Adafruit SHT31 packageName=adafruit/library/Adafruit SHT31 Library

src/Power.cpp

@@ -724,10 +724,12 @@ void Power::reboot()
     SPI.end();
     Wire.end();
     Serial1.end();
-    if (screen)
+    if (screen) {
         delete screen;
+        screen = nullptr;
+    }
     LOG_DEBUG("final reboot!");
-    reboot();
+    ::reboot();
 #elif defined(ARCH_STM32WL)
     HAL_NVIC_SystemReset();
 #else

src/detect/ScanI2CTwoWire.cpp

@@ -184,8 +184,13 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 type = RTC_RV3028;
                 logFoundDevice("RV3028", (uint8_t)addr.address);
                 rtc.initI2C(*i2cBus);
-                rtc.writeToRegister(0x35, 0x07); // no Clkout
-                rtc.writeToRegister(0x37, 0xB4);
+                // Update RTC EEPROM settings, if necessary
+                if (rtc.readEEPROMRegister(0x35) != 0x07) {
+                    rtc.writeEEPROMRegister(0x35, 0x07); // no Clkout
+                }
+                if (rtc.readEEPROMRegister(0x37) != 0xB4) {
+                    rtc.writeEEPROMRegister(0x37, 0xB4);
+                }
                 break;
 #endif
 

src/gps/GPS.cpp

@@ -1511,7 +1511,7 @@ bool GPS::lookForTime()
 
 #ifdef GNSS_AIROHA
     uint8_t fix = reader.fixQuality();
-    if (fix > 0) {
+    if (fix >= 1 && fix <= 5) {
         if (lastFixStartMsec > 0) {
             if (Throttle::isWithinTimespanMs(lastFixStartMsec, GPS_FIX_HOLD_TIME)) {
                 return false;
@@ -1566,7 +1566,7 @@ bool GPS::lookForLocation()
 #ifdef GNSS_AIROHA
     if ((config.position.gps_update_interval * 1000) >= (GPS_FIX_HOLD_TIME * 2)) {
         uint8_t fix = reader.fixQuality();
-        if (fix > 0) {
+        if (fix >= 1 && fix <= 5) {
             if (lastFixStartMsec > 0) {
                 if (Throttle::isWithinTimespanMs(lastFixStartMsec, GPS_FIX_HOLD_TIME)) {
                     return false;

src/graphics/EInkDisplay2.cpp

@@ -151,6 +151,21 @@ bool EInkDisplay::connect()
 #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)

src/graphics/EInkDisplay2.h

@@ -80,7 +80,7 @@ class EInkDisplay : public OLEDDisplay
     // 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(CROWPANEL_ESP32S3_4_EPAPER) || defined(CROWPANEL_ESP32S3_2_EPAPER) || defined(ELECROW_ThinkNode_M5)
     SPIClass *hspi = NULL;
 #endif
 

src/graphics/Screen.cpp

@@ -391,6 +391,10 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             dispdev->displayOn();
 #endif
 
+#ifdef ELECROW_ThinkNode_M5
+            io.digitalWrite(PCA_PIN_EINK_EN, HIGH);
+#endif
+
 #if defined(ST7789_CS) &&                                                                                                        \
     !defined(M5STACK) // set display brightness when turning on screens. Just moved function from TFTDisplay to here.
             static_cast<TFTDisplay *>(dispdev)->setDisplayBrightness(brightness);
@@ -425,6 +429,11 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
                 digitalWrite(PIN_EINK_EN, LOW);
             }
 #endif
+
+#ifdef ELECROW_ThinkNode_M5
+            io.digitalWrite(PCA_PIN_EINK_EN, LOW);
+#endif
+
             dispdev->displayOff();
 #ifdef USE_ST7789
             SPI1.end();
@@ -1264,40 +1273,39 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
             if (shouldWakeOnReceivedMessage()) {
                 setOn(true);    // Wake up the screen first
                 forceDisplay(); // Forces screen redraw
-
-                // === Prepare banner content ===
-                const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet->from);
-                const char *longName = (node && node->has_user) ? node->user.long_name : nullptr;
-
-                const char *msgRaw = reinterpret_cast<const char *>(packet->decoded.payload.bytes);
-
-                char banner[256];
-
-                // Check for bell character in message to determine alert type
-                bool isAlert = false;
-                for (size_t i = 0; i < packet->decoded.payload.size && i < 100; i++) {
-                    if (msgRaw[i] == '\x07') {
-                        isAlert = true;
-                        break;
-                    }
-                }
-
-                if (isAlert) {
-                    if (longName && longName[0]) {
-                        snprintf(banner, sizeof(banner), "Alert Received from\n%s", longName);
-                    } else {
-                        strcpy(banner, "Alert Received");
-                    }
-                } else {
-                    if (longName && longName[0]) {
-                        snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
-                    } else {
-                        strcpy(banner, "New Message");
-                    }
-                }
-
-                screen->showSimpleBanner(banner, 3000);
             }
+            // === Prepare banner content ===
+            const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet->from);
+            const char *longName = (node && node->has_user) ? node->user.long_name : nullptr;
+
+            const char *msgRaw = reinterpret_cast<const char *>(packet->decoded.payload.bytes);
+
+            char banner[256];
+
+            // Check for bell character in message to determine alert type
+            bool isAlert = false;
+            for (size_t i = 0; i < packet->decoded.payload.size && i < 100; i++) {
+                if (msgRaw[i] == '\x07') {
+                    isAlert = true;
+                    break;
+                }
+            }
+
+            if (isAlert) {
+                if (longName && longName[0]) {
+                    snprintf(banner, sizeof(banner), "Alert Received from\n%s", longName);
+                } else {
+                    strcpy(banner, "Alert Received");
+                }
+            } else {
+                if (longName && longName[0]) {
+                    snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
+                } else {
+                    strcpy(banner, "New Message");
+                }
+            }
+
+            screen->showSimpleBanner(banner, 3000);
         }
     }
 

src/graphics/draw/DebugRenderer.cpp

@@ -412,9 +412,9 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     float freq = RadioLibInterface::instance->getFreq();
     snprintf(freqStr, sizeof(freqStr), "%.3f", freq);
     if (config.lora.channel_num == 0) {
-        snprintf(frequencyslot, sizeof(frequencyslot), "Freq: %smhz", freqStr);
+        snprintf(frequencyslot, sizeof(frequencyslot), "Freq: %sMHz", freqStr);
     } else {
-        snprintf(frequencyslot, sizeof(frequencyslot), "Freq/Ch: %smhz (%d)", freqStr, config.lora.channel_num);
+        snprintf(frequencyslot, sizeof(frequencyslot), "Freq/Ch: %sMHz (%d)", freqStr, config.lora.channel_num);
     }
     size_t len = strlen(frequencyslot);
     if (len >= 4 && strcmp(frequencyslot + len - 4, " (0)") == 0) {

src/graphics/draw/MenuHandler.cpp

@@ -15,6 +15,9 @@
 #include "modules/CannedMessageModule.h"
 #include "modules/KeyVerificationModule.h"
 
+#include "modules/TraceRouteModule.h"
+#include <functional>
+
 extern uint16_t TFT_MESH;
 
 namespace graphics
@@ -51,12 +54,14 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
                                          "PH_915",
                                          "ANZ_433",
                                          "KZ_433",
-                                         "KZ_863"};
+                                         "KZ_863",
+                                         "NP_865",
+                                         "BR_902"};
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "Set the LoRa region";
     bannerOptions.durationMs = duration;
     bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 25;
+    bannerOptions.optionsCount = 27;
     bannerOptions.InitialSelected = 0;
     bannerOptions.bannerCallback = [](int selected) -> void {
         if (selected != 0 && config.lora.region != _meshtastic_Config_LoRaConfig_RegionCode(selected)) {
@@ -115,6 +120,22 @@ void menuHandler::TwelveHourPicker()
     screen->showOverlayBanner(bannerOptions);
 }
 
+// Reusable confirmation prompt function
+void menuHandler::showConfirmationBanner(const char *message, std::function<void()> onConfirm)
+{
+    static const char *confirmOptions[] = {"No", "Yes"};
+    BannerOverlayOptions confirmBanner;
+    confirmBanner.message = message;
+    confirmBanner.optionsArrayPtr = confirmOptions;
+    confirmBanner.optionsCount = 2;
+    confirmBanner.bannerCallback = [onConfirm](int confirmSelected) -> void {
+        if (confirmSelected == 1) {
+            onConfirm();
+        }
+    };
+    screen->showOverlayBanner(confirmBanner);
+}
+
 void menuHandler::ClockFacePicker()
 {
     static const char *optionsArray[] = {"Back", "Digital", "Analog"};
@@ -151,6 +172,7 @@ void menuHandler::TZPicker()
                                          "US/Mountain",
                                          "US/Central",
                                          "US/Eastern",
+                                         "BR/Brasilia",
                                          "UTC",
                                          "EU/Western",
                                          "EU/"
@@ -165,7 +187,7 @@ void menuHandler::TZPicker()
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "Pick Timezone";
     bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 17;
+    bannerOptions.optionsCount = 19;
     bannerOptions.bannerCallback = [](int selected) -> void {
         if (selected == 0) {
             menuHandler::menuQueue = menuHandler::clock_menu;
@@ -184,25 +206,27 @@ void menuHandler::TZPicker()
             strncpy(config.device.tzdef, "CST6CDT,M3.2.0,M11.1.0", sizeof(config.device.tzdef));
         } else if (selected == 7) { // Eastern
             strncpy(config.device.tzdef, "EST5EDT,M3.2.0,M11.1.0", sizeof(config.device.tzdef));
-        } else if (selected == 8) { // UTC
-            strncpy(config.device.tzdef, "UTC", sizeof(config.device.tzdef));
-        } else if (selected == 9) { // EU/Western
+        } else if (selected == 8) { // Brazil
+            strncpy(config.device.tzdef, "BRT3", sizeof(config.device.tzdef));
+        } else if (selected == 9) { // UTC
+            strncpy(config.device.tzdef, "UTC0", sizeof(config.device.tzdef));
+        } else if (selected == 10) { // EU/Western
             strncpy(config.device.tzdef, "GMT0BST,M3.5.0/1,M10.5.0", sizeof(config.device.tzdef));
-        } else if (selected == 10) { // EU/Central
+        } else if (selected == 11) { // EU/Central
             strncpy(config.device.tzdef, "CET-1CEST,M3.5.0,M10.5.0/3", sizeof(config.device.tzdef));
-        } else if (selected == 11) { // EU/Eastern
+        } else if (selected == 12) { // EU/Eastern
             strncpy(config.device.tzdef, "EET-2EEST,M3.5.0/3,M10.5.0/4", sizeof(config.device.tzdef));
-        } else if (selected == 12) { // Asia/Kolkata
+        } else if (selected == 13) { // Asia/Kolkata
             strncpy(config.device.tzdef, "IST-5:30", sizeof(config.device.tzdef));
-        } else if (selected == 13) { // China
+        } else if (selected == 14) { // China
             strncpy(config.device.tzdef, "HKT-8", sizeof(config.device.tzdef));
-        } else if (selected == 14) { // AU/AWST
+        } else if (selected == 15) { // AU/AWST
             strncpy(config.device.tzdef, "AWST-8", sizeof(config.device.tzdef));
-        } else if (selected == 15) { // AU/ACST
+        } else if (selected == 16) { // AU/ACST
             strncpy(config.device.tzdef, "ACST-9:30ACDT,M10.1.0,M4.1.0/3", sizeof(config.device.tzdef));
-        } else if (selected == 16) { // AU/AEST
+        } else if (selected == 17) { // AU/AEST
             strncpy(config.device.tzdef, "AEST-10AEDT,M10.1.0,M4.1.0/3", sizeof(config.device.tzdef));
-        } else if (selected == 17) { // NZ
+        } else if (selected == 18) { // NZ
             strncpy(config.device.tzdef, "NZST-12NZDT,M9.5.0,M4.1.0/3", sizeof(config.device.tzdef));
         }
         if (selected != 0) {
@@ -288,7 +312,7 @@ void menuHandler::messageResponseMenu()
 
 void menuHandler::homeBaseMenu()
 {
-    enum optionsNumbers { Back, Backlight, Position, Preset, Freetext, Bluetooth, Sleep, enumEnd };
+    enum optionsNumbers { Back, Backlight, Position, Preset, Freetext, Sleep, enumEnd };
 
     static const char *optionsArray[enumEnd] = {"Back"};
     static int optionsEnumArray[enumEnd] = {Back};
@@ -310,8 +334,6 @@ void menuHandler::homeBaseMenu()
         optionsArray[options] = "New Freetext Msg";
         optionsEnumArray[options++] = Freetext;
     }
-    optionsArray[options] = "Bluetooth Toggle";
-    optionsEnumArray[options++] = Bluetooth;
 
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "Home Action";
@@ -336,9 +358,6 @@ void menuHandler::homeBaseMenu()
             cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST);
         } else if (selected == Freetext) {
             cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST);
-        } else if (selected == Bluetooth) {
-            menuQueue = bluetooth_toggle_menu;
-            screen->runNow();
         }
     };
     screen->showOverlayBanner(bannerOptions);
@@ -375,7 +394,7 @@ void menuHandler::textMessageBaseMenu()
 
 void menuHandler::systemBaseMenu()
 {
-    enum optionsNumbers { Back, Notifications, ScreenOptions, PowerMenu, Test, enumEnd };
+    enum optionsNumbers { Back, Notifications, ScreenOptions, Bluetooth, PowerMenu, Test, enumEnd };
     static const char *optionsArray[enumEnd] = {"Back"};
     static int optionsEnumArray[enumEnd] = {Back};
     int options = 1;
@@ -388,6 +407,9 @@ void menuHandler::systemBaseMenu()
     optionsEnumArray[options++] = ScreenOptions;
 #endif
 
+    optionsArray[options] = "Bluetooth Toggle";
+    optionsEnumArray[options++] = Bluetooth;
+
     optionsArray[options] = "Reboot/Shutdown";
     optionsEnumArray[options++] = PowerMenu;
 
@@ -414,6 +436,9 @@ void menuHandler::systemBaseMenu()
         } else if (selected == Test) {
             menuHandler::menuQueue = menuHandler::test_menu;
             screen->runNow();
+        } else if (selected == Bluetooth) {
+            menuQueue = bluetooth_toggle_menu;
+            screen->runNow();
         } else if (selected == Back && !test_enabled) {
             test_count++;
             if (test_count > 4) {
@@ -426,7 +451,7 @@ void menuHandler::systemBaseMenu()
 
 void menuHandler::favoriteBaseMenu()
 {
-    enum optionsNumbers { Back, Preset, Freetext, Remove, enumEnd };
+    enum optionsNumbers { Back, Preset, Freetext, Remove, TraceRoute, enumEnd };
     static const char *optionsArray[enumEnd] = {"Back", "New Preset Msg"};
     static int optionsEnumArray[enumEnd] = {Back, Preset};
     int options = 2;
@@ -435,6 +460,8 @@ void menuHandler::favoriteBaseMenu()
         optionsArray[options] = "New Freetext Msg";
         optionsEnumArray[options++] = Freetext;
     }
+    optionsArray[options] = "Trace Route";
+    optionsEnumArray[options++] = TraceRoute;
     optionsArray[options] = "Remove Favorite";
     optionsEnumArray[options++] = Remove;
 
@@ -451,6 +478,10 @@ void menuHandler::favoriteBaseMenu()
         } else if (selected == Remove) {
             menuHandler::menuQueue = menuHandler::remove_favorite;
             screen->runNow();
+        } else if (selected == TraceRoute) {
+            if (traceRouteModule) {
+                traceRouteModule->launch(graphics::UIRenderer::currentFavoriteNodeNum);
+            }
         }
     };
     screen->showOverlayBanner(bannerOptions);
@@ -489,12 +520,12 @@ void menuHandler::positionBaseMenu()
 
 void menuHandler::nodeListMenu()
 {
-    enum optionsNumbers { Back, Favorite, Verify, Reset };
-    static const char *optionsArray[] = {"Back", "Add Favorite", "Key Verification", "Reset NodeDB"};
+    enum optionsNumbers { Back, Favorite, TraceRoute, Verify, Reset, enumEnd };
+    static const char *optionsArray[] = {"Back", "Add Favorite", "Trace Route", "Key Verification", "Reset NodeDB"};
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "Node Action";
     bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 4;
+    bannerOptions.optionsCount = 5;
     bannerOptions.bannerCallback = [](int selected) -> void {
         if (selected == Favorite) {
             menuQueue = add_favorite;
@@ -505,6 +536,9 @@ void menuHandler::nodeListMenu()
         } else if (selected == Reset) {
             menuQueue = reset_node_db_menu;
             screen->runNow();
+        } else if (selected == TraceRoute) {
+            menuQueue = trace_route_menu;
+            screen->runNow();
         }
     };
     screen->showOverlayBanner(bannerOptions);
@@ -857,6 +891,16 @@ void menuHandler::removeFavoriteMenu()
     screen->showOverlayBanner(bannerOptions);
 }
 
+void menuHandler::traceRouteMenu()
+{
+    screen->showNodePicker("Node to Trace", 30000, [](uint32_t nodenum) -> void {
+        LOG_INFO("Menu: Node picker selected node 0x%08x, traceRouteModule=%p", nodenum, traceRouteModule);
+        if (traceRouteModule) {
+            traceRouteModule->startTraceRoute(nodenum);
+        }
+    });
+}
+
 void menuHandler::testMenu()
 {
 
@@ -1129,6 +1173,9 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
     case remove_favorite:
         removeFavoriteMenu();
         break;
+    case trace_route_menu:
+        traceRouteMenu();
+        break;
     case test_menu:
         testMenu();
         break;

src/graphics/draw/MenuHandler.h

@@ -36,12 +36,14 @@ class menuHandler
         system_base_menu,
         key_verification_init,
         key_verification_final_prompt,
-        throttle_message
+        trace_route_menu,
+        throttle_message,
     };
     static screenMenus menuQueue;
 
     static void LoraRegionPicker(uint32_t duration = 30000);
     static void handleMenuSwitch(OLEDDisplay *display);
+    static void showConfirmationBanner(const char *message, std::function<void()> onConfirm);
     static void clockMenu();
     static void TZPicker();
     static void TwelveHourPicker();
@@ -64,6 +66,7 @@ class menuHandler
     static void shutdownMenu();
     static void addFavoriteMenu();
     static void removeFavoriteMenu();
+    static void traceRouteMenu();
     static void testMenu();
     static void numberTest();
     static void wifiBaseMenu();

src/graphics/draw/MessageRenderer.cpp

@@ -273,7 +273,7 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     currentKey ^= ((size_t)mp.id << 24);
 
     if (cachedKey != currentKey) {
-        LOG_INFO("Message cache key is misssed cachedKey=0x%0x, currentKey=0x%x", cachedKey, currentKey);
+        LOG_INFO("Onscreen message scroll cache key needs updating: cachedKey=0x%0x, currentKey=0x%x", cachedKey, currentKey);
 
         // Cache miss - regenerate lines and heights
         cachedLines = generateLines(display, headerStr, messageBuf, textWidth);

src/input/ExpressLRSFiveWay.cpp

@@ -199,7 +199,7 @@ void ExpressLRSFiveWay::sendKey(input_broker_event key)
 void ExpressLRSFiveWay::toggleGPS()
 {
 #if HAS_GPS && !MESHTASTIC_EXCLUDE_GPS
-    if (!config.device.disable_triple_click && (gps != nullptr)) {
+    if (gps != nullptr) {
         gps->toggleGpsMode();
         screen->startAlert("GPS Toggled");
         alerting = true;

src/main.cpp

@@ -38,6 +38,10 @@
 #include <memory>
 #include <utility>
 
+#ifdef ELECROW_ThinkNode_M5
+PCA9557 io(0x18, &Wire);
+#endif
+
 #ifdef ARCH_ESP32
 #include "freertosinc.h"
 #if !MESHTASTIC_EXCLUDE_WEBSERVER
@@ -296,6 +300,15 @@ void setup()
     digitalWrite(PIN_POWER_EN, HIGH);
 #endif
 
+#if defined(ELECROW_ThinkNode_M5)
+    Wire.begin(48, 47);
+    io.pinMode(PCA_PIN_EINK_EN, OUTPUT);
+    io.pinMode(PCA_PIN_POWER_EN, OUTPUT);
+    io.digitalWrite(PCA_PIN_EINK_EN, HIGH);
+    io.digitalWrite(PCA_PIN_POWER_EN, HIGH);
+    // io.pinMode(C2_PIN, OUTPUT);
+#endif
+
 #ifdef LED_POWER
     pinMode(LED_POWER, OUTPUT);
     digitalWrite(LED_POWER, LED_STATE_ON);
@@ -902,14 +915,20 @@ void setup()
     service = new MeshService();
     service->init();
 
-    if (nodeDB->keyIsLowEntropy) {
-        service->reloadConfig(SEGMENT_CONFIG);
-        rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
-    }
-
     // Now that the mesh service is created, create any modules
     setupModules();
 
+    // warn the user about a low entropy key
+    if (nodeDB->keyIsLowEntropy && !nodeDB->hasWarned) {
+        LOG_WARN(LOW_ENTROPY_WARNING);
+        meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+        cn->level = meshtastic_LogRecord_Level_WARNING;
+        cn->time = getValidTime(RTCQualityFromNet);
+        sprintf(cn->message, LOW_ENTROPY_WARNING);
+        service->sendClientNotification(cn);
+        nodeDB->hasWarned = true;
+    }
+
 // buttons are now inputBroker, so have to come after setupModules
 #if HAS_BUTTON
     int pullup_sense = 0;

src/main.h

@@ -51,6 +51,11 @@ extern Adafruit_DRV2605 drv;
 extern AudioThread *audioThread;
 #endif
 
+#ifdef ELECROW_ThinkNode_M5
+#include <PCA9557.h>
+extern PCA9557 io;
+#endif
+
 #ifdef HAS_UDP_MULTICAST
 #include "mesh/udp/UdpMulticastHandler.h"
 extern UdpMulticastHandler *udpHandler;

src/mesh/MeshService.h

@@ -146,7 +146,7 @@ class MeshService
     virtual void sendMqttMessageToClientProxy(meshtastic_MqttClientProxyMessage *m);
 
     /// Send a ClientNotification to the phone
-    void sendClientNotification(meshtastic_ClientNotification *cn);
+    virtual void sendClientNotification(meshtastic_ClientNotification *cn);
 
     /// Send an error response to the phone
     void sendRoutingErrorResponse(meshtastic_Routing_Error error, const meshtastic_MeshPacket *mp);

src/mesh/NodeDB.cpp

@@ -264,12 +264,12 @@ NodeDB::NodeDB()
 
     if (!owner.is_licensed && config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
         bool keygenSuccess = false;
-        if (config.security.private_key.size == 32) {
+        keyIsLowEntropy = checkLowEntropyPublicKey(config.security.public_key);
+        if (config.security.private_key.size == 32 && !keyIsLowEntropy) {
             if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
                 keygenSuccess = true;
             }
         } else {
-            LOG_INFO("Generate new PKI keys");
             crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
             keygenSuccess = true;
         }
@@ -288,16 +288,6 @@ NodeDB::NodeDB()
         crypto->setDHPrivateKey(config.security.private_key.bytes);
     }
 #endif
-    keyIsLowEntropy = checkLowEntropyPublicKey(config.security.public_key);
-    if (keyIsLowEntropy) {
-        LOG_WARN("Erasing low entropy keys");
-        config.security.private_key.size = 0;
-        memfll(config.security.private_key.bytes, '\0', sizeof(config.security.private_key.bytes));
-        config.security.public_key.size = 0;
-        memfll(config.security.public_key.bytes, '\0', sizeof(config.security.public_key.bytes));
-        owner.public_key.size = 0;
-        memfll(owner.public_key.bytes, '\0', sizeof(owner.public_key.bytes));
-    }
     // Include our owner in the node db under our nodenum
     meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
     info->user = TypeConversions::ConvertToUserLite(owner);
@@ -406,6 +396,9 @@ NodeDB::NodeDB()
         config.position.gps_mode = meshtastic_Config_PositionConfig_GpsMode_ENABLED;
         config.position.gps_enabled = 0;
     }
+#ifdef USERPREFS_FIRMWARE_EDITION
+    myNodeInfo.firmware_edition = USERPREFS_FIRMWARE_EDITION;
+#endif
 #ifdef USERPREFS_FIXED_GPS
     if (myNodeInfo.reboot_count == 1) { // Check if First boot ever or after Factory Reset.
         meshtastic_Position fixedGPS = meshtastic_Position_init_default;
@@ -628,11 +621,6 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #ifdef PIN_GPS_EN
     config.position.gps_en_gpio = PIN_GPS_EN;
 #endif
-#ifdef GPS_POWER_TOGGLE
-    config.device.disable_triple_click = false;
-#else
-    config.device.disable_triple_click = true;
-#endif
 #if defined(USERPREFS_CONFIG_GPS_MODE)
     config.position.gps_mode = USERPREFS_CONFIG_GPS_MODE;
 #elif !HAS_GPS || GPS_DEFAULT_NOT_PRESENT
@@ -997,8 +985,9 @@ void NodeDB::resetNodes()
 
 void NodeDB::removeNodeByNum(NodeNum nodeNum)
 {
-    int newPos = 0, removed = 0;
-    for (int i = 0; i < numMeshNodes; i++) {
+    // Don't remove the own node at position 0
+    int newPos = 1, removed = 0;
+    for (int i = 1; i < numMeshNodes; i++) {
         if (meshNodes->at(i).num != nodeNum)
             meshNodes->at(newPos++) = meshNodes->at(i);
         else
@@ -1094,18 +1083,16 @@ void NodeDB::pickNewNodeNum()
     }
 
     meshtastic_NodeInfoLite *found;
-    while (((found = getMeshNode(nodeNum)) && memcmp(found->user.macaddr, ourMacAddr, sizeof(ourMacAddr)) != 0) ||
-           (nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED)) {
-        NodeNum candidate = random(NUM_RESERVED, LONG_MAX); // try a new random choice
-        if (found)
-            LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, by MAC ending in 0x%02x%02x vs our 0x%02x%02x, so "
-                     "trying for 0x%x",
-                     nodeNum, found->user.macaddr[4], found->user.macaddr[5], ourMacAddr[4], ourMacAddr[5], candidate);
-        nodeNum = candidate;
+    if (((found = getMeshNode(nodeNum)) && memcmp(found->user.macaddr, ourMacAddr, sizeof(ourMacAddr)) != 0) ||
+        (nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED)) {
+        NodeNum newNodeNum = (ourMacAddr[2] << 24) | (ourMacAddr[3] << 16) | (ourMacAddr[4] << 8) | ourMacAddr[5];
+        LOG_WARN("NOTE! Our saved nodenum 0x%x is invalid or in use. Using 0x%x", nodeNum, newNodeNum);
+        nodeNum = newNodeNum;
     }
     LOG_DEBUG("Use nodenum 0x%x ", nodeNum);
 
     myNodeInfo.my_node_num = nodeNum;
+    removeNodeByNum(nodeNum); // Since we skip 0, this should only ever remove outside matches.
 }
 
 /** Load a protobuf from a file, return LoadFileResult */
@@ -1649,7 +1636,6 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
                              "to regenerate your public keys.";
             LOG_WARN(warning, p.long_name);
             meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
-            cn->which_payload_variant = meshtastic_ClientNotification_duplicated_public_key_tag;
             cn->level = meshtastic_LogRecord_Level_WARNING;
             cn->time = getValidTime(RTCQualityFromNet);
             sprintf(cn->message, warning, p.long_name);
@@ -1702,10 +1688,10 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
 /// we updateGUI and updateGUIforNode if we think our this change is big enough for a redraw
 void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
 {
-    // if (mp.from == getNodeNum()) {
-    //     LOG_DEBUG("Ignore update from self");
-    //     return;
-    // }
+    if (mp.transport_mechanism != meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API && mp.from == getNodeNum()) {
+        LOG_DEBUG("Ignore update from self");
+        return;
+    }
     if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag && mp.from) {
         LOG_DEBUG("Update DB node 0x%x, rx_time=%u", mp.from, mp.rx_time);
 
@@ -1880,28 +1866,10 @@ bool NodeDB::checkLowEntropyPublicKey(const meshtastic_Config_SecurityConfig_pub
         uint8_t keyHash[32] = {0};
         memcpy(keyHash, keyToTest.bytes, keyToTest.size);
         crypto->hash(keyHash, 32);
-        if (memcmp(keyHash, LOW_ENTROPY_HASH1, sizeof(LOW_ENTROPY_HASH1)) ==
-                0 || // should become an array that gets looped through rather than this abomination
-            memcmp(keyHash, LOW_ENTROPY_HASH2, sizeof(LOW_ENTROPY_HASH2)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH3, sizeof(LOW_ENTROPY_HASH3)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH4, sizeof(LOW_ENTROPY_HASH4)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH5, sizeof(LOW_ENTROPY_HASH5)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH6, sizeof(LOW_ENTROPY_HASH6)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH7, sizeof(LOW_ENTROPY_HASH7)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH8, sizeof(LOW_ENTROPY_HASH8)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH9, sizeof(LOW_ENTROPY_HASH9)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH10, sizeof(LOW_ENTROPY_HASH10)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH11, sizeof(LOW_ENTROPY_HASH11)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH12, sizeof(LOW_ENTROPY_HASH12)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH13, sizeof(LOW_ENTROPY_HASH13)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH14, sizeof(LOW_ENTROPY_HASH14)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH15, sizeof(LOW_ENTROPY_HASH15)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH16, sizeof(LOW_ENTROPY_HASH16)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH17, sizeof(LOW_ENTROPY_HASH17)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH18, sizeof(LOW_ENTROPY_HASH18)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH19, sizeof(LOW_ENTROPY_HASH19)) == 0 ||
-            memcmp(keyHash, LOW_ENTROPY_HASH20, sizeof(LOW_ENTROPY_HASH20)) == 0) {
-            return true;
+        for (int i = 0; i < sizeof(LOW_ENTROPY_HASHES) / sizeof(LOW_ENTROPY_HASHES[0]); i++) {
+            if (memcmp(keyHash, LOW_ENTROPY_HASHES[i], sizeof(LOW_ENTROPY_HASHES[0])) == 0) {
+                return true;
+            }
         }
     }
     return false;

src/mesh/NodeDB.h

@@ -18,68 +18,57 @@
 #endif
 
 #if !defined(MESHTASTIC_EXCLUDE_PKI)
-
-static const uint8_t LOW_ENTROPY_HASH1[] = {0xf4, 0x7e, 0xcc, 0x17, 0xe6, 0xb4, 0xa3, 0x22, 0xec, 0xee, 0xd9,
-                                            0x08, 0x4f, 0x39, 0x63, 0xea, 0x80, 0x75, 0xe1, 0x24, 0xce, 0x05,
-                                            0x36, 0x69, 0x63, 0xb2, 0xcb, 0xc0, 0x28, 0xd3, 0x34, 0x8b};
-static const uint8_t LOW_ENTROPY_HASH2[] = {0x5a, 0x9e, 0xa2, 0xa6, 0x8a, 0xa6, 0x66, 0xc1, 0x5f, 0x55, 0x00,
-                                            0x64, 0xa3, 0xa6, 0xfe, 0x71, 0xc0, 0xbb, 0x82, 0xc3, 0x32, 0x3d,
-                                            0x7a, 0x7a, 0xe3, 0x6e, 0xfd, 0xdd, 0xad, 0x3a, 0x66, 0xb9};
-static const uint8_t LOW_ENTROPY_HASH3[] = {0xb3, 0xdf, 0x3b, 0x2e, 0x67, 0xb6, 0xd5, 0xf8, 0xdf, 0x76, 0x2c,
-                                            0x45, 0x5e, 0x2e, 0xbd, 0x16, 0xc5, 0xf8, 0x67, 0xaa, 0x15, 0xf8,
-                                            0x92, 0x0b, 0xdf, 0x5a, 0x66, 0x50, 0xac, 0x0d, 0xbb, 0x2f};
-static const uint8_t LOW_ENTROPY_HASH4[] = {0x3b, 0x8f, 0x86, 0x3a, 0x38, 0x1f, 0x77, 0x39, 0xa9, 0x4e, 0xef,
-                                            0x91, 0x18, 0x5a, 0x62, 0xe1, 0xaa, 0x9d, 0x36, 0xea, 0xce, 0x60,
-                                            0x35, 0x8d, 0x9d, 0x1f, 0xf4, 0xb8, 0xc9, 0x13, 0x6a, 0x5d};
-static const uint8_t LOW_ENTROPY_HASH5[] = {0x36, 0x7e, 0x2d, 0xe1, 0x84, 0x5f, 0x42, 0x52, 0x29, 0x11, 0x0a,
-                                            0x25, 0x64, 0x54, 0x6a, 0x6b, 0xfd, 0xb6, 0x65, 0xff, 0x15, 0x1a,
-                                            0x51, 0x71, 0x22, 0x40, 0x57, 0xf6, 0x91, 0x9b, 0x64, 0x58};
-static const uint8_t LOW_ENTROPY_HASH6[] = {0x16, 0x77, 0xeb, 0xa4, 0x52, 0x91, 0xfb, 0x26, 0xcf, 0x8f, 0xd7,
-                                            0xd9, 0xd1, 0x5d, 0xc4, 0x68, 0x73, 0x75, 0xed, 0xc5, 0x95, 0x58,
-                                            0xee, 0x90, 0x56, 0xd4, 0x2f, 0x31, 0x29, 0xf7, 0x8c, 0x1f};
-static const uint8_t LOW_ENTROPY_HASH7[] = {0x31, 0x8c, 0xa9, 0x5e, 0xed, 0x3c, 0x12, 0xbf, 0x97, 0x9c, 0x47,
-                                            0x8e, 0x98, 0x9d, 0xc2, 0x3e, 0x86, 0x23, 0x90, 0x29, 0xc8, 0xb0,
-                                            0x20, 0xf8, 0xb1, 0xb0, 0xaa, 0x19, 0x2a, 0xcf, 0x0a, 0x54};
-static const uint8_t LOW_ENTROPY_HASH8[] = {0xa4, 0x8a, 0x99, 0x0e, 0x51, 0xdc, 0x12, 0x20, 0xf3, 0x13, 0xf5,
-                                            0x2b, 0x3a, 0xe2, 0x43, 0x42, 0xc6, 0x52, 0x98, 0xcd, 0xbb, 0xca,
-                                            0xb1, 0x31, 0xa0, 0xd4, 0xd6, 0x30, 0xf3, 0x27, 0xfb, 0x49};
-static const uint8_t LOW_ENTROPY_HASH9[] = {0xd2, 0x3f, 0x13, 0x8d, 0x22, 0x04, 0x8d, 0x07, 0x59, 0x58, 0xa0,
-                                            0xf9, 0x55, 0xcf, 0x30, 0xa0, 0x2e, 0x2f, 0xca, 0x80, 0x20, 0xe4,
-                                            0xde, 0xa1, 0xad, 0xd9, 0x58, 0xb3, 0x43, 0x2b, 0x22, 0x70};
-static const uint8_t LOW_ENTROPY_HASH10[] = {0x40, 0x41, 0xec, 0x6a, 0xd2, 0xd6, 0x03, 0xe4, 0x9a, 0x9e, 0xbd,
-                                             0x6c, 0x0a, 0x9b, 0x75, 0xa4, 0xbc, 0xab, 0x6f, 0xa7, 0x95, 0xff,
-                                             0x2d, 0xf6, 0xe9, 0xb9, 0xab, 0x4c, 0x0c, 0x1c, 0xd0, 0x3b};
-static const uint8_t LOW_ENTROPY_HASH11[] = {0x22, 0x49, 0x32, 0x2b, 0x00, 0xf9, 0x22, 0xfa, 0x17, 0x02, 0xe9,
-                                             0x64, 0x82, 0xf0, 0x4d, 0x1b, 0xc7, 0x04, 0xfc, 0xdc, 0x8c, 0x5e,
-                                             0xb6, 0xd9, 0x16, 0xd6, 0x37, 0xce, 0x59, 0xaa, 0x09, 0x49};
-static const uint8_t LOW_ENTROPY_HASH12[] = {0x48, 0x6f, 0x1e, 0x48, 0x97, 0x88, 0x64, 0xac, 0xe8, 0xeb, 0x30,
-                                             0xa3, 0xc3, 0xe1, 0xcf, 0x97, 0x39, 0xa6, 0x55, 0x5b, 0x5f, 0xbf,
-                                             0x18, 0xb7, 0x3a, 0xdf, 0xa8, 0x75, 0xe7, 0x9d, 0xe0, 0x1e};
-static const uint8_t LOW_ENTROPY_HASH13[] = {0x09, 0xb4, 0xe2, 0x6d, 0x28, 0x98, 0xc9, 0x47, 0x66, 0x46, 0xbf,
-                                             0xff, 0x58, 0x17, 0x91, 0xaa, 0xc3, 0xbf, 0x4a, 0x9d, 0x0b, 0x88,
-                                             0xb1, 0xf1, 0x03, 0xdd, 0x61, 0xd7, 0xba, 0x9e, 0x64, 0x98};
-static const uint8_t LOW_ENTROPY_HASH14[] = {0x39, 0x39, 0x84, 0xe0, 0x22, 0x2f, 0x7d, 0x78, 0x45, 0x18, 0x72,
-                                             0xb4, 0x13, 0xd2, 0x01, 0x2f, 0x3c, 0xa1, 0xb0, 0xfe, 0x39, 0xd0,
-                                             0xf1, 0x3c, 0x72, 0xd6, 0xef, 0x54, 0xd5, 0x77, 0x22, 0xa0};
-static const uint8_t LOW_ENTROPY_HASH15[] = {0x0a, 0xda, 0x5f, 0xec, 0xff, 0x5c, 0xc0, 0x2e, 0x5f, 0xc4, 0x8d,
-                                             0x03, 0xe5, 0x80, 0x59, 0xd3, 0x5d, 0x49, 0x86, 0xe9, 0x8d, 0xf6,
-                                             0xf6, 0x16, 0x35, 0x3d, 0xf9, 0x9b, 0x29, 0x55, 0x9e, 0x64};
-static const uint8_t LOW_ENTROPY_HASH16[] = {0x08, 0x56, 0xF0, 0xD7, 0xEF, 0x77, 0xD6, 0x11, 0x1C, 0x8F, 0x95,
-                                             0x2D, 0x3C, 0xDF, 0xB1, 0x22, 0xBF, 0x60, 0x9B, 0xE5, 0xA9, 0xC0,
-                                             0x6E, 0x4B, 0x01, 0xDC, 0xD1, 0x57, 0x44, 0xB2, 0xA5, 0xCF};
-static const uint8_t LOW_ENTROPY_HASH17[] = {0x2C, 0xB2, 0x77, 0x85, 0xD6, 0xB7, 0x48, 0x9C, 0xFE, 0xBC, 0x80,
-                                             0x26, 0x60, 0xF4, 0x6D, 0xCE, 0x11, 0x31, 0xA2, 0x1E, 0x33, 0x0A,
-                                             0x6D, 0x2B, 0x00, 0xFA, 0x0C, 0x90, 0x95, 0x8F, 0x5C, 0x6B};
-static const uint8_t LOW_ENTROPY_HASH18[] = {0xFA, 0x59, 0xC8, 0x6E, 0x94, 0xEE, 0x75, 0xC9, 0x9A, 0xB0, 0xFE,
-                                             0x89, 0x36, 0x40, 0xC9, 0x99, 0x4A, 0x3B, 0xF4, 0xAA, 0x12, 0x24,
-                                             0xA2, 0x0F, 0xF9, 0xD1, 0x08, 0xCB, 0x78, 0x19, 0xAA, 0xE5};
-static const uint8_t LOW_ENTROPY_HASH19[] = {0x6E, 0x42, 0x7A, 0x4A, 0x8C, 0x61, 0x62, 0x22, 0xA1, 0x89, 0xD3,
-                                             0xA4, 0xC2, 0x19, 0xA3, 0x83, 0x53, 0xA7, 0x7A, 0x0A, 0x89, 0xE2,
-                                             0x54, 0x52, 0x62, 0x3D, 0xE7, 0xCA, 0x8C, 0xF6, 0x6A, 0x60};
-static const uint8_t LOW_ENTROPY_HASH20[] = {0x20, 0x27, 0x2F, 0xBA, 0x0C, 0x99, 0xD7, 0x29, 0xF3, 0x11, 0x35,
-                                             0x89, 0x9D, 0x0E, 0x24, 0xA1, 0xC3, 0xCB, 0xDF, 0x8A, 0xF1, 0xC6,
-                                             0xFE, 0xD0, 0xD7, 0x9F, 0x92, 0xD6, 0x8F, 0x59, 0xBF, 0xE4};
-static const char LOW_ENTROPY_WARNING[] = "Compromised keys detected, please regenerate.";
+// E3B0C442 is the blank hash
+static const uint8_t LOW_ENTROPY_HASHES[][32] = {
+    {0xf4, 0x7e, 0xcc, 0x17, 0xe6, 0xb4, 0xa3, 0x22, 0xec, 0xee, 0xd9, 0x08, 0x4f, 0x39, 0x63, 0xea,
+     0x80, 0x75, 0xe1, 0x24, 0xce, 0x05, 0x36, 0x69, 0x63, 0xb2, 0xcb, 0xc0, 0x28, 0xd3, 0x34, 0x8b},
+    {0x5a, 0x9e, 0xa2, 0xa6, 0x8a, 0xa6, 0x66, 0xc1, 0x5f, 0x55, 0x00, 0x64, 0xa3, 0xa6, 0xfe, 0x71,
+     0xc0, 0xbb, 0x82, 0xc3, 0x32, 0x3d, 0x7a, 0x7a, 0xe3, 0x6e, 0xfd, 0xdd, 0xad, 0x3a, 0x66, 0xb9},
+    {0xb3, 0xdf, 0x3b, 0x2e, 0x67, 0xb6, 0xd5, 0xf8, 0xdf, 0x76, 0x2c, 0x45, 0x5e, 0x2e, 0xbd, 0x16,
+     0xc5, 0xf8, 0x67, 0xaa, 0x15, 0xf8, 0x92, 0x0b, 0xdf, 0x5a, 0x66, 0x50, 0xac, 0x0d, 0xbb, 0x2f},
+    {0x3b, 0x8f, 0x86, 0x3a, 0x38, 0x1f, 0x77, 0x39, 0xa9, 0x4e, 0xef, 0x91, 0x18, 0x5a, 0x62, 0xe1,
+     0xaa, 0x9d, 0x36, 0xea, 0xce, 0x60, 0x35, 0x8d, 0x9d, 0x1f, 0xf4, 0xb8, 0xc9, 0x13, 0x6a, 0x5d},
+    {0x36, 0x7e, 0x2d, 0xe1, 0x84, 0x5f, 0x42, 0x52, 0x29, 0x11, 0x0a, 0x25, 0x64, 0x54, 0x6a, 0x6b,
+     0xfd, 0xb6, 0x65, 0xff, 0x15, 0x1a, 0x51, 0x71, 0x22, 0x40, 0x57, 0xf6, 0x91, 0x9b, 0x64, 0x58},
+    {0x16, 0x77, 0xeb, 0xa4, 0x52, 0x91, 0xfb, 0x26, 0xcf, 0x8f, 0xd7, 0xd9, 0xd1, 0x5d, 0xc4, 0x68,
+     0x73, 0x75, 0xed, 0xc5, 0x95, 0x58, 0xee, 0x90, 0x56, 0xd4, 0x2f, 0x31, 0x29, 0xf7, 0x8c, 0x1f},
+    {0x31, 0x8c, 0xa9, 0x5e, 0xed, 0x3c, 0x12, 0xbf, 0x97, 0x9c, 0x47, 0x8e, 0x98, 0x9d, 0xc2, 0x3e,
+     0x86, 0x23, 0x90, 0x29, 0xc8, 0xb0, 0x20, 0xf8, 0xb1, 0xb0, 0xaa, 0x19, 0x2a, 0xcf, 0x0a, 0x54},
+    {0xa4, 0x8a, 0x99, 0x0e, 0x51, 0xdc, 0x12, 0x20, 0xf3, 0x13, 0xf5, 0x2b, 0x3a, 0xe2, 0x43, 0x42,
+     0xc6, 0x52, 0x98, 0xcd, 0xbb, 0xca, 0xb1, 0x31, 0xa0, 0xd4, 0xd6, 0x30, 0xf3, 0x27, 0xfb, 0x49},
+    {0xd2, 0x3f, 0x13, 0x8d, 0x22, 0x04, 0x8d, 0x07, 0x59, 0x58, 0xa0, 0xf9, 0x55, 0xcf, 0x30, 0xa0,
+     0x2e, 0x2f, 0xca, 0x80, 0x20, 0xe4, 0xde, 0xa1, 0xad, 0xd9, 0x58, 0xb3, 0x43, 0x2b, 0x22, 0x70},
+    {0x40, 0x41, 0xec, 0x6a, 0xd2, 0xd6, 0x03, 0xe4, 0x9a, 0x9e, 0xbd, 0x6c, 0x0a, 0x9b, 0x75, 0xa4,
+     0xbc, 0xab, 0x6f, 0xa7, 0x95, 0xff, 0x2d, 0xf6, 0xe9, 0xb9, 0xab, 0x4c, 0x0c, 0x1c, 0xd0, 0x3b},
+    {0x22, 0x49, 0x32, 0x2b, 0x00, 0xf9, 0x22, 0xfa, 0x17, 0x02, 0xe9, 0x64, 0x82, 0xf0, 0x4d, 0x1b,
+     0xc7, 0x04, 0xfc, 0xdc, 0x8c, 0x5e, 0xb6, 0xd9, 0x16, 0xd6, 0x37, 0xce, 0x59, 0xaa, 0x09, 0x49},
+    {0x48, 0x6f, 0x1e, 0x48, 0x97, 0x88, 0x64, 0xac, 0xe8, 0xeb, 0x30, 0xa3, 0xc3, 0xe1, 0xcf, 0x97,
+     0x39, 0xa6, 0x55, 0x5b, 0x5f, 0xbf, 0x18, 0xb7, 0x3a, 0xdf, 0xa8, 0x75, 0xe7, 0x9d, 0xe0, 0x1e},
+    {0x09, 0xb4, 0xe2, 0x6d, 0x28, 0x98, 0xc9, 0x47, 0x66, 0x46, 0xbf, 0xff, 0x58, 0x17, 0x91, 0xaa,
+     0xc3, 0xbf, 0x4a, 0x9d, 0x0b, 0x88, 0xb1, 0xf1, 0x03, 0xdd, 0x61, 0xd7, 0xba, 0x9e, 0x64, 0x98},
+    {0x39, 0x39, 0x84, 0xe0, 0x22, 0x2f, 0x7d, 0x78, 0x45, 0x18, 0x72, 0xb4, 0x13, 0xd2, 0x01, 0x2f,
+     0x3c, 0xa1, 0xb0, 0xfe, 0x39, 0xd0, 0xf1, 0x3c, 0x72, 0xd6, 0xef, 0x54, 0xd5, 0x77, 0x22, 0xa0},
+    {0x0a, 0xda, 0x5f, 0xec, 0xff, 0x5c, 0xc0, 0x2e, 0x5f, 0xc4, 0x8d, 0x03, 0xe5, 0x80, 0x59, 0xd3,
+     0x5d, 0x49, 0x86, 0xe9, 0x8d, 0xf6, 0xf6, 0x16, 0x35, 0x3d, 0xf9, 0x9b, 0x29, 0x55, 0x9e, 0x64},
+    {0x08, 0x56, 0xF0, 0xD7, 0xEF, 0x77, 0xD6, 0x11, 0x1C, 0x8F, 0x95, 0x2D, 0x3C, 0xDF, 0xB1, 0x22,
+     0xBF, 0x60, 0x9B, 0xE5, 0xA9, 0xC0, 0x6E, 0x4B, 0x01, 0xDC, 0xD1, 0x57, 0x44, 0xB2, 0xA5, 0xCF},
+    {0x2C, 0xB2, 0x77, 0x85, 0xD6, 0xB7, 0x48, 0x9C, 0xFE, 0xBC, 0x80, 0x26, 0x60, 0xF4, 0x6D, 0xCE,
+     0x11, 0x31, 0xA2, 0x1E, 0x33, 0x0A, 0x6D, 0x2B, 0x00, 0xFA, 0x0C, 0x90, 0x95, 0x8F, 0x5C, 0x6B},
+    {0xFA, 0x59, 0xC8, 0x6E, 0x94, 0xEE, 0x75, 0xC9, 0x9A, 0xB0, 0xFE, 0x89, 0x36, 0x40, 0xC9, 0x99,
+     0x4A, 0x3B, 0xF4, 0xAA, 0x12, 0x24, 0xA2, 0x0F, 0xF9, 0xD1, 0x08, 0xCB, 0x78, 0x19, 0xAA, 0xE5},
+    {0x6E, 0x42, 0x7A, 0x4A, 0x8C, 0x61, 0x62, 0x22, 0xA1, 0x89, 0xD3, 0xA4, 0xC2, 0x19, 0xA3, 0x83,
+     0x53, 0xA7, 0x7A, 0x0A, 0x89, 0xE2, 0x54, 0x52, 0x62, 0x3D, 0xE7, 0xCA, 0x8C, 0xF6, 0x6A, 0x60},
+    {0x20, 0x27, 0x2F, 0xBA, 0x0C, 0x99, 0xD7, 0x29, 0xF3, 0x11, 0x35, 0x89, 0x9D, 0x0E, 0x24, 0xA1,
+     0xC3, 0xCB, 0xDF, 0x8A, 0xF1, 0xC6, 0xFE, 0xD0, 0xD7, 0x9F, 0x92, 0xD6, 0x8F, 0x59, 0xBF, 0xE4},
+    {0x91, 0x70, 0xb4, 0x7c, 0xfb, 0xff, 0xa0, 0x59, 0x6a, 0x25, 0x1c, 0xa9, 0x9e, 0xe9, 0x43, 0x81,
+     0x5d, 0x74, 0xb1, 0xb1, 0x09, 0x28, 0x00, 0x4a, 0xaf, 0xe3, 0xfc, 0xa9, 0x4e, 0x27, 0x76, 0x4c},
+    {0x85, 0xfe, 0x7c, 0xec, 0xb6, 0x78, 0x74, 0xc3, 0xec, 0xe1, 0x32, 0x7f, 0xb0, 0xb7, 0x02, 0x74,
+     0xf9, 0x23, 0xd8, 0xe7, 0xfa, 0x14, 0xe6, 0xee, 0x66, 0x44, 0xb1, 0x8c, 0xa5, 0x2f, 0x7e, 0xd2},
+    {0x8e, 0x66, 0x65, 0x7b, 0x3b, 0x6f, 0x7e, 0xcc, 0x57, 0xb4, 0x57, 0xea, 0xcc, 0x83, 0xf5, 0xaa,
+     0xf7, 0x65, 0xa3, 0xce, 0x93, 0x72, 0x13, 0xc1, 0xb6, 0x46, 0x7b, 0x29, 0x45, 0xb5, 0xc8, 0x93},
+    {0xcc, 0x11, 0xfb, 0x1a, 0xab, 0xa1, 0x31, 0x87, 0x6a, 0xc6, 0xde, 0x88, 0x87, 0xa9, 0xb9, 0x59,
+     0x37, 0x82, 0x8d, 0xb2, 0xcc, 0xd8, 0x97, 0x40, 0x9a, 0x5c, 0x8f, 0x40, 0x55, 0xcb, 0x4c, 0x3e}};
+static const char LOW_ENTROPY_WARNING[] = "Compromised keys were detected and regenerated.";
 #endif
 /*
 DeviceState versions used to be defined in the .proto file but really only this function cares.  So changed to a

src/mesh/PhoneAPI.cpp

@@ -31,6 +31,9 @@
 #include "Throttle.h"
 #include <RTC.h>
 
+// Flag to indicate a heartbeat was received and we should send queue status
+bool heartbeatReceived = false;
+
 PhoneAPI::PhoneAPI()
 {
     lastContactMsec = millis();
@@ -155,6 +158,7 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
 #endif
         case meshtastic_ToRadio_heartbeat_tag:
             LOG_DEBUG("Got client heartbeat");
+            heartbeatReceived = true;
             break;
         default:
             // Ignore nop messages
@@ -194,6 +198,17 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
     // In case we send a FromRadio packet
     memset(&fromRadioScratch, 0, sizeof(fromRadioScratch));
 
+    // Respond to heartbeat by sending queue status
+    if (heartbeatReceived) {
+        memset(&fromRadioScratch, 0, sizeof(fromRadioScratch));
+        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_queueStatus_tag;
+        fromRadioScratch.queueStatus = router->getQueueStatus();
+        heartbeatReceived = false;
+        size_t numbytes = pb_encode_to_bytes(buf, meshtastic_FromRadio_size, &meshtastic_FromRadio_msg, &fromRadioScratch);
+        LOG_DEBUG("FromRadio=STATE_SEND_QUEUE_STATUS, numbytes=%u", numbytes);
+        return numbytes;
+    }
+
     // Advance states as needed
     switch (state) {
     case STATE_SEND_NOTHING:
@@ -205,6 +220,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
         // app not to send locations on our behalf.
         fromRadioScratch.which_payload_variant = meshtastic_FromRadio_my_info_tag;
         strncpy(myNodeInfo.pio_env, optstr(APP_ENV), sizeof(myNodeInfo.pio_env));
+        myNodeInfo.nodedb_count = static_cast<uint16_t>(nodeDB->getNumMeshNodes());
         fromRadioScratch.my_info = myNodeInfo;
         state = STATE_SEND_UIDATA;
 

src/mesh/RadioInterface.cpp

@@ -67,6 +67,7 @@ const RegionInfo regions[] = {
     /*
         https://www.iot.org.au/wp/wp-content/uploads/2016/12/IoTSpectrumFactSheet.pdf
         https://iotalliance.org.nz/wp-content/uploads/sites/4/2019/05/IoT-Spectrum-in-NZ-Briefing-Paper.pdf
+        Also used in Brazil.
      */
     RDEF(ANZ, 915.0f, 928.0f, 100, 0, 30, true, false, false),
 
@@ -169,6 +170,21 @@ const RegionInfo regions[] = {
     */
     RDEF(KZ_433, 433.075f, 434.775f, 100, 0, 10, true, false, false), RDEF(KZ_863, 863.0f, 868.0f, 100, 0, 30, true, false, true),
 
+
+    /*
+        Nepal
+        865 MHz to 868 MHz frequency band for IoT (Internet of Things), M2M (Machine-to-Machine), and smart metering use, specifically in non-cellular mode.
+        https://www.nta.gov.np/uploads/contents/Radio-Frequency-Policy-2080-English.pdf
+    */
+    RDEF(NP_865, 865.0f, 868.0f, 100, 0, 30, true, false, false),
+
+    /*
+        Brazil
+        902 - 907.5 MHz , 1W power limit, no duty cycle restrictions
+        https://github.com/meshtastic/firmware/issues/3741
+    */
+    RDEF(BR_902, 902.0f, 907.5f, 100, 0, 30, true, false, false),
+
     /*
        2.4 GHZ WLAN Band equivalent. Only for SX128x chips.
     */

src/mesh/Router.cpp

@@ -224,9 +224,10 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     if (!config.lora.override_duty_cycle && myRegion->dutyCycle < 100) {
         float hourlyTxPercent = airTime->utilizationTXPercent();
         if (hourlyTxPercent > myRegion->dutyCycle) {
-#ifdef DEBUG_PORT
             uint8_t silentMinutes = airTime->getSilentMinutes(hourlyTxPercent, myRegion->dutyCycle);
+
             LOG_WARN("Duty cycle limit exceeded. Aborting send for now, you can send again in %d mins", silentMinutes);
+
             meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
             cn->has_reply_id = true;
             cn->reply_id = p->id;
@@ -234,7 +235,7 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
             cn->time = getValidTime(RTCQualityFromNet);
             sprintf(cn->message, "Duty cycle limit exceeded. You can send again in %d mins", silentMinutes);
             service->sendClientNotification(cn);
-#endif
+
             meshtastic_Routing_Error err = meshtastic_Routing_Error_DUTY_CYCLE_LIMIT;
             if (isFromUs(p)) { // only send NAK to API, not to the mesh
                 abortSendAndNak(err, p);
@@ -548,20 +549,6 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
             numbytes += MESHTASTIC_PKC_OVERHEAD;
             p->channel = 0;
             p->pki_encrypted = true;
-
-            // warn the user about a low entropy key
-            if (nodeDB->keyIsLowEntropy) {
-                LOG_WARN(LOW_ENTROPY_WARNING);
-                if (!nodeDB->hasWarned) {
-                    meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
-                    cn->which_payload_variant = meshtastic_ClientNotification_low_entropy_key_tag;
-                    cn->level = meshtastic_LogRecord_Level_WARNING;
-                    cn->time = getValidTime(RTCQualityFromNet);
-                    sprintf(cn->message, LOW_ENTROPY_WARNING);
-                    service->sendClientNotification(cn);
-                    nodeDB->hasWarned = true;
-                }
-            }
         } else {
             if (p->pki_encrypted == true) {
                 // Client specifically requested PKI encryption
@@ -651,11 +638,12 @@ void Router::handleReceived(meshtastic_MeshPacket *p, RxSource src)
         shouldIgnoreNonstandardPorts = true;
 #endif
         if (shouldIgnoreNonstandardPorts && p->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
-            IS_ONE_OF(p->decoded.portnum, meshtastic_PortNum_ATAK_FORWARDER, meshtastic_PortNum_ATAK_PLUGIN,
-                      meshtastic_PortNum_PAXCOUNTER_APP, meshtastic_PortNum_IP_TUNNEL_APP, meshtastic_PortNum_AUDIO_APP,
-                      meshtastic_PortNum_PRIVATE_APP, meshtastic_PortNum_DETECTION_SENSOR_APP, meshtastic_PortNum_RANGE_TEST_APP,
-                      meshtastic_PortNum_REMOTE_HARDWARE_APP)) {
-            LOG_DEBUG("Ignore packet on blacklisted portnum for CORE_PORTNUMS_ONLY");
+            !IS_ONE_OF(p->decoded.portnum, meshtastic_PortNum_TEXT_MESSAGE_APP, meshtastic_PortNum_TEXT_MESSAGE_COMPRESSED_APP,
+                       meshtastic_PortNum_POSITION_APP, meshtastic_PortNum_NODEINFO_APP, meshtastic_PortNum_ROUTING_APP,
+                       meshtastic_PortNum_TELEMETRY_APP, meshtastic_PortNum_ADMIN_APP, meshtastic_PortNum_ALERT_APP,
+                       meshtastic_PortNum_KEY_VERIFICATION_APP, meshtastic_PortNum_WAYPOINT_APP,
+                       meshtastic_PortNum_STORE_FORWARD_APP, meshtastic_PortNum_TRACEROUTE_APP)) {
+            LOG_DEBUG("Ignore packet on non-standard portnum for CORE_PORTNUMS_ONLY");
             cancelSending(p->from, p->id);
             skipHandle = true;
         }

src/mesh/api/PacketAPI.cpp

@@ -70,7 +70,7 @@ bool PacketAPI::receivePacket(void)
             break;
         }
         case meshtastic_ToRadio_heartbeat_tag:
-            if (mr->heartbeat.dummy_field == 1) {
+            if (mr->heartbeat.nonce == 1) {
                 if (nodeInfoModule) {
                     LOG_INFO("Broadcasting nodeinfo ping");
                     nodeInfoModule->sendOurNodeInfo(NODENUM_BROADCAST, true, 0, true);

src/mesh/api/WiFiServerAPI.cpp

@@ -17,7 +17,10 @@ void initApiServer(int port)
 }
 void deInitApiServer()
 {
-    delete apiPort;
+    if (apiPort) {
+        delete apiPort;
+        apiPort = nullptr;
+    }
 }
 
 WiFiServerAPI::WiFiServerAPI(WiFiClient &_client) : ServerAPI(_client)

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

@@ -362,7 +362,7 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
 #define meshtastic_BackupPreferences_size        2271
 #define meshtastic_ChannelFile_size              718
-#define meshtastic_DeviceState_size              1724
+#define meshtastic_DeviceState_size              1737
 #define meshtastic_NodeInfoLite_size             196
 #define meshtastic_PositionLite_size             28
 #define meshtastic_UserLite_size                 98

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

@@ -119,6 +119,8 @@ PB_BIND(meshtastic_ChunkedPayloadResponse, meshtastic_ChunkedPayloadResponse, AU
 
 
 
+
+
 
 
 

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

@@ -267,6 +267,9 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_RAK3312 = 106,
     /* Elecrow ThinkNode M5 https://www.elecrow.com/wiki/ThinkNode_M5_Meshtastic_LoRa_Signal_Transceiver_ESP32-S3.html */
     meshtastic_HardwareModel_THINKNODE_M5 = 107,
+    /* MeshSolar is an integrated power management and communication solution designed for outdoor low-power devices.
+ https://heltec.org/project/meshsolar/ */
+    meshtastic_HardwareModel_HELTEC_MESH_SOLAR = 108,
     /* ------------------------------------------------------------------------------------------------------------------------------------------
  Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
  ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -506,6 +509,26 @@ typedef enum _meshtastic_MeshPacket_Delayed {
     meshtastic_MeshPacket_Delayed_DELAYED_DIRECT = 2
 } meshtastic_MeshPacket_Delayed;
 
+/* Enum to identify which transport mechanism this packet arrived over */
+typedef enum _meshtastic_MeshPacket_TransportMechanism {
+    /* The default case is that the node generated a packet itself */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_INTERNAL = 0,
+    /* Arrived via the primary LoRa radio */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA = 1,
+    /* Arrived via a secondary LoRa radio */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA_ALT1 = 2,
+    /* Arrived via a tertiary LoRa radio */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA_ALT2 = 3,
+    /* Arrived via a quaternary LoRa radio */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA_ALT3 = 4,
+    /* Arrived via an MQTT connection */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MQTT = 5,
+    /* Arrived via Multicast UDP */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP = 6,
+    /* Arrived via API connection */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API = 7
+} meshtastic_MeshPacket_TransportMechanism;
+
 /* Log levels, chosen to match python logging conventions. */
 typedef enum _meshtastic_LogRecord_Level {
     /* Log levels, chosen to match python logging conventions. */
@@ -860,6 +883,8 @@ typedef struct _meshtastic_MeshPacket {
  Timestamp after which this packet may be sent.
  Set by the firmware internally, clients are not supposed to set this. */
     uint32_t tx_after;
+    /* Indicates which transport mechanism this packet arrived over */
+    meshtastic_MeshPacket_TransportMechanism transport_mechanism;
 } meshtastic_MeshPacket;
 
 /* The bluetooth to device link:
@@ -935,6 +960,9 @@ typedef struct _meshtastic_MyNodeInfo {
     char pio_env[40];
     /* The indicator for whether this device is running event firmware and which */
     meshtastic_FirmwareEdition firmware_edition;
+    /* The number of nodes in the nodedb.
+ This is used by the phone to know how many NodeInfo packets to expect on want_config */
+    uint16_t nodedb_count;
 } meshtastic_MyNodeInfo;
 
 /* Debug output from the device.
@@ -1143,7 +1171,8 @@ typedef struct _meshtastic_FromRadio {
 /* A heartbeat message is sent to the node from the client to keep the connection alive.
  This is currently only needed to keep serial connections alive, but can be used by any PhoneAPI. */
 typedef struct _meshtastic_Heartbeat {
-    char dummy_field;
+    /* The nonce of the heartbeat message */
+    uint32_t nonce;
 } meshtastic_Heartbeat;
 
 /* Packets/commands to the radio will be written (reliably) to the toRadio characteristic.
@@ -1261,6 +1290,10 @@ extern "C" {
 #define _meshtastic_MeshPacket_Delayed_MAX meshtastic_MeshPacket_Delayed_DELAYED_DIRECT
 #define _meshtastic_MeshPacket_Delayed_ARRAYSIZE ((meshtastic_MeshPacket_Delayed)(meshtastic_MeshPacket_Delayed_DELAYED_DIRECT+1))
 
+#define _meshtastic_MeshPacket_TransportMechanism_MIN meshtastic_MeshPacket_TransportMechanism_TRANSPORT_INTERNAL
+#define _meshtastic_MeshPacket_TransportMechanism_MAX meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API
+#define _meshtastic_MeshPacket_TransportMechanism_ARRAYSIZE ((meshtastic_MeshPacket_TransportMechanism)(meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API+1))
+
 #define _meshtastic_LogRecord_Level_MIN meshtastic_LogRecord_Level_UNSET
 #define _meshtastic_LogRecord_Level_MAX meshtastic_LogRecord_Level_CRITICAL
 #define _meshtastic_LogRecord_Level_ARRAYSIZE ((meshtastic_LogRecord_Level)(meshtastic_LogRecord_Level_CRITICAL+1))
@@ -1281,6 +1314,7 @@ extern "C" {
 
 #define meshtastic_MeshPacket_priority_ENUMTYPE meshtastic_MeshPacket_Priority
 #define meshtastic_MeshPacket_delayed_ENUMTYPE meshtastic_MeshPacket_Delayed
+#define meshtastic_MeshPacket_transport_mechanism_ENUMTYPE meshtastic_MeshPacket_TransportMechanism
 
 
 #define meshtastic_MyNodeInfo_firmware_edition_ENUMTYPE meshtastic_FirmwareEdition
@@ -1320,9 +1354,9 @@ extern "C" {
 #define meshtastic_KeyVerification_init_default  {0, {0, {0}}, {0, {0}}}
 #define meshtastic_Waypoint_init_default         {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_MqttClientProxyMessage_init_default {"", 0, {{0, {0}}}, 0}
-#define meshtastic_MeshPacket_init_default       {0, 0, 0, 0, {meshtastic_Data_init_default}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0}
+#define meshtastic_MeshPacket_init_default       {0, 0, 0, 0, {meshtastic_Data_init_default}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN}
 #define meshtastic_NodeInfo_init_default         {0, false, meshtastic_User_init_default, false, meshtastic_Position_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0}
-#define meshtastic_MyNodeInfo_init_default       {0, 0, 0, {0, {0}}, "", _meshtastic_FirmwareEdition_MIN}
+#define meshtastic_MyNodeInfo_init_default       {0, 0, 0, {0, {0}}, "", _meshtastic_FirmwareEdition_MIN, 0}
 #define meshtastic_LogRecord_init_default        {"", 0, "", _meshtastic_LogRecord_Level_MIN}
 #define meshtastic_QueueStatus_init_default      {0, 0, 0, 0}
 #define meshtastic_FromRadio_init_default        {0, 0, {meshtastic_MeshPacket_init_default}}
@@ -1351,9 +1385,9 @@ extern "C" {
 #define meshtastic_KeyVerification_init_zero     {0, {0, {0}}, {0, {0}}}
 #define meshtastic_Waypoint_init_zero            {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_MqttClientProxyMessage_init_zero {"", 0, {{0, {0}}}, 0}
-#define meshtastic_MeshPacket_init_zero          {0, 0, 0, 0, {meshtastic_Data_init_zero}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0}
+#define meshtastic_MeshPacket_init_zero          {0, 0, 0, 0, {meshtastic_Data_init_zero}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN}
 #define meshtastic_NodeInfo_init_zero            {0, false, meshtastic_User_init_zero, false, meshtastic_Position_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0}
-#define meshtastic_MyNodeInfo_init_zero          {0, 0, 0, {0, {0}}, "", _meshtastic_FirmwareEdition_MIN}
+#define meshtastic_MyNodeInfo_init_zero          {0, 0, 0, {0, {0}}, "", _meshtastic_FirmwareEdition_MIN, 0}
 #define meshtastic_LogRecord_init_zero           {"", 0, "", _meshtastic_LogRecord_Level_MIN}
 #define meshtastic_QueueStatus_init_zero         {0, 0, 0, 0}
 #define meshtastic_FromRadio_init_zero           {0, 0, {meshtastic_MeshPacket_init_zero}}
@@ -1459,6 +1493,7 @@ extern "C" {
 #define meshtastic_MeshPacket_next_hop_tag       18
 #define meshtastic_MeshPacket_relay_node_tag     19
 #define meshtastic_MeshPacket_tx_after_tag       20
+#define meshtastic_MeshPacket_transport_mechanism_tag 21
 #define meshtastic_NodeInfo_num_tag              1
 #define meshtastic_NodeInfo_user_tag             2
 #define meshtastic_NodeInfo_position_tag         3
@@ -1477,6 +1512,7 @@ extern "C" {
 #define meshtastic_MyNodeInfo_device_id_tag      12
 #define meshtastic_MyNodeInfo_pio_env_tag        13
 #define meshtastic_MyNodeInfo_firmware_edition_tag 14
+#define meshtastic_MyNodeInfo_nodedb_count_tag   15
 #define meshtastic_LogRecord_message_tag         1
 #define meshtastic_LogRecord_time_tag            2
 #define meshtastic_LogRecord_source_tag          3
@@ -1544,6 +1580,7 @@ extern "C" {
 #define meshtastic_FromRadio_fileInfo_tag        15
 #define meshtastic_FromRadio_clientNotification_tag 16
 #define meshtastic_FromRadio_deviceuiConfig_tag  17
+#define meshtastic_Heartbeat_nonce_tag           1
 #define meshtastic_ToRadio_packet_tag            1
 #define meshtastic_ToRadio_want_config_id_tag    3
 #define meshtastic_ToRadio_disconnect_tag        4
@@ -1680,7 +1717,8 @@ X(a, STATIC,   SINGULAR, BYTES,    public_key,       16) \
 X(a, STATIC,   SINGULAR, BOOL,     pki_encrypted,    17) \
 X(a, STATIC,   SINGULAR, UINT32,   next_hop,         18) \
 X(a, STATIC,   SINGULAR, UINT32,   relay_node,       19) \
-X(a, STATIC,   SINGULAR, UINT32,   tx_after,         20)
+X(a, STATIC,   SINGULAR, UINT32,   tx_after,         20) \
+X(a, STATIC,   SINGULAR, UENUM,    transport_mechanism,  21)
 #define meshtastic_MeshPacket_CALLBACK NULL
 #define meshtastic_MeshPacket_DEFAULT NULL
 #define meshtastic_MeshPacket_payload_variant_decoded_MSGTYPE meshtastic_Data
@@ -1710,7 +1748,8 @@ X(a, STATIC,   SINGULAR, UINT32,   reboot_count,      8) \
 X(a, STATIC,   SINGULAR, UINT32,   min_app_version,  11) \
 X(a, STATIC,   SINGULAR, BYTES,    device_id,        12) \
 X(a, STATIC,   SINGULAR, STRING,   pio_env,          13) \
-X(a, STATIC,   SINGULAR, UENUM,    firmware_edition,  14)
+X(a, STATIC,   SINGULAR, UENUM,    firmware_edition,  14) \
+X(a, STATIC,   SINGULAR, UINT32,   nodedb_count,     15)
 #define meshtastic_MyNodeInfo_CALLBACK NULL
 #define meshtastic_MyNodeInfo_DEFAULT NULL
 
@@ -1874,7 +1913,7 @@ X(a, STATIC,   SINGULAR, UINT32,   excluded_modules,  12)
 #define meshtastic_DeviceMetadata_DEFAULT NULL
 
 #define meshtastic_Heartbeat_FIELDLIST(X, a) \
-
+X(a, STATIC,   SINGULAR, UINT32,   nonce,             1)
 #define meshtastic_Heartbeat_CALLBACK NULL
 #define meshtastic_Heartbeat_DEFAULT NULL
 
@@ -1984,16 +2023,16 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_DuplicatedPublicKey_size      0
 #define meshtastic_FileInfo_size                 236
 #define meshtastic_FromRadio_size                510
-#define meshtastic_Heartbeat_size                0
+#define meshtastic_Heartbeat_size                6
 #define meshtastic_KeyVerificationFinal_size     65
 #define meshtastic_KeyVerificationNumberInform_size 58
 #define meshtastic_KeyVerificationNumberRequest_size 52
 #define meshtastic_KeyVerification_size          79
 #define meshtastic_LogRecord_size                426
 #define meshtastic_LowEntropyKey_size            0
-#define meshtastic_MeshPacket_size               378
+#define meshtastic_MeshPacket_size               381
 #define meshtastic_MqttClientProxyMessage_size   501
-#define meshtastic_MyNodeInfo_size               79
+#define meshtastic_MyNodeInfo_size               83
 #define meshtastic_NeighborInfo_size             258
 #define meshtastic_Neighbor_size                 22
 #define meshtastic_NodeInfo_size                 323

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

@@ -82,7 +82,10 @@ typedef enum _meshtastic_ModuleConfig_SerialConfig_Serial_Mode {
     meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85 = 6,
     /* VE.Direct is a serial protocol used by Victron Energy products
  https://beta.ivc.no/wiki/index.php/Victron_VE_Direct_DIY_Cable */
-    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_VE_DIRECT = 7
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_VE_DIRECT = 7,
+    /* Used to configure and view some parameters of MeshSolar.
+https://heltec.org/project/meshsolar/ */
+    meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG = 8
 } meshtastic_ModuleConfig_SerialConfig_Serial_Mode;
 
 /* TODO: REPLACE */
@@ -472,8 +475,8 @@ extern "C" {
 #define _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Baud)(meshtastic_ModuleConfig_SerialConfig_Serial_Baud_BAUD_921600+1))
 
 #define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN meshtastic_ModuleConfig_SerialConfig_Serial_Mode_DEFAULT
-#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MAX meshtastic_ModuleConfig_SerialConfig_Serial_Mode_VE_DIRECT
-#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Mode)(meshtastic_ModuleConfig_SerialConfig_Serial_Mode_VE_DIRECT+1))
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MAX meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG
+#define _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_ARRAYSIZE ((meshtastic_ModuleConfig_SerialConfig_Serial_Mode)(meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG+1))
 
 #define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_NONE
 #define _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MAX meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_BACK

src/mesh/wifi/WiFiAPClient.cpp

@@ -235,6 +235,11 @@ bool isWifiAvailable()
 #ifdef USE_WS5500
     } else if (config.network.eth_enabled) {
         return true;
+#endif
+#ifndef ARCH_PORTDUINO
+    } else if (WiFi.status() == WL_CONNECTED) {
+        // it's likely we have wifi now, but user intends to turn it off in config!
+        return true;
 #endif
     } else {
         return false;

src/modules/AdminModule.cpp

@@ -43,6 +43,10 @@
 #if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C
 #include "motion/AccelerometerThread.h"
 #endif
+#if (defined(ARCH_ESP32) || defined(ARCH_NRF52) || defined(ARCH_RP2040)) && !defined(CONFIG_IDF_TARGET_ESP32S2) &&               \
+    !defined(CONFIG_IDF_TARGET_ESP32C3)
+#include "SerialModule.h"
+#endif
 
 AdminModule *adminModule;
 bool hasOpenEditTransaction;
@@ -596,7 +600,6 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
         if (config.device.button_gpio == c.payload_variant.device.button_gpio &&
             config.device.buzzer_gpio == c.payload_variant.device.buzzer_gpio &&
             config.device.role == c.payload_variant.device.role &&
-            config.device.disable_triple_click == c.payload_variant.device.disable_triple_click &&
             config.device.rebroadcast_mode == c.payload_variant.device.rebroadcast_mode) {
             requiresReboot = false;
         }
@@ -639,7 +642,16 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
     case meshtastic_Config_position_tag:
         LOG_INFO("Set config: Position");
         config.has_position = true;
+        // If we have turned off the GPS (disabled or not present) and we're not using fixed position,
+        // clear the stored position since it may not get updated
+        if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED &&
+            c.payload_variant.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED &&
+            config.position.fixed_position == false && c.payload_variant.position.fixed_position == false) {
+            nodeDB->clearLocalPosition();
+            saveChanges(SEGMENT_NODEDATABASE | SEGMENT_CONFIG, false);
+        }
         config.position = c.payload_variant.position;
+
         // Save nodedb as well in case we got a fixed position packet
         break;
     case meshtastic_Config_power_tag:
@@ -715,7 +727,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
         }
 #endif
         config.lora = c.payload_variant.lora;
-        // If we're setting region for the first time, init the region
+        // If we're setting region for the first time, init the region and regenerate the keys
         if (isRegionUnset && config.lora.region > meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
             if (!owner.is_licensed) {
                 bool keygenSuccess = false;
@@ -760,8 +772,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             if (config.security.private_key.size != 32) {
                 crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
 
-            } else if (config.security.public_key.size != 32) {
-                // We check for a potentially valid private key, and a blank public key, and regen the public key if needed.
+            } else {
                 if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
                     config.security.public_key.size = 32;
                 }
@@ -799,8 +810,13 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
 
 bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
 {
-    if (!hasOpenEditTransaction)
+    // If we are in an open transaction or configuring MQTT or Serial (which have validation), defer disabling Bluetooth
+    // Otherwise, disable Bluetooth to prevent the phone from interfering with the config
+    if (!hasOpenEditTransaction &&
+        !IS_ONE_OF(c.which_payload_variant, meshtastic_ModuleConfig_mqtt_tag, meshtastic_ModuleConfig_serial_tag)) {
         disableBluetooth();
+    }
+
     switch (c.which_payload_variant) {
     case meshtastic_ModuleConfig_mqtt_tag:
 #if MESHTASTIC_EXCLUDE_MQTT
@@ -811,12 +827,22 @@ bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
         if (!MQTT::isValidConfig(c.payload_variant.mqtt)) {
             return false;
         }
+        // Disable Bluetooth to prevent interference during MQTT configuration
+        disableBluetooth();
         moduleConfig.has_mqtt = true;
         moduleConfig.mqtt = c.payload_variant.mqtt;
 #endif
         break;
     case meshtastic_ModuleConfig_serial_tag:
         LOG_INFO("Set module config: Serial");
+#if (defined(ARCH_ESP32) || defined(ARCH_NRF52) || defined(ARCH_RP2040)) && !defined(CONFIG_IDF_TARGET_ESP32S2) &&               \
+    !defined(CONFIG_IDF_TARGET_ESP32C3)
+        if (!SerialModule::isValidConfig(c.payload_variant.serial)) {
+            LOG_ERROR("Invalid serial config");
+            return false;
+        }
+        disableBluetooth(); // Disable Bluetooth to prevent interference during Serial configuration
+#endif
         moduleConfig.has_serial = true;
         moduleConfig.serial = c.payload_variant.serial;
         break;
@@ -972,9 +998,10 @@ void AdminModule::handleGetConfig(const meshtastic_MeshPacket &req, const uint32
         // So even if we internally use 0 to represent 'use default' we still need to send the value we are
         // using to the app (so that even old phone apps work with new device loads).
         // r.get_radio_response.preferences.ls_secs = getPref_ls_secs();
-        // hideSecret(r.get_radio_response.preferences.wifi_ssid); // hmm - leave public for now, because only minimally private
-        // and useful for users to know current provisioning) hideSecret(r.get_radio_response.preferences.wifi_password);
-        // r.get_config_response.which_payloadVariant = Config_ModuleConfig_telemetry_tag;
+        // hideSecret(r.get_radio_response.preferences.wifi_ssid); // hmm - leave public for now, because only minimally
+        // private and useful for users to know current provisioning)
+        // hideSecret(r.get_radio_response.preferences.wifi_password); r.get_config_response.which_payloadVariant =
+        // Config_ModuleConfig_telemetry_tag;
         res.which_payload_variant = meshtastic_AdminMessage_get_config_response_tag;
         setPassKey(&res);
         myReply = allocDataProtobuf(res);
@@ -1058,9 +1085,10 @@ void AdminModule::handleGetModuleConfig(const meshtastic_MeshPacket &req, const
         // So even if we internally use 0 to represent 'use default' we still need to send the value we are
         // using to the app (so that even old phone apps work with new device loads).
         // r.get_radio_response.preferences.ls_secs = getPref_ls_secs();
-        // hideSecret(r.get_radio_response.preferences.wifi_ssid); // hmm - leave public for now, because only minimally private
-        // and useful for users to know current provisioning) hideSecret(r.get_radio_response.preferences.wifi_password);
-        // r.get_config_response.which_payloadVariant = Config_ModuleConfig_telemetry_tag;
+        // hideSecret(r.get_radio_response.preferences.wifi_ssid); // hmm - leave public for now, because only minimally
+        // private and useful for users to know current provisioning)
+        // hideSecret(r.get_radio_response.preferences.wifi_password); r.get_config_response.which_payloadVariant =
+        // Config_ModuleConfig_telemetry_tag;
         res.which_payload_variant = meshtastic_AdminMessage_get_module_config_response_tag;
         setPassKey(&res);
         myReply = allocDataProtobuf(res);

src/modules/CannedMessageModule.cpp

@@ -40,6 +40,9 @@ extern ScanI2C::DeviceAddress cardkb_found;
 extern bool graphics::isMuted;
 
 static const char *cannedMessagesConfigFile = "/prefs/cannedConf.proto";
+static NodeNum lastDest = NODENUM_BROADCAST;
+static uint8_t lastChannel = 0;
+static bool lastDestSet = false;
 
 meshtastic_CannedMessageModuleConfig cannedMessageModuleConfig;
 
@@ -63,8 +66,18 @@ CannedMessageModule::CannedMessageModule()
 
 void CannedMessageModule::LaunchWithDestination(NodeNum newDest, uint8_t newChannel)
 {
+    // Use the requested destination, unless it's "broadcast" and we have a previous node/channel
+    if (newDest == NODENUM_BROADCAST && lastDestSet) {
+        newDest = lastDest;
+        newChannel = lastChannel;
+    }
     dest = newDest;
     channel = newChannel;
+    lastDest = dest;
+    lastChannel = channel;
+    lastDestSet = true;
+
+    // Rest of function unchanged...
     // Always select the first real canned message on activation
     int firstRealMsgIdx = 0;
     for (int i = 0; i < messagesCount; ++i) {
@@ -84,10 +97,28 @@ void CannedMessageModule::LaunchWithDestination(NodeNum newDest, uint8_t newChan
     notifyObservers(&e);
 }
 
+void CannedMessageModule::LaunchRepeatDestination()
+{
+    if (!lastDestSet) {
+        LaunchWithDestination(NODENUM_BROADCAST, 0);
+    } else {
+        LaunchWithDestination(lastDest, lastChannel);
+    }
+}
+
 void CannedMessageModule::LaunchFreetextWithDestination(NodeNum newDest, uint8_t newChannel)
 {
+    // Use the requested destination, unless it's "broadcast" and we have a previous node/channel
+    if (newDest == NODENUM_BROADCAST && lastDestSet) {
+        newDest = lastDest;
+        newChannel = lastChannel;
+    }
     dest = newDest;
     channel = newChannel;
+    lastDest = dest;
+    lastChannel = channel;
+    lastDestSet = true;
+
     runState = CANNED_MESSAGE_RUN_STATE_FREETEXT;
     requestFocus();
     UIFrameEvent e;
@@ -479,6 +510,9 @@ int CannedMessageModule::handleDestinationSelectionInput(const InputEvent *event
         if (destIndex < static_cast<int>(activeChannelIndices.size())) {
             dest = NODENUM_BROADCAST;
             channel = activeChannelIndices[destIndex];
+            lastDest = dest;
+            lastChannel = channel;
+            lastDestSet = true;
         } else {
             int nodeIndex = destIndex - static_cast<int>(activeChannelIndices.size());
             if (nodeIndex >= 0 && nodeIndex < static_cast<int>(filteredNodes.size())) {
@@ -486,6 +520,10 @@ int CannedMessageModule::handleDestinationSelectionInput(const InputEvent *event
                 if (selectedNode) {
                     dest = selectedNode->num;
                     channel = selectedNode->channel;
+                    // Already saves here, but for clarity, also:
+                    lastDest = dest;
+                    lastChannel = channel;
+                    lastDestSet = true;
                 }
             }
         }
@@ -595,8 +633,27 @@ bool CannedMessageModule::handleMessageSelectorInput(const InputEvent *event, bo
         // Normal canned message selection
         if (runState == CANNED_MESSAGE_RUN_STATE_INACTIVE || runState == CANNED_MESSAGE_RUN_STATE_DISABLED) {
         } else {
+            // Show confirmation dialog before sending canned message
+            NodeNum destNode = dest;
+            ChannelIndex chan = channel;
+#if CANNED_MESSAGE_ADD_CONFIRMATION
+            graphics::menuHandler::showConfirmationBanner("Send message?", [this, destNode, chan, current]() {
+                this->sendText(destNode, chan, current, false);
+                payload = runState;
+                runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
+                currentMessageIndex = -1;
+
+                // Notify UI to regenerate frame set and redraw
+                UIFrameEvent e;
+                e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+                notifyObservers(&e);
+                screen->forceDisplay();
+            });
+#else
             payload = runState;
             runState = CANNED_MESSAGE_RUN_STATE_ACTION_SELECT;
+#endif
+            // Do not immediately set runState; wait for confirmation
             handled = true;
         }
     }
@@ -827,6 +884,9 @@ int CannedMessageModule::handleEmotePickerInput(const InputEvent *event)
 
 void CannedMessageModule::sendText(NodeNum dest, ChannelIndex channel, const char *message, bool wantReplies)
 {
+    lastDest = dest;
+    lastChannel = channel;
+    lastDestSet = true;
     // === Prepare packet ===
     meshtastic_MeshPacket *p = allocDataPacket();
     p->to = dest;
@@ -1711,7 +1771,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
                     // Text: split by words and wrap inside word if needed
                     String text = token.second;
                     pos = 0;
-                    while (pos < text.length()) {
+                    while (pos < static_cast<int>(text.length())) {
                         // Find next space (or end)
                         int spacePos = text.indexOf(' ', pos);
                         int endPos = (spacePos == -1) ? text.length() : spacePos + 1; // Include space

src/modules/CannedMessageModule.h

@@ -59,6 +59,7 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     CannedMessageModule();
 
     void LaunchWithDestination(NodeNum, uint8_t newChannel = 0);
+    void LaunchRepeatDestination();
     void LaunchFreetextWithDestination(NodeNum, uint8_t newChannel = 0);
 
     // === Emote Picker navigation ===

src/modules/NodeInfoModule.cpp

@@ -14,6 +14,10 @@ bool NodeInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
 {
     auto p = *pptr;
 
+    if (mp.from == nodeDB->getNodeNum()) {
+        LOG_WARN("Ignoring packet supposed to be from our own node: %08x", mp.from);
+        return false;
+    }
     if (p.is_licensed != owner.is_licensed) {
         LOG_WARN("Invalid nodeInfo detected, is_licensed mismatch!");
         return true;

src/modules/PositionModule.h

@@ -65,8 +65,15 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
     bool hasGPS();
     uint32_t lastSentReply = 0; // Last time we sent a position reply (used for reply throttling only)
 
+#if USERPREFS_EVENT_MODE
+    // In event mode we want to prevent excessive position broadcasts
+    // we set the minimum interval to 5m
+    const uint32_t minimumTimeThreshold =
+        max(300000, Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30));
+#else
     const uint32_t minimumTimeThreshold =
         Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30);
+#endif
 };
 
 struct SmartPosition {

src/modules/ReplyModule.cpp

@@ -8,7 +8,7 @@
 meshtastic_MeshPacket *ReplyModule::allocReply()
 {
     assert(currentRequest); // should always be !NULL
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
     auto req = *currentRequest;
     auto &p = req.decoded;
     // The incoming message is in p.payload

src/modules/SerialModule.cpp

@@ -60,7 +60,8 @@
 SerialModule *serialModule;
 SerialModuleRadio *serialModuleRadio;
 
-#if defined(TTGO_T_ECHO) || defined(CANARYONE) || defined(MESHLINK) || defined(ELECROW_ThinkNode_M1)
+#if defined(TTGO_T_ECHO) || defined(CANARYONE) || defined(MESHLINK) || defined(ELECROW_ThinkNode_M1) ||                          \
+    defined(ELECROW_ThinkNode_M5)
 SerialModule::SerialModule() : StreamAPI(&Serial), concurrency::OSThread("Serial") {}
 static Print *serialPrint = &Serial;
 #elif defined(CONFIG_IDF_TARGET_ESP32C6)
@@ -74,6 +75,26 @@ static Print *serialPrint = &Serial2;
 char serialBytes[512];
 size_t serialPayloadSize;
 
+bool SerialModule::isValidConfig(const meshtastic_ModuleConfig_SerialConfig &config)
+{
+    if (config.override_console_serial_port && !IS_ONE_OF(config.mode, meshtastic_ModuleConfig_SerialConfig_Serial_Mode_NMEA,
+                                                          meshtastic_ModuleConfig_SerialConfig_Serial_Mode_CALTOPO)) {
+        const char *warning =
+            "Invalid Serial config: override console serial port is only supported in NMEA and CalTopo output-only modes.";
+        LOG_ERROR(warning);
+#if !IS_RUNNING_TESTS
+        meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+        cn->level = meshtastic_LogRecord_Level_ERROR;
+        cn->time = getValidTime(RTCQualityFromNet);
+        snprintf(cn->message, sizeof(cn->message), "%s", warning);
+        service->sendClientNotification(cn);
+#endif
+        return false;
+    }
+
+    return true;
+}
+
 SerialModuleRadio::SerialModuleRadio() : MeshModule("SerialModuleRadio")
 {
     switch (moduleConfig.serial.mode) {
@@ -158,7 +179,8 @@ int32_t SerialModule::runOnce()
                 Serial.begin(baud);
                 Serial.setTimeout(moduleConfig.serial.timeout > 0 ? moduleConfig.serial.timeout : TIMEOUT);
             }
-#elif !defined(TTGO_T_ECHO) && !defined(CANARYONE) && !defined(MESHLINK) && !defined(ELECROW_ThinkNode_M1)
+#elif !defined(TTGO_T_ECHO) && !defined(CANARYONE) && !defined(MESHLINK) && !defined(ELECROW_ThinkNode_M1) &&                    \
+    !defined(ELECROW_ThinkNode_M5)
             if (moduleConfig.serial.rxd && moduleConfig.serial.txd) {
 #ifdef ARCH_RP2040
                 Serial2.setFIFOSize(RX_BUFFER);
@@ -214,7 +236,8 @@ int32_t SerialModule::runOnce()
                 }
             }
 
-#if !defined(TTGO_T_ECHO) && !defined(CANARYONE) && !defined(MESHLINK) && !defined(ELECROW_ThinkNode_M1)
+#if !defined(TTGO_T_ECHO) && !defined(CANARYONE) && !defined(MESHLINK) && !defined(ELECROW_ThinkNode_M1) &&                      \
+    !defined(ELECROW_ThinkNode_M5)
             else if ((moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85)) {
                 processWXSerial();
 
@@ -474,7 +497,7 @@ ParsedLine parseLine(const char *line)
 void SerialModule::processWXSerial()
 {
 #if !defined(TTGO_T_ECHO) && !defined(CANARYONE) && !defined(CONFIG_IDF_TARGET_ESP32C6) && !defined(MESHLINK) &&                 \
-    !defined(ELECROW_ThinkNode_M1)
+    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M5)
     static unsigned int lastAveraged = 0;
     static unsigned int averageIntervalMillis = 300000; // 5 minutes hard coded.
     static double dir_sum_sin = 0;

src/modules/SerialModule.h

@@ -20,6 +20,8 @@ class SerialModule : public StreamAPI, private concurrency::OSThread
   public:
     SerialModule();
 
+    static bool isValidConfig(const meshtastic_ModuleConfig_SerialConfig &config);
+
   protected:
     virtual int32_t runOnce() override;
 

src/modules/StoreForwardModule.cpp

@@ -202,6 +202,8 @@ void StoreForwardModule::historyAdd(const meshtastic_MeshPacket &mp)
     this->packetHistory[this->packetHistoryTotalCount].reply_id = p.reply_id;
     this->packetHistory[this->packetHistoryTotalCount].emoji = (bool)p.emoji;
     this->packetHistory[this->packetHistoryTotalCount].payload_size = p.payload.size;
+    this->packetHistory[this->packetHistoryTotalCount].rx_rssi = mp.rx_rssi;
+    this->packetHistory[this->packetHistoryTotalCount].rx_snr = mp.rx_snr;
     memcpy(this->packetHistory[this->packetHistoryTotalCount].payload, p.payload.bytes, meshtastic_Constants_DATA_PAYLOAD_LEN);
 
     this->packetHistoryTotalCount++;
@@ -252,6 +254,8 @@ meshtastic_MeshPacket *StoreForwardModule::preparePayload(NodeNum dest, uint32_t
                 p->decoded.reply_id = this->packetHistory[i].reply_id;
                 p->rx_time = this->packetHistory[i].time;
                 p->decoded.emoji = (uint32_t)this->packetHistory[i].emoji;
+                p->rx_rssi = this->packetHistory[i].rx_rssi;
+                p->rx_snr = this->packetHistory[i].rx_snr;
 
                 // Let's assume that if the server received the S&F request that the client is in range.
                 //   TODO: Make this configurable.
@@ -623,4 +627,4 @@ StoreForwardModule::StoreForwardModule()
         disable();
     }
 #endif
-}
+}

src/modules/StoreForwardModule.h

@@ -19,6 +19,8 @@ struct PacketHistoryStruct {
     bool emoji;
     uint8_t payload[meshtastic_Constants_DATA_PAYLOAD_LEN];
     pb_size_t payload_size;
+    int32_t rx_rssi;
+    float rx_snr;
 };
 
 class StoreForwardModule : private concurrency::OSThread, public ProtobufModule<meshtastic_StoreAndForward>
@@ -108,4 +110,4 @@ class StoreForwardModule : private concurrency::OSThread, public ProtobufModule<
     virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_StoreAndForward *p);
 };
 
-extern StoreForwardModule *storeForwardModule;
+extern StoreForwardModule *storeForwardModule;

src/modules/SystemCommandsModule.cpp

@@ -89,6 +89,11 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
 #if !MESHTASTIC_EXCLUDE_GPS
         if (gps) {
             LOG_WARN("GPS Toggle2");
+            if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED &&
+                config.position.fixed_position == false) {
+                nodeDB->clearLocalPosition();
+                nodeDB->saveToDisk();
+            }
             gps->toggleGpsMode();
             const char *msg =
                 (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) ? "GPS Enabled" : "GPS Disabled";

src/modules/Telemetry/AirQualityTelemetry.cpp

@@ -121,7 +121,7 @@ int32_t AirQualityTelemetryModule::runOnce()
 bool AirQualityTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
 {
     if (t->which_variant == meshtastic_Telemetry_air_quality_metrics_tag) {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
         const char *sender = getSenderShortName(mp);
 
         LOG_INFO("(Received from %s): pm10_standard=%i, pm25_standard=%i, pm100_standard=%i", sender,

src/modules/Telemetry/DeviceTelemetry.cpp

@@ -49,7 +49,7 @@ bool DeviceTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &
         return false;
 
     if (t->which_variant == meshtastic_Telemetry_device_metrics_tag) {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
         const char *sender = getSenderShortName(mp);
 
         LOG_INFO("(Received from %s): air_util_tx=%f, channel_utilization=%f, battery_level=%i, voltage=%f", sender,

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -502,7 +502,7 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt
 bool EnvironmentTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
 {
     if (t->which_variant == meshtastic_Telemetry_environment_metrics_tag) {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
         const char *sender = getSenderShortName(mp);
 
         LOG_INFO("(Received from %s): barometric_pressure=%f, current=%f, gas_resistance=%f, relative_humidity=%f, "

src/modules/Telemetry/HealthTelemetry.cpp

@@ -149,7 +149,7 @@ void HealthTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *
 bool HealthTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
 {
     if (t->which_variant == meshtastic_Telemetry_health_metrics_tag) {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
         const char *sender = getSenderShortName(mp);
 
         LOG_INFO("(Received from %s): temperature=%f, heart_bpm=%d, spO2=%d,", sender, t->variant.health_metrics.temperature,

src/modules/Telemetry/HostMetrics.cpp

@@ -27,7 +27,7 @@ bool HostMetricsModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
         return false;
 
     if (t->which_variant == meshtastic_Telemetry_host_metrics_tag) {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
         const char *sender = getSenderShortName(mp);
         if (t->variant.host_metrics.has_user_string)
             t->variant.host_metrics.user_string[sizeof(t->variant.host_metrics.user_string) - 1] = '\0';

src/modules/Telemetry/PowerTelemetry.cpp

@@ -168,7 +168,7 @@ void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *s
 bool PowerTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
 {
     if (t->which_variant == meshtastic_Telemetry_power_metrics_tag) {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
         const char *sender = getSenderShortName(mp);
 
         LOG_INFO("(Received from %s): ch1_voltage=%.1f, ch1_current=%.1f, ch2_voltage=%.1f, ch2_current=%.1f, "

src/modules/Telemetry/Sensor/INA226Sensor.cpp

@@ -32,16 +32,42 @@ void INA226Sensor::begin(TwoWire *wire, uint8_t addr)
     _addr = addr;
     ina226 = INA226(_addr, _wire);
     _wire->begin();
+    ina226.setMaxCurrentShunt(0.8, 0.100);
 }
 
 bool INA226Sensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    switch (measurement->which_variant) {
+    case meshtastic_Telemetry_environment_metrics_tag:
+        return getEnvironmentMetrics(measurement);
+
+    case meshtastic_Telemetry_power_metrics_tag:
+        return getPowerMetrics(measurement);
+    }
+
+    // unsupported metric
+    return false;
+}
+
+bool INA226Sensor::getEnvironmentMetrics(meshtastic_Telemetry *measurement)
 {
     measurement->variant.environment_metrics.has_voltage = true;
     measurement->variant.environment_metrics.has_current = true;
 
-    // mV conversion to V
     measurement->variant.environment_metrics.voltage = ina226.getBusVoltage();
     measurement->variant.environment_metrics.current = ina226.getCurrent_mA();
+
+    return true;
+}
+
+bool INA226Sensor::getPowerMetrics(meshtastic_Telemetry *measurement)
+{
+    measurement->variant.power_metrics.has_ch1_voltage = true;
+    measurement->variant.power_metrics.has_ch1_current = true;
+
+    measurement->variant.power_metrics.ch1_voltage = ina226.getBusVoltage();
+    measurement->variant.power_metrics.ch1_current = ina226.getCurrent_mA();
+
     return true;
 }
 

src/modules/Telemetry/Sensor/INA226Sensor.h

@@ -15,6 +15,9 @@ class INA226Sensor : public TelemetrySensor, VoltageSensor, CurrentSensor
     TwoWire *_wire = &Wire;
     INA226 ina226 = INA226(_addr, _wire);
 
+    bool getEnvironmentMetrics(meshtastic_Telemetry *measurement);
+    bool getPowerMetrics(meshtastic_Telemetry *measurement);
+
   protected:
     virtual void setup() override;
     void begin(TwoWire *wire = &Wire, uint8_t addr = INA_ADDR);

src/modules/Telemetry/Sensor/NAU7802Sensor.cpp

@@ -112,9 +112,8 @@ bool NAU7802Sensor::saveCalibrationData()
     } else {
         okay = true;
     }
-    spiLock->lock();
+    // Note: SafeFile::close() already acquires the lock and releases it internally
     okay &= file.close();
-    spiLock->unlock();
 
     return okay;
 }

src/modules/TextMessageModule.cpp

@@ -9,7 +9,7 @@ TextMessageModule *textMessageModule;
 
 ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
     auto &p = mp.decoded;
     LOG_INFO("Received text msg from=0x%0x, id=0x%x, msg=%.*s", mp.from, mp.id, p.payload.size, p.payload.bytes);
 #endif

src/modules/TraceRouteModule.cpp

@@ -1,6 +1,13 @@
 #include "TraceRouteModule.h"
 #include "MeshService.h"
+#include "graphics/Screen.h"
+#include "graphics/ScreenFonts.h"
+#include "graphics/SharedUIDisplay.h"
+#include "mesh/Router.h"
 #include "meshUtils.h"
+#include <vector>
+
+extern graphics::Screen *screen;
 
 TraceRouteModule *traceRouteModule;
 
@@ -27,6 +34,123 @@ void TraceRouteModule::alterReceivedProtobuf(meshtastic_MeshPacket &p, meshtasti
     // Set updated route to the payload of the to be flooded packet
     p.decoded.payload.size =
         pb_encode_to_bytes(p.decoded.payload.bytes, sizeof(p.decoded.payload.bytes), &meshtastic_RouteDiscovery_msg, r);
+
+    if (tracingNode != 0) {
+        // check isResponseFromTarget
+        bool isResponseFromTarget = (incoming.request_id != 0 && p.from == tracingNode);
+        bool isRequestToUs = (incoming.request_id == 0 && p.to == nodeDB->getNodeNum() && tracingNode != 0);
+
+        // Check if this is a trace route response containing our target node
+        bool containsTargetNode = false;
+        for (uint8_t i = 0; i < r->route_count; i++) {
+            if (r->route[i] == tracingNode) {
+                containsTargetNode = true;
+                break;
+            }
+        }
+        for (uint8_t i = 0; i < r->route_back_count; i++) {
+            if (r->route_back[i] == tracingNode) {
+                containsTargetNode = true;
+                break;
+            }
+        }
+
+        // Check if this response contains a complete route to our target
+        bool hasCompleteRoute = (r->route_count > 0 && r->route_back_count > 0) ||
+                                (containsTargetNode && (r->route_count > 0 || r->route_back_count > 0));
+
+        LOG_INFO("TracRoute packet analysis: tracingNode=0x%08x, p.from=0x%08x, p.to=0x%08x, request_id=0x%08x", tracingNode,
+                 p.from, p.to, incoming.request_id);
+        LOG_INFO("TracRoute conditions: isResponseFromTarget=%d, isRequestToUs=%d, containsTargetNode=%d, hasCompleteRoute=%d",
+                 isResponseFromTarget, isRequestToUs, containsTargetNode, hasCompleteRoute);
+
+        if (isResponseFromTarget || isRequestToUs || (containsTargetNode && hasCompleteRoute)) {
+            LOG_INFO("TracRoute result detected: isResponseFromTarget=%d, isRequestToUs=%d", isResponseFromTarget, isRequestToUs);
+
+            LOG_INFO("SNR arrays - towards_count=%d, back_count=%d", r->snr_towards_count, r->snr_back_count);
+            for (int i = 0; i < r->snr_towards_count; i++) {
+                LOG_INFO("SNR towards[%d] = %d (%.1fdB)", i, r->snr_towards[i], (float)r->snr_towards[i] / 4.0f);
+            }
+            for (int i = 0; i < r->snr_back_count; i++) {
+                LOG_INFO("SNR back[%d] = %d (%.1fdB)", i, r->snr_back[i], (float)r->snr_back[i] / 4.0f);
+            }
+
+            String result = "";
+
+            // Show request path (from initiator to target)
+            if (r->route_count > 0) {
+                result += getNodeName(nodeDB->getNodeNum());
+                for (uint8_t i = 0; i < r->route_count; i++) {
+                    result += " > ";
+                    const char *name = getNodeName(r->route[i]);
+                    float snr =
+                        (i < r->snr_towards_count && r->snr_towards[i] != INT8_MIN) ? ((float)r->snr_towards[i] / 4.0f) : 0.0f;
+                    result += name;
+                    if (snr != 0.0f) {
+                        result += "(";
+                        result += String(snr, 1);
+                        result += "dB)";
+                    }
+                }
+                result += " > ";
+                result += getNodeName(tracingNode);
+                if (r->snr_towards_count > 0 && r->snr_towards[r->snr_towards_count - 1] != INT8_MIN) {
+                    result += "(";
+                    result += String((float)r->snr_towards[r->snr_towards_count - 1] / 4.0f, 1);
+                    result += "dB)";
+                }
+                result += "\n";
+            } else {
+                // Direct connection (no intermediate hops)
+                result += getNodeName(nodeDB->getNodeNum());
+                result += " > ";
+                result += getNodeName(tracingNode);
+                if (r->snr_towards_count > 0 && r->snr_towards[0] != INT8_MIN) {
+                    result += "(";
+                    result += String((float)r->snr_towards[0] / 4.0f, 1);
+                    result += "dB)";
+                }
+                result += "\n";
+            }
+
+            // Show response path (from target back to initiator)
+            if (r->route_back_count > 0) {
+                result += getNodeName(tracingNode);
+                for (int8_t i = r->route_back_count - 1; i >= 0; i--) {
+                    result += " > ";
+                    const char *name = getNodeName(r->route_back[i]);
+                    float snr = (i < r->snr_back_count && r->snr_back[i] != INT8_MIN) ? ((float)r->snr_back[i] / 4.0f) : 0.0f;
+                    result += name;
+                    if (snr != 0.0f) {
+                        result += "(";
+                        result += String(snr, 1);
+                        result += "dB)";
+                    }
+                }
+                // add initiator node
+                result += " > ";
+                result += getNodeName(nodeDB->getNodeNum());
+                if (r->snr_back_count > 0 && r->snr_back[r->snr_back_count - 1] != INT8_MIN) {
+                    result += "(";
+                    result += String((float)r->snr_back[r->snr_back_count - 1] / 4.0f, 1);
+                    result += "dB)";
+                }
+            } else {
+                // Direct return path (no intermediate hops)
+                result += getNodeName(tracingNode);
+                result += " > ";
+                result += getNodeName(nodeDB->getNodeNum());
+                if (r->snr_back_count > 0 && r->snr_back[0] != INT8_MIN) {
+                    result += "(";
+                    result += String((float)r->snr_back[0] / 4.0f, 1);
+                    result += "dB)";
+                }
+            }
+
+            LOG_INFO("Trace route result: %s", result.c_str());
+            handleTraceRouteResult(result);
+        }
+    }
 }
 
 void TraceRouteModule::insertUnknownHops(meshtastic_MeshPacket &p, meshtastic_RouteDiscovery *r, bool isTowardsDestination)
@@ -108,7 +232,7 @@ void TraceRouteModule::appendMyIDandSNR(meshtastic_RouteDiscovery *updated, floa
 
 void TraceRouteModule::printRoute(meshtastic_RouteDiscovery *r, uint32_t origin, uint32_t dest, bool isTowardsDestination)
 {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
     std::string route = "Route traced:\n";
     route += vformat("0x%x --> ", origin);
     for (uint8_t i = 0; i < r->route_count; i++) {
@@ -173,8 +297,467 @@ meshtastic_MeshPacket *TraceRouteModule::allocReply()
 }
 
 TraceRouteModule::TraceRouteModule()
-    : ProtobufModule("traceroute", meshtastic_PortNum_TRACEROUTE_APP, &meshtastic_RouteDiscovery_msg)
+    : ProtobufModule("traceroute", meshtastic_PortNum_TRACEROUTE_APP, &meshtastic_RouteDiscovery_msg), OSThread("TraceRoute")
 {
     ourPortNum = meshtastic_PortNum_TRACEROUTE_APP;
     isPromiscuous = true; // We need to update the route even if it is not destined to us
+}
+
+const char *TraceRouteModule::getNodeName(NodeNum node)
+{
+    meshtastic_NodeInfoLite *info = nodeDB->getMeshNode(node);
+    if (info && info->has_user) {
+        if (strlen(info->user.short_name) > 0) {
+            return info->user.short_name;
+        }
+        if (strlen(info->user.long_name) > 0) {
+            return info->user.long_name;
+        }
+    }
+
+    static char fallback[12];
+    snprintf(fallback, sizeof(fallback), "0x%08x", node);
+    return fallback;
+}
+
+bool TraceRouteModule::startTraceRoute(NodeNum node)
+{
+    LOG_INFO("=== TraceRoute startTraceRoute CALLED: node=0x%08x ===", node);
+    unsigned long now = millis();
+
+    if (node == 0 || node == NODENUM_BROADCAST) {
+        LOG_ERROR("Invalid node number for trace route: 0x%08x", node);
+        runState = TRACEROUTE_STATE_RESULT;
+        resultText = "Invalid node";
+        resultShowTime = millis();
+        tracingNode = 0;
+
+        requestFocus();
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+        notifyObservers(&e);
+        return false;
+    }
+
+    if (node == nodeDB->getNodeNum()) {
+        LOG_ERROR("Cannot trace route to self: 0x%08x", node);
+        runState = TRACEROUTE_STATE_RESULT;
+        resultText = "Cannot trace self";
+        resultShowTime = millis();
+        tracingNode = 0;
+
+        requestFocus();
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+        notifyObservers(&e);
+        return false;
+    }
+
+    if (!initialized) {
+        lastTraceRouteTime = 0;
+        initialized = true;
+        LOG_INFO("TraceRoute initialized for first time");
+    }
+
+    if (runState == TRACEROUTE_STATE_TRACKING) {
+        LOG_INFO("TraceRoute already in progress");
+        return false;
+    }
+
+    if (initialized && lastTraceRouteTime > 0 && now - lastTraceRouteTime < cooldownMs) {
+        // Cooldown
+        unsigned long wait = (cooldownMs - (now - lastTraceRouteTime)) / 1000;
+        bannerText = String("Wait for ") + String(wait) + String("s");
+        runState = TRACEROUTE_STATE_COOLDOWN;
+
+        requestFocus();
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+        notifyObservers(&e);
+        LOG_INFO("Cooldown active, please wait %lu seconds before starting a new trace route.", wait);
+        return false;
+    }
+
+    tracingNode = node;
+    lastTraceRouteTime = now;
+    runState = TRACEROUTE_STATE_TRACKING;
+    bannerText = String("Tracing ") + getNodeName(node);
+
+    LOG_INFO("TraceRoute UI: Starting trace route to node 0x%08x, requesting focus", node);
+
+    // 请求焦点，然后触发UI更新事件
+    requestFocus();
+    UIFrameEvent e;
+    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+    notifyObservers(&e);
+
+    // 设置定时器来处理超时检查
+    setIntervalFromNow(1000); // 每秒检查一次状态
+
+    meshtastic_RouteDiscovery req = meshtastic_RouteDiscovery_init_zero;
+    LOG_INFO("Creating RouteDiscovery protobuf...");
+
+    // Allocate a packet directly from router like the reference code
+    meshtastic_MeshPacket *p = router->allocForSending();
+    if (p) {
+        // Set destination and port
+        p->to = node;
+        p->decoded.portnum = meshtastic_PortNum_TRACEROUTE_APP;
+        p->decoded.want_response = true;
+
+        // Manually encode the RouteDiscovery payload
+        p->decoded.payload.size =
+            pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_RouteDiscovery_msg, &req);
+
+        LOG_INFO("Packet allocated successfully: to=0x%08x, portnum=%d, want_response=%d, payload_size=%d", p->to,
+                 p->decoded.portnum, p->decoded.want_response, p->decoded.payload.size);
+        LOG_INFO("About to call service->sendToMesh...");
+
+        if (service) {
+            LOG_INFO("MeshService is available, sending packet...");
+            service->sendToMesh(p, RX_SRC_USER);
+            LOG_INFO("sendToMesh called successfully for trace route to node 0x%08x", node);
+        } else {
+            LOG_ERROR("MeshService is NULL!");
+            runState = TRACEROUTE_STATE_RESULT;
+            resultText = "Service unavailable";
+            resultShowTime = millis();
+            tracingNode = 0;
+
+            requestFocus();
+            UIFrameEvent e2;
+            e2.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+            notifyObservers(&e2);
+            return false;
+        }
+    } else {
+        LOG_ERROR("Failed to allocate TraceRoute packet from router");
+        runState = TRACEROUTE_STATE_RESULT;
+        resultText = "Failed to send";
+        resultShowTime = millis();
+        tracingNode = 0;
+
+        requestFocus();
+        UIFrameEvent e2;
+        e2.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+        notifyObservers(&e2);
+        return false;
+    }
+    return true;
+}
+
+void TraceRouteModule::launch(NodeNum node)
+{
+    if (node == 0 || node == NODENUM_BROADCAST) {
+        LOG_ERROR("Invalid node number for trace route: 0x%08x", node);
+        runState = TRACEROUTE_STATE_RESULT;
+        resultText = "Invalid node";
+        resultShowTime = millis();
+        tracingNode = 0;
+
+        requestFocus();
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+        notifyObservers(&e);
+        return;
+    }
+
+    if (node == nodeDB->getNodeNum()) {
+        LOG_ERROR("Cannot trace route to self: 0x%08x", node);
+        runState = TRACEROUTE_STATE_RESULT;
+        resultText = "Cannot trace self";
+        resultShowTime = millis();
+        tracingNode = 0;
+
+        requestFocus();
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+        notifyObservers(&e);
+        return;
+    }
+
+    if (!initialized) {
+        lastTraceRouteTime = 0;
+        initialized = true;
+        LOG_INFO("TraceRoute initialized for first time");
+    }
+
+    unsigned long now = millis();
+    if (initialized && lastTraceRouteTime > 0 && now - lastTraceRouteTime < cooldownMs) {
+        unsigned long wait = (cooldownMs - (now - lastTraceRouteTime)) / 1000;
+        bannerText = String("Wait for ") + String(wait) + String("s");
+        runState = TRACEROUTE_STATE_COOLDOWN;
+
+        requestFocus();
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+        notifyObservers(&e);
+        LOG_INFO("Cooldown active, please wait %lu seconds before starting a new trace route.", wait);
+        return;
+    }
+
+    runState = TRACEROUTE_STATE_TRACKING;
+    tracingNode = node;
+    lastTraceRouteTime = now;
+    bannerText = String("Tracing ") + getNodeName(node);
+
+    requestFocus();
+
+    UIFrameEvent e;
+    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+    notifyObservers(&e);
+
+    setIntervalFromNow(1000);
+
+    meshtastic_RouteDiscovery req = meshtastic_RouteDiscovery_init_zero;
+    LOG_INFO("Creating RouteDiscovery protobuf...");
+
+    meshtastic_MeshPacket *p = router->allocForSending();
+    if (p) {
+        p->to = node;
+        p->decoded.portnum = meshtastic_PortNum_TRACEROUTE_APP;
+        p->decoded.want_response = true;
+
+        p->decoded.payload.size =
+            pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_RouteDiscovery_msg, &req);
+
+        LOG_INFO("Packet allocated successfully: to=0x%08x, portnum=%d, want_response=%d, payload_size=%d", p->to,
+                 p->decoded.portnum, p->decoded.want_response, p->decoded.payload.size);
+
+        if (service) {
+            service->sendToMesh(p, RX_SRC_USER);
+            LOG_INFO("sendToMesh called successfully for trace route to node 0x%08x", node);
+        } else {
+            LOG_ERROR("MeshService is NULL!");
+            runState = TRACEROUTE_STATE_RESULT;
+            resultText = "Service unavailable";
+            resultShowTime = millis();
+            tracingNode = 0;
+        }
+    } else {
+        LOG_ERROR("Failed to allocate TraceRoute packet from router");
+        runState = TRACEROUTE_STATE_RESULT;
+        resultText = "Failed to send";
+        resultShowTime = millis();
+        tracingNode = 0;
+    }
+}
+
+void TraceRouteModule::handleTraceRouteResult(const String &result)
+{
+    resultText = result;
+    runState = TRACEROUTE_STATE_RESULT;
+    resultShowTime = millis();
+    tracingNode = 0;
+
+    LOG_INFO("TraceRoute result ready, requesting focus. Result: %s", result.c_str());
+
+    setIntervalFromNow(1000);
+
+    requestFocus();
+    UIFrameEvent e;
+    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+    notifyObservers(&e);
+
+    LOG_INFO("=== TraceRoute handleTraceRouteResult END ===");
+}
+
+bool TraceRouteModule::shouldDraw()
+{
+    bool draw = (runState != TRACEROUTE_STATE_IDLE);
+    static TraceRouteRunState lastLoggedState = TRACEROUTE_STATE_IDLE;
+    if (runState != lastLoggedState) {
+        LOG_INFO("TraceRoute shouldDraw: runState=%d, draw=%d", runState, draw);
+        lastLoggedState = runState;
+    }
+    return draw;
+}
+#if HAS_SCREEN
+void TraceRouteModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    LOG_DEBUG("TraceRoute drawFrame called: runState=%d", runState);
+
+    display->setTextAlignment(TEXT_ALIGN_CENTER);
+
+    if (runState == TRACEROUTE_STATE_TRACKING) {
+        display->setFont(FONT_MEDIUM);
+        int centerY = y + (display->getHeight() / 2) - (FONT_HEIGHT_MEDIUM / 2);
+        display->drawString(display->getWidth() / 2 + x, centerY, bannerText);
+
+    } else if (runState == TRACEROUTE_STATE_RESULT) {
+        display->setFont(FONT_MEDIUM);
+        display->setTextAlignment(TEXT_ALIGN_LEFT);
+
+        display->drawString(x, y, "Route Result");
+
+        int contentStartY = y + FONT_HEIGHT_MEDIUM + 2; // Add more spacing after title
+        display->setTextAlignment(TEXT_ALIGN_LEFT);
+        display->setFont(FONT_SMALL);
+
+        if (resultText.length() > 0) {
+            std::vector<String> lines;
+            String currentLine = "";
+            int maxWidth = display->getWidth() - 4;
+
+            int start = 0;
+            int newlinePos = resultText.indexOf('\n', start);
+
+            while (newlinePos != -1 || start < resultText.length()) {
+                String segment;
+                if (newlinePos != -1) {
+                    segment = resultText.substring(start, newlinePos);
+                    start = newlinePos + 1;
+                    newlinePos = resultText.indexOf('\n', start);
+                } else {
+                    segment = resultText.substring(start);
+                    start = resultText.length();
+                }
+
+                if (display->getStringWidth(segment) <= maxWidth) {
+                    lines.push_back(segment);
+                } else {
+                    // Try to break at better positions (space, >, <, -)
+                    String remaining = segment;
+
+                    while (remaining.length() > 0) {
+                        String tempLine = "";
+                        int lastGoodBreak = -1;
+                        bool lineComplete = false;
+
+                        for (int i = 0; i < remaining.length(); i++) {
+                            char ch = remaining.charAt(i);
+                            String testLine = tempLine + ch;
+
+                            if (display->getStringWidth(testLine) > maxWidth) {
+                                if (lastGoodBreak >= 0) {
+                                    // Break at the last good position
+                                    lines.push_back(remaining.substring(0, lastGoodBreak + 1));
+                                    remaining = remaining.substring(lastGoodBreak + 1);
+                                    lineComplete = true;
+                                    break;
+                                } else if (tempLine.length() > 0) {
+                                    lines.push_back(tempLine);
+                                    remaining = remaining.substring(i);
+                                    lineComplete = true;
+                                    break;
+                                } else {
+                                    // Single character exceeds width
+                                    lines.push_back(String(ch));
+                                    remaining = remaining.substring(i + 1);
+                                    lineComplete = true;
+                                    break;
+                                }
+                            } else {
+                                tempLine = testLine;
+                                // Mark good break positions
+                                if (ch == ' ' || ch == '>' || ch == '<' || ch == '-' || ch == '(' || ch == ')') {
+                                    lastGoodBreak = i;
+                                }
+                            }
+                        }
+
+                        if (!lineComplete) {
+                            // Reached end of remaining text
+                            if (tempLine.length() > 0) {
+                                lines.push_back(tempLine);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            int lineHeight = FONT_HEIGHT_SMALL + 1; // Use proper font height with 1px spacing
+            for (size_t i = 0; i < lines.size(); i++) {
+                int lineY = contentStartY + (i * lineHeight);
+                if (lineY + FONT_HEIGHT_SMALL <= display->getHeight()) {
+                    display->drawString(x + 2, lineY, lines[i]);
+                }
+            }
+        }
+
+    } else if (runState == TRACEROUTE_STATE_COOLDOWN) {
+        display->setFont(FONT_MEDIUM);
+        int centerY = y + (display->getHeight() / 2) - (FONT_HEIGHT_MEDIUM / 2);
+        display->drawString(display->getWidth() / 2 + x, centerY, bannerText);
+    }
+}
+#endif // HAS_SCREEN
+int32_t TraceRouteModule::runOnce()
+{
+    unsigned long now = millis();
+
+    if (runState == TRACEROUTE_STATE_IDLE) {
+        return INT32_MAX;
+    }
+
+    // Check for tracking timeout
+    if (runState == TRACEROUTE_STATE_TRACKING && now - lastTraceRouteTime > trackingTimeoutMs) {
+        LOG_INFO("TraceRoute timeout, no response received");
+        runState = TRACEROUTE_STATE_RESULT;
+        resultText = "No response received";
+        resultShowTime = now;
+        tracingNode = 0;
+
+        requestFocus();
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+        notifyObservers(&e);
+
+        setIntervalFromNow(resultDisplayMs);
+        return resultDisplayMs;
+    }
+
+    // Update cooldown display every second
+    if (runState == TRACEROUTE_STATE_COOLDOWN) {
+        unsigned long wait = (cooldownMs - (now - lastTraceRouteTime)) / 1000;
+        if (wait > 0) {
+            String newBannerText = String("Wait for ") + String(wait) + String("s");
+            bannerText = newBannerText;
+            LOG_INFO("TraceRoute cooldown: updating banner to %s", bannerText.c_str());
+
+            // Force flash UI
+            requestFocus();
+            UIFrameEvent e;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+            notifyObservers(&e);
+
+            if (screen) {
+                screen->forceDisplay();
+            }
+
+            return 1000;
+        } else {
+            // Cooldown finished
+            LOG_INFO("TraceRoute cooldown finished, returning to IDLE");
+            runState = TRACEROUTE_STATE_IDLE;
+            bannerText = "";
+            UIFrameEvent e;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+            notifyObservers(&e);
+            return INT32_MAX;
+        }
+    }
+
+    if (runState == TRACEROUTE_STATE_RESULT) {
+        if (now - resultShowTime >= resultDisplayMs) {
+            LOG_INFO("TraceRoute result display timeout, returning to IDLE");
+            runState = TRACEROUTE_STATE_IDLE;
+            resultText = "";
+            bannerText = "";
+            tracingNode = 0;
+            UIFrameEvent e;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
+            notifyObservers(&e);
+            return INT32_MAX;
+        } else {
+            return 1000;
+        }
+    }
+
+    if (runState == TRACEROUTE_STATE_TRACKING) {
+        return 1000;
+    }
+
+    return INT32_MAX;
 }

src/modules/TraceRouteModule.h

@@ -1,16 +1,40 @@
 #pragma once
 #include "ProtobufModule.h"
+#include "concurrency/OSThread.h"
+#include "graphics/Screen.h"
+#include "graphics/SharedUIDisplay.h"
+#include "input/InputBroker.h"
+#if HAS_SCREEN
+#include "OLEDDisplayUi.h"
+#endif
 
 #define ROUTE_SIZE sizeof(((meshtastic_RouteDiscovery *)0)->route) / sizeof(((meshtastic_RouteDiscovery *)0)->route[0])
 
 /**
  * A module that traces the route to a certain destination node
  */
-class TraceRouteModule : public ProtobufModule<meshtastic_RouteDiscovery>
+enum TraceRouteRunState { TRACEROUTE_STATE_IDLE, TRACEROUTE_STATE_TRACKING, TRACEROUTE_STATE_RESULT, TRACEROUTE_STATE_COOLDOWN };
+
+class TraceRouteModule : public ProtobufModule<meshtastic_RouteDiscovery>,
+                         public Observable<const UIFrameEvent *>,
+                         private concurrency::OSThread
 {
   public:
     TraceRouteModule();
 
+    bool startTraceRoute(NodeNum node);
+    void launch(NodeNum node);
+    void handleTraceRouteResult(const String &result);
+    bool shouldDraw();
+#if HAS_SCREEN
+    virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) override;
+#endif
+
+    const char *getNodeName(NodeNum node);
+
+    virtual bool wantUIFrame() override { return shouldDraw(); }
+    virtual Observable<const UIFrameEvent *> *getUIFrameObservable() override { return this; }
+
   protected:
     bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_RouteDiscovery *r) override;
 
@@ -20,6 +44,8 @@ class TraceRouteModule : public ProtobufModule<meshtastic_RouteDiscovery>
        the route array containing the IDs of nodes this packet went through */
     void alterReceivedProtobuf(meshtastic_MeshPacket &p, meshtastic_RouteDiscovery *r) override;
 
+    virtual int32_t runOnce() override;
+
   private:
     // Call to add unknown hops (e.g. when a node couldn't decrypt it) to the route based on hopStart and current hopLimit
     void insertUnknownHops(meshtastic_MeshPacket &p, meshtastic_RouteDiscovery *r, bool isTowardsDestination);
@@ -31,6 +57,17 @@ class TraceRouteModule : public ProtobufModule<meshtastic_RouteDiscovery>
        Set origin to where the request came from.
        Set dest to the ID of its destination, or NODENUM_BROADCAST if it has not yet arrived there. */
     void printRoute(meshtastic_RouteDiscovery *r, uint32_t origin, uint32_t dest, bool isTowardsDestination);
+
+    TraceRouteRunState runState = TRACEROUTE_STATE_IDLE;
+    unsigned long lastTraceRouteTime = 0;
+    unsigned long resultShowTime = 0;
+    unsigned long cooldownMs = 30000;
+    unsigned long resultDisplayMs = 10000;
+    unsigned long trackingTimeoutMs = 10000;
+    String bannerText;
+    String resultText;
+    NodeNum tracingNode = 0;
+    bool initialized = false;
 };
 
 extern TraceRouteModule *traceRouteModule;

src/modules/WaypointModule.cpp

@@ -16,7 +16,7 @@ WaypointModule *waypointModule;
 
 ProcessMessage WaypointModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
     auto &p = mp.decoded;
     LOG_INFO("Received waypoint msg from=0x%0x, id=0x%x, msg=%.*s", mp.from, mp.id, p.payload.size, p.payload.bytes);
 #endif

src/mqtt/MQTT.cpp

@@ -39,6 +39,7 @@
 #include <machine/endian.h>
 #define ntohl __ntohl
 #endif
+#include <RTC.h>
 
 MQTT *mqtt;
 
@@ -624,18 +625,32 @@ bool MQTT::isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config, MQTTC
             return connectPubSub(parsed, *pubSub, (client != nullptr) ? *client : *clientConnection);
         }
 #else
-        LOG_ERROR("Invalid MQTT config: proxy_to_client_enabled must be enabled on nodes that do not have a network");
+        const char *warning = "Invalid MQTT config: proxy_to_client_enabled must be enabled on nodes that do not have a network";
+        LOG_ERROR(warning);
+#if !IS_RUNNING_TESTS
+        meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+        cn->level = meshtastic_LogRecord_Level_ERROR;
+        cn->time = getValidTime(RTCQualityFromNet);
+        strncpy(cn->message, warning, sizeof(cn->message) - 1);
+        cn->message[sizeof(cn->message) - 1] = '\0'; // Ensure null termination
+        service->sendClientNotification(cn);
+#endif
         return false;
 #endif
     }
 
     const bool defaultServer = isDefaultServer(parsed.serverAddr);
-    if (defaultServer && config.tls_enabled) {
-        LOG_ERROR("Invalid MQTT config: TLS was enabled, but the default server does not support TLS");
-        return false;
-    }
     if (defaultServer && parsed.serverPort != PubSubConfig::defaultPort) {
-        LOG_ERROR("Invalid MQTT config: Unsupported port '%d' for the default MQTT server", parsed.serverPort);
+        const char *warning = "Invalid MQTT config: default server address must not have a port specified";
+        LOG_ERROR(warning);
+#if !IS_RUNNING_TESTS
+        meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+        cn->level = meshtastic_LogRecord_Level_ERROR;
+        cn->time = getValidTime(RTCQualityFromNet);
+        strncpy(cn->message, warning, sizeof(cn->message) - 1);
+        cn->message[sizeof(cn->message) - 1] = '\0'; // Ensure null termination
+        service->sendClientNotification(cn);
+#endif
         return false;
     }
     return true;

src/platform/esp32/architecture.h

@@ -146,6 +146,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_EBYTE_ESP32_S3
 #elif defined(ELECROW_ThinkNode_M2)
 #define HW_VENDOR meshtastic_HardwareModel_THINKNODE_M2
+#elif defined(ELECROW_ThinkNode_M5)
+#define HW_VENDOR meshtastic_HardwareModel_THINKNODE_M5
 #elif defined(ESP32_S3_PICO)
 #define HW_VENDOR meshtastic_HardwareModel_ESP32_S3_PICO
 #elif defined(SENSELORA_S3)

src/platform/nrf52/architecture.h

@@ -53,6 +53,9 @@
 #define HW_VENDOR meshtastic_HardwareModel_WISMESH_TAG
 #elif defined(GAT562_MESH_TRIAL_TRACKER)
 #define HW_VENDOR meshtastic_HardwareModel_GAT562_MESH_TRIAL_TRACKER
+#elif defined(NOMADSTAR_METEOR_PRO)
+#define HW_VENDOR meshtastic_HardwareModel_NOMADSTAR_METEOR_PRO
+// MAke sure all custom RAK4630 boards are defined before the generic RAK4630
 #elif defined(RAK4630)
 #define HW_VENDOR meshtastic_HardwareModel_RAK4631
 #elif defined(TTGO_T_ECHO)
@@ -89,8 +92,6 @@
 #define HW_VENDOR meshtastic_HardwareModel_SEEED_SOLAR_NODE
 #elif defined(HELTEC_MESH_POCKET)
 #define HW_VENDOR meshtastic_HardwareModel_HELTEC_MESH_POCKET
-#elif defined(NOMADSTAR_METEOR_PRO)
-#define HW_VENDOR meshtastic_HardwareModel_NOMADSTAR_METEOR_PRO
 #elif defined(SEEED_WIO_TRACKER_L1_EINK)
 #define HW_VENDOR meshtastic_HardwareModel_SEEED_WIO_TRACKER_L1_EINK
 #elif defined(SEEED_WIO_TRACKER_L1)

src/platform/stm32wl/architecture.h

@@ -32,3 +32,8 @@
 #define SX126X_DIO1 1001
 #define SX126X_RESET 1003
 #define SX126X_BUSY 1004
+
+#if !defined(DEBUG_MUTE) && !defined(PIO_FRAMEWORK_ARDUINO_NANOLIB_FLOAT_PRINTF)
+#error                                                                                                                           \
+    "You MUST enable PIO_FRAMEWORK_ARDUINO_NANOLIB_FLOAT_PRINTF if debug prints are enabled. printf will print uninitialized garbage instead of floats."
+#endif

src/serialization/MeshPacketSerializer.cpp

@@ -100,6 +100,9 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp,
                     if (decoded->variant.environment_metrics.has_iaq) {
                         msgPayload["iaq"] = new JSONValue((uint)decoded->variant.environment_metrics.iaq);
                     }
+                    if (decoded->variant.environment_metrics.has_distance) {
+                        msgPayload["distance"] = new JSONValue(decoded->variant.environment_metrics.distance);
+                    }
                     if (decoded->variant.environment_metrics.has_wind_speed) {
                         msgPayload["wind_speed"] = new JSONValue(decoded->variant.environment_metrics.wind_speed);
                     }
@@ -115,6 +118,27 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp,
                     if (decoded->variant.environment_metrics.has_radiation) {
                         msgPayload["radiation"] = new JSONValue(decoded->variant.environment_metrics.radiation);
                     }
+                    if (decoded->variant.environment_metrics.has_ir_lux) {
+                        msgPayload["ir_lux"] = new JSONValue(decoded->variant.environment_metrics.ir_lux);
+                    }
+                    if (decoded->variant.environment_metrics.has_uv_lux) {
+                        msgPayload["uv_lux"] = new JSONValue(decoded->variant.environment_metrics.uv_lux);
+                    }
+                    if (decoded->variant.environment_metrics.has_weight) {
+                        msgPayload["weight"] = new JSONValue(decoded->variant.environment_metrics.weight);
+                    }
+                    if (decoded->variant.environment_metrics.has_rainfall_1h) {
+                        msgPayload["rainfall_1h"] = new JSONValue(decoded->variant.environment_metrics.rainfall_1h);
+                    }
+                    if (decoded->variant.environment_metrics.has_rainfall_24h) {
+                        msgPayload["rainfall_24h"] = new JSONValue(decoded->variant.environment_metrics.rainfall_24h);
+                    }
+                    if (decoded->variant.environment_metrics.has_soil_moisture) {
+                        msgPayload["soil_moisture"] = new JSONValue((uint)decoded->variant.environment_metrics.soil_moisture);
+                    }
+                    if (decoded->variant.environment_metrics.has_soil_temperature) {
+                        msgPayload["soil_temperature"] = new JSONValue(decoded->variant.environment_metrics.soil_temperature);
+                    }
                 } else if (decoded->which_variant == meshtastic_Telemetry_air_quality_metrics_tag) {
                     if (decoded->variant.air_quality_metrics.has_pm10_standard) {
                         msgPayload["pm10"] = new JSONValue((unsigned int)decoded->variant.air_quality_metrics.pm10_standard);

src/sleep.cpp

@@ -131,7 +131,7 @@ void initDeepSleep()
       support busted boards, assume button one was pressed wakeButtons = ((uint64_t)1) << buttons.gpios[0];
       */
 
-#ifdef DEBUG_PORT
+#if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
     // If we booted because our timer ran out or the user pressed reset, send those as fake events
     RESET_REASON hwReason = rtc_get_reset_reason(0);
 

test/test_meshpacket_serializer/ports/test_encrypted.cpp

@@ -0,0 +1,50 @@
+#include "../test_helpers.h"
+
+// Test encrypted packet serialization
+void test_encrypted_packet_serialization()
+{
+    meshtastic_MeshPacket packet = meshtastic_MeshPacket_init_zero;
+    packet.from = 0x11223344;
+    packet.to = 0x55667788;
+    packet.id = 0x9999;
+    packet.which_payload_variant = meshtastic_MeshPacket_encrypted_tag;
+
+    // Add some dummy encrypted data
+    const char *encrypted_data = "encrypted_payload_data";
+    packet.encrypted.size = strlen(encrypted_data);
+    memcpy(packet.encrypted.bytes, encrypted_data, packet.encrypted.size);
+
+    std::string json = MeshPacketSerializer::JsonSerializeEncrypted(&packet);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check basic packet fields
+    TEST_ASSERT_TRUE(jsonObj.find("from") != jsonObj.end());
+    TEST_ASSERT_EQUAL(0x11223344, (uint32_t)jsonObj["from"]->AsNumber());
+
+    TEST_ASSERT_TRUE(jsonObj.find("to") != jsonObj.end());
+    TEST_ASSERT_EQUAL(0x55667788, (uint32_t)jsonObj["to"]->AsNumber());
+
+    TEST_ASSERT_TRUE(jsonObj.find("id") != jsonObj.end());
+    TEST_ASSERT_EQUAL(0x9999, (uint32_t)jsonObj["id"]->AsNumber());
+
+    // Check that it has encrypted data fields (not "payload" but "bytes" and "size")
+    TEST_ASSERT_TRUE(jsonObj.find("bytes") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["bytes"]->IsString());
+
+    TEST_ASSERT_TRUE(jsonObj.find("size") != jsonObj.end());
+    TEST_ASSERT_EQUAL(22, (int)jsonObj["size"]->AsNumber()); // strlen("encrypted_payload_data") = 22
+
+    // The encrypted data should be hex-encoded
+    std::string encrypted_hex = jsonObj["bytes"]->AsString();
+    TEST_ASSERT_TRUE(encrypted_hex.length() > 0);
+    // Should be twice the size of the original data (hex encoding)
+    TEST_ASSERT_EQUAL(44, encrypted_hex.length()); // 22 * 2 = 44
+
+    delete root;
+}

test/test_meshpacket_serializer/ports/test_nodeinfo.cpp

@@ -0,0 +1,51 @@
+#include "../test_helpers.h"
+
+static size_t encode_user_info(uint8_t *buffer, size_t buffer_size)
+{
+    meshtastic_User user = meshtastic_User_init_zero;
+    strcpy(user.short_name, "TEST");
+    strcpy(user.long_name, "Test User");
+    strcpy(user.id, "!12345678");
+    user.hw_model = meshtastic_HardwareModel_HELTEC_V3;
+
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, buffer_size);
+    pb_encode(&stream, &meshtastic_User_msg, &user);
+    return stream.bytes_written;
+}
+
+// Test NODEINFO_APP port
+void test_nodeinfo_serialization()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_user_info(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_NODEINFO_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check message type
+    TEST_ASSERT_TRUE(jsonObj.find("type") != jsonObj.end());
+    TEST_ASSERT_EQUAL_STRING("nodeinfo", jsonObj["type"]->AsString().c_str());
+
+    // Check payload
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // Verify user data
+    TEST_ASSERT_TRUE(payload.find("shortname") != payload.end());
+    TEST_ASSERT_EQUAL_STRING("TEST", payload["shortname"]->AsString().c_str());
+
+    TEST_ASSERT_TRUE(payload.find("longname") != payload.end());
+    TEST_ASSERT_EQUAL_STRING("Test User", payload["longname"]->AsString().c_str());
+
+    delete root;
+}

test/test_meshpacket_serializer/ports/test_position.cpp

@@ -0,0 +1,57 @@
+#include "../test_helpers.h"
+
+static size_t encode_position(uint8_t *buffer, size_t buffer_size)
+{
+    meshtastic_Position position = meshtastic_Position_init_zero;
+    position.latitude_i = 374208000;    // 37.4208 degrees * 1e7
+    position.longitude_i = -1221981000; // -122.1981 degrees * 1e7
+    position.altitude = 123;
+    position.time = 1609459200;
+    position.has_altitude = true;
+    position.has_latitude_i = true;
+    position.has_longitude_i = true;
+
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, buffer_size);
+    pb_encode(&stream, &meshtastic_Position_msg, &position);
+    return stream.bytes_written;
+}
+
+// Test POSITION_APP port
+void test_position_serialization()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_position(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_POSITION_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check message type
+    TEST_ASSERT_TRUE(jsonObj.find("type") != jsonObj.end());
+    TEST_ASSERT_EQUAL_STRING("position", jsonObj["type"]->AsString().c_str());
+
+    // Check payload
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // Verify position data
+    TEST_ASSERT_TRUE(payload.find("latitude_i") != payload.end());
+    TEST_ASSERT_EQUAL(374208000, (int)payload["latitude_i"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("longitude_i") != payload.end());
+    TEST_ASSERT_EQUAL(-1221981000, (int)payload["longitude_i"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("altitude") != payload.end());
+    TEST_ASSERT_EQUAL(123, (int)payload["altitude"]->AsNumber());
+
+    delete root;
+}

test/test_meshpacket_serializer/ports/test_telemetry.cpp

@@ -0,0 +1,528 @@
+#include "../test_helpers.h"
+
+// Helper function to create and encode device metrics
+static size_t encode_telemetry_device_metrics(uint8_t *buffer, size_t buffer_size)
+{
+    meshtastic_Telemetry telemetry = meshtastic_Telemetry_init_zero;
+    telemetry.time = 1609459200;
+    telemetry.which_variant = meshtastic_Telemetry_device_metrics_tag;
+    telemetry.variant.device_metrics.battery_level = 85;
+    telemetry.variant.device_metrics.has_battery_level = true;
+    telemetry.variant.device_metrics.voltage = 3.72f;
+    telemetry.variant.device_metrics.has_voltage = true;
+    telemetry.variant.device_metrics.channel_utilization = 15.56f;
+    telemetry.variant.device_metrics.has_channel_utilization = true;
+    telemetry.variant.device_metrics.air_util_tx = 8.23f;
+    telemetry.variant.device_metrics.has_air_util_tx = true;
+    telemetry.variant.device_metrics.uptime_seconds = 12345;
+    telemetry.variant.device_metrics.has_uptime_seconds = true;
+
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, buffer_size);
+    pb_encode(&stream, &meshtastic_Telemetry_msg, &telemetry);
+    return stream.bytes_written;
+}
+
+// Helper function to create and encode empty environment metrics (no fields set)
+static size_t encode_telemetry_environment_metrics_empty(uint8_t *buffer, size_t buffer_size)
+{
+    meshtastic_Telemetry telemetry = meshtastic_Telemetry_init_zero;
+    telemetry.time = 1609459200;
+    telemetry.which_variant = meshtastic_Telemetry_environment_metrics_tag;
+
+    // NO fields are set - all has_* flags remain false
+    // This tests that empty environment metrics don't produce any JSON fields
+
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, buffer_size);
+    pb_encode(&stream, &meshtastic_Telemetry_msg, &telemetry);
+    return stream.bytes_written;
+}
+
+// Helper function to create environment metrics with ALL possible fields set
+// This function should be updated whenever new fields are added to the protobuf
+static size_t encode_telemetry_environment_metrics_all_fields(uint8_t *buffer, size_t buffer_size)
+{
+    meshtastic_Telemetry telemetry = meshtastic_Telemetry_init_zero;
+    telemetry.time = 1609459200;
+    telemetry.which_variant = meshtastic_Telemetry_environment_metrics_tag;
+
+    // Basic environment metrics
+    telemetry.variant.environment_metrics.temperature = 23.56f;
+    telemetry.variant.environment_metrics.has_temperature = true;
+    telemetry.variant.environment_metrics.relative_humidity = 65.43f;
+    telemetry.variant.environment_metrics.has_relative_humidity = true;
+    telemetry.variant.environment_metrics.barometric_pressure = 1013.27f;
+    telemetry.variant.environment_metrics.has_barometric_pressure = true;
+
+    // Gas and air quality
+    telemetry.variant.environment_metrics.gas_resistance = 50.58f;
+    telemetry.variant.environment_metrics.has_gas_resistance = true;
+    telemetry.variant.environment_metrics.iaq = 120;
+    telemetry.variant.environment_metrics.has_iaq = true;
+
+    // Power measurements
+    telemetry.variant.environment_metrics.voltage = 3.34f;
+    telemetry.variant.environment_metrics.has_voltage = true;
+    telemetry.variant.environment_metrics.current = 0.53f;
+    telemetry.variant.environment_metrics.has_current = true;
+
+    // Light measurements (ALL 4 types)
+    telemetry.variant.environment_metrics.lux = 450.12f;
+    telemetry.variant.environment_metrics.has_lux = true;
+    telemetry.variant.environment_metrics.white_lux = 380.95f;
+    telemetry.variant.environment_metrics.has_white_lux = true;
+    telemetry.variant.environment_metrics.ir_lux = 25.37f;
+    telemetry.variant.environment_metrics.has_ir_lux = true;
+    telemetry.variant.environment_metrics.uv_lux = 15.68f;
+    telemetry.variant.environment_metrics.has_uv_lux = true;
+
+    // Distance measurement
+    telemetry.variant.environment_metrics.distance = 150.29f;
+    telemetry.variant.environment_metrics.has_distance = true;
+
+    // Wind measurements (ALL 4 types)
+    telemetry.variant.environment_metrics.wind_direction = 180;
+    telemetry.variant.environment_metrics.has_wind_direction = true;
+    telemetry.variant.environment_metrics.wind_speed = 5.52f;
+    telemetry.variant.environment_metrics.has_wind_speed = true;
+    telemetry.variant.environment_metrics.wind_gust = 8.24f;
+    telemetry.variant.environment_metrics.has_wind_gust = true;
+    telemetry.variant.environment_metrics.wind_lull = 2.13f;
+    telemetry.variant.environment_metrics.has_wind_lull = true;
+
+    // Weight measurement
+    telemetry.variant.environment_metrics.weight = 75.56f;
+    telemetry.variant.environment_metrics.has_weight = true;
+
+    // Radiation measurement
+    telemetry.variant.environment_metrics.radiation = 0.13f;
+    telemetry.variant.environment_metrics.has_radiation = true;
+
+    // Rainfall measurements (BOTH types)
+    telemetry.variant.environment_metrics.rainfall_1h = 2.57f;
+    telemetry.variant.environment_metrics.has_rainfall_1h = true;
+    telemetry.variant.environment_metrics.rainfall_24h = 15.89f;
+    telemetry.variant.environment_metrics.has_rainfall_24h = true;
+
+    // Soil measurements (BOTH types)
+    telemetry.variant.environment_metrics.soil_moisture = 85;
+    telemetry.variant.environment_metrics.has_soil_moisture = true;
+    telemetry.variant.environment_metrics.soil_temperature = 18.54f;
+    telemetry.variant.environment_metrics.has_soil_temperature = true;
+
+    // IMPORTANT: When new environment fields are added to the protobuf,
+    // they MUST be added here too, or the coverage test will fail!
+
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, buffer_size);
+    pb_encode(&stream, &meshtastic_Telemetry_msg, &telemetry);
+    return stream.bytes_written;
+}
+
+// Helper function to create and encode environment metrics with all current fields
+static size_t encode_telemetry_environment_metrics(uint8_t *buffer, size_t buffer_size)
+{
+    meshtastic_Telemetry telemetry = meshtastic_Telemetry_init_zero;
+    telemetry.time = 1609459200;
+    telemetry.which_variant = meshtastic_Telemetry_environment_metrics_tag;
+
+    // Basic environment metrics
+    telemetry.variant.environment_metrics.temperature = 23.56f;
+    telemetry.variant.environment_metrics.has_temperature = true;
+    telemetry.variant.environment_metrics.relative_humidity = 65.43f;
+    telemetry.variant.environment_metrics.has_relative_humidity = true;
+    telemetry.variant.environment_metrics.barometric_pressure = 1013.27f;
+    telemetry.variant.environment_metrics.has_barometric_pressure = true;
+
+    // Gas and air quality
+    telemetry.variant.environment_metrics.gas_resistance = 50.58f;
+    telemetry.variant.environment_metrics.has_gas_resistance = true;
+    telemetry.variant.environment_metrics.iaq = 120;
+    telemetry.variant.environment_metrics.has_iaq = true;
+
+    // Power measurements
+    telemetry.variant.environment_metrics.voltage = 3.34f;
+    telemetry.variant.environment_metrics.has_voltage = true;
+    telemetry.variant.environment_metrics.current = 0.53f;
+    telemetry.variant.environment_metrics.has_current = true;
+
+    // Light measurements
+    telemetry.variant.environment_metrics.lux = 450.12f;
+    telemetry.variant.environment_metrics.has_lux = true;
+    telemetry.variant.environment_metrics.white_lux = 380.95f;
+    telemetry.variant.environment_metrics.has_white_lux = true;
+    telemetry.variant.environment_metrics.ir_lux = 25.37f;
+    telemetry.variant.environment_metrics.has_ir_lux = true;
+    telemetry.variant.environment_metrics.uv_lux = 15.68f;
+    telemetry.variant.environment_metrics.has_uv_lux = true;
+
+    // Distance measurement
+    telemetry.variant.environment_metrics.distance = 150.29f;
+    telemetry.variant.environment_metrics.has_distance = true;
+
+    // Wind measurements
+    telemetry.variant.environment_metrics.wind_direction = 180;
+    telemetry.variant.environment_metrics.has_wind_direction = true;
+    telemetry.variant.environment_metrics.wind_speed = 5.52f;
+    telemetry.variant.environment_metrics.has_wind_speed = true;
+    telemetry.variant.environment_metrics.wind_gust = 8.24f;
+    telemetry.variant.environment_metrics.has_wind_gust = true;
+    telemetry.variant.environment_metrics.wind_lull = 2.13f;
+    telemetry.variant.environment_metrics.has_wind_lull = true;
+
+    // Weight measurement
+    telemetry.variant.environment_metrics.weight = 75.56f;
+    telemetry.variant.environment_metrics.has_weight = true;
+
+    // Radiation measurement
+    telemetry.variant.environment_metrics.radiation = 0.13f;
+    telemetry.variant.environment_metrics.has_radiation = true;
+
+    // Rainfall measurements
+    telemetry.variant.environment_metrics.rainfall_1h = 2.57f;
+    telemetry.variant.environment_metrics.has_rainfall_1h = true;
+    telemetry.variant.environment_metrics.rainfall_24h = 15.89f;
+    telemetry.variant.environment_metrics.has_rainfall_24h = true;
+
+    // Soil measurements
+    telemetry.variant.environment_metrics.soil_moisture = 85;
+    telemetry.variant.environment_metrics.has_soil_moisture = true;
+    telemetry.variant.environment_metrics.soil_temperature = 18.54f;
+    telemetry.variant.environment_metrics.has_soil_temperature = true;
+
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, buffer_size);
+    pb_encode(&stream, &meshtastic_Telemetry_msg, &telemetry);
+    return stream.bytes_written;
+}
+
+// Test TELEMETRY_APP port with device metrics
+void test_telemetry_device_metrics_serialization()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_telemetry_device_metrics(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_TELEMETRY_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check message type
+    TEST_ASSERT_TRUE(jsonObj.find("type") != jsonObj.end());
+    TEST_ASSERT_EQUAL_STRING("telemetry", jsonObj["type"]->AsString().c_str());
+
+    // Check payload
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // Verify telemetry data
+    TEST_ASSERT_TRUE(payload.find("battery_level") != payload.end());
+    TEST_ASSERT_EQUAL(85, (int)payload["battery_level"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("voltage") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 3.72f, payload["voltage"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("channel_utilization") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 15.56f, payload["channel_utilization"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("uptime_seconds") != payload.end());
+    TEST_ASSERT_EQUAL(12345, (int)payload["uptime_seconds"]->AsNumber());
+
+    // Note: JSON serialization may not preserve exact 2-decimal formatting due to float precision
+    // We verify the numeric values are correct within tolerance
+
+    delete root;
+}
+
+// Test that telemetry environment metrics are properly serialized
+void test_telemetry_environment_metrics_serialization()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_telemetry_environment_metrics(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_TELEMETRY_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check payload exists
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // Test key fields that should be present in the serializer
+    TEST_ASSERT_TRUE(payload.find("temperature") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 23.56f, payload["temperature"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("relative_humidity") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 65.43f, payload["relative_humidity"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("distance") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 150.29f, payload["distance"]->AsNumber());
+
+    // Note: JSON serialization may have float precision limitations
+    // We focus on verifying numeric accuracy rather than exact string formatting
+
+    delete root;
+}
+
+// Test comprehensive environment metrics coverage
+void test_telemetry_environment_metrics_comprehensive()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_telemetry_environment_metrics(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_TELEMETRY_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check payload exists
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // Check all 15 originally supported fields
+    TEST_ASSERT_TRUE(payload.find("temperature") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("relative_humidity") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("barometric_pressure") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("gas_resistance") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("voltage") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("current") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("iaq") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("distance") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("lux") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("white_lux") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("wind_direction") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("wind_speed") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("wind_gust") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("wind_lull") != payload.end());
+    TEST_ASSERT_TRUE(payload.find("radiation") != payload.end());
+
+    delete root;
+}
+
+// Test for the 7 environment fields that were added to complete coverage
+void test_telemetry_environment_metrics_missing_fields()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_telemetry_environment_metrics(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_TELEMETRY_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check payload exists
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // Check the 7 fields that were previously missing
+    TEST_ASSERT_TRUE(payload.find("ir_lux") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 25.37f, payload["ir_lux"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("uv_lux") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 15.68f, payload["uv_lux"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("weight") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 75.56f, payload["weight"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("rainfall_1h") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 2.57f, payload["rainfall_1h"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("rainfall_24h") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 15.89f, payload["rainfall_24h"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("soil_moisture") != payload.end());
+    TEST_ASSERT_EQUAL(85, (int)payload["soil_moisture"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("soil_temperature") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 18.54f, payload["soil_temperature"]->AsNumber());
+
+    // Note: JSON float serialization may not preserve exact decimal formatting
+    // We verify the values are numerically correct within tolerance
+
+    delete root;
+}
+
+// Test that ALL environment fields are serialized (canary test for forgotten fields)
+// This test will FAIL if a new environment field is added to the protobuf but not to the serializer
+void test_telemetry_environment_metrics_complete_coverage()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_telemetry_environment_metrics_all_fields(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_TELEMETRY_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check payload exists
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // ✅ ALL 22 environment fields MUST be present and correct
+    // If this test fails, it means either:
+    // 1. A new field was added to the protobuf but not to the serializer
+    // 2. The encode_telemetry_environment_metrics_all_fields() function wasn't updated
+
+    // Basic environment (3 fields)
+    TEST_ASSERT_TRUE(payload.find("temperature") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 23.56f, payload["temperature"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("relative_humidity") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 65.43f, payload["relative_humidity"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("barometric_pressure") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 1013.27f, payload["barometric_pressure"]->AsNumber());
+
+    // Gas and air quality (2 fields)
+    TEST_ASSERT_TRUE(payload.find("gas_resistance") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 50.58f, payload["gas_resistance"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("iaq") != payload.end());
+    TEST_ASSERT_EQUAL(120, (int)payload["iaq"]->AsNumber());
+
+    // Power measurements (2 fields)
+    TEST_ASSERT_TRUE(payload.find("voltage") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 3.34f, payload["voltage"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("current") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 0.53f, payload["current"]->AsNumber());
+
+    // Light measurements (4 fields)
+    TEST_ASSERT_TRUE(payload.find("lux") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 450.12f, payload["lux"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("white_lux") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 380.95f, payload["white_lux"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("ir_lux") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 25.37f, payload["ir_lux"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("uv_lux") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 15.68f, payload["uv_lux"]->AsNumber());
+
+    // Distance measurement (1 field)
+    TEST_ASSERT_TRUE(payload.find("distance") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 150.29f, payload["distance"]->AsNumber());
+
+    // Wind measurements (4 fields)
+    TEST_ASSERT_TRUE(payload.find("wind_direction") != payload.end());
+    TEST_ASSERT_EQUAL(180, (int)payload["wind_direction"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("wind_speed") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 5.52f, payload["wind_speed"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("wind_gust") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 8.24f, payload["wind_gust"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("wind_lull") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 2.13f, payload["wind_lull"]->AsNumber());
+
+    // Weight measurement (1 field)
+    TEST_ASSERT_TRUE(payload.find("weight") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 75.56f, payload["weight"]->AsNumber());
+
+    // Radiation measurement (1 field)
+    TEST_ASSERT_TRUE(payload.find("radiation") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 0.13f, payload["radiation"]->AsNumber());
+
+    // Rainfall measurements (2 fields)
+    TEST_ASSERT_TRUE(payload.find("rainfall_1h") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 2.57f, payload["rainfall_1h"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("rainfall_24h") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 15.89f, payload["rainfall_24h"]->AsNumber());
+
+    // Soil measurements (2 fields)
+    TEST_ASSERT_TRUE(payload.find("soil_moisture") != payload.end());
+    TEST_ASSERT_EQUAL(85, (int)payload["soil_moisture"]->AsNumber());
+    TEST_ASSERT_TRUE(payload.find("soil_temperature") != payload.end());
+    TEST_ASSERT_FLOAT_WITHIN(0.01f, 18.54f, payload["soil_temperature"]->AsNumber());
+
+    // Total: 22 environment fields
+    // This test ensures 100% coverage of environment metrics
+
+    // Note: JSON float serialization precision may vary due to the underlying library
+    // The important aspect is that all values are numerically accurate within tolerance
+
+    delete root;
+}
+
+// Test that unset environment fields are not present in JSON
+void test_telemetry_environment_metrics_unset_fields()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_telemetry_environment_metrics_empty(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_TELEMETRY_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check payload exists
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // With completely empty environment metrics, NO fields should be present
+    // Only basic telemetry fields like "time" might be present
+
+    // All 22 environment fields should be absent (none were set)
+    TEST_ASSERT_TRUE(payload.find("temperature") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("relative_humidity") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("barometric_pressure") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("gas_resistance") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("iaq") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("voltage") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("current") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("lux") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("white_lux") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("ir_lux") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("uv_lux") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("distance") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("wind_direction") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("wind_speed") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("wind_gust") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("wind_lull") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("weight") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("radiation") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("rainfall_1h") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("rainfall_24h") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("soil_moisture") == payload.end());
+    TEST_ASSERT_TRUE(payload.find("soil_temperature") == payload.end());
+
+    delete root;
+}

test/test_meshpacket_serializer/ports/test_text_message.cpp

@@ -0,0 +1,42 @@
+#include "../test_helpers.h"
+
+// Test TEXT_MESSAGE_APP port
+void test_text_message_serialization()
+{
+    const char *test_text = "Hello Meshtastic!";
+    meshtastic_MeshPacket packet =
+        create_test_packet(meshtastic_PortNum_TEXT_MESSAGE_APP, (const uint8_t *)test_text, strlen(test_text));
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check basic packet fields
+    TEST_ASSERT_TRUE(jsonObj.find("from") != jsonObj.end());
+    TEST_ASSERT_EQUAL(0x11223344, (uint32_t)jsonObj["from"]->AsNumber());
+
+    TEST_ASSERT_TRUE(jsonObj.find("to") != jsonObj.end());
+    TEST_ASSERT_EQUAL(0x55667788, (uint32_t)jsonObj["to"]->AsNumber());
+
+    TEST_ASSERT_TRUE(jsonObj.find("id") != jsonObj.end());
+    TEST_ASSERT_EQUAL(0x9999, (uint32_t)jsonObj["id"]->AsNumber());
+
+    // Check message type
+    TEST_ASSERT_TRUE(jsonObj.find("type") != jsonObj.end());
+    TEST_ASSERT_EQUAL_STRING("text", jsonObj["type"]->AsString().c_str());
+
+    // Check payload
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+    TEST_ASSERT_TRUE(payload.find("text") != payload.end());
+    TEST_ASSERT_EQUAL_STRING("Hello Meshtastic!", payload["text"]->AsString().c_str());
+
+    delete root;
+}

test/test_meshpacket_serializer/ports/test_waypoint.cpp

@@ -0,0 +1,53 @@
+#include "../test_helpers.h"
+
+static size_t encode_waypoint(uint8_t *buffer, size_t buffer_size)
+{
+    meshtastic_Waypoint waypoint = meshtastic_Waypoint_init_zero;
+    waypoint.id = 12345;
+    waypoint.latitude_i = 374208000;
+    waypoint.longitude_i = -1221981000;
+    waypoint.expire = 1609459200 + 3600; // 1 hour from now
+    strcpy(waypoint.name, "Test Point");
+    strcpy(waypoint.description, "Test waypoint description");
+
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, buffer_size);
+    pb_encode(&stream, &meshtastic_Waypoint_msg, &waypoint);
+    return stream.bytes_written;
+}
+
+// Test WAYPOINT_APP port
+void test_waypoint_serialization()
+{
+    uint8_t buffer[256];
+    size_t payload_size = encode_waypoint(buffer, sizeof(buffer));
+
+    meshtastic_MeshPacket packet = create_test_packet(meshtastic_PortNum_WAYPOINT_APP, buffer, payload_size);
+
+    std::string json = MeshPacketSerializer::JsonSerialize(&packet, false);
+    TEST_ASSERT_TRUE(json.length() > 0);
+
+    JSONValue *root = JSON::Parse(json.c_str());
+    TEST_ASSERT_NOT_NULL(root);
+    TEST_ASSERT_TRUE(root->IsObject());
+
+    JSONObject jsonObj = root->AsObject();
+
+    // Check message type
+    TEST_ASSERT_TRUE(jsonObj.find("type") != jsonObj.end());
+    TEST_ASSERT_EQUAL_STRING("waypoint", jsonObj["type"]->AsString().c_str());
+
+    // Check payload
+    TEST_ASSERT_TRUE(jsonObj.find("payload") != jsonObj.end());
+    TEST_ASSERT_TRUE(jsonObj["payload"]->IsObject());
+
+    JSONObject payload = jsonObj["payload"]->AsObject();
+
+    // Verify waypoint data
+    TEST_ASSERT_TRUE(payload.find("id") != payload.end());
+    TEST_ASSERT_EQUAL(12345, (int)payload["id"]->AsNumber());
+
+    TEST_ASSERT_TRUE(payload.find("name") != payload.end());
+    TEST_ASSERT_EQUAL_STRING("Test Point", payload["name"]->AsString().c_str());
+
+    delete root;
+}

test/test_meshpacket_serializer/test_helpers.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "serialization/JSON.h"
+#include "serialization/MeshPacketSerializer.h"
+#include <Arduino.h>
+#include <meshtastic/mesh.pb.h>
+#include <meshtastic/mqtt.pb.h>
+#include <meshtastic/telemetry.pb.h>
+#include <pb_decode.h>
+#include <pb_encode.h>
+#include <unity.h>
+
+// Helper function to create a test packet with the given port and payload
+static meshtastic_MeshPacket create_test_packet(meshtastic_PortNum port, const uint8_t *payload, size_t payload_size)
+{
+    meshtastic_MeshPacket packet = meshtastic_MeshPacket_init_zero;
+
+    packet.id = 0x9999;
+    packet.from = 0x11223344;
+    packet.to = 0x55667788;
+    packet.channel = 0;
+    packet.hop_limit = 3;
+    packet.want_ack = false;
+    packet.priority = meshtastic_MeshPacket_Priority_UNSET;
+    packet.rx_time = 1609459200;
+    packet.rx_snr = 10.5f;
+    packet.hop_start = 3;
+    packet.rx_rssi = -85;
+    packet.delayed = meshtastic_MeshPacket_Delayed_NO_DELAY;
+
+    // Set decoded variant
+    packet.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
+    packet.decoded.portnum = port;
+    memcpy(packet.decoded.payload.bytes, payload, payload_size);
+    packet.decoded.payload.size = payload_size;
+    packet.decoded.want_response = false;
+    packet.decoded.dest = 0x55667788;
+    packet.decoded.source = 0x11223344;
+    packet.decoded.request_id = 0;
+    packet.decoded.reply_id = 0;
+    packet.decoded.emoji = 0;
+
+    return packet;
+}