[WIP][Testing] custom github action

.devcontainer/Dockerfile

@@ -1,7 +1,7 @@
 # trunk-ignore-all(terrascan/AC_DOCKER_0002): Known terrascan issue
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
-FROM mcr.microsoft.com/devcontainers/cpp:2-debian-12
+FROM mcr.microsoft.com/devcontainers/cpp:1-debian-12
 
 USER root
 

.devcontainer/devcontainer.json

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

.github/actions/build-variant/action.yml

@@ -100,7 +100,7 @@ runs:
       id: version
 
     - name: Store binaries as an artifact
-      uses: actions/upload-artifact@v5
+      uses: actions/upload-artifact@v4
       with:
         name: firmware-${{ inputs.arch }}-${{ inputs.board }}-${{ steps.version.outputs.long }}.zip
         overwrite: true

.github/workflows/build_debian_src.yml

@@ -64,7 +64,7 @@ jobs:
           PKG_VERSION: ${{ steps.version.outputs.deb }}
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           overwrite: true

.github/workflows/build_firmware.yml

@@ -18,9 +18,7 @@ permissions: read-all
 jobs:
   pio-build:
     name: build-${{ inputs.platform }}
-    runs-on: ubuntu-24.04
-    outputs:
-      artifact-id: ${{ steps.upload.outputs.artifact-id }}
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
         with:
@@ -47,7 +45,7 @@ jobs:
 
       - name: Build ${{ inputs.platform }}
         id: build
-        uses: meshtastic/gh-action-firmware@main
+        uses: fifieldt/gh-action-firmware@fifield
         with:
           pio_platform: ${{ inputs.platform }}
           pio_env: ${{ inputs.pio_env }}
@@ -56,8 +54,7 @@ jobs:
           ota_firmware_target: ${{ steps.ota_dir.outputs.tgt || '' }}
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
-        id: upload
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}.zip
           overwrite: true

.github/workflows/build_one_arch.yml

@@ -3,7 +3,6 @@ name: Build One Arch
 on:
   workflow_dispatch:
     inputs:
-      # trunk-ignore(checkov/CKV_GHA_7)
       arch:
         type: choice
         options:
@@ -17,14 +16,11 @@ on:
           - stm32
           - native
 
-permissions: read-all
-
-env:
-  INPUT_ARCH: ${{ github.event.inputs.arch }}
-
 jobs:
   setup:
-    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
       - uses: actions/setup-python@v6
@@ -35,11 +31,23 @@ jobs:
       - name: Generate matrix
         id: jsonStep
         run: |
-          TARGETS=$(./bin/generate_ci_matrix.py $INPUT_ARCH --level extra)
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "selected_arch=$TARGETS" >> $GITHUB_OUTPUT
+          if [[ "$GITHUB_HEAD_REF" == "" ]]; then
+            TARGETS=$(./bin/generate_ci_matrix.py ${{inputs.arch}} extra)
+          else  
+            TARGETS=$(./bin/generate_ci_matrix.py ${{inputs.arch}} pr)
+          fi
+          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF Targets: $TARGETS"
+          echo "${{inputs.arch}}=$(jq -cn --argjson environments "$TARGETS" '{board: $environments}')" >> $GITHUB_OUTPUT
     outputs:
-      selected_arch: ${{ steps.jsonStep.outputs.selected_arch }}
+      esp32: ${{ steps.jsonStep.outputs.esp32 }}
+      esp32s3: ${{ steps.jsonStep.outputs.esp32s3 }}
+      esp32c3: ${{ steps.jsonStep.outputs.esp32c3 }}
+      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
@@ -56,18 +64,101 @@ jobs:
       long: ${{ steps.version.outputs.long }}
       deb: ${{ steps.version.outputs.deb }}
 
-  build:
-    if: ${{ github.event_name != 'workflow_dispatch' }}
+  build-esp32:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'esp32'}}
     needs: [setup, version]
     strategy:
       fail-fast: false
-      matrix:
-        build: ${{ fromJson(needs.setup.outputs.selected_arch) }}
+      matrix: ${{ fromJson(needs.setup.outputs.esp32) }}
     uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.build.board }}
-      platform: ${{ matrix.build.arch }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32
+
+  build-esp32s3:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'esp32s3'}}
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32s3) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32s3
+
+  build-esp32c3:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'esp32c3'}}
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32c3) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c3
+
+  build-esp32c6:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'esp32c6'}}
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32c6) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c6
+
+  build-nrf52840:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'nrf52840'}}
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.nrf52840) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: nrf52840
+
+  build-rp2040:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'rp2040'}}
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.rp2040) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: rp2040
+
+  build-rp2350:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == '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:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'stm32' }}
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.stm32) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: stm32
 
   build-debian-src:
     if: ${{ github.repository == 'meshtastic/firmware' && github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
@@ -88,6 +179,62 @@ jobs:
     if: ${{ !contains(github.ref_name, 'event/') && github.event_name != 'workflow_dispatch' ||  !contains(github.ref_name, 'event/') && inputs.arch == 'native' }}
     uses: ./.github/workflows/test_native.yml
 
+  docker-deb-amd64:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-deb-amd64-tft:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-alp-amd64:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-alp-amd64-tft:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-deb-arm64:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm64
+      runs-on: ubuntu-24.04-arm
+      push: false
+
+  docker-deb-armv7:
+    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm/v7
+      runs-on: ubuntu-24.04-arm
+      push: false
+
   gather-artifacts:
     permissions:
       contents: write
@@ -105,7 +252,18 @@ jobs:
           - rp2350
           - stm32
     runs-on: ubuntu-latest
-    needs: [version, build]
+    needs:
+      [
+        version,
+        build-esp32,
+        build-esp32s3,
+        build-esp32c3,
+        build-esp32c6,
+        build-nrf52840,
+        build-rp2040,
+        build-rp2350,
+        build-stm32,
+      ]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
@@ -113,7 +271,7 @@ jobs:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           path: ./
           pattern: firmware-${{inputs.arch}}-*
@@ -126,7 +284,7 @@ jobs:
         run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -142,7 +300,7 @@ jobs:
             ./Meshtastic_nRF52_factory_erase*.uf2
           retention-days: 30
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -161,7 +319,7 @@ jobs:
         run: zip -j -9 -r ./firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
           overwrite: true
@@ -174,3 +332,169 @@ jobs:
           name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
           description: "Download firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
           github-token: ${{ secrets.GITHUB_TOKEN }}
+
+  release-artifacts:
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'workflow_dispatch' }}
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+    needs:
+      - version
+      - gather-artifacts
+      - build-debian-src
+      - package-pio-deps-native-tft
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: 3.x
+
+      - name: Create release
+        uses: softprops/action-gh-release@v2
+        id: create_release
+        with:
+          draft: true
+          prerelease: true
+          name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
+          tag_name: v${{ needs.version.outputs.long }}
+          body: |
+            Autogenerated by github action, developer should edit as required before publishing...
+
+      - name: Download source deb
+        uses: actions/download-artifact@v5
+        with:
+          pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
+          merge-multiple: true
+          path: ./output/debian-src
+
+      - name: Download `native-tft` pio deps
+        uses: actions/download-artifact@v5
+        with:
+          pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
+          merge-multiple: true
+          path: ./output/pio-deps-native-tft
+
+      - name: Zip Linux sources
+        working-directory: output
+        run: |
+          zip -j -9 -r ./meshtasticd-${{ needs.version.outputs.deb }}-src.zip ./debian-src
+          zip -9 -r ./platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip ./pio-deps-native-tft
+
+      # For diagnostics
+      - name: Display structure of downloaded files
+        run: ls -lR
+
+      - name: Add Linux sources to GtiHub Release
+        # Only run when targeting master branch with workflow_dispatch
+        if: ${{ github.ref_name == 'master' }}
+        run: |
+          gh release upload v${{ needs.version.outputs.long }} ./output/meshtasticd-${{ needs.version.outputs.deb }}-src.zip
+          gh release upload v${{ needs.version.outputs.long }} ./output/platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  release-firmware:
+    strategy:
+      fail-fast: false
+      matrix:
+        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@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: 3.x
+
+      - uses: actions/download-artifact@v5
+        with:
+          pattern: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
+          merge-multiple: true
+          path: ./output
+
+      - name: Display structure of downloaded files
+        run: ls -lR
+
+      - name: Device scripts permissions
+        run: |
+          chmod +x ./output/device-install.sh
+          chmod +x ./output/device-update.sh
+
+      - name: Zip firmware
+        run: zip -j -9 -r ./firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip ./output
+
+      - uses: actions/download-artifact@v5
+        with:
+          name: debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
+          merge-multiple: true
+          path: ./elfs
+
+      - name: Zip debug elfs
+        run: zip -j -9 -r ./debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip ./elfs
+
+      # For diagnostics
+      - name: Display structure of downloaded files
+        run: ls -lR
+
+      - name: Add bins and debug elfs to GitHub Release
+        # Only run when targeting master branch with workflow_dispatch
+        if: ${{ github.ref_name == 'master' }}
+        run: |
+          gh release upload v${{ needs.version.outputs.long }} ./firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
+          gh release upload v${{ needs.version.outputs.long }} ./debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  publish-firmware:
+    runs-on: ubuntu-24.04
+    if: ${{ github.event_name == 'workflow_dispatch' }}
+    needs: [release-firmware, version]
+    env:
+      targets: |-
+        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: 3.x
+
+      - uses: actions/download-artifact@v5
+        with:
+          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
+          merge-multiple: true
+          path: ./publish
+
+      - name: Publish firmware to meshtastic.github.io
+        uses: peaceiris/actions-gh-pages@v4
+        env:
+          # On event/* branches, use the event name as the destination prefix
+          DEST_PREFIX: ${{ contains(github.ref_name, 'event/') && format('{0}/', github.ref_name) || '' }}
+        with:
+          deploy_key: ${{ secrets.DIST_PAGES_DEPLOY_KEY }}
+          external_repository: meshtastic/meshtastic.github.io
+          publish_branch: master
+          publish_dir: ./publish
+          destination_dir: ${{ env.DEST_PREFIX }}firmware-${{ needs.version.outputs.long }}
+          keep_files: true
+          user_name: github-actions[bot]
+          user_email: github-actions[bot]@users.noreply.github.com
+          commit_message: ${{ needs.version.outputs.long }}
+          enable_jekyll: true

.github/workflows/build_one_target.yml

@@ -3,7 +3,6 @@ name: Build One Target
 on:
   workflow_dispatch:
     inputs:
-      # trunk-ignore(checkov/CKV_GHA_7)
       arch:
         type: choice
         options:
@@ -20,13 +19,11 @@ on:
         type: string
         required: false
         description: Choose the target board, e.g. nrf52_promicro_diy_tcxo. If blank, will find available targets.
+
       # find-target:
       #   type: boolean
       #   default: true
       #   description: 'Find the available targets'
-
-permissions: read-all
-
 jobs:
   find-targets:
     if: ${{ inputs.target == '' }}
@@ -43,7 +40,7 @@ jobs:
           - rp2350
           - stm32
 
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
       - uses: actions/setup-python@v6
@@ -54,13 +51,13 @@ jobs:
       - name: Generate matrix
         id: jsonStep
         run: |
-          TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level extra)
+          TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} extra)
           echo "Name: $GITHUB_REF_NAME" >> $GITHUB_STEP_SUMMARY
           echo "Base: $GITHUB_BASE_REF" >> $GITHUB_STEP_SUMMARY
           echo "Arch: ${{matrix.arch}}" >> $GITHUB_STEP_SUMMARY
           echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
           echo "Targets:" >> $GITHUB_STEP_SUMMARY
-          echo $TARGETS >> $GITHUB_STEP_SUMMARY
+          echo $TARGETS | sed 's/[][]//g; s/", "/\n- /g; s/"//g; s/^/- /' >> $GITHUB_STEP_SUMMARY
 
   version:
     if: ${{ inputs.target != '' }}
@@ -78,9 +75,11 @@ jobs:
       long: ${{ steps.version.outputs.long }}
       deb: ${{ steps.version.outputs.deb }}
 
-  build:
+  build-arch:
     if: ${{ inputs.target != '' && inputs.arch != 'native' }}
     needs: [version]
+    strategy:
+      fail-fast: false
     uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
@@ -106,12 +105,70 @@ jobs:
     if: ${{ !contains(github.ref_name, 'event/') && github.event_name != 'workflow_dispatch' ||  !contains(github.ref_name, 'event/') && inputs.arch == 'native' && inputs.target != '' }}
     uses: ./.github/workflows/test_native.yml
 
+  docker-deb-amd64:
+    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-deb-amd64-tft:
+    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-alp-amd64:
+    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-alp-amd64-tft:
+    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-deb-arm64:
+    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm64
+      runs-on: ubuntu-24.04-arm
+      push: false
+
+  docker-deb-armv7:
+    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm/v7
+      runs-on: ubuntu-24.04-arm
+      push: false
+
   gather-artifacts:
     permissions:
       contents: write
       pull-requests: write
+    strategy:
+      fail-fast: false
     runs-on: ubuntu-latest
-    needs: [version, build]
+    needs: [version, build-arch]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
@@ -119,7 +176,7 @@ jobs:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           path: ./
           pattern: firmware-*-*
@@ -132,7 +189,7 @@ jobs:
         run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-${{inputs.target}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -148,7 +205,7 @@ jobs:
             ./Meshtastic_nRF52_factory_erase*.uf2
           retention-days: 30
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           pattern: firmware-*-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -167,7 +224,7 @@ jobs:
         run: zip -j -9 -r ./firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: debug-elfs-${{inputs.target}}-${{ needs.version.outputs.long }}.zip
           overwrite: true
@@ -180,3 +237,159 @@ jobs:
           name: firmware-${{inputs.target}}-${{ needs.version.outputs.long }}
           description: "Download firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
           github-token: ${{ secrets.GITHUB_TOKEN }}
+
+  release-artifacts:
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'workflow_dispatch' && inputs.target != ''}}
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+    needs:
+      - version
+      - gather-artifacts
+      - build-debian-src
+      - package-pio-deps-native-tft
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: 3.x
+
+      - name: Create release
+        uses: softprops/action-gh-release@v2
+        id: create_release
+        with:
+          draft: true
+          prerelease: true
+          name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
+          tag_name: v${{ needs.version.outputs.long }}
+          body: |
+            Autogenerated by github action, developer should edit as required before publishing...
+
+      - name: Download source deb
+        uses: actions/download-artifact@v5
+        with:
+          pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
+          merge-multiple: true
+          path: ./output/debian-src
+
+      - name: Download `native-tft` pio deps
+        uses: actions/download-artifact@v5
+        with:
+          pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
+          merge-multiple: true
+          path: ./output/pio-deps-native-tft
+
+      - name: Zip Linux sources
+        working-directory: output
+        run: |
+          zip -j -9 -r ./meshtasticd-${{ needs.version.outputs.deb }}-src.zip ./debian-src
+          zip -9 -r ./platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip ./pio-deps-native-tft
+
+      # For diagnostics
+      - name: Display structure of downloaded files
+        run: ls -lR
+
+      - name: Add Linux sources to GtiHub Release
+        # Only run when targeting master branch with workflow_dispatch
+        if: ${{ github.ref_name == 'master' }}
+        run: |
+          gh release upload v${{ needs.version.outputs.long }} ./output/meshtasticd-${{ needs.version.outputs.deb }}-src.zip
+          gh release upload v${{ needs.version.outputs.long }} ./output/platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  release-firmware:
+    strategy:
+      fail-fast: false
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'workflow_dispatch' && inputs.target != ''}}
+    needs: [release-artifacts, version]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: 3.x
+
+      - uses: actions/download-artifact@v5
+        with:
+          pattern: firmware-*-${{ needs.version.outputs.long }}
+          merge-multiple: true
+          path: ./output
+
+      - name: Display structure of downloaded files
+        run: ls -lR
+
+      - name: Device scripts permissions
+        run: |
+          chmod +x ./output/device-install.sh
+          chmod +x ./output/device-update.sh
+
+      - name: Zip firmware
+        run: zip -j -9 -r ./firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip ./output
+
+      - uses: actions/download-artifact@v5
+        with:
+          pattern: debug-elfs-*-${{ needs.version.outputs.long }}.zip
+          merge-multiple: true
+          path: ./elfs
+
+      - name: Zip debug elfs
+        run: zip -j -9 -r ./debug-elfs-${{inputs.target}}-${{ needs.version.outputs.long }}.zip ./elfs
+
+      # For diagnostics
+      - name: Display structure of downloaded files
+        run: ls -lR
+
+      - name: Add bins and debug elfs to GitHub Release
+        # Only run when targeting master branch with workflow_dispatch
+        if: ${{ github.ref_name == 'master' }}
+        run: |
+          gh release upload v${{ needs.version.outputs.long }} ./firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip
+          gh release upload v${{ needs.version.outputs.long }} ./debug-elfs-${{inputs.target}}-${{ needs.version.outputs.long }}.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  publish-firmware:
+    runs-on: ubuntu-24.04
+    if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware' && inputs.target != '' }}
+    needs: [release-firmware, version]
+    env:
+      targets: |-
+        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: 3.x
+
+      - uses: actions/download-artifact@v5
+        with:
+          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
+          merge-multiple: true
+          path: ./publish
+
+      - name: Publish firmware to meshtastic.github.io
+        uses: peaceiris/actions-gh-pages@v4
+        env:
+          # On event/* branches, use the event name as the destination prefix
+          DEST_PREFIX: ${{ contains(github.ref_name, 'event/') && format('{0}/', github.ref_name) || '' }}
+        with:
+          deploy_key: ${{ secrets.DIST_PAGES_DEPLOY_KEY }}
+          external_repository: meshtastic/meshtastic.github.io
+          publish_branch: master
+          publish_dir: ./publish
+          destination_dir: ${{ env.DEST_PREFIX }}firmware-${{ needs.version.outputs.long }}
+          keep_files: true
+          user_name: github-actions[bot]
+          user_email: github-actions[bot]@users.noreply.github.com
+          commit_message: ${{ needs.version.outputs.long }}
+          enable_jekyll: true

.github/workflows/main_matrix.yml

@@ -19,6 +19,7 @@ on:
       - master
       - develop
       - event/*
+      - self-hosted-testing
     paths-ignore:
       - "**.md"
       #- "**.yml"
@@ -27,13 +28,21 @@ on:
 
 jobs:
   setup:
+    if: github.repository == 'meshtastic/firmware'
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         arch:
-          - all
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
           - check
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
       - uses: actions/setup-python@v6
@@ -41,22 +50,33 @@ jobs:
           python-version: 3.x
           cache: pip
       - run: pip install -U platformio
+      - name: Uncomment build epoch
+        shell: bash
+        run: |
+          sed -i 's/#-DBUILD_EPOCH=$UNIX_TIME/-DBUILD_EPOCH=$UNIX_TIME/' platformio.ini
       - name: Generate matrix
         id: jsonStep
         run: |
           if [[ "$GITHUB_HEAD_REF" == "" ]]; then
             TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
           else  
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level pr)
+            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} pr)
           fi
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "${{matrix.arch}}=$TARGETS" >> $GITHUB_OUTPUT
-          echo "$TARGETS" >> $GITHUB_STEP_SUMMARY
+          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
     outputs:
-      all: ${{ steps.jsonStep.outputs.all }}
+      esp32: ${{ steps.jsonStep.outputs.esp32 }}
+      esp32s3: ${{ steps.jsonStep.outputs.esp32s3 }}
+      esp32c3: ${{ steps.jsonStep.outputs.esp32c3 }}
+      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:
+    if: github.repository == 'meshtastic/firmware'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
@@ -75,8 +95,7 @@ jobs:
     needs: setup
     strategy:
       fail-fast: false
-      matrix:
-        check: ${{ fromJson(needs.setup.outputs.check) }}
+      matrix: ${{ fromJson(needs.setup.outputs.check) }}
 
     runs-on: ubuntu-latest
     if: ${{ github.event_name != 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
@@ -85,20 +104,96 @@ jobs:
       - name: Build base
         id: base
         uses: ./.github/actions/setup-base
-      - name: Check ${{ matrix.check.board }}
-        run: bin/check-all.sh ${{ matrix.check.board }}
+      - name: Check ${{ matrix.board }}
+        run: bin/check-all.sh ${{ matrix.board }}
 
-  build:
+  build-esp32:
     needs: [setup, version]
     strategy:
       fail-fast: false
-      matrix:
-        build: ${{ fromJson(needs.setup.outputs.all) }}
+      matrix: ${{ fromJson(needs.setup.outputs.esp32) }}
     uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.build.board }}
-      platform: ${{ matrix.build.platform }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32
+
+  build-esp32s3:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32s3) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32s3
+
+  build-esp32c3:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32c3) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c3
+
+  build-esp32c6:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32c6) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c6
+
+  build-nrf52840:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.nrf52840) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: nrf52840
+
+  build-rp2040:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.rp2040) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      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_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: stm32
 
   build-debian-src:
     if: github.repository == 'meshtastic/firmware'
@@ -109,7 +204,7 @@ jobs:
     secrets: inherit
 
   package-pio-deps-native-tft:
-    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name == 'workflow_dispatch' }}
+    if: ${{ github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/package_pio_deps.yml
     with:
       pio_env: native-tft
@@ -119,26 +214,60 @@ jobs:
     if: ${{ !contains(github.ref_name, 'event/') && github.repository == 'meshtastic/firmware' }}
     uses: ./.github/workflows/test_native.yml
 
-  docker:
-    strategy:
-      fail-fast: false
-      matrix:
-        distro: [debian, alpine]
-        platform: [linux/amd64, linux/arm64, linux/arm/v7]
-        pio_env: [native, native-tft]
-        exclude:
-          - distro: alpine
-            platform: linux/arm/v7
-          - pio_env: native-tft
-            platform: linux/arm64
-          - pio_env: native-tft
-            platform: linux/arm/v7
+  docker-deb-amd64:
+    if: github.repository == 'meshtastic/firmware'
     uses: ./.github/workflows/docker_build.yml
     with:
-      distro: ${{ matrix.distro }}
-      platform: ${{ matrix.platform }}
-      runs-on: ${{ contains(matrix.platform, 'arm') && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
-      pio_env: ${{ matrix.pio_env }}
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-deb-amd64-tft:
+    if: github.repository == 'meshtastic/firmware'
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-alp-amd64:
+    if: github.repository == 'meshtastic/firmware'
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-alp-amd64-tft:
+    if: github.repository == 'meshtastic/firmware'
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-deb-arm64:
+    if: github.repository == 'meshtastic/firmware'
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm64
+      runs-on: ubuntu-24.04-arm
+      push: false
+
+  docker-deb-armv7:
+    if: github.repository == 'meshtastic/firmware'
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm/v7
+      runs-on: ubuntu-24.04-arm
       push: false
 
   gather-artifacts:
@@ -160,7 +289,18 @@ jobs:
           - rp2350
           - stm32
     runs-on: ubuntu-latest
-    needs: [version, build]
+    needs:
+      [
+        version,
+        build-esp32,
+        build-esp32s3,
+        build-esp32c3,
+        build-esp32c6,
+        build-nrf52840,
+        build-rp2040,
+        build-rp2350,
+        build-stm32,
+      ]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
@@ -168,7 +308,7 @@ jobs:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           path: ./
           pattern: firmware-${{matrix.arch}}-*
@@ -181,7 +321,7 @@ jobs:
         run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -197,7 +337,7 @@ jobs:
             ./Meshtastic_nRF52_factory_erase*.uf2
           retention-days: 30
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -216,7 +356,7 @@ jobs:
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
           overwrite: true
@@ -261,14 +401,14 @@ jobs:
             Autogenerated by github action, developer should edit as required before publishing...
 
       - name: Download source deb
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
           merge-multiple: true
           path: ./output/debian-src
 
       - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -318,7 +458,7 @@ jobs:
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -335,7 +475,7 @@ jobs:
       - name: Zip firmware
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
           merge-multiple: true
@@ -373,7 +513,7 @@ jobs:
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
           merge-multiple: true

.github/workflows/merge_queue.yml

@@ -7,15 +7,25 @@ on:
   # Merge group is a special trigger that is used to trigger the workflow when a merge group is created.
   merge_group:
 
+env:
+  FAIL_FAST_PER_ARCH: true
+
 jobs:
   setup:
     strategy:
       fail-fast: true
       matrix:
         arch:
-          - all
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
           - check
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
       - uses: actions/setup-python@v6
@@ -29,12 +39,19 @@ jobs:
           if [[ "$GITHUB_HEAD_REF" == "" ]]; then
             TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
           else  
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level pr)
+            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} pr)
           fi
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "${{matrix.arch}}=$TARGETS" >> $GITHUB_OUTPUT
+          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
     outputs:
-      all: ${{ steps.jsonStep.outputs.all }}
+      esp32: ${{ steps.jsonStep.outputs.esp32 }}
+      esp32s3: ${{ steps.jsonStep.outputs.esp32s3 }}
+      esp32c3: ${{ steps.jsonStep.outputs.esp32c3 }}
+      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:
@@ -56,8 +73,7 @@ jobs:
     needs: setup
     strategy:
       fail-fast: true
-      matrix:
-        check: ${{ fromJson(needs.setup.outputs.check) }}
+      matrix: ${{ fromJson(needs.setup.outputs.check) }}
 
     runs-on: ubuntu-latest
     if: ${{ github.event_name != 'workflow_dispatch' }}
@@ -66,19 +82,96 @@ jobs:
       - name: Build base
         id: base
         uses: ./.github/actions/setup-base
-      - name: Check ${{ matrix.check.board }}
-        run: bin/check-all.sh ${{ matrix.check.board }}
+      - name: Check ${{ matrix.board }}
+        run: bin/check-all.sh ${{ matrix.board }}
 
-  build:
+  build-esp32:
     needs: [setup, version]
     strategy:
-      matrix:
-        build: ${{ fromJson(needs.setup.outputs.all) }}
+      fail-fast: ${{ vars.FAIL_FAST_PER_ARCH == true }}
+      matrix: ${{ fromJson(needs.setup.outputs.esp32) }}
     uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.build.board }}
-      platform: ${{ matrix.build.platform }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32
+
+  build-esp32s3:
+    needs: [setup, version]
+    strategy:
+      fail-fast: ${{ vars.FAIL_FAST_PER_ARCH == true }}
+      matrix: ${{ fromJson(needs.setup.outputs.esp32s3) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32s3
+
+  build-esp32c3:
+    needs: [setup, version]
+    strategy:
+      fail-fast: ${{ vars.FAIL_FAST_PER_ARCH == true }}
+      matrix: ${{ fromJson(needs.setup.outputs.esp32c3) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c3
+
+  build-esp32c6:
+    needs: [setup, version]
+    strategy:
+      fail-fast: ${{ vars.FAIL_FAST_PER_ARCH == true }}
+      matrix: ${{ fromJson(needs.setup.outputs.esp32c6) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c6
+
+  build-nrf52840:
+    needs: [setup, version]
+    strategy:
+      fail-fast: ${{ vars.FAIL_FAST_PER_ARCH == true }}
+      matrix: ${{ fromJson(needs.setup.outputs.nrf52840) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: nrf52840
+
+  build-rp2040:
+    needs: [setup, version]
+    strategy:
+      fail-fast: ${{ vars.FAIL_FAST_PER_ARCH == true }}
+      matrix: ${{ fromJson(needs.setup.outputs.rp2040) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: rp2040
+
+  build-rp2350:
+    needs: [setup, version]
+    strategy:
+      fail-fast: ${{ vars.FAIL_FAST_PER_ARCH == true }}
+      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: ${{ vars.FAIL_FAST_PER_ARCH == true }}
+      matrix: ${{ fromJson(needs.setup.outputs.stm32) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: stm32
 
   build-debian-src:
     if: github.repository == 'meshtastic/firmware'
@@ -99,26 +192,54 @@ jobs:
     if: ${{ !contains(github.ref_name, 'event/') }}
     uses: ./.github/workflows/test_native.yml
 
-  docker:
-    strategy:
-      fail-fast: false
-      matrix:
-        distro: [debian, alpine]
-        platform: [linux/amd64, linux/arm64, linux/arm/v7]
-        pio_env: [native, native-tft]
-        exclude:
-          - distro: alpine
-            platform: linux/arm/v7
-          - pio_env: native-tft
-            platform: linux/arm64
-          - pio_env: native-tft
-            platform: linux/arm/v7
+  docker-deb-amd64:
     uses: ./.github/workflows/docker_build.yml
     with:
-      distro: ${{ matrix.distro }}
-      platform: ${{ matrix.platform }}
-      runs-on: ${{ contains(matrix.platform, 'arm') && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
-      pio_env: ${{ matrix.pio_env }}
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-deb-amd64-tft:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-alp-amd64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-alp-amd64-tft:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-deb-arm64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm64
+      runs-on: ubuntu-24.04-arm
+      push: false
+
+  docker-deb-armv7:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm/v7
+      runs-on: ubuntu-24.04-arm
       push: false
 
   gather-artifacts:
@@ -139,7 +260,18 @@ jobs:
           - rp2350
           - stm32
     runs-on: ubuntu-latest
-    needs: [version, build]
+    needs:
+      [
+        version,
+        build-esp32,
+        build-esp32s3,
+        build-esp32c3,
+        build-esp32c6,
+        build-nrf52840,
+        build-rp2040,
+        build-rp2350,
+        build-stm32,
+      ]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
@@ -147,7 +279,7 @@ jobs:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           path: ./
           pattern: firmware-${{matrix.arch}}-*
@@ -160,7 +292,7 @@ jobs:
         run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -176,7 +308,7 @@ jobs:
             ./Meshtastic_nRF52_factory_erase*.uf2
           retention-days: 30
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -195,7 +327,7 @@ jobs:
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
           overwrite: true
@@ -240,14 +372,14 @@ jobs:
             Autogenerated by github action, developer should edit as required before publishing...
 
       - name: Download source deb
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
           merge-multiple: true
           path: ./output/debian-src
 
       - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -297,7 +429,7 @@ jobs:
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -314,7 +446,7 @@ jobs:
       - name: Zip firmware
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
           merge-multiple: true
@@ -352,7 +484,7 @@ jobs:
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
           merge-multiple: true

.github/workflows/package_obs.yml

@@ -58,7 +58,7 @@ jobs:
         id: version
 
       - name: Download artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           merge-multiple: true

.github/workflows/package_pio_deps.yml

@@ -56,7 +56,7 @@ jobs:
           PLATFORMIO_CORE_DIR: pio/core
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: platformio-deps-${{ inputs.pio_env }}-${{ steps.version.outputs.long }}
           overwrite: true

.github/workflows/package_ppa.yml

@@ -60,7 +60,7 @@ jobs:
         id: version
 
       - name: Download artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           merge-multiple: true

.github/workflows/pr_tests.yml

@@ -50,7 +50,7 @@ jobs:
 
       - name: Download test artifacts
         if: needs.native-tests.result != 'skipped'
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           name: platformio-test-report-${{ steps.version.outputs.long }}.zip
           merge-multiple: true

.github/workflows/sec_sast_semgrep_cron.yml

@@ -33,7 +33,7 @@ jobs:
 
       # step 3
       - name: save report as pipeline artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: report.sarif
           overwrite: true
@@ -41,7 +41,7 @@ jobs:
 
       # step 4
       - name: publish code scanning alerts
-        uses: github/codeql-action/upload-sarif@v4
+        uses: github/codeql-action/upload-sarif@v3
         with:
           sarif_file: report.sarif
           category: semgrep

.github/workflows/stale_bot.yml

@@ -17,10 +17,8 @@ jobs:
 
     steps:
       - name: Stale PR+Issues
-        uses: actions/stale@v10.1.0
+        uses: actions/stale@v10.0.0
         with:
           days-before-stale: 45
-          stale-issue-message: This issue has not had any comment or update in the last month. If it is still relevant, please post update comments. If no comments are made, this issue will be closed automagically in 7 days.
-          close-issue-message: This issue has not had any comment since the last notice. It has been closed automatically. If this is incorrect, or the issue becomes relevant again, please request that it is reopened.
-          exempt-issue-labels: pinned,3.0,triaged,backlog
-          exempt-pr-labels: pinned,3.0,triaged,backlog
+          exempt-issue-labels: pinned,3.0
+          exempt-pr-labels: pinned,3.0

.github/workflows/test_native.yml

@@ -40,7 +40,7 @@ jobs:
 
       - name: Integration test
         run: |
-          .pio/build/coverage/program -s &
+          .pio/build/coverage/program &
           PID=$!
           timeout 20 bash -c "until ls -al /proc/$PID/fd | grep socket; do sleep 1; done"
           echo "Simulator started, launching python test..."
@@ -59,7 +59,7 @@ jobs:
         id: version
 
       - name: Save coverage information
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         if: always() # run this step even if previous step failed
         with:
           name: lcov-coverage-info-native-simulator-test-${{ steps.version.outputs.long }}.zip
@@ -94,7 +94,7 @@ jobs:
 
       - name: Save test results
         if: always() # run this step even if previous step failed
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: platformio-test-report-${{ steps.version.outputs.long }}.zip
           overwrite: true
@@ -108,7 +108,7 @@ jobs:
           sed -i -e "s#${PWD}#.#" coverage_tests.info # Make paths relative.
 
       - name: Save coverage information
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         if: always() # run this step even if previous step failed
         with:
           name: lcov-coverage-info-native-platformio-tests-${{ steps.version.outputs.long }}.zip
@@ -137,7 +137,7 @@ jobs:
         id: version
 
       - name: Download test artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           name: platformio-test-report-${{ steps.version.outputs.long }}.zip
           merge-multiple: true
@@ -150,7 +150,7 @@ jobs:
           reporter: java-junit
 
       - name: Download coverage artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           pattern: lcov-coverage-info-native-*-${{ steps.version.outputs.long }}.zip
           path: code-coverage-report
@@ -163,7 +163,7 @@ jobs:
           genhtml --quiet --legend --prefix "${PWD}" code-coverage-report/coverage_src.info --output-directory code-coverage-report
 
       - name: Save Code Coverage Report
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: code-coverage-report-${{ steps.version.outputs.long }}.zip
           path: code-coverage-report

.github/workflows/tests.yml

@@ -47,9 +47,9 @@ jobs:
           pio upgrade
 
       - name: Setup Node
-        uses: actions/setup-node@v6
+        uses: actions/setup-node@v5
         with:
-          node-version: 24
+          node-version: 22
 
       - name: Setup pnpm
         uses: pnpm/action-setup@v4

.trunk/trunk.yaml

@@ -4,31 +4,31 @@ cli:
 plugins:
   sources:
     - id: trunk
-      ref: v1.7.3
+      ref: v1.7.2
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.490
-    - renovate@41.173.1
+    - checkov@3.2.471
+    - renovate@41.115.6
     - prettier@3.6.2
-    - trufflehog@3.90.13
+    - trufflehog@3.90.6
     - yamllint@1.37.1
     - bandit@1.8.6
-    - trivy@0.67.2
+    - trivy@0.66.0
     - taplo@0.10.0
-    - ruff@0.14.3
-    - isort@7.0.0
+    - ruff@0.13.0
+    - isort@6.0.1
     - markdownlint@0.45.0
     - oxipng@9.1.5
     - svgo@4.0.0
-    - actionlint@1.7.8
+    - actionlint@1.7.7
     - flake8@7.3.0
-    - hadolint@2.14.0
+    - hadolint@2.13.1
     - shfmt@3.6.0
     - shellcheck@0.11.0
-    - black@25.9.0
+    - black@25.1.0
     - git-diff-check
-    - gitleaks@8.29.0
+    - gitleaks@8.28.0
     - clang-format@16.0.3
   ignore:
     - linters: [ALL]

Dockerfile

@@ -3,7 +3,7 @@
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
-FROM python:3.14-slim-trixie AS builder
+FROM python:3.13-slim-trixie AS builder
 ARG PIO_ENV=native
 ENV DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC

alpine.Dockerfile

@@ -3,7 +3,7 @@
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
-FROM python:3.14-alpine3.22 AS builder
+FROM python:3.13-alpine3.22 AS builder
 ARG PIO_ENV=native
 ENV PIP_ROOT_USER_ACTION=ignore
 

arch/esp32/esp32.ini

@@ -31,13 +31,11 @@ build_flags =
   -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
   -DAXP_DEBUG_PORT=Serial
   -DCONFIG_BT_NIMBLE_ENABLED
-  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
   -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
   -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
   -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
   -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
   -DSERIAL_BUFFER_SIZE=4096
-  -DSERIAL_HAS_ON_RECEIVE
   -DLIBPAX_ARDUINO
   -DLIBPAX_WIFI
   -DLIBPAX_BLE
@@ -57,7 +55,7 @@ lib_deps =
   # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
   https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
   # renovate: datasource=github-tags depName=XPowersLib packageName=lewisxhe/XPowersLib
-  https://github.com/lewisxhe/XPowersLib/archive/v0.3.1.zip
+  https://github.com/lewisxhe/XPowersLib/archive/v0.3.0.zip
   # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
   https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto

arch/esp32/esp32c6.ini

@@ -28,7 +28,7 @@ lib_deps =
   ${environmental_extra.lib_deps}
   ${radiolib_base.lib_deps}
   # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
-  lewisxhe/XPowersLib@0.3.1
+  lewisxhe/XPowersLib@0.3.0
   # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
   https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto

arch/portduino/portduino.ini

@@ -2,7 +2,7 @@
 [portduino_base]
 platform =
   # renovate: datasource=git-refs depName=platform-native packageName=https://github.com/meshtastic/platform-native gitBranch=develop
-  https://github.com/meshtastic/platform-native/archive/f566d364204416cdbf298e349213f7d551f793d9.zip
+  https://github.com/meshtastic/platform-native/archive/c490bcd019e0658404088a61b96e653c9da22c45.zip
 framework = arduino
 
 build_src_filter = 

bin/device-install.bat

@@ -15,12 +15,12 @@ SET "LOGCOUNTER=0"
 SET "BPS_RESET=0"
 
 @REM FIXME: Determine mcu from PlatformIO variant, this is unmaintainable.
-SET "S3=s3 v3 t-deck wireless-paper wireless-tracker station-g2 unphone t-eth-elite tlora-pager mesh-tab dreamcatcher ESP32-S3-Pico seeed-sensecap-indicator heltec_capsule_sensor_v3 vision-master icarus tracksenger elecrow-adv heltec-v4"
+SET "S3=s3 v3 t-deck wireless-paper wireless-tracker station-g2 unphone t-eth-elite tlora-pager mesh-tab dreamcatcher ESP32-S3-Pico seeed-sensecap-indicator heltec_capsule_sensor_v3 vision-master icarus tracksenger elecrow-adv"
 SET "C3=esp32c3"
 @REM FIXME: Determine flash size from PlatformIO variant, this is unmaintainable.
 SET "BIGDB_8MB=crowpanel-esp32s3 heltec_capsule_sensor_v3 heltec-v3 heltec-vision-master-e213 heltec-vision-master-e290 heltec-vision-master-t190 heltec-wireless-paper heltec-wireless-tracker heltec-wsl-v3 icarus seeed-xiao-s3 tbeam-s3-core tracksenger"
 SET "MUIDB_8MB=picomputer-s3 unphone seeed-sensecap-indicator"
-SET "BIGDB_16MB=t-deck mesh-tab t-energy-s3 dreamcatcher ESP32-S3-Pico m5stack-cores3 station-g2 t-eth-elite tlora-pager t-watch-s3 elecrow-adv heltec-v4"
+SET "BIGDB_16MB=t-deck mesh-tab t-energy-s3 dreamcatcher ESP32-S3-Pico m5stack-cores3 station-g2 t-eth-elite tlora-pager t-watch-s3 elecrow-adv"
 
 GOTO getopts
 :help

bin/device-install.sh

@@ -31,23 +31,21 @@ MUIDB_8MB=(
     "seeed-sensecap-indicator"
 )
 BIGDB_16MB=(
-    "dreamcatcher"
-    "elecrow-adv"
-    "ESP32-S3-Pico"
-    "heltec-v4"
-    "m5stack-cores3"
-    "mesh-tab"
-    "station-g2"
     "t-deck"
+    "mesh-tab"
     "t-energy-s3"
+    "dreamcatcher"
+    "ESP32-S3-Pico"
+    "m5stack-cores3"
+    "station-g2"
     "t-eth-elite"
-    "t-watch-s3"
     "tlora-pager"
+    "t-watch-s3"
+    "elecrow-adv"
 )
 S3_VARIANTS=(
     "s3"
     "-v3"
-    "-v4"
     "t-deck"
     "wireless-paper"
     "wireless-tracker"

bin/generate_ci_matrix.py

@@ -1,32 +1,28 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 
 """Generate the CI matrix."""
 
-import argparse
 import json
+import sys
+import random
 import re
 from platformio.project.config import ProjectConfig
 
-parser = argparse.ArgumentParser(description="Generate the CI matrix")
-parser.add_argument("platform", help="Platform to build for")
-parser.add_argument(
-  "--level",
-  choices=["extra", "pr"],
-  nargs="*",
-  default=[],
-  help="Board level to build for (omit for full release boards)",
-)
-args = parser.parse_args()
+options = sys.argv[1:]
 
 outlist = []
 
+if len(options) < 1:
+  print(json.dumps(outlist))
+  exit(1)
+
 cfg = ProjectConfig.get_instance()
 pio_envs = cfg.envs()
 
 # Gather all PlatformIO environments for filtering later
 all_envs = []
 for pio_env in pio_envs:
-  env_build_flags = cfg.get(f"env:{pio_env}", "build_flags")
+  env_build_flags = cfg.get(f"env:{pio_env}", 'build_flags')
   env_platform = None
   for flag in env_build_flags:
     # Extract the platform from the build flags
@@ -41,35 +37,36 @@ for pio_env in pio_envs:
     exit(1)
   # Store env details as a dictionary, and add to 'all_envs' list
   env = {
-    "ci": {"board": pio_env, "platform": env_platform},
-    "board_level": cfg.get(f"env:{pio_env}", "board_level", default=None),
-    "board_check": bool(cfg.get(f"env:{pio_env}", "board_check", default=False)),
+    'name': pio_env,
+    'platform': env_platform,
+    'board_level': cfg.get(f"env:{pio_env}", 'board_level', default=None),
+    'board_check': bool(cfg.get(f"env:{pio_env}", 'board_check', default=False))
   }
   all_envs.append(env)
 
 # Filter outputs based on options
 # Check is mutually exclusive with other options (except 'pr')
-if "check" in args.platform:
+if "check" in options:
   for env in all_envs:
-    if env["board_check"]:
-      if "pr" in args.level:
-        if env["board_level"] == "pr":
-          outlist.append(env["ci"])
+    if env['board_check']:
+      if "pr" in options:
+        if env['board_level'] == 'pr':
+          outlist.append(env['name'])
       else:
-        outlist.append(env["ci"])
+        outlist.append(env['name'])
 # Filter (non-check) builds by platform
 else:
   for env in all_envs:
-    if args.platform == env["ci"]["platform"] or args.platform == "all":
+    if options[0] == env['platform']:
       # Always include board_level = 'pr'
-      if env["board_level"] == "pr":
-        outlist.append(env["ci"])
+      if env['board_level'] == 'pr':
+        outlist.append(env['name'])
       # Include board_level = 'extra' when requested
-      elif "extra" in args.level and env["board_level"] == "extra":
-        outlist.append(env["ci"])
+      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 args.level and not env["board_level"]:
-        outlist.append(env["ci"])
+      elif "pr" not in options and not env['board_level']:
+        outlist.append(env['name'])
 
 # Return as a JSON list
 print(json.dumps(outlist))

bin/kill-github-actions.sh

@@ -1,116 +0,0 @@
-#!/bin/bash
-
-# Script to cancel all running GitHub Actions workflows
-# Requires GitHub CLI (gh) to be installed and authenticated
-
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# Function to print colored output
-print_status() {
-    echo -e "${GREEN}[INFO]${NC} $1"
-}
-
-print_warning() {
-    echo -e "${YELLOW}[WARN]${NC} $1"
-}
-
-print_error() {
-    echo -e "${RED}[ERROR]${NC} $1"
-}
-
-# Check if gh CLI is installed
-if ! command -v gh &> /dev/null; then
-    print_error "GitHub CLI (gh) is not installed. Please install it first:"
-    echo "  brew install gh"
-    echo "  Or visit: https://cli.github.com/"
-    exit 1
-fi
-
-# Check if authenticated
-if ! gh auth status &> /dev/null; then
-    print_error "GitHub CLI is not authenticated. Please run:"
-    echo "  gh auth login"
-    exit 1
-fi
-
-# Get repository info
-REPO=$(gh repo view --json owner,name -q '.owner.login + "/" + .name')
-if [[ -z "$REPO" ]]; then
-    print_error "Could not determine repository. Make sure you're in a GitHub repository."
-    exit 1
-fi
-
-print_status "Working with repository: $REPO"
-
-# Get all active workflows (both queued and in-progress)
-print_status "Fetching active workflows (queued and in-progress)..."
-QUEUED_WORKFLOWS=$(gh run list --status queued --json databaseId,displayTitle,headBranch,status --limit 100)
-IN_PROGRESS_WORKFLOWS=$(gh run list --status in_progress --json databaseId,displayTitle,headBranch,status --limit 100)
-
-# Combine both lists
-ALL_WORKFLOWS=$(echo "$QUEUED_WORKFLOWS $IN_PROGRESS_WORKFLOWS" | jq -s 'add | unique_by(.databaseId)')
-
-if [[ "$ALL_WORKFLOWS" == "[]" ]]; then
-    print_status "No active workflows found."
-    exit 0
-fi
-
-# Parse and display active workflows
-echo
-print_warning "Found active workflows:"
-echo "$ALL_WORKFLOWS" | jq -r '.[] | "  - \(.displayTitle) (Branch: \(.headBranch), Status: \(.status), ID: \(.databaseId))"'
-
-echo
-read -p "Do you want to cancel ALL these workflows? (y/N): " -n 1 -r
-echo
-
-if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-    print_status "Cancelled by user."
-    exit 0
-fi
-
-# Cancel each workflow
-print_status "Cancelling workflows..."
-CANCELLED_COUNT=0
-FAILED_COUNT=0
-
-while IFS= read -r WORKFLOW_ID; do
-    if [[ -n "$WORKFLOW_ID" ]]; then
-        print_status "Cancelling workflow ID: $WORKFLOW_ID"
-        if gh run cancel "$WORKFLOW_ID" 2>/dev/null; then
-            ((CANCELLED_COUNT++))
-        else
-            print_error "Failed to cancel workflow ID: $WORKFLOW_ID"
-            ((FAILED_COUNT++))
-        fi
-    fi
-done < <(echo "$ALL_WORKFLOWS" | jq -r '.[].databaseId')
-
-echo
-print_status "Summary:"
-echo "  - Cancelled: $CANCELLED_COUNT workflows"
-if [[ $FAILED_COUNT -gt 0 ]]; then
-    echo "  - Failed: $FAILED_COUNT workflows"
-fi
-
-print_status "Done!"
-
-# Optional: Show remaining active workflows
-echo
-print_status "Checking for any remaining active workflows..."
-REMAINING_QUEUED=$(gh run list --status queued --json databaseId --limit 10)
-REMAINING_IN_PROGRESS=$(gh run list --status in_progress --json databaseId --limit 10)
-REMAINING_ALL=$(echo "$REMAINING_QUEUED $REMAINING_IN_PROGRESS" | jq -s 'add | unique_by(.databaseId)')
-
-if [[ "$REMAINING_ALL" == "[]" ]]; then
-    print_status "All workflows successfully cancelled."
-else
-    REMAINING_COUNT=$(echo "$REMAINING_ALL" | jq '. | length')
-    print_warning "Still $REMAINING_COUNT workflows active (may take a moment to update status)"
-fi

bin/org.meshtastic.meshtasticd.metainfo.xml

@@ -87,15 +87,6 @@
   </screenshots>
 
   <releases>
-    <release version="2.7.13" date="2025-10-11">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.13</url>
-    </release>
-    <release version="2.7.12" date="2025-10-01">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.12</url>
-    </release>
-    <release version="2.7.11" date="2025-09-24">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.11</url>
-    </release>
     <release version="2.7.10" date="2025-09-18">
       <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.10</url>
     </release>

bin/platformio-custom.py

@@ -86,7 +86,7 @@ if platform.name == "espressif32":
 
 if platform.name == "nordicnrf52":
     env.AddPostAction("$BUILD_DIR/${PROGNAME}.hex",
-                      env.VerboseAction(f"\"{sys.executable}\" ./bin/uf2conv.py \"$BUILD_DIR/firmware.hex\" -c -f 0xADA52840 -o \"$BUILD_DIR/firmware.uf2\"",
+                      env.VerboseAction(f"\"{sys.executable}\" ./bin/uf2conv.py $BUILD_DIR/firmware.hex -c -f 0xADA52840 -o $BUILD_DIR/firmware.uf2",
                                         "Generating UF2 file"))
 
 Import("projenv")

bin/web.version

@@ -1 +1 @@
-2.6.7
+2.6.4

boards/heltec_wireless_tracker_v2.json

@@ -1,37 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "esp32s3_out.ld",
-      "partitions": "default_8MB.csv"
-    },
-    "core": "esp32",
-    "extra_flags": [
-      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
-      "-DARDUINO_RUNNING_CORE=1",
-      "-DARDUINO_EVENT_RUNNING_CORE=1"
-    ],
-    "f_cpu": "240000000L",
-    "f_flash": "80000000L",
-    "flash_mode": "qio",
-    "hwids": [["0x303A", "0x1001"]],
-    "mcu": "esp32s3",
-    "variant": "heltec_wireless_tracker_v2"
-  },
-  "connectivity": ["wifi", "bluetooth", "lora"],
-  "debug": {
-    "openocd_target": "esp32s3.cfg"
-  },
-  "frameworks": ["arduino", "espidf"],
-  "name": "Heltec Wireless Tracker V2",
-  "upload": {
-    "flash_size": "8MB",
-    "maximum_ram_size": 327680,
-    "maximum_size": 8388608,
-    "wait_for_upload_port": true,
-    "require_upload_port": true,
-    "speed": 921600
-  },
-  "url": "https://heltec.org",
-  "vendor": "Heltec"
-}

boards/r1-neo.json

@@ -1,52 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
-    },
-    "core": "nRF5",
-    "cpu": "cortex-m4",
-    "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
-    "f_cpu": "64000000L",
-    "hwids": [
-      ["0x239A", "0x8029"],
-      ["0x239A", "0x0029"],
-      ["0x239A", "0x002A"],
-      ["0x239A", "0x802A"]
-    ],
-    "usb_product": "Muzi R1 Neo",
-    "mcu": "nrf52840",
-    "variant": "r1-neo",
-    "bsp": {
-      "name": "adafruit"
-    },
-    "softdevice": {
-      "sd_flags": "-DS140",
-      "sd_name": "s140",
-      "sd_version": "6.1.1",
-      "sd_fwid": "0x00B6"
-    },
-    "bootloader": {
-      "settings_addr": "0xFF000"
-    }
-  },
-  "connectivity": ["bluetooth"],
-  "debug": {
-    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
-  },
-  "frameworks": ["arduino", "freertos"],
-  "name": "WisCore RAK4631 Board",
-  "upload": {
-    "maximum_ram_size": 248832,
-    "maximum_size": 815104,
-    "speed": 115200,
-    "protocol": "nrfutil",
-    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
-    "use_1200bps_touch": true,
-    "require_upload_port": true,
-    "wait_for_upload_port": true
-  },
-  "url": "https://muzi.works/",
-  "vendor": "Muzi Works"
-}

debian/changelog

@@ -1,19 +1,49 @@
-meshtasticd (2.7.13.0) unstable; urgency=medium
+meshtasticd (2.7.10.0) UNRELEASED; urgency=medium
 
-  * Version 2.7.13
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Sat, 11 Oct 2025 15:27:28 +0000
-
-meshtasticd (2.7.12.0) unstable; urgency=medium
-
-  [ Austin Lane ]
   * Initial packaging
   * Version 2.5.19
 
   [  ]
   * GitHub Actions Automatic version bump
 
-  [ GitHub Actions ]
-  * Version 2.7.12
+  [  ]
+  * GitHub Actions Automatic version bump
 
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Wed, 01 Oct 2025 19:51:41 +0000
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [ Ubuntu ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+ --  <github-actions[bot]@users.noreply.github.com>  Thu, 18 Sep 2025 22:11:37 +0000

platformio.ini

@@ -56,7 +56,6 @@ build_flags = -Wno-missing-field-initializers
 	#-DBUILD_EPOCH=$UNIX_TIME ; set in platformio-custom.py now
 	#-D OLED_PL=1
 	#-D DEBUG_HEAP=1 ; uncomment to add free heap space / memory leak debugging logs
-	#-D DEBUG_LOOP_TIMING=1 ; uncomment to add main loop timing logs
 
 monitor_speed = 115200
 monitor_filters = direct
@@ -70,7 +69,7 @@ lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-TinyGPSPlus packageName=https://github.com/meshtastic/TinyGPSPlus gitBranch=master
 	https://github.com/meshtastic/TinyGPSPlus/archive/71a82db35f3b973440044c476d4bcdc673b104f4.zip
 	# renovate: datasource=git-refs depName=meshtastic-ArduinoThread packageName=https://github.com/meshtastic/ArduinoThread gitBranch=master
-	https://github.com/meshtastic/ArduinoThread/archive/b841b0415721f1341ea41cccfb4adccfaf951567.zip
+	https://github.com/meshtastic/ArduinoThread/archive/7c3ee9e1951551b949763b1f5280f8db1fa4068d.zip
 	# renovate: datasource=custom.pio depName=Nanopb packageName=nanopb/library/Nanopb
 	nanopb/Nanopb@0.4.91
 	# renovate: datasource=custom.pio depName=ErriezCRC32 packageName=erriez/library/ErriezCRC32
@@ -120,13 +119,13 @@ 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/28167c67dfd13015a0b5eef1828f95fe8e3ab7c3.zip
+	https://github.com/meshtastic/device-ui/archive/9ed5355a24059750e9b2eb5d669574d9ea42a37b.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
 lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit BusIO packageName=adafruit/library/Adafruit BusIO
-	adafruit/Adafruit BusIO@1.17.4
+	adafruit/Adafruit BusIO@1.17.3
 	# renovate: datasource=custom.pio depName=Adafruit Unified Sensor packageName=adafruit/library/Adafruit Unified Sensor
 	adafruit/Adafruit Unified Sensor@1.1.15
 	# renovate: datasource=custom.pio depName=Adafruit BMP280 packageName=adafruit/library/Adafruit BMP280 Library
@@ -164,7 +163,7 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=QMC5883L Compass packageName=mprograms/library/QMC5883LCompass
 	mprograms/QMC5883LCompass@1.2.3
 	# renovate: datasource=custom.pio depName=DFRobot_RTU packageName=dfrobot/library/DFRobot_RTU
-	dfrobot/DFRobot_RTU@1.0.6
+	dfrobot/DFRobot_RTU@1.0.3
 	# renovate: datasource=git-refs depName=DFRobot_RainfallSensor packageName=https://github.com/DFRobot/DFRobot_RainfallSensor gitBranch=master
 	https://github.com/DFRobot/DFRobot_RainfallSensor/archive/38fea5e02b40a5430be6dab39a99a6f6347d667e.zip
 	# renovate: datasource=custom.pio depName=INA226 packageName=robtillaart/library/INA226
@@ -176,7 +175,7 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit LTR390 Library packageName=adafruit/library/Adafruit LTR390 Library
 	adafruit/Adafruit LTR390 Library@1.1.2
 	# renovate: datasource=custom.pio depName=Adafruit PCT2075 packageName=adafruit/library/Adafruit PCT2075
-	adafruit/Adafruit PCT2075@1.0.6
+	adafruit/Adafruit PCT2075@1.0.5
 	# renovate: datasource=custom.pio depName=DFRobot_BMM150 packageName=dfrobot/library/DFRobot_BMM150
 	dfrobot/DFRobot_BMM150@1.0.0
 	# renovate: datasource=custom.pio depName=Adafruit_TSL2561 packageName=adafruit/library/Adafruit TSL2561

src/AudioThread.h

@@ -11,11 +11,6 @@
 #include <AudioOutputI2S.h>
 #include <ESP8266SAM.h>
 
-#ifdef USE_XL9555
-#include "ExtensionIOXL9555.hpp"
-extern ExtensionIOXL9555 io;
-#endif
-
 #define AUDIO_THREAD_INTERVAL_MS 100
 
 class AudioThread : public concurrency::OSThread
@@ -25,16 +20,12 @@ class AudioThread : public concurrency::OSThread
 
     void beginRttl(const void *data, uint32_t len)
     {
-#ifdef T_LORA_PAGER
-        io.digitalWrite(EXPANDS_AMP_EN, HIGH);
-#endif
         setCPUFast(true);
         rtttlFile = new AudioFileSourcePROGMEM(data, len);
         i2sRtttl = new AudioGeneratorRTTTL();
         i2sRtttl->begin(rtttlFile, audioOut);
     }
 
-    // Also handles actually playing the RTTTL, needs to be called in loop
     bool isPlaying()
     {
         if (i2sRtttl != nullptr) {
@@ -54,9 +45,6 @@ class AudioThread : public concurrency::OSThread
         rtttlFile = nullptr;
 
         setCPUFast(false);
-#ifdef T_LORA_PAGER
-        io.digitalWrite(EXPANDS_AMP_EN, LOW);
-#endif
     }
 
     void readAloud(const char *text)
@@ -67,16 +55,10 @@ class AudioThread : public concurrency::OSThread
             i2sRtttl = nullptr;
         }
 
-#ifdef T_LORA_PAGER
-        io.digitalWrite(EXPANDS_AMP_EN, HIGH);
-#endif
         ESP8266SAM *sam = new ESP8266SAM;
         sam->Say(audioOut, text);
         delete sam;
         setCPUFast(false);
-#ifdef T_LORA_PAGER
-        io.digitalWrite(EXPANDS_AMP_EN, LOW);
-#endif
     }
 
   protected:

src/DisplayFormatters.cpp

@@ -76,6 +76,9 @@ const char *DisplayFormatters::getDeviceRole(meshtastic_Config_DeviceConfig_Role
     case meshtastic_Config_DeviceConfig_Role_ROUTER_LATE:
         return "Router Late";
         break;
+    case meshtastic_Config_DeviceConfig_Role_REPEATER:
+        return "Repeater";
+        break;
     default:
         return "Unknown";
         break;

src/Power.cpp

@@ -562,7 +562,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
                    config.power.device_battery_ina_address) {
             if (!ina226Sensor.isInitialized())
                 return ina226Sensor.runOnce() > 0;
-            return ina226Sensor.isRunning();
         } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first ==
                    config.power.device_battery_ina_address) {
             if (!ina260Sensor.isInitialized())
@@ -692,16 +691,6 @@ bool Power::setup()
 #ifdef NRF_APM
     found = true;
 #endif
-#ifdef EXT_PWR_DETECT
-    attachInterrupt(
-        EXT_PWR_DETECT,
-        []() {
-            power->setIntervalFromNow(0);
-            runASAP = true;
-            BaseType_t higherWake = 0;
-        },
-        CHANGE);
-#endif
 
     enabled = found;
     low_voltage_counter = 0;
@@ -839,11 +828,8 @@ void Power::readPowerStatus()
 
     // Notify any status instances that are observing us
     const PowerStatus powerStatus2 = PowerStatus(hasBattery, usbPowered, isChargingNow, batteryVoltageMv, batteryChargePercent);
-    if (millis() > lastLogTime + 50 * 1000) {
-        LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d", powerStatus2.getHasUSB(),
-                  powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
-        lastLogTime = millis();
-    }
+    LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d", powerStatus2.getHasUSB(), powerStatus2.getIsCharging(),
+              powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
     newStatus.notifyObservers(&powerStatus2);
 #ifdef DEBUG_HEAP
     if (lastheap != memGet.getFreeHeap()) {

src/SerialConsole.cpp

@@ -6,14 +6,6 @@
 #include "configuration.h"
 #include "time.h"
 
-#if defined(ARDUINO_USB_CDC_ON_BOOT) && ARDUINO_USB_CDC_ON_BOOT
-#define IS_USB_SERIAL
-#ifdef SERIAL_HAS_ON_RECEIVE
-#undef SERIAL_HAS_ON_RECEIVE
-#endif
-#include "HWCDC.h"
-#endif
-
 #ifdef RP2040_SLOW_CLOCK
 #define Port Serial2
 #else
@@ -30,12 +22,7 @@ SerialConsole *console;
 
 void consoleInit()
 {
-    auto sc = new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
-
-#if defined(SERIAL_HAS_ON_RECEIVE)
-    // onReceive does only exist for HardwareSerial not for USB CDC serial
-    Port.onReceive([sc]() { sc->rxInt(); });
-#endif
+    new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
     DEBUG_PORT.rpInit(); // Simply sets up semaphore
 }
 
@@ -78,21 +65,14 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), con
 int32_t SerialConsole::runOnce()
 {
 #ifdef HELTEC_MESH_SOLAR
-    // After enabling the mesh solar serial port module configuration, command processing is handled by the serial port module.
-    if (moduleConfig.serial.enabled && moduleConfig.serial.override_console_serial_port &&
-        moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG) {
+    //After enabling the mesh solar serial port module configuration, command processing is handled by the serial port module.
+    if(moduleConfig.serial.enabled && moduleConfig.serial.override_console_serial_port
+        && moduleConfig.serial.mode==meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG)
+    {
         return 250;
     }
 #endif
-
-    int32_t delay = runOncePart();
-#if defined(SERIAL_HAS_ON_RECEIVE) || defined(CONFIG_IDF_TARGET_ESP32S2)
-    return Port.available() ? delay : INT32_MAX;
-#elif defined(IS_USB_SERIAL)
-    return HWCDC::isPlugged() ? delay : (1000 * 20);
-#else
-    return delay;
-#endif
+    return runOncePart();
 }
 
 void SerialConsole::flush()
@@ -100,18 +80,6 @@ void SerialConsole::flush()
     Port.flush();
 }
 
-// trigger tx of serial data
-void SerialConsole::onNowHasData(uint32_t fromRadioNum)
-{
-    setIntervalFromNow(0);
-}
-
-// trigger rx of serial data
-void SerialConsole::rxInt()
-{
-    setIntervalFromNow(0);
-}
-
 // For the serial port we can't really detect if any client is on the other side, so instead just look for recent messages
 bool SerialConsole::checkIsConnected()
 {

src/SerialConsole.h

@@ -32,14 +32,11 @@ class SerialConsole : public StreamAPI, public RedirectablePrint, private concur
     virtual int32_t runOnce() override;
 
     void flush();
-    void rxInt();
 
   protected:
     /// Check the current underlying physical link to see if the client is currently connected
     virtual bool checkIsConnected() override;
 
-    virtual void onNowHasData(uint32_t fromRadioNum) override;
-
     /// Possibly switch to protobufs if we see a valid protobuf message
     virtual void log_to_serial(const char *logLevel, const char *format, va_list arg);
 };

src/buzz/BuzzerFeedbackThread.cpp

@@ -5,7 +5,7 @@
 
 BuzzerFeedbackThread *buzzerFeedbackThread;
 
-BuzzerFeedbackThread::BuzzerFeedbackThread()
+BuzzerFeedbackThread::BuzzerFeedbackThread() : OSThread("BuzzerFeedback")
 {
     if (inputBroker)
         inputObserver.observe(inputBroker);
@@ -15,11 +15,14 @@ int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event)
 {
     // Only provide feedback if buzzer is enabled for notifications
     if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
-        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY ||
-        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY) {
+        config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_NOTIFICATIONS_ONLY) {
         return 0; // Let other handlers process the event
     }
 
+    // Track last event time for potential future use
+    lastEventTime = millis();
+    needsUpdate = true;
+
     // Handle different input events with appropriate buzzer feedback
     switch (event->inputEvent) {
     case INPUT_BROKER_USER_PRESS:
@@ -58,4 +61,15 @@ int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event)
     }
 
     return 0; // Allow other handlers to process the event
-}
+}
+
+int32_t BuzzerFeedbackThread::runOnce()
+{
+    // This thread is primarily event-driven, but we can use runOnce
+    // for any periodic tasks if needed in the future
+
+    needsUpdate = false;
+
+    // Run every 100ms when active, less frequently when idle
+    return needsUpdate ? 100 : 1000;
+}

src/buzz/BuzzerFeedbackThread.h

@@ -4,7 +4,7 @@
 #include "concurrency/OSThread.h"
 #include "input/InputBroker.h"
 
-class BuzzerFeedbackThread
+class BuzzerFeedbackThread : public concurrency::OSThread
 {
     CallbackObserver<BuzzerFeedbackThread, const InputEvent *> inputObserver =
         CallbackObserver<BuzzerFeedbackThread, const InputEvent *>(this, &BuzzerFeedbackThread::handleInputEvent);
@@ -12,6 +12,13 @@ class BuzzerFeedbackThread
   public:
     BuzzerFeedbackThread();
     int handleInputEvent(const InputEvent *event);
+
+  protected:
+    virtual int32_t runOnce() override;
+
+  private:
+    uint32_t lastEventTime = 0;
+    bool needsUpdate = false;
 };
 
 extern BuzzerFeedbackThread *buzzerFeedbackThread;

src/concurrency/OSThread.cpp

@@ -90,9 +90,7 @@ void OSThread::run()
     if (heap < newHeap)
         LOG_HEAP("++++++ Thread %s freed heap %d -> %d (%d) ++++++", ThreadName.c_str(), heap, newHeap, newHeap - heap);
 #endif
-#ifdef DEBUG_LOOP_TIMING
-    LOG_DEBUG("====== Thread next run in: %d", newDelay);
-#endif
+
     runned();
 
     if (newDelay >= 0)

src/configuration.h

@@ -33,9 +33,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "pcf8563.h"
 #endif
 
-/* Offer chance for variant-specific defines */
-#include "variant.h"
-
 // -----------------------------------------------------------------------------
 // Version
 // -----------------------------------------------------------------------------
@@ -120,17 +117,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define SX126X_MAX_POWER 22
 #endif
 
-#ifdef USE_GC1109_PA
-// Power Amps are often non-linear, so we can use an array of values for the power curve
-#define NUM_PA_POINTS 22
-#define TX_GAIN_LORA 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 10, 10, 9, 9, 8, 7
-#endif
-
-#ifdef RAK13302
-#define NUM_PA_POINTS 22
-#define TX_GAIN_LORA 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8
-#endif
-
 // Default system gain to 0 if not defined
 #ifndef TX_GAIN_LORA
 #define TX_GAIN_LORA 0
@@ -268,6 +254,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // convert 24-bit color to 16-bit (56K)
 #define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))
 
+/* Step #1: offer chance for variant-specific defines */
+#include "variant.h"
+
 #if defined(VEXT_ENABLE) && !defined(VEXT_ON_VALUE)
 // Older variant.h files might not be defining this value, so stay with the old default
 #define VEXT_ON_VALUE LOW

src/detect/ScanI2C.cpp

@@ -25,8 +25,8 @@ ScanI2C::FoundDevice ScanI2C::firstScreen() const
 
 ScanI2C::FoundDevice ScanI2C::firstRTC() const
 {
-    ScanI2C::DeviceType types[] = {RTC_RV3028, RTC_PCF8563, RTC_RX8130CE};
-    return firstOfOrNONE(3, types);
+    ScanI2C::DeviceType types[] = {RTC_RV3028, RTC_PCF8563};
+    return firstOfOrNONE(2, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::firstKeyboard() const

src/detect/ScanI2C.h

@@ -14,7 +14,6 @@ class ScanI2C
         SCREEN_ST7567,
         RTC_RV3028,
         RTC_PCF8563,
-        RTC_RX8130CE,
         CARDKB,
         TDECKKB,
         BBQ10KB,

src/detect/ScanI2CConsumer.cpp

@@ -1,16 +0,0 @@
-#include "ScanI2CConsumer.h"
-#include <forward_list>
-
-static std::forward_list<ScanI2CConsumer *> ScanI2CConsumers;
-
-ScanI2CConsumer::ScanI2CConsumer()
-{
-    ScanI2CConsumers.push_front(this);
-}
-
-void ScanI2CCompleted(ScanI2C *i2cScanner)
-{
-    for (ScanI2CConsumer *consumer : ScanI2CConsumers) {
-        consumer->i2cScanFinished(i2cScanner);
-    }
-}

src/detect/ScanI2CConsumer.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#include "ScanI2C.h"
-#include <stddef.h>
-
-class ScanI2CConsumer
-{
-  public:
-    ScanI2CConsumer();
-    virtual void i2cScanFinished(ScanI2C *i2cScanner) = 0;
-};
-
-void ScanI2CCompleted(ScanI2C *i2cScanner);

src/detect/ScanI2CTwoWire.cpp

@@ -197,9 +197,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 #ifdef PCF8563_RTC
                 SCAN_SIMPLE_CASE(PCF8563_RTC, RTC_PCF8563, "PCF8563", (uint8_t)addr.address)
 #endif
-#ifdef RX8130CE_RTC
-                SCAN_SIMPLE_CASE(RX8130CE_RTC, RTC_RX8130CE, "RX8130CE", (uint8_t)addr.address)
-#endif
 
             case CARDKB_ADDR:
                 // Do we have the RAK14006 instead?
@@ -378,8 +375,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
             case SHT31_4x_ADDR:     // same as OPT3001_ADDR_ALT
             case SHT31_4x_ADDR_ALT: // same as OPT3001_ADDR
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2);
-                if (registerValue == 0x11a2 || registerValue == 0x11da || registerValue == 0x11f3 || registerValue == 0xe9c ||
-                    registerValue == 0xc8d) {
+                if (registerValue == 0x11a2 || registerValue == 0x11da || registerValue == 0xe9c || registerValue == 0xc8d) {
                     type = SHT4X;
                     logFoundDevice("SHT4X", (uint8_t)addr.address);
                 } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
@@ -581,7 +577,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
     scanPort(port, nullptr, 0);
 }
 
-TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address)
+TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address) const
 {
     if (address.port == ScanI2C::I2CPort::WIRE) {
         return &Wire;

src/detect/ScanI2CTwoWire.h

@@ -23,12 +23,12 @@ class ScanI2CTwoWire : public ScanI2C
 
     ScanI2C::FoundDevice find(ScanI2C::DeviceType) const override;
 
+    TwoWire *fetchI2CBus(ScanI2C::DeviceAddress) const;
+
     bool exists(ScanI2C::DeviceType) const override;
 
     size_t countDevices() const override;
 
-    static TwoWire *fetchI2CBus(ScanI2C::DeviceAddress);
-
   protected:
     FoundDevice firstOfOrNONE(size_t, DeviceType[]) const override;
 

src/gps/GPS.cpp

@@ -494,10 +494,22 @@ bool GPS::setup()
     if (!didSerialInit) {
         int msglen = 0;
         if (tx_gpio && gnssModel == GNSS_MODEL_UNKNOWN) {
+#ifdef TRACKER_T1000_E
+            // add power up/down strategy, improve ag3335 detection success
+            digitalWrite(PIN_GPS_EN, LOW);
+            delay(500);
+            digitalWrite(GPS_VRTC_EN, LOW);
+            delay(1000);
+            digitalWrite(GPS_VRTC_EN, HIGH);
+            delay(500);
+            digitalWrite(PIN_GPS_EN, HIGH);
+            delay(1000);
+#endif
             if (probeTries < GPS_PROBETRIES) {
+                LOG_DEBUG("Probe for GPS at %d", serialSpeeds[speedSelect]);
                 gnssModel = probe(serialSpeeds[speedSelect]);
                 if (gnssModel == GNSS_MODEL_UNKNOWN) {
-                    if (currentStep == 0 && ++speedSelect == array_count(serialSpeeds)) {
+                    if (++speedSelect == array_count(serialSpeeds)) {
                         speedSelect = 0;
                         ++probeTries;
                     }
@@ -506,9 +518,10 @@ bool GPS::setup()
             // Rare Serial Speeds
 #ifndef CONFIG_IDF_TARGET_ESP32C6
             if (probeTries == GPS_PROBETRIES) {
+                LOG_DEBUG("Probe for GPS at %d", rareSerialSpeeds[speedSelect]);
                 gnssModel = probe(rareSerialSpeeds[speedSelect]);
                 if (gnssModel == GNSS_MODEL_UNKNOWN) {
-                    if (currentStep == 0 && ++speedSelect == array_count(rareSerialSpeeds)) {
+                    if (++speedSelect == array_count(rareSerialSpeeds)) {
                         LOG_WARN("Give up on GPS probe and set to %d", GPS_BAUDRATE);
                         return true;
                     }
@@ -1020,7 +1033,7 @@ void GPS::down()
     LOG_DEBUG("%us until next search", sleepTime / 1000);
 
     // If update interval less than 10 seconds, no attempt to sleep
-    if (updateInterval <= GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS || sleepTime == 0)
+    if (updateInterval <= 10 * 1000UL || sleepTime == 0)
         setPowerState(GPS_IDLE);
 
     else {
@@ -1081,7 +1094,7 @@ int32_t GPS::runOnce()
             return disable();
         }
         if (!setup())
-            return currentDelay; // Setup failed, re-run in two seconds
+            return 2000; // Setup failed, re-run in two seconds
 
         // We have now loaded our saved preferences from flash
         if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
@@ -1091,29 +1104,11 @@ int32_t GPS::runOnce()
         publishUpdate();
     }
 
-    // ======================== GPS_ACTIVE state ========================
-    // In GPS_ACTIVE state, GPS is powered on and we're receiving NMEA messages.
-    // We use the following logic to determine when to update the local position
-    // or time by running GPS::publishUpdate.
-    // Note: Local position update is asynchronous to position broadcast. We
-    // generally run this state every gps_update_interval seconds, and in most cases
-    // gps_update_interval is faster than the position broadcast interval so there's a
-    // fresh position ready when the device wants to broadcast one on the mesh.
-    //
-    // 1. Got a time for the first time --> set the time, don't publish.
-    // 2. Got a lock for the first time
-    //   --> If gps_update_interval is <= 10s --> publishUpdate
-    //   --> Otherwise, hold for MIN(gps_update_interval - GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS, 20s)
-    //  3. Got a lock after turning back on
-    //   --> If gps_update_interval is <= 10s --> publishUpdate
-    //   --> Otherwise, hold for MIN(gps_update_interval - GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS, 20s)
-    // 4. Hold has expired
-    //   --> If we have a time and a location --> publishUpdate
-    //   --> down()
-    // 5. Search time has expired
-    //   --> If we have a time and a location --> publishUpdate
-    //   --> If we had a location before but don't now --> publishUpdate
-    //   --> down()
+    // Repeaters have no need for GPS
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
+        return disable();
+    }
+
     if (whileActive()) {
         // if we have received valid NMEA claim we are connected
         setConnected();
@@ -1123,81 +1118,55 @@ int32_t GPS::runOnce()
     if (!config.position.fixed_position && powerState != GPS_ACTIVE && scheduling.isUpdateDue())
         up();
 
-    // quality of the previous fix. We set it to 0 when we go down, so it's a way
-    // to check if we're getting a lock after being GPS_OFF.
+    // If we've already set time from the GPS, no need to ask the GPS
+    bool gotTime = (getRTCQuality() >= RTCQualityGPS);
+    if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
+        gotTime = true;
+        shouldPublish = true;
+    }
+
     uint8_t prev_fixQual = fixQual;
+    bool gotLoc = lookForLocation();
+    if (gotLoc && !hasValidLocation) { // declare that we have location ASAP
+        LOG_DEBUG("hasValidLocation RISING EDGE");
+        hasValidLocation = true;
+        shouldPublish = true;
+        // Hold for 20secs after getting a lock to download ephemeris etc
+        fixHoldEnds = millis() + 20000;
+    }
 
-    if (powerState == GPS_ACTIVE) {
-        // if gps_update_interval is <=10s, GPS never goes off, so we treat that differently
-        uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval);
+    if (gotLoc && prev_fixQual == 0) { // just got a lock after turning back on.
+        fixHoldEnds = millis() + 20000;
+        shouldPublish = true; // Publish immediately, since next publish is at end of hold
+    }
 
-        // 1. Got a time for the first time
-        bool gotTime = (getRTCQuality() >= RTCQualityGPS);
-        if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
-            gotTime = true;
-        }
+    bool tooLong = scheduling.searchedTooLong();
+    if (tooLong)
+        LOG_WARN("Couldn't publish a valid location: didn't get a GPS lock in time");
 
-        // 2. Got a lock for the first time, or 3. Got a lock after turning back on
-        bool gotLoc = lookForLocation();
-        if (gotLoc) {
-#ifdef GPS_DEBUG
-            if (!hasValidLocation) { // declare that we have location ASAP
-                LOG_DEBUG("hasValidLocation RISING EDGE");
-            }
-#endif
-            if (updateInterval <= GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS) {
-                hasValidLocation = true;
-                shouldPublish = true;
-            } else if (!hasValidLocation || prev_fixQual == 0 || (fixHoldEnds + GPS_THREAD_INTERVAL) < millis()) {
-                hasValidLocation = true;
-                // Hold for up to 20secs after getting a lock to download ephemeris etc
-                uint32_t holdTime = updateInterval - GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS;
-                if (holdTime > GPS_FIX_HOLD_MAX_MS)
-                    holdTime = GPS_FIX_HOLD_MAX_MS;
-                fixHoldEnds = millis() + holdTime;
-#ifdef GPS_DEBUG
-                LOG_DEBUG("Holding for %ums after lock", holdTime);
-#endif
-            }
-        }
-
-        bool tooLong = scheduling.searchedTooLong();
+    // Once we get a location we no longer desperately want an update
+    if ((gotLoc && gotTime) || tooLong) {
         if (tooLong && !gotLoc) {
-            LOG_WARN("Couldn't publish a valid location: didn't get a GPS lock in time");
             // we didn't get a location during this ack window, therefore declare loss of lock
             if (hasValidLocation) {
-                p = meshtastic_Position_init_default;
-                hasValidLocation = false;
-                shouldPublish = true;
-#ifdef GPS_DEBUG
                 LOG_DEBUG("hasValidLocation FALLING EDGE");
-#endif
             }
+            p = meshtastic_Position_init_default;
+            hasValidLocation = false;
         }
-
-        // Hold has expired , Search time has expired, we got a time only, or we never needed to hold.
-        bool holdExpired = (fixHoldEnds != 0 && millis() > fixHoldEnds);
-        if (shouldPublish || tooLong || holdExpired) {
-            if (gotTime && hasValidLocation) {
-                shouldPublish = true;
-            }
-            if (shouldPublish) {
-                fixHoldEnds = 0;
-                publishUpdate();
-            }
-
-            // There's a chance we just got a time, so keep going to see if we can get a location too
-            if (tooLong || holdExpired) {
-                down();
-            }
-
+        if (millis() > fixHoldEnds) {
+            shouldPublish = true; // publish our update at the end of the lock hold
+            publishUpdate();
+            down();
 #ifdef GPS_DEBUG
-        } else if (fixHoldEnds != 0) {
+        } else {
             LOG_DEBUG("Holding for GPS data download: %d ms (numSats=%d)", fixHoldEnds - millis(), p.sats_in_view);
 #endif
         }
     }
-    // ===================== end GPS_ACTIVE state ========================
+
+    // If state has changed do a publish
+    publishUpdate();
 
     if (config.position.fixed_position == true && hasValidLocation)
         return disable(); // This should trigger when we have a fixed position, and get that first position
@@ -1254,197 +1223,163 @@ static const char *DETECTED_MESSAGE = "%s detected";
 
 GnssModel_t GPS::probe(int serialSpeed)
 {
-    uint8_t buffer[768] = {0};
-
-    switch (currentStep) {
-    case 0: {
 #if defined(ARCH_NRF52) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32WL)
-        _serial_gps->end();
-        _serial_gps->begin(serialSpeed);
+    _serial_gps->end();
+    _serial_gps->begin(serialSpeed);
 #elif defined(ARCH_RP2040)
-        _serial_gps->end();
-        _serial_gps->setFIFOSize(256);
-        _serial_gps->begin(serialSpeed);
+    _serial_gps->end();
+    _serial_gps->setFIFOSize(256);
+    _serial_gps->begin(serialSpeed);
 #else
-        if (_serial_gps->baudRate() != serialSpeed) {
-            LOG_DEBUG("Set GPS Baud to %i", serialSpeed);
-            _serial_gps->updateBaudRate(serialSpeed);
-        }
+    if (_serial_gps->baudRate() != serialSpeed) {
+        LOG_DEBUG("Set Baud to %i", serialSpeed);
+        _serial_gps->updateBaudRate(serialSpeed);
+    }
 #endif
 
-        memset(&ublox_info, 0, sizeof(ublox_info));
-        delay(100);
+    memset(&ublox_info, 0, sizeof(ublox_info));
+    uint8_t buffer[768] = {0};
+    delay(100);
 
-        // Close all NMEA sentences, valid for L76K, ATGM336H (and likely other AT6558 devices)
-        _serial_gps->write("$PCAS03,0,0,0,0,0,0,0,0,0,0,,,0,0*02\r\n");
-        delay(20);
-        // Close NMEA sequences on Ublox
-        _serial_gps->write("$PUBX,40,GLL,0,0,0,0,0,0*5C\r\n");
-        _serial_gps->write("$PUBX,40,GSV,0,0,0,0,0,0*59\r\n");
-        _serial_gps->write("$PUBX,40,VTG,0,0,0,0,0,0*5E\r\n");
-        delay(20);
-        // Close NMEA sequences on CM121
-        _serial_gps->write("$CFGMSG,0,1,0,1*1B\r\n");
-        _serial_gps->write("$CFGMSG,0,2,0,1*18\r\n");
-        _serial_gps->write("$CFGMSG,0,3,0,1*19\r\n");
-        currentDelay = 20;
-        currentStep = 1;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 1: {
+    // Close all NMEA sentences, valid for L76K, ATGM336H (and likely other AT6558 devices)
+    _serial_gps->write("$PCAS03,0,0,0,0,0,0,0,0,0,0,,,0,0*02\r\n");
+    delay(20);
+    // Close NMEA sequences on Ublox
+    _serial_gps->write("$PUBX,40,GLL,0,0,0,0,0,0*5C\r\n");
+    _serial_gps->write("$PUBX,40,GSV,0,0,0,0,0,0*59\r\n");
+    _serial_gps->write("$PUBX,40,VTG,0,0,0,0,0,0*5E\r\n");
+    delay(20);
+    // Close NMEA sequences on CM121
+    _serial_gps->write("$CFGMSG,0,1,0,1*1B\r\n");
+    _serial_gps->write("$CFGMSG,0,2,0,1*18\r\n");
+    _serial_gps->write("$CFGMSG,0,3,0,1*19\r\n");
+    delay(20);
 
-        // Unicore UFirebirdII Series: UC6580, UM620, UM621, UM670A, UM680A, or UM681A,or CM121
-        std::vector<ChipInfo> unicore = {
-            {"UC6580", "UC6580", GNSS_MODEL_UC6580}, {"UM600", "UM600", GNSS_MODEL_UC6580}, {"CM121", "CM121", GNSS_MODEL_CM121}};
-        PROBE_FAMILY("Unicore Family", "$PDTINFO", unicore, 500);
-        currentDelay = 20;
-        currentStep = 2;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 2: {
-        std::vector<ChipInfo> atgm = {
-            {"ATGM336H", "$GPTXT,01,01,02,HW=ATGM336H", GNSS_MODEL_ATGM336H},
-            /* ATGM332D series (-11(GPS), -21(BDS), -31(GPS+BDS), -51(GPS+GLONASS), -71-0(GPS+BDS+GLONASS)) based on AT6558 */
-            {"ATGM332D", "$GPTXT,01,01,02,HW=ATGM332D", GNSS_MODEL_ATGM336H}};
-        PROBE_FAMILY("ATGM33xx Family", "$PCAS06,1*1A", atgm, 500);
-        currentDelay = 20;
-        currentStep = 3;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 3: {
-        /* Airoha (Mediatek) AG3335A/M/S, A3352Q, Quectel L89 2.0, SimCom SIM65M */
-        _serial_gps->write("$PAIR062,2,0*3C\r\n"); // GSA OFF to reduce volume
-        _serial_gps->write("$PAIR062,3,0*3D\r\n"); // GSV OFF to reduce volume
-        _serial_gps->write("$PAIR513*3D\r\n");     // save configuration
-        std::vector<ChipInfo> airoha = {{"AG3335", "$PAIR021,AG3335", GNSS_MODEL_AG3335},
-                                        {"AG3352", "$PAIR021,AG3352", GNSS_MODEL_AG3352},
-                                        {"RYS3520", "$PAIR021,REYAX_RYS3520_V2", GNSS_MODEL_AG3352}};
-        PROBE_FAMILY("Airoha Family", "$PAIR021*39", airoha, 1000);
-        currentDelay = 20;
-        currentStep = 4;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 4: {
-        PROBE_SIMPLE("LC86", "$PQTMVERNO*58", "$PQTMVERNO,LC86", GNSS_MODEL_AG3352, 500);
-        PROBE_SIMPLE("L76K", "$PCAS06,0*1B", "$GPTXT,01,01,02,SW=", GNSS_MODEL_MTK, 500);
-        currentDelay = 20;
-        currentStep = 5;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 5: {
+    // Unicore UFirebirdII Series: UC6580, UM620, UM621, UM670A, UM680A, or UM681A,or CM121
+    std::vector<ChipInfo> unicore = {
+        {"UC6580", "UC6580", GNSS_MODEL_UC6580}, {"UM600", "UM600", GNSS_MODEL_UC6580}, {"CM121", "CM121", GNSS_MODEL_CM121}};
+    PROBE_FAMILY("Unicore Family", "$PDTINFO", unicore, 500);
 
-        // Close all NMEA sentences, valid for MTK3333 and MTK3339 platforms
-        _serial_gps->write("$PMTK514,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*2E\r\n");
-        delay(20);
-        std::vector<ChipInfo> mtk = {{"L76B", "Quectel-L76B", GNSS_MODEL_MTK_L76B}, {"PA1010D", "1010D", GNSS_MODEL_MTK_PA1010D},
-                                     {"PA1616S", "1616S", GNSS_MODEL_MTK_PA1616S},  {"LS20031", "MC-1513", GNSS_MODEL_MTK_L76B},
-                                     {"L96", "Quectel-L96", GNSS_MODEL_MTK_L76B},   {"L80-R", "_3337_", GNSS_MODEL_MTK_L76B},
-                                     {"L80", "_3339_", GNSS_MODEL_MTK_L76B}};
+    std::vector<ChipInfo> atgm = {
+        {"ATGM336H", "$GPTXT,01,01,02,HW=ATGM336H", GNSS_MODEL_ATGM336H},
+        /* ATGM332D series (-11(GPS), -21(BDS), -31(GPS+BDS), -51(GPS+GLONASS), -71-0(GPS+BDS+GLONASS)) based on AT6558 */
+        {"ATGM332D", "$GPTXT,01,01,02,HW=ATGM332D", GNSS_MODEL_ATGM336H}};
+    PROBE_FAMILY("ATGM33xx Family", "$PCAS06,1*1A", atgm, 500);
 
-        PROBE_FAMILY("MTK Family", "$PMTK605*31", mtk, 500);
-        currentDelay = 20;
-        currentStep = 6;
+    /* Airoha (Mediatek) AG3335A/M/S, A3352Q, Quectel L89 2.0, SimCom SIM65M */
+    _serial_gps->write("$PAIR062,2,0*3C\r\n"); // GSA OFF to reduce volume
+    _serial_gps->write("$PAIR062,3,0*3D\r\n"); // GSV OFF to reduce volume
+    _serial_gps->write("$PAIR513*3D\r\n");     // save configuration
+    std::vector<ChipInfo> airoha = {{"AG3335", "$PAIR021,AG3335", GNSS_MODEL_AG3335},
+                                    {"AG3352", "$PAIR021,AG3352", GNSS_MODEL_AG3352},
+                                    {"RYS3520", "$PAIR021,REYAX_RYS3520_V2", GNSS_MODEL_AG3352}};
+    PROBE_FAMILY("Airoha Family", "$PAIR021*39", airoha, 1000);
+
+    PROBE_SIMPLE("LC86", "$PQTMVERNO*58", "$PQTMVERNO,LC86", GNSS_MODEL_AG3352, 500);
+    PROBE_SIMPLE("L76K", "$PCAS06,0*1B", "$GPTXT,01,01,02,SW=", GNSS_MODEL_MTK, 500);
+
+    // Close all NMEA sentences, valid for MTK3333 and MTK3339 platforms
+    _serial_gps->write("$PMTK514,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*2E\r\n");
+    delay(20);
+    std::vector<ChipInfo> mtk = {{"L76B", "Quectel-L76B", GNSS_MODEL_MTK_L76B}, {"PA1010D", "1010D", GNSS_MODEL_MTK_PA1010D},
+                                 {"PA1616S", "1616S", GNSS_MODEL_MTK_PA1616S},  {"LS20031", "MC-1513", GNSS_MODEL_MTK_L76B},
+                                 {"L96", "Quectel-L96", GNSS_MODEL_MTK_L76B},   {"L80-R", "_3337_", GNSS_MODEL_MTK_L76B},
+                                 {"L80", "_3339_", GNSS_MODEL_MTK_L76B}};
+
+    PROBE_FAMILY("MTK Family", "$PMTK605*31", mtk, 500);
+
+    uint8_t cfg_rate[] = {0xB5, 0x62, 0x06, 0x08, 0x00, 0x00, 0x00, 0x00};
+    UBXChecksum(cfg_rate, sizeof(cfg_rate));
+    clearBuffer();
+    _serial_gps->write(cfg_rate, sizeof(cfg_rate));
+    // Check that the returned response class and message ID are correct
+    GPS_RESPONSE response = getACK(0x06, 0x08, 750);
+    if (response == GNSS_RESPONSE_NONE) {
+        LOG_WARN("No GNSS Module (baudrate %d)", serialSpeed);
         return GNSS_MODEL_UNKNOWN;
+    } else if (response == GNSS_RESPONSE_FRAME_ERRORS) {
+        LOG_INFO("UBlox Frame Errors (baudrate %d)", serialSpeed);
     }
-    case 6: {
-        uint8_t cfg_rate[] = {0xB5, 0x62, 0x06, 0x08, 0x00, 0x00, 0x00, 0x00};
-        UBXChecksum(cfg_rate, sizeof(cfg_rate));
-        clearBuffer();
-        _serial_gps->write(cfg_rate, sizeof(cfg_rate));
-        // Check that the returned response class and message ID are correct
-        GPS_RESPONSE response = getACK(0x06, 0x08, 750);
-        if (response == GNSS_RESPONSE_NONE) {
-            LOG_WARN("No GNSS Module (baudrate %d)", serialSpeed);
-            currentDelay = 2000;
-            currentStep = 0;
-            return GNSS_MODEL_UNKNOWN;
-        } else if (response == GNSS_RESPONSE_FRAME_ERRORS) {
-            LOG_INFO("UBlox Frame Errors (baudrate %d)", serialSpeed);
+
+    memset(buffer, 0, sizeof(buffer));
+    uint8_t _message_MONVER[8] = {
+        0xB5, 0x62, // Sync message for UBX protocol
+        0x0A, 0x04, // Message class and ID (UBX-MON-VER)
+        0x00, 0x00, // Length of payload (we're asking for an answer, so no payload)
+        0x00, 0x00  // Checksum
+    };
+    //  Get Ublox gnss module hardware and software info
+    UBXChecksum(_message_MONVER, sizeof(_message_MONVER));
+    clearBuffer();
+    _serial_gps->write(_message_MONVER, sizeof(_message_MONVER));
+
+    uint16_t len = getACK(buffer, sizeof(buffer), 0x0A, 0x04, 1200);
+    if (len) {
+        uint16_t position = 0;
+        for (int i = 0; i < 30; i++) {
+            ublox_info.swVersion[i] = buffer[position];
+            position++;
+        }
+        for (int i = 0; i < 10; i++) {
+            ublox_info.hwVersion[i] = buffer[position];
+            position++;
+        }
+
+        while (len >= position + 30) {
+            for (int i = 0; i < 30; i++) {
+                ublox_info.extension[ublox_info.extensionNo][i] = buffer[position];
+                position++;
+            }
+            ublox_info.extensionNo++;
+            if (ublox_info.extensionNo > 9)
+                break;
+        }
+
+        LOG_DEBUG("Module Info : ");
+        LOG_DEBUG("Soft version: %s", ublox_info.swVersion);
+        LOG_DEBUG("Hard version: %s", ublox_info.hwVersion);
+        LOG_DEBUG("Extensions:%d", ublox_info.extensionNo);
+        for (int i = 0; i < ublox_info.extensionNo; i++) {
+            LOG_DEBUG("  %s", ublox_info.extension[i]);
         }
 
         memset(buffer, 0, sizeof(buffer));
-        uint8_t _message_MONVER[8] = {
-            0xB5, 0x62, // Sync message for UBX protocol
-            0x0A, 0x04, // Message class and ID (UBX-MON-VER)
-            0x00, 0x00, // Length of payload (we're asking for an answer, so no payload)
-            0x00, 0x00  // Checksum
-        };
-        //  Get Ublox gnss module hardware and software info
-        UBXChecksum(_message_MONVER, sizeof(_message_MONVER));
-        clearBuffer();
-        _serial_gps->write(_message_MONVER, sizeof(_message_MONVER));
 
-        uint16_t len = getACK(buffer, sizeof(buffer), 0x0A, 0x04, 1200);
-        if (len) {
-            uint16_t position = 0;
-            for (int i = 0; i < 30; i++) {
-                ublox_info.swVersion[i] = buffer[position];
-                position++;
-            }
-            for (int i = 0; i < 10; i++) {
-                ublox_info.hwVersion[i] = buffer[position];
-                position++;
-            }
-
-            while (len >= position + 30) {
-                for (int i = 0; i < 30; i++) {
-                    ublox_info.extension[ublox_info.extensionNo][i] = buffer[position];
-                    position++;
+        // tips: extensionNo field is 0 on some 6M GNSS modules
+        for (int i = 0; i < ublox_info.extensionNo; ++i) {
+            if (!strncmp(ublox_info.extension[i], "MOD=", 4)) {
+                strncpy((char *)buffer, &(ublox_info.extension[i][4]), sizeof(buffer));
+            } else if (!strncmp(ublox_info.extension[i], "PROTVER", 7)) {
+                char *ptr = nullptr;
+                memset(buffer, 0, sizeof(buffer));
+                strncpy((char *)buffer, &(ublox_info.extension[i][8]), sizeof(buffer));
+                LOG_DEBUG("Protocol Version:%s", (char *)buffer);
+                if (strlen((char *)buffer)) {
+                    ublox_info.protocol_version = strtoul((char *)buffer, &ptr, 10);
+                    LOG_DEBUG("ProtVer=%d", ublox_info.protocol_version);
+                } else {
+                    ublox_info.protocol_version = 0;
                 }
-                ublox_info.extensionNo++;
-                if (ublox_info.extensionNo > 9)
-                    break;
-            }
-
-            LOG_DEBUG("Module Info : ");
-            LOG_DEBUG("Soft version: %s", ublox_info.swVersion);
-            LOG_DEBUG("Hard version: %s", ublox_info.hwVersion);
-            LOG_DEBUG("Extensions:%d", ublox_info.extensionNo);
-            for (int i = 0; i < ublox_info.extensionNo; i++) {
-                LOG_DEBUG("  %s", ublox_info.extension[i]);
-            }
-
-            memset(buffer, 0, sizeof(buffer));
-
-            // tips: extensionNo field is 0 on some 6M GNSS modules
-            for (int i = 0; i < ublox_info.extensionNo; ++i) {
-                if (!strncmp(ublox_info.extension[i], "MOD=", 4)) {
-                    strncpy((char *)buffer, &(ublox_info.extension[i][4]), sizeof(buffer));
-                } else if (!strncmp(ublox_info.extension[i], "PROTVER", 7)) {
-                    char *ptr = nullptr;
-                    memset(buffer, 0, sizeof(buffer));
-                    strncpy((char *)buffer, &(ublox_info.extension[i][8]), sizeof(buffer));
-                    LOG_DEBUG("Protocol Version:%s", (char *)buffer);
-                    if (strlen((char *)buffer)) {
-                        ublox_info.protocol_version = strtoul((char *)buffer, &ptr, 10);
-                        LOG_DEBUG("ProtVer=%d", ublox_info.protocol_version);
-                    } else {
-                        ublox_info.protocol_version = 0;
-                    }
-                }
-            }
-            if (strncmp(ublox_info.hwVersion, "00040007", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 6", "6");
-                return GNSS_MODEL_UBLOX6;
-            } else if (strncmp(ublox_info.hwVersion, "00070000", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 7", "7");
-                return GNSS_MODEL_UBLOX7;
-            } else if (strncmp(ublox_info.hwVersion, "00080000", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 8", "8");
-                return GNSS_MODEL_UBLOX8;
-            } else if (strncmp(ublox_info.hwVersion, "00190000", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 9", "9");
-                return GNSS_MODEL_UBLOX9;
-            } else if (strncmp(ublox_info.hwVersion, "000A0000", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 10", "10");
-                return GNSS_MODEL_UBLOX10;
             }
         }
-    }
+        if (strncmp(ublox_info.hwVersion, "00040007", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 6", "6");
+            return GNSS_MODEL_UBLOX6;
+        } else if (strncmp(ublox_info.hwVersion, "00070000", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 7", "7");
+            return GNSS_MODEL_UBLOX7;
+        } else if (strncmp(ublox_info.hwVersion, "00080000", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 8", "8");
+            return GNSS_MODEL_UBLOX8;
+        } else if (strncmp(ublox_info.hwVersion, "00190000", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 9", "9");
+            return GNSS_MODEL_UBLOX9;
+        } else if (strncmp(ublox_info.hwVersion, "000A0000", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 10", "10");
+            return GNSS_MODEL_UBLOX10;
+        }
     }
     LOG_WARN("No GNSS Module (baudrate %d)", serialSpeed);
-    currentDelay = 2000;
-    currentStep = 0;
     return GNSS_MODEL_UNKNOWN;
 }
 
@@ -1659,12 +1594,8 @@ bool GPS::lookForLocation()
 
 #ifndef TINYGPS_OPTION_NO_STATISTICS
     if (reader.failedChecksum() > lastChecksumFailCount) {
-// In a GPS_DEBUG build we want to log all of these. In production, we only care if there are many of them.
-#ifndef GPS_DEBUG
-        if (reader.failedChecksum() > 4)
-#endif
-            LOG_WARN("%u new GPS checksum failures, for a total of %u", reader.failedChecksum() - lastChecksumFailCount,
-                     reader.failedChecksum());
+        LOG_WARN("%u new GPS checksum failures, for a total of %u", reader.failedChecksum() - lastChecksumFailCount,
+                 reader.failedChecksum());
         lastChecksumFailCount = reader.failedChecksum();
     }
 #endif

src/gps/GPS.h

@@ -16,9 +16,6 @@
 #define GPS_EN_ACTIVE 1
 #endif
 
-static constexpr uint32_t GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS = 10 * 1000UL;
-static constexpr uint32_t GPS_FIX_HOLD_MAX_MS = 20000;
-
 typedef enum {
     GNSS_MODEL_ATGM336H,
     GNSS_MODEL_MTK,
@@ -154,8 +151,6 @@ class GPS : private concurrency::OSThread
     TinyGPSPlus reader;
     uint8_t fixQual = 0; // fix quality from GPGGA
     uint32_t lastChecksumFailCount = 0;
-    uint8_t currentStep = 0;
-    int32_t currentDelay = 2000;
 
 #ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
     // (20210908) TinyGps++ can only read the GPGSA "FIX TYPE" field
@@ -178,6 +173,8 @@ class GPS : private concurrency::OSThread
      */
     bool hasValidLocation = false; // default to false, until we complete our first read
 
+    bool isInPowersave = false;
+
     bool shouldPublish = false; // If we've changed GPS state, this will force a publish the next loop()
 
     bool hasGPS = false; // Do we have a GPS we are talking to

src/gps/RTC.cpp

@@ -109,35 +109,6 @@ RTCSetResult readFromRTC()
         }
         return RTCSetResultSuccess;
     }
-#elif defined(RX8130CE_RTC)
-    if (rtc_found.address == RX8130CE_RTC) {
-        uint32_t now = millis();
-        ArtronShop_RX8130CE rtc(&Wire);
-        tm t;
-        if (rtc.getTime(&t)) {
-            tv.tv_sec = gm_mktime(&t);
-            tv.tv_usec = 0;
-
-            uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms
-            LOG_DEBUG("Read RTC time from RX8130CE getDateTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)", t.tm_year + 1900,
-                      t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch);
-#ifdef BUILD_EPOCH
-            if (tv.tv_sec < BUILD_EPOCH) {
-                if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
-                    LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
-                    lastTimeValidationWarning = millis();
-                }
-                return RTCSetResultInvalidTime;
-            }
-#endif
-            if (currentQuality == RTCQualityNone) {
-                timeStartMsec = now;
-                zeroOffsetSecs = tv.tv_sec;
-                currentQuality = RTCQualityDevice;
-            }
-            return RTCSetResultSuccess;
-        }
-    }
 #else
     if (!gettimeofday(&tv, NULL)) {
         uint32_t now = millis();
@@ -243,17 +214,6 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
             LOG_DEBUG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
                       t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
         }
-#elif defined(RX8130CE_RTC)
-        if (rtc_found.address == RX8130CE_RTC) {
-            ArtronShop_RX8130CE rtc(&Wire);
-            tm *t = gmtime(&tv->tv_sec);
-            if (rtc.setTime(*t)) {
-                LOG_DEBUG("RX8130CE setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1,
-                          t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
-            } else {
-                LOG_WARN("Failed to set time for RX8130CE");
-            }
-        }
 #elif defined(ARCH_ESP32)
         settimeofday(tv, NULL);
 #endif

src/gps/RTC.h

@@ -4,10 +4,6 @@
 #include "sys/time.h"
 #include <Arduino.h>
 
-#ifdef RX8130CE_RTC
-#include <ArtronShop_RX8130CE.h>
-#endif
-
 enum RTCQuality {
 
     /// We haven't had our RTC set yet

src/graphics/EInkDisplay2.cpp

@@ -243,7 +243,7 @@ bool EInkDisplay::connect()
         adafruitDisplay->setRotation(1);
         adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
     }
-#elif defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK) || defined(HELTEC_MESH_SOLAR_EINK)
+#elif defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK)
     {
         spi1 = &SPI1;
         spi1->begin();

src/graphics/EInkDisplay2.h

@@ -84,7 +84,7 @@ class EInkDisplay : public OLEDDisplay
     SPIClass *hspi = NULL;
 #endif
 
-#if defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK) || defined(HELTEC_MESH_SOLAR_EINK)
+#if defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK)
     SPIClass *spi1 = NULL;
 #endif
 

src/graphics/Panel_sdl.cpp

@@ -1,687 +0,0 @@
-/*----------------------------------------------------------------------------/
-  Lovyan GFX - Graphics library for embedded devices.
-
-Original Source:
- https://github.com/lovyan03/LovyanGFX/
-
-Licence:
- [FreeBSD](https://github.com/lovyan03/LovyanGFX/blob/master/license.txt)
-
-Author:
- [lovyan03](https://twitter.com/lovyan03)
-
-Contributors:
- [ciniml](https://github.com/ciniml)
- [mongonta0716](https://github.com/mongonta0716)
- [tobozo](https://github.com/tobozo)
-
-Porting for SDL:
- [imliubo](https://github.com/imliubo)
-/----------------------------------------------------------------------------*/
-#include "Panel_sdl.hpp"
-
-#if defined(SDL_h_)
-
-// #include "../common.hpp"
-// #include "../../misc/common_function.hpp"
-// #include "../../Bus.hpp"
-
-#include <list>
-#include <math.h>
-#include <vector>
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-namespace lgfx
-{
-inline namespace v1
-{
-SDL_Keymod Panel_sdl::_keymod = KMOD_NONE;
-static SDL_semaphore *_update_in_semaphore = nullptr;
-static SDL_semaphore *_update_out_semaphore = nullptr;
-volatile static uint32_t _in_step_exec = 0;
-volatile static uint32_t _msec_step_exec = 512;
-static bool _inited = false;
-static bool _all_close = false;
-
-volatile uint8_t Panel_sdl::_gpio_dummy_values[EMULATED_GPIO_MAX];
-
-static inline void *heap_alloc_dma(size_t length)
-{
-    return malloc(length);
-} // aligned_alloc(16, length);
-static inline void heap_free(void *buf)
-{
-    free(buf);
-}
-
-static std::list<monitor_t *> _list_monitor;
-
-static monitor_t *const getMonitorByWindowID(uint32_t windowID)
-{
-    for (auto &m : _list_monitor) {
-        if (SDL_GetWindowID(m->window) == windowID) {
-            return m;
-        }
-    }
-    return nullptr;
-}
-//----------------------------------------------------------------------------
-
-static std::vector<Panel_sdl::KeyCodeMapping_t> _key_code_map;
-
-void Panel_sdl::addKeyCodeMapping(SDL_KeyCode keyCode, uint8_t gpio)
-{
-    if (gpio > EMULATED_GPIO_MAX)
-        return;
-    KeyCodeMapping_t map;
-    map.keycode = keyCode;
-    map.gpio = gpio;
-    _key_code_map.push_back(map);
-}
-
-int Panel_sdl::getKeyCodeMapping(SDL_KeyCode keyCode)
-{
-    for (const auto &i : _key_code_map) {
-        if (i.keycode == keyCode)
-            return i.gpio;
-    }
-    return -1;
-}
-
-void Panel_sdl::_event_proc(void)
-{
-    SDL_Event event;
-    while (SDL_PollEvent(&event)) {
-        if ((event.type == SDL_KEYDOWN) || (event.type == SDL_KEYUP)) {
-            auto mon = getMonitorByWindowID(event.button.windowID);
-            int gpio = -1;
-
-            /// Check key mapping
-            gpio = getKeyCodeMapping((SDL_KeyCode)event.key.keysym.sym);
-            if (gpio < 0) {
-                switch (event.key.keysym.sym) { /// M5StackのBtnA～BtnCのエミュレート;
-                // case SDLK_LEFT:  gpio = 39; break;
-                // case SDLK_DOWN:  gpio = 38; break;
-                // case SDLK_RIGHT: gpio = 37; break;
-                // case SDLK_UP:    gpio = 36; break;
-
-                /// L/Rキーで画面回転
-                case SDLK_r:
-                case SDLK_l:
-                    if (event.type == SDL_KEYDOWN && event.key.keysym.mod == _keymod) {
-                        if (mon != nullptr) {
-                            mon->frame_rotation = (mon->frame_rotation += event.key.keysym.sym == SDLK_r ? 1 : -1);
-                            int x, y, w, h;
-                            SDL_GetWindowSize(mon->window, &w, &h);
-                            SDL_GetWindowPosition(mon->window, &x, &y);
-                            SDL_SetWindowSize(mon->window, h, w);
-                            SDL_SetWindowPosition(mon->window, x + (w - h) / 2, y + (h - w) / 2);
-                            mon->panel->sdl_invalidate();
-                        }
-                    }
-                    break;
-
-                /// 1～6キーで画面拡大率変更
-                case SDLK_1:
-                case SDLK_2:
-                case SDLK_3:
-                case SDLK_4:
-                case SDLK_5:
-                case SDLK_6:
-                    if (event.type == SDL_KEYDOWN && event.key.keysym.mod == _keymod) {
-                        if (mon != nullptr) {
-                            int size = 1 + (event.key.keysym.sym - SDLK_1);
-                            _update_scaling(mon, size, size);
-                        }
-                    }
-                    break;
-                default:
-                    continue;
-                }
-            }
-
-            if (event.type == SDL_KEYDOWN) {
-                Panel_sdl::gpio_lo(gpio);
-            } else {
-                Panel_sdl::gpio_hi(gpio);
-            }
-        } else if (event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP || event.type == SDL_MOUSEMOTION) {
-            auto mon = getMonitorByWindowID(event.button.windowID);
-            if (mon != nullptr) {
-                {
-                    int x, y, w, h;
-                    SDL_GetWindowSize(mon->window, &w, &h);
-                    SDL_GetMouseState(&x, &y);
-                    float sf = sinf(mon->frame_angle * M_PI / 180);
-                    float cf = cosf(mon->frame_angle * M_PI / 180);
-                    x -= w / 2.0f;
-                    y -= h / 2.0f;
-                    float nx = y * sf + x * cf;
-                    float ny = y * cf - x * sf;
-                    if (mon->frame_rotation & 1) {
-                        std::swap(w, h);
-                    }
-                    x = (nx * mon->frame_width / w) + (mon->frame_width >> 1);
-                    y = (ny * mon->frame_height / h) + (mon->frame_height >> 1);
-                    mon->touch_x = x - mon->frame_inner_x;
-                    mon->touch_y = y - mon->frame_inner_y;
-                }
-                if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
-                    mon->touched = true;
-                }
-                if (event.type == SDL_MOUSEBUTTONUP && event.button.button == SDL_BUTTON_LEFT) {
-                    mon->touched = false;
-                }
-            }
-        } else if (event.type == SDL_WINDOWEVENT) {
-            auto monitor = getMonitorByWindowID(event.window.windowID);
-            if (monitor) {
-                if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
-                    int mw, mh;
-                    SDL_GetRendererOutputSize(monitor->renderer, &mw, &mh);
-                    if (monitor->frame_rotation & 1) {
-                        std::swap(mw, mh);
-                    }
-                    monitor->scaling_x = (mw * 2 / monitor->frame_width) / 2.0f;
-                    monitor->scaling_y = (mh * 2 / monitor->frame_height) / 2.0f;
-                    monitor->panel->sdl_invalidate();
-                } else if (event.window.event == SDL_WINDOWEVENT_CLOSE) {
-                    monitor->closing = true;
-                }
-            }
-        } else if (event.type == SDL_QUIT) {
-            for (auto &m : _list_monitor) {
-                m->closing = true;
-            }
-        }
-    }
-}
-
-/// デバッガでステップ実行されていることを検出するスレッド用関数。
-static int detectDebugger(bool *running)
-{
-    uint32_t prev_ms = SDL_GetTicks();
-    do {
-        SDL_Delay(1);
-        uint32_t ms = SDL_GetTicks();
-        /// 時間間隔が広すぎる場合はステップ実行中 (ブレークポイントで止まった)と判断する。
-        /// また、解除されたと判断した後も1023msecほど状態を維持する。
-        if (ms - prev_ms > 64) {
-            _in_step_exec = _msec_step_exec;
-        } else if (_in_step_exec) {
-            --_in_step_exec;
-        }
-        prev_ms = ms;
-    } while (*running);
-    return 0;
-}
-
-void Panel_sdl::_update_proc(void)
-{
-    for (auto it = _list_monitor.begin(); it != _list_monitor.end();) {
-        if ((*it)->closing) {
-            if ((*it)->texture_frameimage) {
-                SDL_DestroyTexture((*it)->texture_frameimage);
-            }
-            SDL_DestroyTexture((*it)->texture);
-            SDL_DestroyRenderer((*it)->renderer);
-            SDL_DestroyWindow((*it)->window);
-            _list_monitor.erase(it++);
-            if (_list_monitor.empty()) {
-                _all_close = true;
-                return;
-            }
-            continue;
-        }
-        (*it)->panel->sdl_update();
-        ++it;
-    }
-}
-
-int Panel_sdl::setup(void)
-{
-    if (_inited)
-        return 1;
-    _inited = true;
-
-    /// Add default keycode mapping
-    /// M5StackのBtnA～BtnCのエミュレート;
-    addKeyCodeMapping(SDLK_LEFT, 39);
-    addKeyCodeMapping(SDLK_DOWN, 38);
-    addKeyCodeMapping(SDLK_RIGHT, 37);
-    addKeyCodeMapping(SDLK_UP, 36);
-
-    SDL_CreateThread((SDL_ThreadFunction)detectDebugger, "dbg", &_inited);
-
-    _update_in_semaphore = SDL_CreateSemaphore(0);
-    _update_out_semaphore = SDL_CreateSemaphore(0);
-    for (size_t pin = 0; pin < EMULATED_GPIO_MAX; ++pin) {
-        gpio_hi(pin);
-    }
-    /*Initialize the SDL*/
-    SDL_Init(SDL_INIT_VIDEO);
-    SDL_StartTextInput();
-
-    // SDL_SetThreadPriority(SDL_ThreadPriority::SDL_THREAD_PRIORITY_HIGH);
-    return 0;
-}
-
-int Panel_sdl::loop(void)
-{
-    if (!_inited)
-        return 1;
-
-    _event_proc();
-    SDL_SemWaitTimeout(_update_in_semaphore, 1);
-    _update_proc();
-    _event_proc();
-    if (SDL_SemValue(_update_out_semaphore) == 0) {
-        SDL_SemPost(_update_out_semaphore);
-    }
-
-    return _all_close;
-}
-
-int Panel_sdl::close(void)
-{
-    if (!_inited)
-        return 1;
-    _inited = false;
-
-    SDL_StopTextInput();
-    SDL_DestroySemaphore(_update_in_semaphore);
-    SDL_DestroySemaphore(_update_out_semaphore);
-    SDL_Quit();
-    return 0;
-}
-
-int Panel_sdl::main(int (*fn)(bool *), uint32_t msec_step_exec)
-{
-    _msec_step_exec = msec_step_exec;
-
-    /// SDLの準備
-    if (0 != Panel_sdl::setup()) {
-        return 1;
-    }
-
-    /// ユーザコード関数の動作・停止フラグ
-    bool running = true;
-
-    /// ユーザコード関数を起動する
-    auto thread = SDL_CreateThread((SDL_ThreadFunction)fn, "fn", &running);
-
-    /// 全部のウィンドウが閉じられるまでSDLのイベント・描画処理を継続
-    while (0 == Panel_sdl::loop()) {
-    };
-
-    /// ユーザコード関数を終了する
-    running = false;
-    SDL_WaitThread(thread, nullptr);
-
-    /// SDLを終了する
-    return Panel_sdl::close();
-}
-
-void Panel_sdl::setScaling(uint_fast8_t scaling_x, uint_fast8_t scaling_y)
-{
-    monitor.scaling_x = scaling_x;
-    monitor.scaling_y = scaling_y;
-}
-
-void Panel_sdl::setFrameImage(const void *frame_image, int frame_width, int frame_height, int inner_x, int inner_y)
-{
-    monitor.frame_image = frame_image;
-    monitor.frame_width = frame_width;
-    monitor.frame_height = frame_height;
-    monitor.frame_inner_x = inner_x;
-    monitor.frame_inner_y = inner_y;
-}
-
-void Panel_sdl::setFrameRotation(uint_fast16_t frame_rotation)
-{
-    monitor.frame_rotation = frame_rotation;
-    monitor.frame_angle = (monitor.frame_rotation) * 90;
-}
-
-Panel_sdl::~Panel_sdl(void)
-{
-    _list_monitor.remove(&monitor);
-    SDL_DestroyMutex(_sdl_mutex);
-}
-
-Panel_sdl::Panel_sdl(void) : Panel_FrameBufferBase()
-{
-    _sdl_mutex = SDL_CreateMutex();
-    _auto_display = true;
-    monitor.panel = this;
-}
-
-bool Panel_sdl::init(bool use_reset)
-{
-    initFrameBuffer(_cfg.panel_width * 4, _cfg.panel_height);
-    bool res = Panel_FrameBufferBase::init(use_reset);
-
-    _list_monitor.push_back(&monitor);
-
-    return res;
-}
-
-color_depth_t Panel_sdl::setColorDepth(color_depth_t depth)
-{
-    auto bits = depth & color_depth_t::bit_mask;
-    if (bits >= 16) {
-        depth = (bits > 16) ? rgb888_3Byte : rgb565_2Byte;
-    } else {
-        depth = (depth == color_depth_t::grayscale_8bit) ? grayscale_8bit : rgb332_1Byte;
-    }
-    _write_depth = depth;
-    _read_depth = depth;
-
-    return depth;
-}
-
-Panel_sdl::lock_t::lock_t(Panel_sdl *parent) : _parent{parent}
-{
-    SDL_LockMutex(parent->_sdl_mutex);
-};
-
-Panel_sdl::lock_t::~lock_t(void)
-{
-    ++_parent->_modified_counter;
-    SDL_UnlockMutex(_parent->_sdl_mutex);
-    if (SDL_SemValue(_update_in_semaphore) < 2) {
-        SDL_SemPost(_update_in_semaphore);
-        if (!_in_step_exec) {
-            SDL_SemWaitTimeout(_update_out_semaphore, 1);
-        }
-    }
-};
-
-void Panel_sdl::drawPixelPreclipped(uint_fast16_t x, uint_fast16_t y, uint32_t rawcolor)
-{
-    lock_t lock(this);
-    Panel_FrameBufferBase::drawPixelPreclipped(x, y, rawcolor);
-}
-
-void Panel_sdl::writeFillRectPreclipped(uint_fast16_t x, uint_fast16_t y, uint_fast16_t w, uint_fast16_t h, uint32_t rawcolor)
-{
-    lock_t lock(this);
-    Panel_FrameBufferBase::writeFillRectPreclipped(x, y, w, h, rawcolor);
-}
-
-void Panel_sdl::writeBlock(uint32_t rawcolor, uint32_t length)
-{
-    //    lock_t lock(this);
-    Panel_FrameBufferBase::writeBlock(rawcolor, length);
-}
-
-void Panel_sdl::writeImage(uint_fast16_t x, uint_fast16_t y, uint_fast16_t w, uint_fast16_t h, pixelcopy_t *param, bool use_dma)
-{
-    lock_t lock(this);
-    Panel_FrameBufferBase::writeImage(x, y, w, h, param, use_dma);
-}
-
-void Panel_sdl::writeImageARGB(uint_fast16_t x, uint_fast16_t y, uint_fast16_t w, uint_fast16_t h, pixelcopy_t *param)
-{
-    lock_t lock(this);
-    Panel_FrameBufferBase::writeImageARGB(x, y, w, h, param);
-}
-
-void Panel_sdl::writePixels(pixelcopy_t *param, uint32_t len, bool use_dma)
-{
-    lock_t lock(this);
-    Panel_FrameBufferBase::writePixels(param, len, use_dma);
-}
-
-void Panel_sdl::display(uint_fast16_t x, uint_fast16_t y, uint_fast16_t w, uint_fast16_t h)
-{
-    (void)x;
-    (void)y;
-    (void)w;
-    (void)h;
-    if (_in_step_exec) {
-        if (_display_counter != _modified_counter) {
-            do {
-                SDL_SemPost(_update_in_semaphore);
-                SDL_SemWaitTimeout(_update_out_semaphore, 1);
-            } while (_display_counter != _modified_counter);
-            SDL_Delay(1);
-        }
-    }
-}
-
-uint_fast8_t Panel_sdl::getTouchRaw(touch_point_t *tp, uint_fast8_t count)
-{
-    (void)count;
-    tp->x = monitor.touch_x;
-    tp->y = monitor.touch_y;
-    tp->size = monitor.touched ? 1 : 0;
-    tp->id = 0;
-    return monitor.touched;
-}
-
-void Panel_sdl::setWindowTitle(const char *title)
-{
-    _window_title = title;
-    if (monitor.window) {
-        SDL_SetWindowTitle(monitor.window, _window_title);
-    }
-}
-
-void Panel_sdl::_update_scaling(monitor_t *mon, float sx, float sy)
-{
-    mon->scaling_x = sx;
-    mon->scaling_y = sy;
-    int nw = mon->frame_width;
-    int nh = mon->frame_height;
-    if (mon->frame_rotation & 1) {
-        std::swap(nw, nh);
-    }
-
-    int x, y, w, h;
-    int rw, rh;
-    SDL_GetRendererOutputSize(mon->renderer, &rw, &rh);
-    SDL_GetWindowSize(mon->window, &w, &h);
-    nw = nw * sx * w / rw;
-    nh = nh * sy * h / rh;
-    SDL_GetWindowPosition(mon->window, &x, &y);
-    SDL_SetWindowSize(mon->window, nw, nh);
-    SDL_SetWindowPosition(mon->window, x + (w - nw) / 2, y + (h - nh) / 2);
-    mon->panel->sdl_invalidate();
-}
-
-void Panel_sdl::sdl_create(monitor_t *m)
-{
-    int flag = SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI;
-#if SDL_FULLSCREEN
-    flag |= SDL_WINDOW_FULLSCREEN;
-#endif
-
-    if (m->frame_width < _cfg.panel_width) {
-        m->frame_width = _cfg.panel_width;
-    }
-    if (m->frame_height < _cfg.panel_height) {
-        m->frame_height = _cfg.panel_height;
-    }
-
-    int window_width = m->frame_width * m->scaling_x;
-    int window_height = m->frame_height * m->scaling_y;
-    int scaling_x = m->scaling_x;
-    int scaling_y = m->scaling_y;
-    if (m->frame_rotation & 1) {
-        std::swap(window_width, window_height);
-        std::swap(scaling_x, scaling_y);
-    }
-
-    {
-        m->window = SDL_CreateWindow(_window_title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, window_width, window_height,
-                                     flag); /*last param. SDL_WINDOW_BORDERLESS to hide borders*/
-    }
-    m->renderer = SDL_CreateRenderer(m->window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
-    m->texture =
-        SDL_CreateTexture(m->renderer, SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_STREAMING, _cfg.panel_width, _cfg.panel_height);
-    SDL_SetTextureBlendMode(m->texture, SDL_BLENDMODE_NONE);
-
-    if (m->frame_image) {
-        // 枠画像用のサーフェイスを作成
-        auto sf = SDL_CreateRGBSurfaceFrom((void *)m->frame_image, m->frame_width, m->frame_height, 32, m->frame_width * 4,
-                                           0xFF000000, 0xFF0000, 0xFF00, 0xFF);
-        if (sf != nullptr) {
-            // 枠画像からテクスチャを作成
-            m->texture_frameimage = SDL_CreateTextureFromSurface(m->renderer, sf);
-            SDL_FreeSurface(sf);
-        }
-    }
-    SDL_SetTextureBlendMode(m->texture_frameimage, SDL_BLENDMODE_BLEND);
-    _update_scaling(m, scaling_x, scaling_y);
-}
-
-void Panel_sdl::sdl_update(void)
-{
-    if (monitor.renderer == nullptr) {
-        sdl_create(&monitor);
-    }
-
-    bool step_exec = _in_step_exec;
-
-    if (_texupdate_counter != _modified_counter) {
-        pixelcopy_t pc(nullptr, color_depth_t::rgb888_3Byte, _write_depth, false);
-        if (_write_depth == rgb565_2Byte) {
-            pc.fp_copy = pixelcopy_t::copy_rgb_fast<bgr888_t, swap565_t>;
-        } else if (_write_depth == rgb888_3Byte) {
-            pc.fp_copy = pixelcopy_t::copy_rgb_fast<bgr888_t, bgr888_t>;
-        } else if (_write_depth == rgb332_1Byte) {
-            pc.fp_copy = pixelcopy_t::copy_rgb_fast<bgr888_t, rgb332_t>;
-        } else if (_write_depth == grayscale_8bit) {
-            pc.fp_copy = pixelcopy_t::copy_rgb_fast<bgr888_t, grayscale_t>;
-        }
-
-        if (0 == SDL_LockMutex(_sdl_mutex)) {
-            _texupdate_counter = _modified_counter;
-            for (int y = 0; y < _cfg.panel_height; ++y) {
-                pc.src_x32 = 0;
-                pc.src_data = _lines_buffer[y];
-                pc.fp_copy(&_texturebuf[y * _cfg.panel_width], 0, _cfg.panel_width, &pc);
-            }
-            SDL_UnlockMutex(_sdl_mutex);
-            SDL_UpdateTexture(monitor.texture, nullptr, _texturebuf, _cfg.panel_width * sizeof(rgb888_t));
-        }
-    }
-
-    int angle = monitor.frame_angle;
-    int target = (monitor.frame_rotation) * 90;
-    angle = (((target * 4) + (angle * 4) + (angle < target ? 8 : 0)) >> 3);
-
-    if (monitor.frame_angle != angle) { // 表示する向きを変える
-        monitor.frame_angle = angle;
-        sdl_invalidate();
-    } else if (monitor.frame_rotation & ~3u) {
-        monitor.frame_rotation &= 3;
-        monitor.frame_angle = (monitor.frame_rotation) * 90;
-        sdl_invalidate();
-    }
-
-    if (_invalidated || (_display_counter != _texupdate_counter)) {
-        SDL_RendererInfo info;
-        if (0 == SDL_GetRendererInfo(monitor.renderer, &info)) {
-            // ステップ実行中はVSYNCを待機しない
-            if (((bool)(info.flags & SDL_RENDERER_PRESENTVSYNC)) == step_exec) {
-                SDL_RenderSetVSync(monitor.renderer, !step_exec);
-            }
-        }
-        {
-            int red = 0;
-            int green = 0;
-            int blue = 0;
-#if defined(M5GFX_BACK_COLOR)
-            red = ((M5GFX_BACK_COLOR) >> 16) & 0xFF;
-            green = ((M5GFX_BACK_COLOR) >> 8) & 0xFF;
-            blue = ((M5GFX_BACK_COLOR)) & 0xFF;
-#endif
-            SDL_SetRenderDrawColor(monitor.renderer, red, green, blue, 0xFF);
-        }
-        SDL_RenderClear(monitor.renderer);
-        if (_invalidated) {
-            _invalidated = false;
-            int mw, mh;
-            SDL_GetRendererOutputSize(monitor.renderer, &mw, &mh);
-        }
-        render_texture(monitor.texture, monitor.frame_inner_x, monitor.frame_inner_y, _cfg.panel_width, _cfg.panel_height, angle);
-        render_texture(monitor.texture_frameimage, 0, 0, monitor.frame_width, monitor.frame_height, angle);
-        SDL_RenderPresent(monitor.renderer);
-        _display_counter = _texupdate_counter;
-        if (_invalidated) {
-            _invalidated = false;
-            SDL_SetRenderDrawColor(monitor.renderer, 0, 0, 0, 0xFF);
-            SDL_RenderClear(monitor.renderer);
-            render_texture(monitor.texture, monitor.frame_inner_x, monitor.frame_inner_y, _cfg.panel_width, _cfg.panel_height,
-                           angle);
-            render_texture(monitor.texture_frameimage, 0, 0, monitor.frame_width, monitor.frame_height, angle);
-            SDL_RenderPresent(monitor.renderer);
-        }
-    }
-}
-
-void Panel_sdl::render_texture(SDL_Texture *texture, int tx, int ty, int tw, int th, float angle)
-{
-    SDL_Point pivot;
-    pivot.x = (monitor.frame_width / 2.0f - tx) * (float)monitor.scaling_x;
-    pivot.y = (monitor.frame_height / 2.0f - ty) * (float)monitor.scaling_y;
-    SDL_Rect dstrect;
-    dstrect.w = tw * monitor.scaling_x;
-    dstrect.h = th * monitor.scaling_y;
-    int mw, mh;
-    SDL_GetRendererOutputSize(monitor.renderer, &mw, &mh);
-    dstrect.x = mw / 2.0f - pivot.x;
-    dstrect.y = mh / 2.0f - pivot.y;
-    SDL_RenderCopyEx(monitor.renderer, texture, nullptr, &dstrect, angle, &pivot, SDL_RendererFlip::SDL_FLIP_NONE);
-}
-
-bool Panel_sdl::initFrameBuffer(size_t width, size_t height)
-{
-    uint8_t **lineArray = (uint8_t **)heap_alloc_dma(height * sizeof(uint8_t *));
-    if (nullptr == lineArray) {
-        return false;
-    }
-
-    _texturebuf = (rgb888_t *)heap_alloc_dma(width * height * sizeof(rgb888_t));
-
-    /// 8byte alignment;
-    width = (width + 7) & ~7u;
-
-    _lines_buffer = lineArray;
-    memset(lineArray, 0, height * sizeof(uint8_t *));
-
-    uint8_t *framebuffer = (uint8_t *)heap_alloc_dma(width * height + 16);
-
-    auto fb = framebuffer;
-    {
-        for (size_t y = 0; y < height; ++y) {
-            lineArray[y] = fb;
-            fb += width;
-        }
-    }
-    return true;
-}
-
-void Panel_sdl::deinitFrameBuffer(void)
-{
-    auto lines = _lines_buffer;
-    _lines_buffer = nullptr;
-    if (lines != nullptr) {
-        heap_free(lines[0]);
-        heap_free(lines);
-    }
-    if (_texturebuf) {
-        heap_free(_texturebuf);
-        _texturebuf = nullptr;
-    }
-}
-
-//----------------------------------------------------------------------------
-} // namespace v1
-} // namespace lgfx
-
-#endif

src/graphics/Panel_sdl.hpp

@@ -1,166 +0,0 @@
-/*----------------------------------------------------------------------------/
-  Lovyan GFX - Graphics library for embedded devices.
-
-Original Source:
- https://github.com/lovyan03/LovyanGFX/
-
-Licence:
- [FreeBSD](https://github.com/lovyan03/LovyanGFX/blob/master/license.txt)
-
-Author:
- [lovyan03](https://twitter.com/lovyan03)
-
-Contributors:
- [ciniml](https://github.com/ciniml)
- [mongonta0716](https://github.com/mongonta0716)
- [tobozo](https://github.com/tobozo)
-
-Porting for SDL:
- [imliubo](https://github.com/imliubo)
-/----------------------------------------------------------------------------*/
-#pragma once
-
-#define SDL_MAIN_HANDLED
-// cppcheck-suppress preprocessorErrorDirective
-#if __has_include(<SDL2/SDL.h>)
-#include <SDL2/SDL.h>
-#include <SDL2/SDL_main.h>
-#elif __has_include(<SDL.h>)
-#include <SDL.h>
-#include <SDL_main.h>
-#endif
-
-#if defined(SDL_h_)
-#include "lgfx/v1/Touch.hpp"
-#include "lgfx/v1/misc/range.hpp"
-#include "lgfx/v1/panel/Panel_FrameBufferBase.hpp"
-#include <cstdint>
-
-namespace lgfx
-{
-inline namespace v1
-{
-
-struct Panel_sdl;
-struct monitor_t {
-    SDL_Window *window = nullptr;
-    SDL_Renderer *renderer = nullptr;
-    SDL_Texture *texture = nullptr;
-    SDL_Texture *texture_frameimage = nullptr;
-    Panel_sdl *panel = nullptr;
-
-    // 外枠
-    const void *frame_image = 0;
-    uint_fast16_t frame_width = 0;
-    uint_fast16_t frame_height = 0;
-    uint_fast16_t frame_inner_x = 0;
-    uint_fast16_t frame_inner_y = 0;
-    int_fast16_t frame_rotation = 0;
-    int_fast16_t frame_angle = 0;
-
-    float scaling_x = 1;
-    float scaling_y = 1;
-    int_fast16_t touch_x, touch_y;
-    bool touched = false;
-    bool closing = false;
-};
-//----------------------------------------------------------------------------
-
-struct Touch_sdl : public ITouch {
-    bool init(void) override { return true; }
-    void wakeup(void) override {}
-    void sleep(void) override {}
-    bool isEnable(void) override { return true; };
-    uint_fast8_t getTouchRaw(touch_point_t *tp, uint_fast8_t count) override { return 0; }
-};
-
-//----------------------------------------------------------------------------
-
-struct Panel_sdl : public Panel_FrameBufferBase {
-    static constexpr size_t EMULATED_GPIO_MAX = 128;
-    static volatile uint8_t _gpio_dummy_values[EMULATED_GPIO_MAX];
-
-  public:
-    Panel_sdl(void);
-    virtual ~Panel_sdl(void);
-
-    bool init(bool use_reset) override;
-
-    color_depth_t setColorDepth(color_depth_t depth) override;
-
-    void display(uint_fast16_t x, uint_fast16_t y, uint_fast16_t w, uint_fast16_t h) override;
-
-    // void setInvert(bool invert) override {}
-    void drawPixelPreclipped(uint_fast16_t x, uint_fast16_t y, uint32_t rawcolor) override;
-    void writeFillRectPreclipped(uint_fast16_t x, uint_fast16_t y, uint_fast16_t w, uint_fast16_t h, uint32_t rawcolor) override;
-    void writeBlock(uint32_t rawcolor, uint32_t length) override;
-    void writeImage(uint_fast16_t x, uint_fast16_t y, uint_fast16_t w, uint_fast16_t h, pixelcopy_t *param,
-                    bool use_dma) override;
-    void writeImageARGB(uint_fast16_t x, uint_fast16_t y, uint_fast16_t w, uint_fast16_t h, pixelcopy_t *param) override;
-    void writePixels(pixelcopy_t *param, uint32_t len, bool use_dma) override;
-
-    uint_fast8_t getTouchRaw(touch_point_t *tp, uint_fast8_t count) override;
-
-    void setWindowTitle(const char *title);
-    void setScaling(uint_fast8_t scaling_x, uint_fast8_t scaling_y);
-    void setFrameImage(const void *frame_image, int frame_width, int frame_height, int inner_x, int inner_y);
-    void setFrameRotation(uint_fast16_t frame_rotaion);
-    void setBrightness(uint8_t brightness) override{};
-
-    static volatile void gpio_hi(uint32_t pin) { _gpio_dummy_values[pin & (EMULATED_GPIO_MAX - 1)] = 1; }
-    static volatile void gpio_lo(uint32_t pin) { _gpio_dummy_values[pin & (EMULATED_GPIO_MAX - 1)] = 0; }
-    static volatile bool gpio_in(uint32_t pin) { return _gpio_dummy_values[pin & (EMULATED_GPIO_MAX - 1)]; }
-
-    static int setup(void);
-    static int loop(void);
-    static int close(void);
-
-    static int main(int (*fn)(bool *), uint32_t msec_step_exec = 512);
-
-    static void setShortcutKeymod(SDL_Keymod keymod) { _keymod = keymod; }
-
-    struct KeyCodeMapping_t {
-        SDL_KeyCode keycode = SDLK_UNKNOWN;
-        uint8_t gpio = 0;
-    };
-    static void addKeyCodeMapping(SDL_KeyCode keyCode, uint8_t gpio);
-    static int getKeyCodeMapping(SDL_KeyCode keyCode);
-
-  protected:
-    const char *_window_title = "LGFX Simulator";
-    SDL_mutex *_sdl_mutex = nullptr;
-
-    void sdl_create(monitor_t *m);
-    void sdl_update(void);
-
-    touch_point_t _touch_point;
-    monitor_t monitor;
-
-    rgb888_t *_texturebuf = nullptr;
-    uint_fast16_t _modified_counter;
-    uint_fast16_t _texupdate_counter;
-    uint_fast16_t _display_counter;
-    bool _invalidated;
-
-    static void _event_proc(void);
-    static void _update_proc(void);
-    static void _update_scaling(monitor_t *m, float sx, float sy);
-    void sdl_invalidate(void) { _invalidated = true; }
-    void render_texture(SDL_Texture *texture, int tx, int ty, int tw, int th, float angle);
-    bool initFrameBuffer(size_t width, size_t height);
-    void deinitFrameBuffer(void);
-
-    static SDL_Keymod _keymod;
-
-    struct lock_t {
-        lock_t(Panel_sdl *parent);
-        ~lock_t();
-
-      protected:
-        Panel_sdl *_parent;
-    };
-};
-//----------------------------------------------------------------------------
-} // namespace v1
-} // namespace lgfx
-#endif

src/graphics/Screen.cpp

@@ -83,11 +83,6 @@ extern uint16_t TFT_MESH;
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 
-#if defined(T_LORA_PAGER)
-// KB backlight control
-#include "input/cardKbI2cImpl.h"
-#endif
-
 using namespace meshtastic; /** @todo remove */
 
 namespace graphics
@@ -100,7 +95,7 @@ namespace graphics
 #define NUM_EXTRA_FRAMES 3 // text message and debug frame
 // if defined a pixel will blink to show redraws
 // #define SHOW_REDRAWS
-#define ASCII_BELL '\x07'
+
 // A text message frame + debug frame + all the node infos
 FrameCallback *normalFrames;
 static uint32_t targetFramerate = IDLE_FRAMERATE;
@@ -443,7 +438,7 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             if (uiconfig.screen_brightness == 1)
                 digitalWrite(PIN_EINK_EN, HIGH);
 #elif defined(PCA_PIN_EINK_EN)
-            if (uiconfig.screen_brightness > 0)
+            if (uiconfig.screen_brightness == 1)
                 io.digitalWrite(PCA_PIN_EINK_EN, HIGH);
 #endif
 
@@ -453,7 +448,7 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 
             dispdev->displayOn();
-#if defined(HELTEC_TRACKER_V1_X) || defined(HELTEC_WIRELESS_TRACKER_V2)
+#ifdef HELTEC_TRACKER_V1_X
             ui->init();
 #endif
 #ifdef USE_ST7789
@@ -660,19 +655,6 @@ void Screen::setup()
     MeshModule::observeUIEvents(&uiFrameEventObserver);
 }
 
-void Screen::setOn(bool on, FrameCallback einkScreensaver)
-{
-#if defined(T_LORA_PAGER)
-    if (cardKbI2cImpl)
-        cardKbI2cImpl->toggleBacklight(on);
-#endif
-    if (!on)
-        // We handle off commands immediately, because they might be called because the CPU is shutting down
-        handleSetOn(false, einkScreensaver);
-    else
-        enqueueCmd(ScreenCmd{.cmd = Cmd::SET_ON});
-}
-
 void Screen::forceDisplay(bool forceUiUpdate)
 {
     // Nasty hack to force epaper updates for 'key' frames.  FIXME, cleanup.
@@ -1428,9 +1410,6 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
         }
         nodeDB->updateGUI = false;
         break;
-    case STATUS_TYPE_POWER:
-        forceDisplay(true);
-        break;
     }
 
     return 0;
@@ -1461,36 +1440,28 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
             }
             // === Prepare banner content ===
             const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet->from);
-            const meshtastic_Channel channel =
-                channels.getByIndex(packet->channel ? packet->channel : channels.getPrimaryIndex());
             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;
-
-            if (moduleConfig.external_notification.alert_bell || moduleConfig.external_notification.alert_bell_vibra ||
-                moduleConfig.external_notification.alert_bell_buzzer)
-                // Check for bell character to determine if this message is an alert
-                for (size_t i = 0; i < packet->decoded.payload.size && i < 100; i++) {
-                    if (msgRaw[i] == ASCII_BELL) {
-                        isAlert = true;
-                        break;
-                    }
+            for (size_t i = 0; i < packet->decoded.payload.size && i < 100; i++) {
+                if (msgRaw[i] == '\x07') {
+                    isAlert = true;
+                    break;
                 }
+            }
 
-            // Unlike generic messages, alerts (when enabled via the ext notif module) ignore any
-            // 'mute' preferences set to any specific node or channel.
             if (isAlert) {
                 if (longName && longName[0]) {
                     snprintf(banner, sizeof(banner), "Alert Received from\n%s", longName);
                 } else {
                     strcpy(banner, "Alert Received");
                 }
-                screen->showSimpleBanner(banner, 3000);
-            } else if (!channel.settings.has_module_settings || !channel.settings.module_settings.is_muted) {
+            } else {
                 if (longName && longName[0]) {
 #if defined(M5STACK_UNITC6L)
                     strcpy(banner, "New Message");
@@ -1501,21 +1472,14 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
                 } else {
                     strcpy(banner, "New Message");
                 }
-#if defined(M5STACK_UNITC6L)
-                screen->setOn(true);
-                screen->showSimpleBanner(banner, 1500);
-                if (config.device.buzzer_mode != meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY ||
-                    (isAlert && moduleConfig.external_notification.alert_bell_buzzer) ||
-                    (!isBroadcast(packet->to) && isToUs(packet))) {
-                    // Beep if not in DIRECT_MSG_ONLY mode or if in DIRECT_MSG_ONLY mode and either
-                    // - packet contains an alert and alert bell buzzer is enabled
-                    // - packet is a non-broadcast that is addressed to this node
-                    playLongBeep();
-                }
-#else
-                screen->showSimpleBanner(banner, 3000);
-#endif
             }
+#if defined(M5STACK_UNITC6L)
+            screen->setOn(true);
+            screen->showSimpleBanner(banner, 1500);
+            playLongBeep();
+#else
+            screen->showSimpleBanner(banner, 3000);
+#endif
         }
     }
 

src/graphics/Screen.h

@@ -259,7 +259,15 @@ class Screen : public concurrency::OSThread
     void setup();
 
     /// Turns the screen on/off. Optionally, pass a custom screensaver frame for E-Ink
-    void setOn(bool on, FrameCallback einkScreensaver = NULL);
+    void setOn(bool on, FrameCallback einkScreensaver = NULL)
+    {
+        if (!on)
+            // We handle off commands immediately, because they might be called because the CPU is shutting down
+            handleSetOn(false, einkScreensaver);
+        else
+            enqueueCmd(ScreenCmd{.cmd = Cmd::SET_ON});
+    }
+
     /**
      * Prepare the display for the unit going to the lowest power mode possible.  Most screens will just
      * poweroff, but eink screens will show a "I'm sleeping" graphic, possibly with a QR code

src/graphics/SharedUIDisplay.cpp

@@ -1,8 +1,6 @@
-#include "configuration.h"
-#if HAS_SCREEN
+#include "graphics/SharedUIDisplay.h"
 #include "RTC.h"
 #include "graphics/ScreenFonts.h"
-#include "graphics/SharedUIDisplay.h"
 #include "graphics/draw/UIRenderer.h"
 #include "main.h"
 #include "meshtastic/config.pb.h"
@@ -286,7 +284,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 int iconX = iconRightEdge - mute_symbol_big_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mute_symbol_big_height) / 2;
 
-                if (isInverted && !force_no_invert) {
+                if (isInverted) {
                     display->setColor(WHITE);
                     display->fillRect(iconX - 1, iconY - 1, mute_symbol_big_width + 2, mute_symbol_big_height + 2);
                     display->setColor(BLACK);
@@ -425,4 +423,3 @@ std::string sanitizeString(const std::string &input)
 }
 
 } // namespace graphics
-#endif

src/graphics/TFTDisplay.cpp

@@ -751,8 +751,10 @@ static LGFX *tft = nullptr;
 
 static TFT_eSPI *tft = nullptr; // Invoke library, pins defined in User_Setup.h
 #elif ARCH_PORTDUINO
-#include "Panel_sdl.hpp"
 #include <LovyanGFX.hpp> // Graphics and font library for ST7735 driver chip
+#if defined(LGFX_SDL)
+#include <lgfx/v1/platforms/sdl/Panel_sdl.hpp>
+#endif
 
 class LGFX : public lgfx::LGFX_Device
 {
@@ -781,10 +783,10 @@ class LGFX : public lgfx::LGFX_Device
             _panel_instance = new lgfx::Panel_ILI9488;
         else if (portduino_config.displayPanel == hx8357d)
             _panel_instance = new lgfx::Panel_HX8357D;
-#if defined(SDL_h_)
-
-        else if (portduino_config.displayPanel == x11)
+#if defined(LGFX_SDL)
+        else if (portduino_config.displayPanel == x11) {
             _panel_instance = new lgfx::Panel_sdl;
+        }
 #endif
         else {
             _panel_instance = new lgfx::Panel_NULL;
@@ -797,9 +799,8 @@ class LGFX : public lgfx::LGFX_Device
 
         buscfg.pin_dc = portduino_config.displayDC.pin; // Set SPI DC pin number (-1 = disable)
 
-        _bus_instance.config(buscfg); // applies the set value to the bus.
-        if (portduino_config.displayPanel != x11)
-            _panel_instance->setBus(&_bus_instance); // set the bus on the panel.
+        _bus_instance.config(buscfg);            // applies the set value to the bus.
+        _panel_instance->setBus(&_bus_instance); // set the bus on the panel.
 
         auto cfg = _panel_instance->config(); // Gets a structure for display panel settings.
         LOG_DEBUG("Width: %d, Height: %d", portduino_config.displayWidth, portduino_config.displayHeight);
@@ -847,7 +848,7 @@ class LGFX : public lgfx::LGFX_Device
             _touch_instance->config(touch_cfg);
             _panel_instance->setTouch(_touch_instance);
         }
-#if defined(SDL_h_)
+#if defined(LGFX_SDL)
         if (portduino_config.displayPanel == x11) {
             lgfx::Panel_sdl *sdl_panel_ = (lgfx::Panel_sdl *)_panel_instance;
             sdl_panel_->setup();
@@ -1236,7 +1237,7 @@ void TFTDisplay::display(bool fromBlank)
 
 void TFTDisplay::sdlLoop()
 {
-#if defined(SDL_h_)
+#if defined(LGFX_SDL)
     static int lastPressed = 0;
     static int shuttingDown = false;
     if (portduino_config.displayPanel == x11) {
@@ -1246,26 +1247,27 @@ void TFTDisplay::sdlLoop()
             InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_SHUTDOWN, .kbchar = 0, .touchX = 0, .touchY = 0};
             inputBroker->injectInputEvent(&event);
         }
+
         // debounce
-        if (lastPressed != 0 && !sdl_panel_->gpio_in(lastPressed))
+        if (lastPressed != 0 && !lgfx::v1::gpio_in(lastPressed))
             return;
-        if (!sdl_panel_->gpio_in(37)) {
+        if (!lgfx::v1::gpio_in(37)) {
             lastPressed = 37;
             InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_RIGHT, .kbchar = 0, .touchX = 0, .touchY = 0};
             inputBroker->injectInputEvent(&event);
-        } else if (!sdl_panel_->gpio_in(36)) {
+        } else if (!lgfx::v1::gpio_in(36)) {
             lastPressed = 36;
             InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_UP, .kbchar = 0, .touchX = 0, .touchY = 0};
             inputBroker->injectInputEvent(&event);
-        } else if (!sdl_panel_->gpio_in(38)) {
+        } else if (!lgfx::v1::gpio_in(38)) {
             lastPressed = 38;
             InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_DOWN, .kbchar = 0, .touchX = 0, .touchY = 0};
             inputBroker->injectInputEvent(&event);
-        } else if (!sdl_panel_->gpio_in(39)) {
+        } else if (!lgfx::v1::gpio_in(39)) {
             lastPressed = 39;
             InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_LEFT, .kbchar = 0, .touchX = 0, .touchY = 0};
             inputBroker->injectInputEvent(&event);
-        } else if (!sdl_panel_->gpio_in(SDL_SCANCODE_KP_ENTER)) {
+        } else if (!lgfx::v1::gpio_in(SDL_SCANCODE_KP_ENTER)) {
             lastPressed = SDL_SCANCODE_KP_ENTER;
             InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_SELECT, .kbchar = 0, .touchX = 0, .touchY = 0};
             inputBroker->injectInputEvent(&event);

src/graphics/VirtualKeyboard.cpp

@@ -1,6 +1,5 @@
-#include "configuration.h"
-#if HAS_SCREEN
 #include "VirtualKeyboard.h"
+#include "configuration.h"
 #include "graphics/Screen.h"
 #include "graphics/ScreenFonts.h"
 #include "graphics/SharedUIDisplay.h"
@@ -737,4 +736,3 @@ bool VirtualKeyboard::isTimedOut() const
 }
 
 } // namespace graphics
-#endif

src/graphics/draw/CompassRenderer.cpp

@@ -1,5 +1,3 @@
-#include "configuration.h"
-#if HAS_SCREEN
 #include "CompassRenderer.h"
 #include "NodeDB.h"
 #include "UIRenderer.h"
@@ -137,4 +135,3 @@ uint16_t getCompassDiam(uint32_t displayWidth, uint32_t displayHeight)
 
 } // namespace CompassRenderer
 } // namespace graphics
-#endif

src/graphics/draw/MenuHandler.cpp

@@ -116,8 +116,6 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
     bannerOptions.bannerCallback = [](int selected) -> void {
         if (selected != 0 && config.lora.region != _meshtastic_Config_LoRaConfig_RegionCode(selected)) {
             config.lora.region = _meshtastic_Config_LoRaConfig_RegionCode(selected);
-            auto changes = SEGMENT_CONFIG;
-
             // This is needed as we wait til picking the LoRa region to generate keys for the first time.
             if (!owner.is_licensed) {
                 bool keygenSuccess = false;
@@ -126,7 +124,6 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
                     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);
@@ -144,14 +141,7 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
             if (myRegion->dutyCycle < 100) {
                 config.lora.ignore_mqtt = true; // Ignore MQTT by default if region has a duty cycle limit
             }
-
-            if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
-                //  Default broker is in use, so subscribe to the appropriate MQTT root topic for this region
-                sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
-                changes |= SEGMENT_MODULECONFIG;
-            }
-
-            service->reloadConfig(changes);
+            service->reloadConfig(SEGMENT_CONFIG);
             rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
         }
     };
@@ -515,7 +505,7 @@ void menuHandler::homeBaseMenu()
             }
             saveUIConfig();
 #elif defined(PCA_PIN_EINK_EN)
-            if (uiconfig.screen_brightness > 0) {
+            if (uiconfig.screen_brightness == 1) {
                 uiconfig.screen_brightness = 0;
                 io.digitalWrite(PCA_PIN_EINK_EN, LOW);
             } else {
@@ -762,32 +752,6 @@ void menuHandler::nodeListMenu()
     screen->showOverlayBanner(bannerOptions);
 }
 
-void menuHandler::nodeNameLengthMenu()
-{
-    enum OptionsNumbers { Back, Long, Short };
-    static const char *optionsArray[] = {"Back", "Long", "Short"};
-    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Node Name Length";
-    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 3;
-    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == Long) {
-            // Set names to long
-            LOG_INFO("Setting names to long");
-            config.display.use_long_node_name = true;
-        } else if (selected == Short) {
-            // Set names to short
-            LOG_INFO("Setting names to short");
-            config.display.use_long_node_name = false;
-        } else if (selected == Back) {
-            menuQueue = screen_options_menu;
-            screen->runNow();
-        }
-    };
-    bannerOptions.InitialSelected = config.display.use_long_node_name == true ? 1 : 2;
-    screen->showOverlayBanner(bannerOptions);
-}
-
 void menuHandler::resetNodeDBMenu()
 {
     static const char *optionsArray[] = {"Back", "Confirm"};
@@ -888,31 +852,24 @@ void menuHandler::GPSFormatMenu()
     bannerOptions.bannerCallback = [](int selected) -> void {
         if (selected == 1) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC;
-            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 2) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS;
-            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 3) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_UTM;
-            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 4) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_MGRS;
-            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 5) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC;
-            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 6) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_OSGR;
-            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 7) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS;
-            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else {
             menuQueue = position_base_menu;
@@ -936,9 +893,7 @@ void menuHandler::BluetoothToggleMenu()
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsCount = 3;
     bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == 0)
-            return;
-        else if (selected != (config.bluetooth.enabled ? 1 : 2)) {
+        if (selected == 1 || selected == 2) {
             InputEvent event = {.inputEvent = (input_broker_event)170, .kbchar = 170, .touchX = 0, .touchY = 0};
             inputBroker->injectInputEvent(&event);
         }
@@ -949,11 +904,11 @@ void menuHandler::BluetoothToggleMenu()
 
 void menuHandler::BuzzerModeMenu()
 {
-    static const char *optionsArray[] = {"All Enabled", "Disabled", "Notifications", "System Only", "DMs Only"};
+    static const char *optionsArray[] = {"All Enabled", "Disabled", "Notifications", "System Only"};
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "Buzzer Mode";
     bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 5;
+    bannerOptions.optionsCount = 4;
     bannerOptions.bannerCallback = [](int selected) -> void {
         config.device.buzzer_mode = (meshtastic_Config_DeviceConfig_BuzzerMode)selected;
         service->reloadConfig(SEGMENT_CONFIG);
@@ -1332,16 +1287,11 @@ void menuHandler::screenOptionsMenu()
     hasSupportBrightness = false;
 #endif
 
-    enum optionsNumbers { Back, NodeNameLength, Brightness, ScreenColor };
-    static const char *optionsArray[5] = {"Back"};
-    static int optionsEnumArray[5] = {Back};
+    enum optionsNumbers { Back, Brightness, ScreenColor };
+    static const char *optionsArray[4] = {"Back"};
+    static int optionsEnumArray[4] = {Back};
     int options = 1;
 
-#if defined(T_DECK) || defined(T_LORA_PAGER)
-    optionsArray[options] = "Show Long/Short Name";
-    optionsEnumArray[options++] = NodeNameLength;
-#endif
-
     // Only show brightness for B&W displays
     if (hasSupportBrightness) {
         optionsArray[options] = "Brightness";
@@ -1366,9 +1316,6 @@ void menuHandler::screenOptionsMenu()
         } else if (selected == ScreenColor) {
             menuHandler::menuQueue = menuHandler::tftcolormenupicker;
             screen->runNow();
-        } else if (selected == NodeNameLength) {
-            menuHandler::menuQueue = menuHandler::node_name_length_menu;
-            screen->runNow();
         } else {
             menuQueue = system_base_menu;
             screen->runNow();
@@ -1467,8 +1414,6 @@ void menuHandler::FrameToggles_menu()
         lora,
         clock,
         show_favorites,
-        show_telemetry,
-        show_power,
         enumEnd
     };
     static const char *optionsArray[enumEnd] = {"Finish"};
@@ -1507,12 +1452,6 @@ void menuHandler::FrameToggles_menu()
     optionsArray[options] = screen->isFrameHidden("show_favorites") ? "Show Favorites" : "Hide Favorites";
     optionsEnumArray[options++] = show_favorites;
 
-    optionsArray[options] = moduleConfig.telemetry.environment_screen_enabled ? "Hide Telemetry" : "Show Telemetry";
-    optionsEnumArray[options++] = show_telemetry;
-
-    optionsArray[options] = moduleConfig.telemetry.power_screen_enabled ? "Hide Power" : "Show Power";
-    optionsEnumArray[options++] = show_power;
-
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "Show/Hide Frames";
     bannerOptions.optionsArrayPtr = optionsArray;
@@ -1567,14 +1506,6 @@ void menuHandler::FrameToggles_menu()
             screen->toggleFrameVisibility("show_favorites");
             menuHandler::menuQueue = menuHandler::FrameToggles;
             screen->runNow();
-        } else if (selected == show_telemetry) {
-            moduleConfig.telemetry.environment_screen_enabled = !moduleConfig.telemetry.environment_screen_enabled;
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == show_power) {
-            moduleConfig.telemetry.power_screen_enabled = !moduleConfig.telemetry.power_screen_enabled;
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
         }
     };
     screen->showOverlayBanner(bannerOptions);
@@ -1646,9 +1577,6 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
     case brightness_picker:
         BrightnessPickerMenu();
         break;
-    case node_name_length_menu:
-        nodeNameLengthMenu();
-        break;
     case reboot_menu:
         rebootMenu();
         break;

src/graphics/draw/MenuHandler.h

@@ -43,7 +43,6 @@ class menuHandler
         key_verification_final_prompt,
         trace_route_menu,
         throttle_message,
-        node_name_length_menu,
         FrameToggles
     };
     static screenMenus menuQueue;
@@ -86,7 +85,6 @@ class menuHandler
     static void notificationsMenu();
     static void screenOptionsMenu();
     static void powerMenu();
-    static void nodeNameLengthMenu();
     static void FrameToggles_menu();
     static void textMessageMenu();
 

src/graphics/draw/NodeListRenderer.cpp

@@ -53,56 +53,28 @@ static int scrollIndex = 0;
 // Utility Functions
 // =============================
 
-const char *getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node)
+const char *getSafeNodeName(meshtastic_NodeInfoLite *node)
 {
-    const char *name = NULL;
     static char nodeName[16] = "?";
-    if (config.display.use_long_node_name == true) {
-        if (node->has_user && strlen(node->user.long_name) > 0) {
-            name = node->user.long_name;
+    if (node->has_user && strlen(node->user.short_name) > 0) {
+        bool valid = true;
+        const char *name = node->user.short_name;
+        for (size_t i = 0; i < strlen(name); i++) {
+            uint8_t c = (uint8_t)name[i];
+            if (c < 32 || c > 126) {
+                valid = false;
+                break;
+            }
+        }
+        if (valid) {
+            strncpy(nodeName, name, sizeof(nodeName) - 1);
+            nodeName[sizeof(nodeName) - 1] = '\0';
         } else {
             snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
         }
-    } else {
-        if (node->has_user && strlen(node->user.short_name) > 0) {
-            name = node->user.short_name;
-        } else {
-            snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
-        }
-    }
-
-    // Use sanitizeString() function and copy directly into nodeName
-    std::string sanitized_name = sanitizeString(name ? name : "");
-
-    if (!sanitized_name.empty()) {
-        strncpy(nodeName, sanitized_name.c_str(), sizeof(nodeName) - 1);
-        nodeName[sizeof(nodeName) - 1] = '\0';
     } else {
         snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
     }
-
-    if (config.display.use_long_node_name == true) {
-        int availWidth = (SCREEN_WIDTH / 2) - 65;
-        if (availWidth < 0)
-            availWidth = 0;
-
-        size_t origLen = strlen(nodeName);
-        while (nodeName[0] && display->getStringWidth(nodeName) > availWidth) {
-            nodeName[strlen(nodeName) - 1] = '\0';
-        }
-
-        // If we actually truncated, append "..." (ensure space remains in buffer)
-        if (strlen(nodeName) < origLen) {
-            size_t len = strlen(nodeName);
-            size_t maxLen = sizeof(nodeName) - 4; // 3 for "..." and 1 for '\0'
-            if (len > maxLen) {
-                nodeName[maxLen] = '\0';
-                len = maxLen;
-            }
-            strcat(nodeName, "...");
-        }
-    }
-
     return nodeName;
 }
 
@@ -169,7 +141,7 @@ void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
     int timeOffset = (isHighResolution) ? (isLeftCol ? 7 : 10) : (isLeftCol ? 3 : 7);
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(node);
 
     char timeStr[10];
     uint32_t seconds = sinceLastSeen(node);
@@ -214,7 +186,7 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 
     int barsXOffset = columnWidth - barsOffset;
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(node);
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
@@ -258,7 +230,7 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
     int nameMaxWidth = columnWidth - (isHighResolution ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(node);
     char distStr[10] = "";
 
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
@@ -353,7 +325,7 @@ void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     // Adjust max text width depending on column and screen width
     int nameMaxWidth = columnWidth - (isHighResolution ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(node);
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
@@ -384,11 +356,11 @@ void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     float bearing = GeoCoord::bearing(userLat, userLon, nodeLat, nodeLon);
     float bearingToNode = RAD_TO_DEG * bearing;
     float relativeBearing = fmod((bearingToNode - myHeading + 360), 360);
+    float angle = relativeBearing * DEG_TO_RAD;
     // Shrink size by 2px
     int size = FONT_HEIGHT_SMALL - 5;
     CompassRenderer::drawArrowToNode(display, centerX, centerY, size, relativeBearing);
     /*
-    float angle = relativeBearing * DEG_TO_RAD;
     float halfSize = size / 2.0;
 
     // Point of the arrow

src/graphics/draw/UIRenderer.cpp

@@ -125,10 +125,8 @@ void UIRenderer::drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y,
     char displayLine[32];
 
     if (!gps->getIsConnected() && !config.position.fixed_position) {
-        if (strcmp(mode, "line1") == 0) {
-            strcpy(displayLine, "No GPS present");
-            display->drawString(x, y, displayLine);
-        }
+        strcpy(displayLine, "No GPS present");
+        display->drawString(x, y, displayLine);
     } else if (!gps->getHasLock() && !config.position.fixed_position) {
         if (strcmp(mode, "line1") == 0) {
             strcpy(displayLine, "No GPS Lock");
@@ -563,7 +561,6 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     int line = 1;
-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
     // === Header ===
 #if defined(M5STACK_UNITC6L)
@@ -741,6 +738,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     int yOffset = (isHighResolution) ? 0 : 5;
     std::string longNameStr;
 
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     if (ourNode && ourNode->has_user && strlen(ourNode->user.long_name) > 0) {
         longNameStr = sanitizeString(ourNode->user.long_name);
     }
@@ -1000,7 +998,24 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
     const char *displayLine = ""; // Initialize to empty string by default
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
-    if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
+    bool usePhoneGPS = (ourNode && nodeDB->hasValidPosition(ourNode) &&
+                        config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED);
+
+    if (usePhoneGPS) {
+        // Phone-provided GPS is active
+        displayLine = "Phone GPS";
+        int yOffset = (isHighResolution) ? 3 : 1;
+        if (isHighResolution) {
+            NodeListRenderer::drawScaledXBitmap16x16(x, getTextPositions(display)[line] + yOffset - 5, imgSatellite_width,
+                                                     imgSatellite_height, imgSatellite, display);
+        } else {
+            display->drawXbm(x + 1, getTextPositions(display)[line] + yOffset, imgSatellite_width, imgSatellite_height,
+                             imgSatellite);
+        }
+        int xOffset = (isHighResolution) ? 6 : 0;
+        display->drawString(x + 11 + xOffset, getTextPositions(display)[line++], displayLine);
+    } else if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
+        // GPS disabled / not present
         if (config.position.fixed_position) {
             displayLine = "Fixed GPS";
         } else {
@@ -1088,16 +1103,6 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
             // === Fourth Row: Line 2 GPS Info ===
             UIRenderer::drawGpsCoordinates(display, x, getTextPositions(display)[line++], gpsStatus, "line2");
         }
-
-        // === Final Row: Altitude ===
-        char altitudeLine[32] = {0};
-        int32_t alt = geoCoord.getAltitude();
-        if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
-            snprintf(altitudeLine, sizeof(altitudeLine), "Alt: %.0fft", alt * METERS_TO_FEET);
-        } else {
-            snprintf(altitudeLine, sizeof(altitudeLine), "Alt: %.0im", alt);
-        }
-        display->drawString(x, getTextPositions(display)[line++], altitudeLine);
     }
 #if !defined(M5STACK_UNITC6L)
     // === Draw Compass if heading is valid ===

src/graphics/emotes.cpp

@@ -1,5 +1,3 @@
-#include "configuration.h"
-#if HAS_SCREEN
 #include "emotes.h"
 
 namespace graphics
@@ -277,4 +275,3 @@ const unsigned char bell_icon[] PROGMEM = {
 #endif
 
 } // namespace graphics
-#endif

src/graphics/niche/InkHUD/Applets/Bases/Map/MapApplet.cpp

@@ -13,147 +13,45 @@ void InkHUD::MapApplet::onRender()
         return;
     }
 
-    // Helper: draw rounded rectangle centered at x,y
-    auto fillRoundedRect = [&](int16_t cx, int16_t cy, int16_t w, int16_t h, int16_t r, uint16_t color) {
-        int16_t x = cx - (w / 2);
-        int16_t y = cy - (h / 2);
-
-        // center rects
-        fillRect(x + r, y, w - 2 * r, h, color);
-        fillRect(x, y + r, r, h - 2 * r, color);
-        fillRect(x + w - r, y + r, r, h - 2 * r, color);
-
-        // corners
-        fillCircle(x + r, y + r, r, color);
-        fillCircle(x + w - r - 1, y + r, r, color);
-        fillCircle(x + r, y + h - r - 1, r, color);
-        fillCircle(x + w - r - 1, y + h - r - 1, r, color);
-    };
-
     // Find center of map
+    // - latitude and longitude
+    // - will be placed at X(0.5), Y(0.5)
     getMapCenter(&latCenter, &lngCenter);
+
+    // Calculate North+East distance of each node to map center
+    // - which nodes to use controlled by virtual shouldDrawNode method
     calculateAllMarkers();
+
+    // Set the region shown on the map
+    // - default: fit all nodes, plus padding
+    // - maybe overriden by derived applet
+    // - getMapSize *sets* passed parameters (C-style)
     getMapSize(&widthMeters, &heightMeters);
+
+    // Set the metersToPx conversion value
     calculateMapScale();
 
-    // Draw all markers first
+    // Special marker for own node
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    if (ourNode && nodeDB->hasValidPosition(ourNode))
+        drawLabeledMarker(ourNode);
+
+    // Draw all markers
     for (Marker m : markers) {
         int16_t x = X(0.5) + (m.eastMeters * metersToPx);
         int16_t y = Y(0.5) - (m.northMeters * metersToPx);
 
-        // Add white halo outline first
-        constexpr int outlinePad = 1;
-        int boxSize = 11;
-        int radius = 2; // rounded corner radius
+        // Cross Size
+        constexpr uint16_t csMin = 5;
+        constexpr uint16_t csMax = 12;
 
-        // White halo background
-        fillRoundedRect(x, y, boxSize + (outlinePad * 2), boxSize + (outlinePad * 2), radius + 1, WHITE);
-
-        // Draw inner box
-        fillRoundedRect(x, y, boxSize, boxSize, radius, BLACK);
-
-        // Text inside
-        setFont(fontSmall);
-        setTextColor(WHITE);
-
-        // Draw actual marker on top
-        if (m.hasHopsAway && m.hopsAway > config.lora.hop_limit) {
-            printAt(x + 1, y + 1, "X", CENTER, MIDDLE);
-        } else if (!m.hasHopsAway) {
-            printAt(x + 1, y + 1, "?", CENTER, MIDDLE);
-        } else {
-            char hopStr[4];
-            snprintf(hopStr, sizeof(hopStr), "%d", m.hopsAway);
-            printAt(x, y + 1, hopStr, CENTER, MIDDLE);
-        }
-
-        // Restore default font and color
-        setFont(fontSmall);
-        setTextColor(BLACK);
-    }
-
-    // Dual map scale bars
-    int16_t horizPx = width() * 0.25f;
-    int16_t vertPx = height() * 0.25f;
-    float horizMeters = horizPx / metersToPx;
-    float vertMeters = vertPx / metersToPx;
-
-    auto formatDistance = [&](float meters, char *out, size_t len) {
-        if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
-            float feet = meters * 3.28084f;
-            if (feet < 528)
-                snprintf(out, len, "%.0f ft", feet);
-            else {
-                float miles = feet / 5280.0f;
-                snprintf(out, len, miles < 10 ? "%.1f mi" : "%.0f mi", miles);
-            }
-        } else {
-            if (meters >= 1000)
-                snprintf(out, len, "%.1f km", meters / 1000.0f);
-            else
-                snprintf(out, len, "%.0f m", meters);
-        }
-    };
-
-    // Horizontal scale bar
-    int16_t horizBarY = height() - 2;
-    int16_t horizBarX = 1;
-    drawLine(horizBarX, horizBarY, horizBarX + horizPx, horizBarY, BLACK);
-    drawLine(horizBarX, horizBarY - 3, horizBarX, horizBarY + 3, BLACK);
-    drawLine(horizBarX + horizPx, horizBarY - 3, horizBarX + horizPx, horizBarY + 3, BLACK);
-
-    char horizLabel[32];
-    formatDistance(horizMeters, horizLabel, sizeof(horizLabel));
-    int16_t horizLabelW = getTextWidth(horizLabel);
-    int16_t horizLabelH = getFont().lineHeight();
-    int16_t horizLabelX = horizBarX + horizPx + 4;
-    int16_t horizLabelY = horizBarY - horizLabelH + 1;
-    fillRect(horizLabelX - 2, horizLabelY - 1, horizLabelW + 4, horizLabelH + 2, WHITE);
-    printAt(horizLabelX, horizBarY, horizLabel, LEFT, BOTTOM);
-
-    // Vertical scale bar
-    int16_t vertBarX = 1;
-    int16_t vertBarBottom = horizBarY;
-    int16_t vertBarTop = vertBarBottom - vertPx;
-    drawLine(vertBarX, vertBarBottom, vertBarX, vertBarTop, BLACK);
-    drawLine(vertBarX - 3, vertBarBottom, vertBarX + 3, vertBarBottom, BLACK);
-    drawLine(vertBarX - 3, vertBarTop, vertBarX + 3, vertBarTop, BLACK);
-
-    char vertTopLabel[32];
-    formatDistance(vertMeters, vertTopLabel, sizeof(vertTopLabel));
-    int16_t topLabelY = vertBarTop - getFont().lineHeight() - 2;
-    int16_t topLabelW = getTextWidth(vertTopLabel);
-    int16_t topLabelH = getFont().lineHeight();
-    fillRect(vertBarX - 2, topLabelY - 1, topLabelW + 6, topLabelH + 2, WHITE);
-    printAt(vertBarX + (topLabelW / 2) + 1, topLabelY + (topLabelH / 2), vertTopLabel, CENTER, MIDDLE);
-
-    char vertBottomLabel[32];
-    formatDistance(vertMeters, vertBottomLabel, sizeof(vertBottomLabel));
-    int16_t bottomLabelY = vertBarBottom + 4;
-    int16_t bottomLabelW = getTextWidth(vertBottomLabel);
-    int16_t bottomLabelH = getFont().lineHeight();
-    fillRect(vertBarX - 2, bottomLabelY - 1, bottomLabelW + 6, bottomLabelH + 2, WHITE);
-    printAt(vertBarX + (bottomLabelW / 2) + 1, bottomLabelY + (bottomLabelH / 2), vertBottomLabel, CENTER, MIDDLE);
-
-    // Draw our node LAST with full white fill + outline
-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    if (ourNode && nodeDB->hasValidPosition(ourNode)) {
-        Marker self = calculateMarker(ourNode->position.latitude_i * 1e-7, ourNode->position.longitude_i * 1e-7, false, 0);
-
-        int16_t centerX = X(0.5) + (self.eastMeters * metersToPx);
-        int16_t centerY = Y(0.5) - (self.northMeters * metersToPx);
-
-        // White fill background + halo
-        fillCircle(centerX, centerY, 8, WHITE); // big white base
-        drawCircle(centerX, centerY, 8, WHITE); // crisp edge
-
-        // Black bullseye on top
-        drawCircle(centerX, centerY, 6, BLACK);
-        fillCircle(centerX, centerY, 2, BLACK);
-
-        // Crosshairs
-        drawLine(centerX - 8, centerY, centerX + 8, centerY, BLACK);
-        drawLine(centerX, centerY - 8, centerX, centerY + 8, BLACK);
+        // Too many hops away
+        if (m.hasHopsAway && m.hopsAway > config.lora.hop_limit) // Too many mops
+            printAt(x, y, "!", CENTER, MIDDLE);
+        else if (!m.hasHopsAway) // Unknown hops
+            drawCross(x, y, csMin);
+        else // The fewer hops, the larger the cross
+            drawCross(x, y, map(m.hopsAway, 0, config.lora.hop_limit, csMax, csMin));
     }
 }
 
@@ -165,123 +63,110 @@ void InkHUD::MapApplet::onRender()
 
 void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
 {
-    // If we have a valid position for our own node, use that as the anchor
-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    if (ourNode && nodeDB->hasValidPosition(ourNode)) {
-        *lat = ourNode->position.latitude_i * 1e-7;
-        *lng = ourNode->position.longitude_i * 1e-7;
-    } else {
-        // Find mean lat long coords
-        // ============================
-        // - assigning X, Y and Z values to position on Earth's surface in 3D space, relative to center of planet
-        // - averages the x, y and z coords
-        // - uses tan to find angles for lat / long degrees
-        //   - longitude: triangle formed by x and y (on plane of the equator)
-        //   - latitude: triangle formed by z (north south),
-        //     and the line along plane of equator which stretches from earth's axis to where point xyz intersects planet's
-        //     surface
+    // Find mean lat long coords
+    // ============================
+    // - assigning X, Y and Z values to position on Earth's surface in 3D space, relative to center of planet
+    // - averages the x, y and z coords
+    // - uses tan to find angles for lat / long degrees
+    //   - longitude: triangle formed by x and y (on plane of the equator)
+    //   - latitude: triangle formed by z (north south),
+    //     and the line along plane of equator which stretches from earth's axis to where point xyz intersects planet's surface
 
-        // Working totals, averaged after nodeDB processed
-        uint32_t positionCount = 0;
-        float xAvg = 0;
-        float yAvg = 0;
-        float zAvg = 0;
+    // Working totals, averaged after nodeDB processed
+    uint32_t positionCount = 0;
+    float xAvg = 0;
+    float yAvg = 0;
+    float zAvg = 0;
 
-        // For each node in db
-        for (uint32_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
+    // For each node in db
+    for (uint32_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
-            // Skip if no position
-            if (!nodeDB->hasValidPosition(node))
-                continue;
+        // Skip if no position
+        if (!nodeDB->hasValidPosition(node))
+            continue;
 
-            // Skip if derived applet doesn't want to show this node on the map
-            if (!shouldDrawNode(node))
-                continue;
+        // Skip if derived applet doesn't want to show this node on the map
+        if (!shouldDrawNode(node))
+            continue;
 
-            // Latitude and Longitude of node, in radians
-            float latRad = node->position.latitude_i * (1e-7) * DEG_TO_RAD;
-            float lngRad = node->position.longitude_i * (1e-7) * DEG_TO_RAD;
+        // Latitude and Longitude of node, in radians
+        float latRad = node->position.latitude_i * (1e-7) * DEG_TO_RAD;
+        float lngRad = node->position.longitude_i * (1e-7) * DEG_TO_RAD;
 
-            // Convert to cartesian points, with center of earth at 0, 0, 0
-            // Exact distance from center is irrelevant, as we're only interested in the vector
-            float x = cos(latRad) * cos(lngRad);
-            float y = cos(latRad) * sin(lngRad);
-            float z = sin(latRad);
+        // Convert to cartesian points, with center of earth at 0, 0, 0
+        // Exact distance from center is irrelevant, as we're only interested in the vector
+        float x = cos(latRad) * cos(lngRad);
+        float y = cos(latRad) * sin(lngRad);
+        float z = sin(latRad);
 
-            // To find mean values shortly
-            xAvg += x;
-            yAvg += y;
-            zAvg += z;
-            positionCount++;
-        }
-
-        // All NodeDB processed, find mean values
-        xAvg /= positionCount;
-        yAvg /= positionCount;
-        zAvg /= positionCount;
-
-        // Longitude from cartesian coords
-        // (Angle from 3D coords describing a point of globe's surface)
-        /*
-                          UK
-                       /-------\
-        (Top View)   /-         -\
-                   /-      (You)  -\
-                 /-           .     -\
-               /-             . X     -\
-         Asia -             ...         - USA
-               \-           Y         -/
-                 \-                 -/
-                   \-             -/
-                     \-         -/
-                       \- -----/
-                       Pacific
-
-        */
-
-        *lng = atan2(yAvg, xAvg) * RAD_TO_DEG;
-
-        // Latitude from cartesian coords
-        // (Angle from 3D coords describing a point on the globe's surface)
-        // As latitude increases, distance from the Earth's north-south axis out to our surface point decreases.
-        // Means we need to first find the hypotenuse which becomes base of our triangle in the second step
-        /*
-                           UK                                         North
-                        /-------\                 (Front View)      /-------\
-         (Top View)   /-         -\                               /-         -\
-                    /-       (You) -\                           /-(You)        -\
-                  /-         /.      -\                       /-   .             -\
-                /-    √X²+Y²/ . X      -\                   /-   Z .               -\
-        Asia   -           /...          - USA             -       .....             -
-                \-           Y         -/                   \-     √X²+Y²          -/
-                  \-                 -/                       \-                 -/
-                    \-             -/                           \-             -/
-                      \-         -/                               \-         -/
-                        \- -----/                                   \- -----/
-                         Pacific                                      South
-        */
-
-        float hypotenuse = sqrt((xAvg * xAvg) + (yAvg * yAvg)); // Distance from globe's north-south axis to surface intersect
-        *lat = atan2(zAvg, hypotenuse) * RAD_TO_DEG;
+        // To find mean values shortly
+        xAvg += x;
+        yAvg += y;
+        zAvg += z;
+        positionCount++;
     }
 
-    // Use either our node position, or the mean fallback as the center
-    latCenter = *lat;
-    lngCenter = *lng;
+    // All NodeDB processed, find mean values
+    xAvg /= positionCount;
+    yAvg /= positionCount;
+    zAvg /= positionCount;
+
+    // Longitude from cartesian coords
+    // (Angle from 3D coords describing a point of globe's surface)
+    /*
+                      UK
+                   /-------\
+    (Top View)   /-         -\
+               /-      (You)  -\
+             /-           .     -\
+           /-             . X     -\
+     Asia -             ...         - USA
+           \-           Y         -/
+             \-                 -/
+               \-             -/
+                 \-         -/
+                   \- -----/
+                   Pacific
+
+    */
+
+    *lng = atan2(yAvg, xAvg) * RAD_TO_DEG;
+
+    // Latitude from cartesian coords
+    // (Angle from 3D coords describing a point on the globe's surface)
+    // As latitude increases, distance from the Earth's north-south axis out to our surface point decreases.
+    // Means we need to first find the hypotenuse which becomes base of our triangle in the second step
+    /*
+                       UK                                         North
+                    /-------\                 (Front View)      /-------\
+     (Top View)   /-         -\                               /-         -\
+                /-       (You) -\                           /-(You)        -\
+              /-         /.      -\                       /-   .             -\
+            /-    √X²+Y²/ . X      -\                   /-   Z .               -\
+    Asia   -           /...          - USA             -       .....             -
+            \-           Y         -/                   \-     √X²+Y²          -/
+              \-                 -/                       \-                 -/
+                \-             -/                           \-             -/
+                  \-         -/                               \-         -/
+                    \- -----/                                   \- -----/
+                     Pacific                                      South
+    */
+
+    float hypotenuse = sqrt((xAvg * xAvg) + (yAvg * yAvg)); // Distance from globe's north-south axis to surface intersect
+    *lat = atan2(zAvg, hypotenuse) * RAD_TO_DEG;
 
     // ----------------------------------------------
-    // This has given us either:
-    // - our actual position (preferred), or
-    // - a mean position (fallback if we had no fix)
-    //
-    // What we actually want is to place our center so that our outermost nodes
-    // end up on the border of our map. The only real use of our "center" is to give
-    // us a reference frame: which direction is east, and which is west.
+    // This has given us the "mean position"
+    // This will be a position *somewhere* near the center of our nodes.
+    // What we actually want is to place our center so that our outermost nodes end up on the border of our map.
+    // The only real use of our "mean position" is to give us a reference frame:
+    // which direction is east, and which is west.
     //------------------------------------------------
 
-    // Find furthest nodes from our center
+    // Find furthest nodes from "mean lat long"
     // ========================================
+
     float northernmost = latCenter;
     float southernmost = latCenter;
     float easternmost = lngCenter;
@@ -299,14 +184,14 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
             continue;
 
         // Check for a new top or bottom latitude
-        float latNode = node->position.latitude_i * 1e-7;
-        northernmost = max(northernmost, latNode);
-        southernmost = min(southernmost, latNode);
+        float lat = node->position.latitude_i * 1e-7;
+        northernmost = max(northernmost, lat);
+        southernmost = min(southernmost, lat);
 
         // Longitude is trickier
-        float lngNode = node->position.longitude_i * 1e-7;
-        float degEastward = fmod(((lngNode - lngCenter) + 360), 360);      // Degrees traveled east from lngCenter to reach node
-        float degWestward = abs(fmod(((lngNode - lngCenter) - 360), 360)); // Degrees traveled west from lngCenter to reach node
+        float lng = node->position.longitude_i * 1e-7;
+        float degEastward = fmod(((lng - lngCenter) + 360), 360);      // Degrees traveled east from lngCenter to reach node
+        float degWestward = abs(fmod(((lng - lngCenter) - 360), 360)); // Degrees traveled west from lngCenter to reach node
         if (degEastward < degWestward)
             easternmost = max(easternmost, lngCenter + degEastward);
         else
@@ -365,6 +250,7 @@ InkHUD::MapApplet::Marker InkHUD::MapApplet::calculateMarker(float lat, float ln
     m.hopsAway = hopsAway;
     return m;
 }
+
 // Draw a marker on the map for a node, with a shortname label, and backing box
 void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeInfoLite *node)
 {
@@ -438,18 +324,6 @@ void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeInfoLite *node)
         textX = labelX + paddingW;
     }
 
-    // Prevent overlap with scale bars and their labels
-    // Define a "safe zone" in the bottom-left where the scale bars and text are drawn
-    constexpr int16_t safeZoneHeight = 28; // adjust based on your label font height
-    constexpr int16_t safeZoneWidth = 60;  // adjust based on horizontal label width zone
-    bool overlapsScale = (labelY + labelH > height() - safeZoneHeight) && (labelX < safeZoneWidth);
-
-    // If it overlaps, shift label upward slightly above the safe zone
-    if (overlapsScale) {
-        labelY = height() - safeZoneHeight - labelH - 2;
-        textY = labelY + (labelH / 2);
-    }
-
     // Backing box
     fillRect(labelX, labelY, labelW, labelH, WHITE);
     drawRect(labelX, labelY, labelW, labelH, BLACK);

src/graphics/niche/InkHUD/Applets/Bases/NodeList/NodeListApplet.cpp

@@ -127,11 +127,6 @@ void InkHUD::NodeListApplet::onRender()
     // Y value (top) of the current card. Increases as we draw.
     uint16_t cardTopY = headerDivY + padDivH;
 
-    // Clean up deleted nodes before drawing
-    cards.erase(
-        std::remove_if(cards.begin(), cards.end(), [](const CardInfo &c) { return nodeDB->getMeshNode(c.nodeNum) == nullptr; }),
-        cards.end());
-
     // -- Each node in list --
     for (auto card = cards.begin(); card != cards.end(); ++card) {
 
@@ -146,11 +141,6 @@ void InkHUD::NodeListApplet::onRender()
 
         meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeNum);
 
-        // Skip deleted nodes
-        if (!node) {
-            continue;
-        }
-
         // -- Shortname --
         // Parse special chars in the short name
         // Use "?" if unknown
@@ -198,7 +188,7 @@ void InkHUD::NodeListApplet::onRender()
             drawSignalIndicator(signalX, signalY, signalW, signalH, signal);
         }
         // Otherwise, print "hops away" info, if available
-        else if (hopsAway != CardInfo::HOPS_UNKNOWN && node) {
+        else if (hopsAway != CardInfo::HOPS_UNKNOWN) {
             std::string hopString = to_string(node->hops_away);
             hopString += " Hop";
             if (node->hops_away != 1)

src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp

@@ -709,7 +709,7 @@ void InkHUD::MenuApplet::drawSystemInfoPanel(int16_t left, int16_t top, uint16_t
     // Voltage
     float voltage = powerStatus->getBatteryVoltageMv() / 1000.0;
     char voltageStr[6]; // "XX.XV"
-    sprintf(voltageStr, "%.2fV", voltage);
+    sprintf(voltageStr, "%.1fV", voltage);
     printAt(colC[0], labelT, "Bat", CENTER, TOP);
     printAt(colC[0], valT, voltageStr, CENTER, TOP);
 

src/input/ButtonThread.cpp

@@ -274,12 +274,7 @@ int32_t ButtonThread::runOnce()
         }
     }
     btnEvent = BUTTON_EVENT_NONE;
-
-    // only pull when the button is pressed, we get notified via IRQ on a new press
-    if (!userButton.isIdle() || waitingForLongPress) {
-        return 50;
-    }
-    return 100; // FIXME: Why can't we rely on interrupts and use INT32_MAX here?
+    return 50;
 }
 
 /*

src/input/InputBroker.cpp

@@ -1,76 +1,18 @@
 #include "InputBroker.h"
 #include "PowerFSM.h" // needed for event trigger
-#include "configuration.h"
-#include "modules/ExternalNotificationModule.h"
 
 InputBroker *inputBroker = nullptr;
 
-InputBroker::InputBroker()
-{
-#if defined(HAS_FREE_RTOS) && !defined(ARCH_RP2040)
-    inputEventQueue = xQueueCreate(5, sizeof(InputEvent));
-    pollSoonQueue = xQueueCreate(5, sizeof(InputPollable *));
-    xTaskCreate(pollSoonWorker, "input-pollSoon", 2 * 1024, this, 10, &pollSoonTask);
-#endif
-}
+InputBroker::InputBroker(){};
 
 void InputBroker::registerSource(Observable<const InputEvent *> *source)
 {
     this->inputEventObserver.observe(source);
 }
 
-#if defined(HAS_FREE_RTOS) && !defined(ARCH_RP2040)
-void InputBroker::requestPollSoon(InputPollable *pollable)
-{
-    if (xPortInIsrContext() == pdTRUE) {
-        xQueueSendFromISR(pollSoonQueue, &pollable, NULL);
-    } else {
-        xQueueSend(pollSoonQueue, &pollable, 0);
-    }
-}
-
-void InputBroker::queueInputEvent(const InputEvent *event)
-{
-    if (xPortInIsrContext() == pdTRUE) {
-        xQueueSendFromISR(inputEventQueue, event, NULL);
-    } else {
-        xQueueSend(inputEventQueue, event, portMAX_DELAY);
-    }
-}
-
-void InputBroker::processInputEventQueue()
-{
-    InputEvent event;
-    while (xQueueReceive(inputEventQueue, &event, 0)) {
-        handleInputEvent(&event);
-    }
-}
-#endif
-
 int InputBroker::handleInputEvent(const InputEvent *event)
 {
     powerFSM.trigger(EVENT_INPUT); // todo: not every input should wake, like long hold release
-
-    if (event && event->inputEvent != INPUT_BROKER_NONE && externalNotificationModule &&
-        moduleConfig.external_notification.enabled) {
-        externalNotificationModule->stopNow();
-    }
-
     this->notifyObservers(event);
     return 0;
-}
-
-#if defined(HAS_FREE_RTOS) && !defined(ARCH_RP2040)
-void InputBroker::pollSoonWorker(void *p)
-{
-    InputBroker *instance = (InputBroker *)p;
-    while (true) {
-        InputPollable *pollable = NULL;
-        xQueueReceive(instance->pollSoonQueue, &pollable, portMAX_DELAY);
-        if (pollable) {
-            pollable->pollOnce();
-        }
-    }
-    vTaskDelete(NULL);
-}
-#endif
+}

src/input/InputBroker.h

@@ -1,7 +1,5 @@
 #pragma once
-
 #include "Observer.h"
-#include "freertosinc.h"
 
 enum input_broker_event {
     INPUT_BROKER_NONE = 0,
@@ -43,13 +41,6 @@ typedef struct _InputEvent {
     uint16_t touchX;
     uint16_t touchY;
 } InputEvent;
-
-class InputPollable
-{
-  public:
-    virtual void pollOnce() = 0;
-};
-
 class InputBroker : public Observable<const InputEvent *>
 {
     CallbackObserver<InputBroker, const InputEvent *> inputEventObserver =
@@ -59,22 +50,9 @@ class InputBroker : public Observable<const InputEvent *>
     InputBroker();
     void registerSource(Observable<const InputEvent *> *source);
     void injectInputEvent(const InputEvent *event) { handleInputEvent(event); }
-#if defined(HAS_FREE_RTOS) && !defined(ARCH_RP2040)
-    void requestPollSoon(InputPollable *pollable);
-    void queueInputEvent(const InputEvent *event);
-    void processInputEventQueue();
-#endif
 
   protected:
     int handleInputEvent(const InputEvent *event);
-
-  private:
-#if defined(HAS_FREE_RTOS) && !defined(ARCH_RP2040)
-    QueueHandle_t inputEventQueue;
-    QueueHandle_t pollSoonQueue;
-    TaskHandle_t pollSoonTask;
-    static void pollSoonWorker(void *p);
-#endif
 };
 
 extern InputBroker *inputBroker;

src/input/RotaryEncoderImpl.cpp

@@ -8,7 +8,7 @@
 
 RotaryEncoderImpl *rotaryEncoderImpl;
 
-RotaryEncoderImpl::RotaryEncoderImpl()
+RotaryEncoderImpl::RotaryEncoderImpl() : concurrency::OSThread(ORIGIN_NAME), originName(ORIGIN_NAME)
 {
     rotary = nullptr;
 }
@@ -18,6 +18,7 @@ bool RotaryEncoderImpl::init()
     if (!moduleConfig.canned_message.updown1_enabled || moduleConfig.canned_message.inputbroker_pin_a == 0 ||
         moduleConfig.canned_message.inputbroker_pin_b == 0) {
         // Input device is disabled.
+        disable();
         return false;
     }
 
@@ -29,11 +30,7 @@ bool RotaryEncoderImpl::init()
                                moduleConfig.canned_message.inputbroker_pin_press);
     rotary->resetButton();
 
-    interruptInstance = this;
-    auto interruptHandler = []() { inputBroker->requestPollSoon(interruptInstance); };
-    attachInterrupt(moduleConfig.canned_message.inputbroker_pin_a, interruptHandler, CHANGE);
-    attachInterrupt(moduleConfig.canned_message.inputbroker_pin_b, interruptHandler, CHANGE);
-    attachInterrupt(moduleConfig.canned_message.inputbroker_pin_press, interruptHandler, CHANGE);
+    inputBroker->registerSource(this);
 
     LOG_INFO("RotaryEncoder initialized pins(%d, %d, %d), events(%d, %d, %d)", moduleConfig.canned_message.inputbroker_pin_a,
              moduleConfig.canned_message.inputbroker_pin_b, moduleConfig.canned_message.inputbroker_pin_press, eventCw, eventCcw,
@@ -41,36 +38,36 @@ bool RotaryEncoderImpl::init()
     return true;
 }
 
-void RotaryEncoderImpl::pollOnce()
+int32_t RotaryEncoderImpl::runOnce()
 {
-    InputEvent e{ORIGIN_NAME, INPUT_BROKER_NONE, 0, 0, 0};
-
+    InputEvent e{originName, INPUT_BROKER_NONE, 0, 0, 0};
     static uint32_t lastPressed = millis();
     if (rotary->readButton() == RotaryEncoder::ButtonState::BUTTON_PRESSED) {
         if (lastPressed + 200 < millis()) {
             LOG_DEBUG("Rotary event Press");
             lastPressed = millis();
             e.inputEvent = this->eventPressed;
-            inputBroker->queueInputEvent(&e);
+        }
+    } else {
+        switch (rotary->process()) {
+        case RotaryEncoder::DIRECTION_CW:
+            LOG_DEBUG("Rotary event CW");
+            e.inputEvent = this->eventCw;
+            break;
+        case RotaryEncoder::DIRECTION_CCW:
+            LOG_DEBUG("Rotary event CCW");
+            e.inputEvent = this->eventCcw;
+            break;
+        default:
+            break;
         }
     }
 
-    switch (rotary->process()) {
-    case RotaryEncoder::DIRECTION_CW:
-        LOG_DEBUG("Rotary event CW");
-        e.inputEvent = this->eventCw;
-        inputBroker->queueInputEvent(&e);
-        break;
-    case RotaryEncoder::DIRECTION_CCW:
-        LOG_DEBUG("Rotary event CCW");
-        e.inputEvent = this->eventCcw;
-        inputBroker->queueInputEvent(&e);
-        break;
-    default:
-        break;
+    if (e.inputEvent != INPUT_BROKER_NONE) {
+        this->notifyObservers(&e);
     }
+
+    return 10;
 }
 
-RotaryEncoderImpl *RotaryEncoderImpl::interruptInstance;
-
 #endif

src/input/RotaryEncoderImpl.h

@@ -1,6 +1,6 @@
 #pragma once
 
-// This is a version of RotaryEncoder which is based on a debounce inherent FSM table (see RotaryEncoder library)
+// This is a non-interrupt version of RotaryEncoder which is based on a debounce inherent FSM table (see RotaryEncoder library)
 
 #include "InputBroker.h"
 #include "concurrency/OSThread.h"
@@ -8,21 +8,21 @@
 
 class RotaryEncoder;
 
-class RotaryEncoderImpl : public InputPollable
+class RotaryEncoderImpl : public Observable<const InputEvent *>, public concurrency::OSThread
 {
   public:
     RotaryEncoderImpl();
     bool init(void);
-    virtual void pollOnce() override;
 
   protected:
-    static RotaryEncoderImpl *interruptInstance;
+    virtual int32_t runOnce() override;
 
     input_broker_event eventCw = INPUT_BROKER_NONE;
     input_broker_event eventCcw = INPUT_BROKER_NONE;
     input_broker_event eventPressed = INPUT_BROKER_NONE;
 
     RotaryEncoder *rotary;
+    const char *originName;
 };
 
 extern RotaryEncoderImpl *rotaryEncoderImpl;

src/input/TCA8418KeyboardBase.cpp

@@ -200,11 +200,6 @@ uint8_t TCA8418KeyboardBase::flush()
     return count;
 }
 
-void TCA8418KeyboardBase::clearInt()
-{
-    writeRegister(TCA8418_REG_INT_STAT, 3);
-}
-
 uint8_t TCA8418KeyboardBase::digitalRead(uint8_t pinnum) const
 {
     if (pinnum > TCA8418_COL9)

src/input/TCA8418KeyboardBase.h

@@ -37,8 +37,6 @@ class TCA8418KeyboardBase
     virtual void begin(i2c_com_fptr_t r, i2c_com_fptr_t w, uint8_t addr = TCA8418_KB_ADDR);
 
     virtual void reset(void);
-    void clearInt(void);
-
     virtual void trigger(void);
 
     virtual void setBacklight(bool on);

src/input/TDeckProKeyboard.cpp

@@ -57,7 +57,7 @@ static unsigned char TDeckProTapMap[_TCA8418_NUM_KEYS][5] = {
     {0x00, 0x00, 0x00},
     {0x00, 0x00, 0x00},
     {0x20, 0x00, 0x00},
-    {0x00, 0x00, '0'},
+    {0x00, 0x00, 0x00},
     {0x00, 0x00, 0x00} // R_Shift, sym, space, mic, L_Shift
 };
 

src/input/TLoraPagerKeyboard.cpp

@@ -105,14 +105,7 @@ void TLoraPagerKeyboard::trigger()
 
 void TLoraPagerKeyboard::setBacklight(bool on)
 {
-    uint32_t _brightness = 0;
-    if (on)
-        _brightness = brightness;
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-    ledcWrite(KB_BL_PIN, _brightness);
-#else
-    ledcWrite(LEDC_BACKLIGHT_CHANNEL, _brightness);
-#endif
+    toggleBacklight(!on);
 }
 
 void TLoraPagerKeyboard::pressed(uint8_t key)
@@ -199,6 +192,7 @@ void TLoraPagerKeyboard::hapticFeedback()
 // toggle brightness of the backlight in three steps
 void TLoraPagerKeyboard::toggleBacklight(bool off)
 {
+    static uint32_t brightness = 0;
     if (off) {
         brightness = 0;
     } else {
@@ -212,7 +206,11 @@ void TLoraPagerKeyboard::toggleBacklight(bool off)
     }
     LOG_DEBUG("Toggle backlight: %d", brightness);
 
-    setBacklight(true);
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+    ledcWrite(KB_BL_PIN, brightness);
+#else
+    ledcWrite(LEDC_BACKLIGHT_CHANNEL, brightness);
+#endif
 }
 
 void TLoraPagerKeyboard::updateModifierFlag(uint8_t key)

src/input/TLoraPagerKeyboard.h

@@ -26,5 +26,4 @@ class TLoraPagerKeyboard : public TCA8418KeyboardBase
     uint32_t last_tap;
     uint8_t char_idx;
     int32_t tap_interval;
-    uint32_t brightness = 0;
 };

src/input/kbI2cBase.cpp

@@ -333,7 +333,6 @@ int32_t KbI2cBase::runOnce()
             }
             TCAKeyboard.trigger();
         }
-        TCAKeyboard.clearInt();
         break;
     }
     case 0x02: {
@@ -520,11 +519,4 @@ int32_t KbI2cBase::runOnce()
         LOG_WARN("Unknown kb_model 0x%02x", kb_model);
     }
     return 300;
-}
-
-void KbI2cBase::toggleBacklight(bool on)
-{
-#if defined(T_LORA_PAGER)
-    TCAKeyboard.setBacklight(on);
-#endif
-}
+}

src/input/kbI2cBase.h

@@ -12,7 +12,6 @@ class KbI2cBase : public Observable<const InputEvent *>, public concurrency::OST
 {
   public:
     explicit KbI2cBase(const char *name);
-    void toggleBacklight(bool on);
 
   protected:
     virtual int32_t runOnce() override;

src/main.cpp

@@ -23,7 +23,6 @@
 #include "power.h"
 
 #if !MESHTASTIC_EXCLUDE_I2C
-#include "detect/ScanI2CConsumer.h"
 #include "detect/ScanI2CTwoWire.h"
 #include <Wire.h>
 #endif
@@ -298,12 +297,6 @@ void printInfo()
 #ifndef PIO_UNIT_TESTING
 void setup()
 {
-#if defined(R1_NEO)
-    pinMode(DCDC_EN_HOLD, OUTPUT);
-    digitalWrite(DCDC_EN_HOLD, HIGH);
-    pinMode(NRF_ON, OUTPUT);
-    digitalWrite(NRF_ON, HIGH);
-#endif
 
 #if defined(PIN_POWER_EN)
     pinMode(PIN_POWER_EN, OUTPUT);
@@ -376,13 +369,12 @@ void setup()
     digitalWrite(SDCARD_CS, HIGH);
     pinMode(TFT_CS, OUTPUT);
     digitalWrite(TFT_CS, HIGH);
-    pinMode(KB_INT, INPUT_PULLUP);
     // io expander
     io.begin(Wire, XL9555_SLAVE_ADDRESS0, SDA, SCL);
     io.pinMode(EXPANDS_DRV_EN, OUTPUT);
     io.digitalWrite(EXPANDS_DRV_EN, HIGH);
     io.pinMode(EXPANDS_AMP_EN, OUTPUT);
-    io.digitalWrite(EXPANDS_AMP_EN, LOW);
+    io.digitalWrite(EXPANDS_AMP_EN, HIGH);
     io.pinMode(EXPANDS_LORA_EN, OUTPUT);
     io.digitalWrite(EXPANDS_LORA_EN, HIGH);
     io.pinMode(EXPANDS_GPS_EN, OUTPUT);
@@ -436,12 +428,6 @@ void setup()
 
     LOG_INFO("\n\n//\\ E S H T /\\ S T / C\n");
 
-#if defined(DEBUG_MUTE) && defined(DEBUG_PORT)
-    DEBUG_PORT.printf("\r\n\r\n//\\ E S H T /\\ S T / C\r\n");
-    DEBUG_PORT.printf("Version %s for %s from %s\r\n", optstr(APP_VERSION), optstr(APP_ENV), optstr(APP_REPO));
-    DEBUG_PORT.printf("Debug mute is enabled, there will be no serial output.\r\n");
-#endif
-
     initDeepSleep();
 
 #if defined(MODEM_POWER_EN)
@@ -725,21 +711,46 @@ void setup()
     LOG_DEBUG("acc_info = %i", acc_info.type);
 #endif
 
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BME_680, meshtastic_TelemetrySensorType_BME680);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BME_280, meshtastic_TelemetrySensorType_BME280);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BMP_280, meshtastic_TelemetrySensorType_BMP280);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BMP_3XX, meshtastic_TelemetrySensorType_BMP3XX);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BMP_085, meshtastic_TelemetrySensorType_BMP085);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::INA260, meshtastic_TelemetrySensorType_INA260);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::INA226, meshtastic_TelemetrySensorType_INA226);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::INA219, meshtastic_TelemetrySensorType_INA219);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::INA3221, meshtastic_TelemetrySensorType_INA3221);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MAX17048, meshtastic_TelemetrySensorType_MAX17048);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MCP9808, meshtastic_TelemetrySensorType_MCP9808);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SHT31, meshtastic_TelemetrySensorType_SHT31);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SHTC3, meshtastic_TelemetrySensorType_SHTC3);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::LPS22HB, meshtastic_TelemetrySensorType_LPS22);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::QMC6310, meshtastic_TelemetrySensorType_QMC6310);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::QMI8658, meshtastic_TelemetrySensorType_QMI8658);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::QMC5883L, meshtastic_TelemetrySensorType_QMC5883L);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::HMC5883L, meshtastic_TelemetrySensorType_QMC5883L);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::PMSA0031, meshtastic_TelemetrySensorType_PMSA003I);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::RCWL9620, meshtastic_TelemetrySensorType_RCWL9620);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::VEML7700, meshtastic_TelemetrySensorType_VEML7700);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::TSL2591, meshtastic_TelemetrySensorType_TSL25911FN);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::OPT3001, meshtastic_TelemetrySensorType_OPT3001);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MLX90632, meshtastic_TelemetrySensorType_MLX90632);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MLX90614, meshtastic_TelemetrySensorType_MLX90614);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SHT4X, meshtastic_TelemetrySensorType_SHT4X);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::AHT10, meshtastic_TelemetrySensorType_AHT10);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DFROBOT_LARK, meshtastic_TelemetrySensorType_DFROBOT_LARK);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::ICM20948, meshtastic_TelemetrySensorType_ICM20948);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MAX30102, meshtastic_TelemetrySensorType_MAX30102);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::CGRADSENS, meshtastic_TelemetrySensorType_RADSENS);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DFROBOT_RAIN, meshtastic_TelemetrySensorType_DFROBOT_RAIN);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::LTR390UV, meshtastic_TelemetrySensorType_LTR390UV);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DPS310, meshtastic_TelemetrySensorType_DPS310);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::RAK12035, meshtastic_TelemetrySensorType_RAK12035);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::PCT2075, meshtastic_TelemetrySensorType_PCT2075);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SCD4X, meshtastic_TelemetrySensorType_SCD4X);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::TSL2561, meshtastic_TelemetrySensorType_TSL2561);
 
+    i2cScanner.reset();
 #endif
 
 #ifdef HAS_SDCARD
@@ -781,7 +792,14 @@ void setup()
     }
 #endif
 
-    router = new ReliableRouter();
+    // If we're taking on the repeater role, use NextHopRouter and turn off 3V3_S rail because peripherals are not needed
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
+        router = new NextHopRouter();
+#ifdef PIN_3V3_EN
+        digitalWrite(PIN_3V3_EN, LOW);
+#endif
+    } else
+        router = new ReliableRouter();
 
     // only play start melody when role is not tracker or sensor
     if (config.power.is_power_saving == true &&
@@ -847,14 +865,7 @@ void setup()
         SPI.begin();
     }
 #elif !defined(ARCH_ESP32) // ARCH_RP2040
-#if defined(RAK3401) || defined(RAK13302)
-    pinMode(WB_IO2, OUTPUT);
-    digitalWrite(WB_IO2, HIGH);
-    SPI1.setPins(LORA_MISO, LORA_SCK, LORA_MOSI);
-    SPI1.begin();
-#else
     SPI.begin();
-#endif
 #else
         // ESP32
 #if defined(HW_SPI1_DEVICE)
@@ -914,7 +925,8 @@ void setup()
     if (sensor_detected == false) {
 #endif
         if (HAS_GPS) {
-            if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT) {
+            if (config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
+                config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT) {
                 gps = GPS::createGps();
                 if (gps) {
                     gpsStatus->observe(&gps->newStatus);
@@ -953,12 +965,6 @@ void setup()
     // Now that the mesh service is created, create any modules
     setupModules();
 
-#if !MESHTASTIC_EXCLUDE_I2C
-    // Inform modules about I2C devices
-    ScanI2CCompleted(i2cScanner.get());
-    i2cScanner.reset();
-#endif
-
     // warn the user about a low entropy key
     if (nodeDB->keyIsLowEntropy && !nodeDB->hasWarned) {
         LOG_WARN(LOW_ENTROPY_WARNING);
@@ -995,7 +1001,6 @@ void setup()
             config.pullupSense = INPUT_PULLUP;
             config.intRoutine = []() {
                 UserButtonThread->userButton.tick();
-                UserButtonThread->setIntervalFromNow(0);
                 runASAP = true;
                 BaseType_t higherWake = 0;
                 mainDelay.interruptFromISR(&higherWake);
@@ -1016,7 +1021,6 @@ void setup()
     touchConfig.pullupSense = pullup_sense;
     touchConfig.intRoutine = []() {
         TouchButtonThread->userButton.tick();
-        TouchButtonThread->setIntervalFromNow(0);
         runASAP = true;
         BaseType_t higherWake = 0;
         mainDelay.interruptFromISR(&higherWake);
@@ -1036,7 +1040,6 @@ void setup()
     cancelConfig.pullupSense = pullup_sense;
     cancelConfig.intRoutine = []() {
         CancelButtonThread->userButton.tick();
-        CancelButtonThread->setIntervalFromNow(0);
         runASAP = true;
         BaseType_t higherWake = 0;
         mainDelay.interruptFromISR(&higherWake);
@@ -1057,7 +1060,6 @@ void setup()
     backConfig.pullupSense = pullup_sense;
     backConfig.intRoutine = []() {
         BackButtonThread->userButton.tick();
-        BackButtonThread->setIntervalFromNow(0);
         runASAP = true;
         BaseType_t higherWake = 0;
         mainDelay.interruptFromISR(&higherWake);
@@ -1092,7 +1094,6 @@ void setup()
         userConfig.pullupSense = pullup_sense;
         userConfig.intRoutine = []() {
             UserButtonThread->userButton.tick();
-            UserButtonThread->setIntervalFromNow(0);
             runASAP = true;
             BaseType_t higherWake = 0;
             mainDelay.interruptFromISR(&higherWake);
@@ -1110,7 +1111,6 @@ void setup()
         userConfigNoScreen.pullupSense = pullup_sense;
         userConfigNoScreen.intRoutine = []() {
             UserButtonThread->userButton.tick();
-            UserButtonThread->setIntervalFromNow(0);
             runASAP = true;
             BaseType_t higherWake = 0;
             mainDelay.interruptFromISR(&higherWake);
@@ -1595,13 +1595,8 @@ void loop()
 #endif
 
     service->loop();
-#if !MESHTASTIC_EXCLUDE_INPUTBROKER && defined(HAS_FREE_RTOS) && !defined(ARCH_RP2040)
-    if (inputBroker)
-        inputBroker->processInputEventQueue();
-#endif
-#if ARCH_PORTDUINO && HAS_TFT
-    if (screen && portduino_config.displayPanel == x11 &&
-        config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+#if defined(LGFX_SDL)
+    if (screen) {
         auto dispdev = screen->getDisplayDevice();
         if (dispdev)
             static_cast<TFTDisplay *>(dispdev)->sdlLoop();
@@ -1611,9 +1606,6 @@ void loop()
 
     // We want to sleep as long as possible here - because it saves power
     if (!runASAP && loopCanSleep()) {
-#ifdef DEBUG_LOOP_TIMING
-        LOG_DEBUG("main loop delay: %d", delayMsec);
-#endif
         mainDelay.delay(delayMsec);
     }
 }

src/mesh/Default.h

@@ -27,7 +27,7 @@
 #ifdef USERPREFS_RINGTONE_NAG_SECS
 #define default_ringtone_nag_secs USERPREFS_RINGTONE_NAG_SECS
 #else
-#define default_ringtone_nag_secs 15
+#define default_ringtone_nag_secs 60
 #endif
 
 #define default_mqtt_address "mqtt.meshtastic.org"
@@ -84,4 +84,4 @@ class Default
             return 1.0 + (nodesOverForty * throttlingFactor); // Each number of online node scales by 0.075 (default)
         }
     }
-};
+};

src/mesh/FloodingRouter.cpp

@@ -1,12 +1,7 @@
 #include "FloodingRouter.h"
-#include "MeshTypes.h"
-#include "NodeDB.h"
+
 #include "configuration.h"
 #include "mesh-pb-constants.h"
-#include "meshUtils.h"
-#if !MESHTASTIC_EXCLUDE_TRACEROUTE
-#include "modules/TraceRouteModule.h"
-#endif
 
 FloodingRouter::FloodingRouter() {}
 
@@ -26,16 +21,7 @@ ErrorCode FloodingRouter::send(meshtastic_MeshPacket *p)
 
 bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
 {
-    bool wasUpgraded = false;
-    bool seenRecently =
-        wasSeenRecently(p, true, nullptr, nullptr, &wasUpgraded); // Updates history; returns false when an upgrade is detected
-
-    // Handle hop_limit upgrade scenario for rebroadcasters
-    if (wasUpgraded && perhapsHandleUpgradedPacket(p)) {
-        return true; // we handled it, so stop processing
-    }
-
-    if (seenRecently) {
+    if (wasSeenRecently(p)) { // Note: this will also add a recent packet record
         printPacket("Ignore dupe incoming msg", p);
         rxDupe++;
 
@@ -45,10 +31,8 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
         if (isRepeated) {
             LOG_DEBUG("Repeated reliable tx");
             // Check if it's still in the Tx queue, if not, we have to relay it again
-            if (!findInTxQueue(p->from, p->id)) {
-                reprocessPacket(p);
+            if (!findInTxQueue(p->from, p->id))
                 perhapsRebroadcast(p);
-            }
         } else {
             perhapsCancelDupe(p);
         }
@@ -59,45 +43,12 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
     return Router::shouldFilterReceived(p);
 }
 
-bool FloodingRouter::perhapsHandleUpgradedPacket(const meshtastic_MeshPacket *p)
-{
-    // isRebroadcaster() is duplicated in perhapsRebroadcast(), but this avoids confusing log messages
-    if (isRebroadcaster() && iface && p->hop_limit > 0) {
-        // If we overhear a duplicate copy of the packet with more hops left than the one we are waiting to
-        // rebroadcast, then remove the packet currently sitting in the TX queue and use this one instead.
-        uint8_t dropThreshold = p->hop_limit; // remove queued packets that have fewer hops remaining
-        if (iface->removePendingTXPacket(getFrom(p), p->id, dropThreshold)) {
-            LOG_DEBUG("Processing upgraded packet 0x%08x for rebroadcast with hop limit %d (dropping queued < %d)", p->id,
-                      p->hop_limit, dropThreshold);
-
-            reprocessPacket(p);
-            perhapsRebroadcast(p);
-
-            rxDupe++;
-            // We already enqueued the improved copy, so make sure the incoming packet stops here.
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void FloodingRouter::reprocessPacket(const meshtastic_MeshPacket *p)
-{
-    if (nodeDB)
-        nodeDB->updateFrom(*p);
-#if !MESHTASTIC_EXCLUDE_TRACEROUTE
-    if (traceRouteModule && p->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
-        p->decoded.portnum == meshtastic_PortNum_TRACEROUTE_APP)
-        traceRouteModule->processUpgradedPacket(*p);
-#endif
-}
-
 bool FloodingRouter::roleAllowsCancelingDupe(const meshtastic_MeshPacket *p)
 {
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
+        config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER ||
         config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
-        // ROUTER, ROUTER_LATE should never cancel relaying a packet (i.e. we should always rebroadcast),
+        // ROUTER, REPEATER, ROUTER_LATE should never cancel relaying a packet (i.e. we should always rebroadcast),
         // even if we've heard another station rebroadcast it already.
         return false;
     }
@@ -116,7 +67,7 @@ bool FloodingRouter::roleAllowsCancelingDupe(const meshtastic_MeshPacket *p)
 void FloodingRouter::perhapsCancelDupe(const meshtastic_MeshPacket *p)
 {
     if (p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA && roleAllowsCancelingDupe(p)) {
-        // cancel rebroadcast of this message *if* there was already one, unless we're a router!
+        // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
         // But only LoRa packets should be able to trigger this.
         if (Router::cancelSending(p->from, p->id))
             txRelayCanceled++;
@@ -132,6 +83,36 @@ bool FloodingRouter::isRebroadcaster()
            config.device.rebroadcast_mode != meshtastic_Config_DeviceConfig_RebroadcastMode_NONE;
 }
 
+void FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
+{
+    if (!isToUs(p) && (p->hop_limit > 0) && !isFromUs(p)) {
+        if (p->id != 0) {
+            if (isRebroadcaster()) {
+                meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
+
+                tosend->hop_limit--; // bump down the hop count
+#if USERPREFS_EVENT_MODE
+                if (tosend->hop_limit > 2) {
+                    // if we are "correcting" the hop_limit, "correct" the hop_start by the same amount to preserve hops away.
+                    tosend->hop_start -= (tosend->hop_limit - 2);
+                    tosend->hop_limit = 2;
+                }
+#endif
+                tosend->next_hop = NO_NEXT_HOP_PREFERENCE; // this should already be the case, but just in case
+
+                LOG_INFO("Rebroadcast received floodmsg");
+                // Note: we are careful to resend using the original senders node id
+                // We are careful not to call our hooked version of send() - because we don't want to check this again
+                Router::send(tosend);
+            } else {
+                LOG_DEBUG("No rebroadcast: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
+            }
+        } else {
+            LOG_DEBUG("Ignore 0 id broadcast");
+        }
+    }
+}
+
 void FloodingRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)
 {
     bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) &&
@@ -146,4 +127,4 @@ void FloodingRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
 
     // handle the packet as normal
     Router::sniffReceived(p, c);
-}
+}

src/mesh/FloodingRouter.h

@@ -27,6 +27,10 @@
  */
 class FloodingRouter : public Router
 {
+  private:
+    /* Check if we should rebroadcast this packet, and do so if needed */
+    void perhapsRebroadcast(const meshtastic_MeshPacket *p);
+
   public:
     /**
      * Constructor
@@ -55,18 +59,7 @@ class FloodingRouter : public Router
      */
     virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
 
-    /* Check if we should rebroadcast this packet, and do so if needed */
-    virtual bool perhapsRebroadcast(const meshtastic_MeshPacket *p) = 0;
-
-    /* Check if we should handle an upgraded packet (with higher hop_limit)
-     * @return true if we handled it (so stop processing)
-     */
-    bool perhapsHandleUpgradedPacket(const meshtastic_MeshPacket *p);
-
-    /* Call when we receive a packet that needs some reprocessing, but afterwards should be filtered */
-    void reprocessPacket(const meshtastic_MeshPacket *p);
-
-    // Return false for roles like ROUTER which should always rebroadcast even when we've heard another rebroadcast of
+    // Return false for roles like ROUTER or REPEATER which should always rebroadcast even when we've heard another rebroadcast of
     // the same packet
     bool roleAllowsCancelingDupe(const meshtastic_MeshPacket *p);
 

src/mesh/LR11x0Interface.cpp

@@ -155,7 +155,7 @@ template <typename T> bool LR11x0Interface<T>::reconfigure()
     if (err != RADIOLIB_ERR_NONE)
         RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
 
-    err = lora.setBandwidth(bw, wideLora() && (getFreq() > 1000.0f));
+    err = lora.setBandwidth(bw);
     if (err != RADIOLIB_ERR_NONE)
         RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
 
@@ -218,7 +218,6 @@ template <typename T> void LR11x0Interface<T>::addReceiveMetadata(meshtastic_Mes
     // LOG_DEBUG("PacketStatus %x", lora.getPacketStatus());
     mp->rx_snr = lora.getSNR();
     mp->rx_rssi = lround(lora.getRSSI());
-    LOG_DEBUG("Corrected frequency offset: %f", lora.getFrequencyError());
 }
 
 /** We override to turn on transmitter power as needed.

src/mesh/LR11x0Interface.h

@@ -65,7 +65,5 @@ template <class T> class LR11x0Interface : public RadioLibInterface
     virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) override;
 
     virtual void setStandby() override;
-
-    uint32_t getPacketTime(uint32_t pl, bool received) override { return computePacketTime(lora, pl, received); }
 };
 #endif

src/mesh/MeshPacketQueue.cpp

@@ -65,7 +65,7 @@ void fixPriority(meshtastic_MeshPacket *p)
 }
 
 /** enqueue a packet, return false if full */
-bool MeshPacketQueue::enqueue(meshtastic_MeshPacket *p, bool *dropped)
+bool MeshPacketQueue::enqueue(meshtastic_MeshPacket *p)
 {
     // no space - try to replace a lower priority packet in the queue
     if (queue.size() >= maxLen) {
@@ -73,16 +73,9 @@ bool MeshPacketQueue::enqueue(meshtastic_MeshPacket *p, bool *dropped)
         if (!replaced) {
             LOG_WARN("TX queue is full, and there is no lower-priority packet available to evict in favour of 0x%08x", p->id);
         }
-        if (dropped) {
-            *dropped = true;
-        }
         return replaced;
     }
 
-    if (dropped) {
-        *dropped = false;
-    }
-
     // Find the correct position using upper_bound to maintain a stable order
     auto it = std::upper_bound(queue.begin(), queue.end(), p, CompareMeshPacketFunc);
     queue.insert(it, p); // Insert packet at the found position
@@ -110,26 +103,12 @@ meshtastic_MeshPacket *MeshPacketQueue::getFront()
     return p;
 }
 
-/** Get a packet from this queue. Returns a pointer to the packet, or NULL if not found. */
-meshtastic_MeshPacket *MeshPacketQueue::getPacketFromQueue(NodeNum from, PacketId id)
-{
-    for (auto it = queue.begin(); it != queue.end(); it++) {
-        auto p = (*it);
-        if (getFrom(p) == from && p->id == id) {
-            return p;
-        }
-    }
-
-    return NULL;
-}
-
 /** Attempt to find and remove a packet from this queue.  Returns a pointer to the removed packet, or NULL if not found */
-meshtastic_MeshPacket *MeshPacketQueue::remove(NodeNum from, PacketId id, bool tx_normal, bool tx_late, uint8_t hop_limit_lt)
+meshtastic_MeshPacket *MeshPacketQueue::remove(NodeNum from, PacketId id, bool tx_normal, bool tx_late)
 {
     for (auto it = queue.begin(); it != queue.end(); it++) {
         auto p = (*it);
-        if (getFrom(p) == from && p->id == id && ((tx_normal && !p->tx_after) || (tx_late && p->tx_after)) &&
-            (!hop_limit_lt || p->hop_limit < hop_limit_lt)) {
+        if (getFrom(p) == from && p->id == id && ((tx_normal && !p->tx_after) || (tx_late && p->tx_after))) {
             queue.erase(it);
             return p;
         }
@@ -141,7 +120,14 @@ meshtastic_MeshPacket *MeshPacketQueue::remove(NodeNum from, PacketId id, bool t
 /* Attempt to find a packet from this queue. Return true if it was found. */
 bool MeshPacketQueue::find(const NodeNum from, const PacketId id)
 {
-    return getPacketFromQueue(from, id) != NULL;
+    for (auto it = queue.begin(); it != queue.end(); it++) {
+        const auto *p = *it;
+        if (getFrom(p) == from && p->id == id) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
 /**

src/mesh/MeshPacketQueue.h

@@ -19,10 +19,8 @@ class MeshPacketQueue
   public:
     explicit MeshPacketQueue(size_t _maxLen);
 
-    /** enqueue a packet, return false if full
-     * @param dropped Optional pointer to a bool that will be set to true if a packet was dropped
-     */
-    bool enqueue(meshtastic_MeshPacket *p, bool *dropped = nullptr);
+    /** enqueue a packet, return false if full */
+    bool enqueue(meshtastic_MeshPacket *p);
 
     /** return true if the queue is empty */
     bool empty();
@@ -37,12 +35,8 @@ class MeshPacketQueue
 
     meshtastic_MeshPacket *getFront();
 
-    /** Get a packet from this queue. Returns a pointer to the packet, or NULL if not found. */
-    meshtastic_MeshPacket *getPacketFromQueue(NodeNum from, PacketId id);
-
     /** Attempt to find and remove a packet from this queue.  Returns the packet which was removed from the queue */
-    meshtastic_MeshPacket *remove(NodeNum from, PacketId id, bool tx_normal = true, bool tx_late = true,
-                                  uint8_t hop_limit_lt = 0);
+    meshtastic_MeshPacket *remove(NodeNum from, PacketId id, bool tx_normal = true, bool tx_late = true);
 
     /* Attempt to find a packet from this queue. Return true if it was found. */
     bool find(const NodeNum from, const PacketId id);

src/mesh/MeshService.cpp

@@ -85,11 +85,12 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp)
     powerFSM.trigger(EVENT_PACKET_FOR_PHONE); // Possibly keep the node from sleeping
 
     nodeDB->updateFrom(*mp); // update our DB state based off sniffing every RX packet from the radio
-    bool isPreferredRebroadcaster = config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER;
+    bool isPreferredRebroadcaster =
+        IS_ONE_OF(config.device.role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_REPEATER);
     if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
         mp->decoded.portnum == meshtastic_PortNum_TELEMETRY_APP && mp->decoded.request_id > 0) {
-        LOG_DEBUG("Received telemetry response. Skip sending our NodeInfo");
-        //  ignore our request for its NodeInfo
+        LOG_DEBUG("Received telemetry response. Skip sending our NodeInfo"); //  because this potentially a Repeater which will
+                                                                             //  ignore our request for its NodeInfo
     } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !nodeDB->getMeshNode(mp->from)->has_user &&
                nodeInfoModule && !isPreferredRebroadcaster && !nodeDB->isFull()) {
         if (airTime->isTxAllowedChannelUtil(true)) {
@@ -452,4 +453,4 @@ uint32_t MeshService::GetTimeSinceMeshPacket(const meshtastic_MeshPacket *mp)
         delta = 0;
 
     return delta;
-}
+}

src/mesh/MeshService.h

@@ -190,4 +190,4 @@ class MeshService
     friend class RoutingModule;
 };
 
-extern MeshService *service;
+extern MeshService *service;

src/mesh/NextHopRouter.cpp

@@ -1,10 +1,4 @@
 #include "NextHopRouter.h"
-#include "MeshTypes.h"
-#include "meshUtils.h"
-#if !MESHTASTIC_EXCLUDE_TRACEROUTE
-#include "modules/TraceRouteModule.h"
-#endif
-#include "NodeDB.h"
 
 NextHopRouter::NextHopRouter() {}
 
@@ -38,16 +32,7 @@ bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
 {
     bool wasFallback = false;
     bool weWereNextHop = false;
-    bool wasUpgraded = false;
-    bool seenRecently = wasSeenRecently(p, true, &wasFallback, &weWereNextHop,
-                                        &wasUpgraded); // Updates history; returns false when an upgrade is detected
-
-    // Handle hop_limit upgrade scenario for rebroadcasters
-    if (wasUpgraded && perhapsHandleUpgradedPacket(p)) {
-        return true; // we handled it, so stop processing
-    }
-
-    if (seenRecently) {
+    if (wasSeenRecently(p, true, &wasFallback, &weWereNextHop)) { // Note: this will also add a recent packet record
         printPacket("Ignore dupe incoming msg", p);
 
         if (p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA) {
@@ -59,20 +44,14 @@ bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
         if (wasFallback) {
             LOG_INFO("Fallback to flooding from relay_node=0x%x", p->relay_node);
             // Check if it's still in the Tx queue, if not, we have to relay it again
-            if (!findInTxQueue(p->from, p->id)) {
-                reprocessPacket(p);
-                perhapsRebroadcast(p);
-            }
+            if (!findInTxQueue(p->from, p->id))
+                perhapsRelay(p);
         } else {
             bool isRepeated = p->hop_start > 0 && p->hop_start == p->hop_limit;
             // If repeated and not in Tx queue anymore, try relaying again, or if we are the destination, send the ACK again
             if (isRepeated) {
-                if (!findInTxQueue(p->from, p->id)) {
-                    reprocessPacket(p);
-                    if (!perhapsRebroadcast(p) && isToUs(p) && p->want_ack) {
-                        sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
-                    }
-                }
+                if (!findInTxQueue(p->from, p->id) && !perhapsRelay(p) && isToUs(p) && p->want_ack)
+                    sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
             } else if (!weWereNextHop) {
                 perhapsCancelDupe(p); // If it's a dupe, cancel relay if we were not explicitly asked to relay
             }
@@ -90,22 +69,18 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
     bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) &&
                         (p->decoded.request_id != 0 || p->decoded.reply_id != 0);
     if (isAckorReply) {
-        // Update next-hop for the original transmitter of this successful transmission to the relay node, but ONLY if "from"
-        // is not 0 (means implicit ACK) and original packet was also relayed by this node, or we sent it directly to the
-        // destination
+        // Update next-hop for the original transmitter of this successful transmission to the relay node, but ONLY if "from" is
+        // not 0 (means implicit ACK) and original packet was also relayed by this node, or we sent it directly to the destination
         if (p->from != 0) {
             meshtastic_NodeInfoLite *origTx = nodeDB->getMeshNode(p->from);
             if (origTx) {
-                // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came
-                // directly from the destination
-                bool wasAlreadyRelayer = wasRelayer(p->relay_node, p->decoded.request_id, p->to);
-                bool weWereSoleRelayer = false;
-                bool weWereRelayer = wasRelayer(ourRelayID, p->decoded.request_id, p->to, &weWereSoleRelayer);
-                if ((weWereRelayer && wasAlreadyRelayer) ||
-                    (p->hop_start != 0 && p->hop_start == p->hop_limit && weWereSoleRelayer)) {
+                // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came directly
+                // from the destination
+                if (wasRelayer(p->relay_node, p->decoded.request_id, p->to) ||
+                    (p->hop_start != 0 && p->hop_start == p->hop_limit &&
+                     wasSoleRelayer(ourRelayID, p->decoded.request_id, p->to))) {
                     if (origTx->next_hop != p->relay_node) { // Not already set
-                        LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply (was relayer %d we were sole %d)", p->from,
-                                 p->relay_node, wasAlreadyRelayer, weWereSoleRelayer);
+                        LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply", p->from, p->relay_node);
                         origTx->next_hop = p->relay_node;
                     }
                 }
@@ -118,49 +93,28 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
         }
     }
 
-    perhapsRebroadcast(p);
+    perhapsRelay(p);
 
     // handle the packet as normal
     Router::sniffReceived(p, c);
 }
 
-/* Check if we should be rebroadcasting this packet if so, do so. */
-bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
+/* Check if we should be relaying this packet if so, do so. */
+bool NextHopRouter::perhapsRelay(const meshtastic_MeshPacket *p)
 {
     if (!isToUs(p) && !isFromUs(p) && p->hop_limit > 0) {
-        if (p->id != 0) {
+        if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
             if (isRebroadcaster()) {
-                if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
-                    meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
-                    LOG_INFO("Rebroadcast received message coming from %x", p->relay_node);
+                meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
+                LOG_INFO("Relaying received message coming from %x", p->relay_node);
 
-                    // Use shared logic to determine if hop_limit should be decremented
-                    if (shouldDecrementHopLimit(p)) {
-                        tosend->hop_limit--; // bump down the hop count
-                    } else {
-                        LOG_INFO("favorite-ROUTER/CLIENT_BASE-to-ROUTER/CLIENT_BASE rebroadcast: preserving hop_limit");
-                    }
-#if USERPREFS_EVENT_MODE
-                    if (tosend->hop_limit > 2) {
-                        // if we are "correcting" the hop_limit, "correct" the hop_start by the same amount to preserve hops away.
-                        tosend->hop_start -= (tosend->hop_limit - 2);
-                        tosend->hop_limit = 2;
-                    }
-#endif
+                tosend->hop_limit--; // bump down the hop count
+                NextHopRouter::send(tosend);
 
-                    if (p->next_hop == NO_NEXT_HOP_PREFERENCE) {
-                        FloodingRouter::send(tosend);
-                    } else {
-                        NextHopRouter::send(tosend);
-                    }
-
-                    return true;
-                }
+                return true;
             } else {
-                LOG_DEBUG("No rebroadcast: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
+                LOG_DEBUG("Not rebroadcasting: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
             }
-        } else {
-            LOG_DEBUG("Ignore 0 id broadcast");
         }
     }
 
@@ -173,6 +127,7 @@ bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
  */
 uint8_t NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
 {
+    // When we're a repeater router->sniffReceived will call NextHopRouter directly without checking for broadcast
     if (isBroadcast(to))
         return NO_NEXT_HOP_PREFERENCE;
 
@@ -210,7 +165,7 @@ bool NextHopRouter::roleAllowsCancelingFromTxQueue(const meshtastic_MeshPacket *
 {
     // Return true if we're allowed to cancel a packet in the txQueue (so we may never transmit it even once)
 
-    // Return false for roles like ROUTER, ROUTER_LATE which should always transmit the packet at least once.
+    // Return false for roles like ROUTER, REPEATER, ROUTER_LATE which should always transmit the packet at least once.
 
     return roleAllowsCancelingDupe(p); // same logic as FloodingRouter::roleAllowsCancelingDupe
 }
@@ -223,20 +178,20 @@ bool NextHopRouter::stopRetransmission(GlobalPacketId key)
         /* Only when we already transmitted a packet via LoRa, we will cancel the packet in the Tx queue
           to avoid canceling a transmission if it was ACKed super fast via MQTT */
         if (old->numRetransmissions < NUM_RELIABLE_RETX - 1) {
-            // We only cancel it if we are the original sender or if we're not a router(_late)
+            // We only cancel it if we are the original sender or if we're not a router(_late)/repeater
             if (isFromUs(p) || roleAllowsCancelingFromTxQueue(p)) {
                 // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
                 cancelSending(getFrom(p), p->id);
             }
         }
 
-        // Regardless of whether or not we canceled this packet from the txQueue, remove it from our pending list so it
-        // doesn't get scheduled again. (This is the core of stopRetransmission.)
+        // Regardless of whether or not we canceled this packet from the txQueue, remove it from our pending list so it doesn't
+        // get scheduled again. (This is the core of stopRetransmission.)
         auto numErased = pending.erase(key);
         assert(numErased == 1);
 
-        // When we remove an entry from pending, always be sure to release the copy of the packet that was allocated in the
-        // call to startRetransmission.
+        // When we remove an entry from pending, always be sure to release the copy of the packet that was allocated in the call
+        // to startRetransmission.
         packetPool.release(p);
 
         return true;
@@ -336,4 +291,4 @@ void NextHopRouter::setNextTx(PendingPacket *pending)
     LOG_DEBUG("Setting next retransmission in %u msecs: ", d);
     printPacket("", pending->packet);
     setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time
-}
+}

src/mesh/NextHopRouter.h

@@ -148,7 +148,7 @@ class NextHopRouter : public FloodingRouter
      */
     uint8_t getNextHop(NodeNum to, uint8_t relay_node);
 
-    /** Check if we should be rebroadcasting this packet if so, do so.
-     *  @return true if we did rebroadcast */
-    bool perhapsRebroadcast(const meshtastic_MeshPacket *p) override;
+    /** Check if we should be relaying this packet if so, do so.
+     *  @return true if we did relay */
+    bool perhapsRelay(const meshtastic_MeshPacket *p);
 };

src/mesh/NodeDB.cpp

@@ -204,7 +204,7 @@ NodeDB::NodeDB()
 
     int saveWhat = 0;
     // Get device unique id
-#if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)
+#if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
     uint32_t unique_id[4];
     // ESP32 factory burns a unique id in efuse for S2+ series and evidently C3+ series
     // This is used for HMACs in the esp-rainmaker AIOT platform and seems to be a good choice for us
@@ -256,8 +256,6 @@ NodeDB::NodeDB()
     owner.role = config.device.role;
     // Ensure macaddr is set to our macaddr as it will be copied in our info below
     memcpy(owner.macaddr, ourMacAddr, sizeof(owner.macaddr));
-    // Ensure owner.id is always derived from the node number
-    snprintf(owner.id, sizeof(owner.id), "!%08x", getNodeNum());
 
     if (!config.has_security) {
         config.has_security = true;
@@ -556,9 +554,10 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #endif
 
 #ifdef USERPREFS_CONFIG_DEVICE_ROLE
-    // Restrict ROUTER*, LOST AND FOUND roles for security reasons
+    // Restrict ROUTER*, LOST AND FOUND, and REPEATER roles for security reasons
     if (IS_ONE_OF(USERPREFS_CONFIG_DEVICE_ROLE, meshtastic_Config_DeviceConfig_Role_ROUTER,
-                  meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND)) {
+                  meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_REPEATER,
+                  meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND)) {
         LOG_WARN("ROUTER roles are restricted, falling back to CLIENT role");
         config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
     } else {
@@ -702,7 +701,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #ifdef USERPREFS_NETWORK_ENABLED_PROTOCOLS
     config.network.enabled_protocols = USERPREFS_NETWORK_ENABLED_PROTOCOLS;
 #else
-    config.network.enabled_protocols = 0;
+    config.network.enabled_protocols = 1;
 #endif
 #endif
 
@@ -907,6 +906,11 @@ void NodeDB::installRoleDefaults(meshtastic_Config_DeviceConfig_Role role)
         moduleConfig.telemetry.device_update_interval = ONE_DAY;
         owner.has_is_unmessagable = true;
         owner.is_unmessagable = true;
+    } else if (role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
+        owner.has_is_unmessagable = true;
+        owner.is_unmessagable = true;
+        config.display.screen_on_secs = 1;
+        config.device.rebroadcast_mode = meshtastic_Config_DeviceConfig_RebroadcastMode_CORE_PORTNUMS_ONLY;
     } else if (role == meshtastic_Config_DeviceConfig_Role_SENSOR) {
         owner.has_is_unmessagable = true;
         owner.is_unmessagable = true;
@@ -978,25 +982,12 @@ void NodeDB::installDefaultChannels()
     channelFile.version = DEVICESTATE_CUR_VER;
 }
 
-void NodeDB::resetNodes(bool keepFavorites)
+void NodeDB::resetNodes()
 {
     if (!config.position.fixed_position)
         clearLocalPosition();
     numMeshNodes = 1;
-    if (keepFavorites) {
-        LOG_INFO("Clearing node database - preserving favorites");
-        for (size_t i = 0; i < meshNodes->size(); i++) {
-            meshtastic_NodeInfoLite &node = meshNodes->at(i);
-            if (i > 0 && !node.is_favorite) {
-                node = meshtastic_NodeInfoLite();
-            } else {
-                numMeshNodes += 1;
-            }
-        };
-    } else {
-        LOG_INFO("Clearing node database - removing favorites");
-        std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite());
-    }
+    std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite());
     devicestate.has_rx_text_message = false;
     devicestate.has_rx_waypoint = false;
     saveNodeDatabaseToDisk();
@@ -1167,20 +1158,6 @@ void NodeDB::loadFromDisk()
     spiLock->unlock();
 #endif
 #ifdef FSCom
-#ifdef FACTORY_INSTALL
-    spiLock->lock();
-    if (!FSCom.exists("/prefs/" xstr(BUILD_EPOCH))) {
-        LOG_WARN("Factory Install Reset!");
-        FSCom.format();
-        FSCom.mkdir("/prefs");
-        File f2 = FSCom.open("/prefs/" xstr(BUILD_EPOCH), FILE_O_WRITE);
-        if (f2) {
-            f2.flush();
-            f2.close();
-        }
-    }
-    spiLock->unlock();
-#endif
     spiLock->lock();
     if (FSCom.exists(legacyPrefFileName)) {
         spiLock->unlock();
@@ -1626,18 +1603,9 @@ void NodeDB::updateTelemetry(uint32_t nodeId, const meshtastic_Telemetry &t, RxS
 void NodeDB::addFromContact(meshtastic_SharedContact contact)
 {
     meshtastic_NodeInfoLite *info = getOrCreateMeshNode(contact.node_num);
-    if (!info || !contact.has_user) {
+    if (!info) {
         return;
     }
-    // If the local node has this node marked as manually verified
-    // and the client does not, do not allow the client to update the
-    // saved public key.
-    if ((info->bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK) && !contact.manually_verified) {
-        if (contact.user.public_key.size != info->user.public_key.size ||
-            memcmp(contact.user.public_key.bytes, info->user.public_key.bytes, info->user.public_key.size) != 0) {
-            return;
-        }
-    }
     info->num = contact.node_num;
     info->has_user = true;
     info->user = TypeConversions::ConvertToUserLite(contact.user);
@@ -1645,38 +1613,17 @@ void NodeDB::addFromContact(meshtastic_SharedContact contact)
         // If should_ignore is set,
         // we need to clear the public key and other cruft, in addition to setting the node as ignored
         info->is_ignored = true;
-        info->is_favorite = false;
         info->has_device_metrics = false;
         info->has_position = false;
         info->user.public_key.size = 0;
         info->user.public_key.bytes[0] = 0;
     } else {
-        /* Clients are sending add_contact before every text message DM (because clients may hold a larger node database with
-         * public keys than the radio holds). However, we don't want to update last_heard just because we sent someone a DM!
-         */
-
-        /* "Boring old nodes" are the first to be evicted out of the node database when full. This includes a newly-zeroed
-         * nodeinfo because it has: !is_favorite && last_heard==0. To keep this from happening when we addFromContact, we set the
-         * new node as a favorite, and we leave last_heard alone (even if it's zero).
-         */
-        if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) {
-            // Special case for CLIENT_BASE: is_favorite has special meaning, and we don't want to automatically set it
-            // without the user doing so deliberately. We don't normally expect users to use a CLIENT_BASE to send DMs or to add
-            // contacts, but we should make sure it doesn't auto-favorite in case they do. Instead, as a workaround, we'll set
-            // last_heard to now, so that the add_contact node doesn't immediately get evicted.
-            info->last_heard = getTime();
-        } else {
-            // Normal case: set is_favorite to prevent expiration.
-            // last_heard will remain as-is (or remain 0 if this entry wasn't in the nodeDB).
-            info->is_favorite = true;
-        }
-
-        // As the clients will begin sending the contact with DMs, we want to strictly check if the node is manually verified
-        if (contact.manually_verified) {
-            info->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
-        }
+        info->last_heard = getValidTime(RTCQualityNTP);
+        info->is_favorite = true;
+        info->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
         // Mark the node's key as manually verified to indicate trustworthiness.
         updateGUIforNode = info;
+        // powerFSM.trigger(EVENT_NODEDB_UPDATED); This event has been retired
         sortMeshDB();
         notifyObservers(true); // Force an update whether or not our node counts have changed
     }
@@ -1720,14 +1667,14 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
             return false;
         }
         LOG_INFO("Public Key set for node, not updating!");
+        // we copy the key into the incoming packet, to prevent overwrite
+        p.public_key.size = 32;
+        memcpy(p.public_key.bytes, info->user.public_key.bytes, 32);
     } else if (p.public_key.size == 32) {
         LOG_INFO("Update Node Pubkey!");
     }
 #endif
 
-    // Always ensure user.id is derived from nodeId, regardless of what was received
-    snprintf(p.id, sizeof(p.id), "!%08x", nodeId);
-
     // Both of info->user and p start as filled with zero so I think this is okay
     auto lite = TypeConversions::ConvertToUserLite(p);
     bool changed = memcmp(&info->user, &lite, sizeof(info->user)) || (info->channel != channelIndex);
@@ -1906,13 +1853,6 @@ uint8_t NodeDB::getMeshNodeChannel(NodeNum n)
     return info->channel;
 }
 
-std::string NodeDB::getNodeId() const
-{
-    char nodeId[16];
-    snprintf(nodeId, sizeof(nodeId), "!%08x", myNodeInfo.my_node_num);
-    return std::string(nodeId);
-}
-
 /// Find a node in our DB, return null for missing
 /// NOTE: This function might be called from an ISR
 meshtastic_NodeInfoLite *NodeDB::getMeshNode(NodeNum n)

src/mesh/NodeDB.h

@@ -5,7 +5,6 @@
 #include <algorithm>
 #include <assert.h>
 #include <pb_encode.h>
-#include <string>
 #include <vector>
 
 #include "MeshTypes.h"
@@ -204,9 +203,6 @@ class NodeDB
     /// @return our node number
     NodeNum getNodeNum() { return myNodeInfo.my_node_num; }
 
-    /// @return our node ID as a string in the format "!xxxxxxxx"
-    std::string getNodeId() const;
-
     // @return last byte of a NodeNum, 0xFF if it ended at 0x00
     uint8_t getLastByteOfNodeNum(NodeNum num) { return (uint8_t)((num & 0xFF) ? (num & 0xFF) : 0xFF); }
 
@@ -229,8 +225,7 @@ class NodeDB
      */
     size_t getNumOnlineMeshNodes(bool localOnly = false);
 
-    void initConfigIntervals(), initModuleConfigIntervals(), resetNodes(bool keepFavorites = false),
-        removeNodeByNum(NodeNum nodeNum);
+    void initConfigIntervals(), initModuleConfigIntervals(), resetNodes(), removeNodeByNum(NodeNum nodeNum);
 
     bool factoryReset(bool eraseBleBonds = false);
 

src/mesh/PacketCache.cpp

@@ -1,253 +0,0 @@
-#include "PacketCache.h"
-#include "Router.h"
-
-PacketCache packetCache{};
-
-/**
- * Allocate a new cache entry and copy the packet header and payload into it
- */
-PacketCacheEntry *PacketCache::cache(const meshtastic_MeshPacket *p, bool preserveMetadata)
-{
-    size_t payload_size =
-        (p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag) ? p->encrypted.size : p->decoded.payload.size;
-    PacketCacheEntry *e = (PacketCacheEntry *)malloc(sizeof(PacketCacheEntry) + payload_size +
-                                                     (preserveMetadata ? sizeof(PacketCacheMetadata) : 0));
-    if (!e) {
-        LOG_ERROR("Unable to allocate memory for packet cache entry");
-        return NULL;
-    }
-
-    *e = {};
-    e->header.from = p->from;
-    e->header.to = p->to;
-    e->header.id = p->id;
-    e->header.channel = p->channel;
-    e->header.next_hop = p->next_hop;
-    e->header.relay_node = p->relay_node;
-    e->header.flags = (p->hop_limit & PACKET_FLAGS_HOP_LIMIT_MASK) | (p->want_ack ? PACKET_FLAGS_WANT_ACK_MASK : 0) |
-                      (p->via_mqtt ? PACKET_FLAGS_VIA_MQTT_MASK : 0) |
-                      ((p->hop_start << PACKET_FLAGS_HOP_START_SHIFT) & PACKET_FLAGS_HOP_START_MASK);
-
-    PacketCacheMetadata m{};
-    if (preserveMetadata) {
-        e->has_metadata = true;
-        m.rx_rssi = (uint8_t)(p->rx_rssi + 200);
-        m.rx_snr = (uint8_t)((p->rx_snr + 30.0f) / 0.25f);
-        m.rx_time = p->rx_time;
-        m.transport_mechanism = p->transport_mechanism;
-        m.priority = p->priority;
-    }
-    if (p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag) {
-        e->encrypted = true;
-        e->payload_len = p->encrypted.size;
-        memcpy(((unsigned char *)e) + sizeof(PacketCacheEntry), p->encrypted.bytes, p->encrypted.size);
-    } else if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
-        e->encrypted = false;
-        if (preserveMetadata) {
-            m.portnum = p->decoded.portnum;
-            m.want_response = p->decoded.want_response;
-            m.emoji = p->decoded.emoji;
-            m.bitfield = p->decoded.bitfield;
-            if (p->decoded.reply_id)
-                m.reply_id = p->decoded.reply_id;
-            else if (p->decoded.request_id)
-                m.request_id = p->decoded.request_id;
-        }
-        e->payload_len = p->decoded.payload.size;
-        memcpy(((unsigned char *)e) + sizeof(PacketCacheEntry), p->decoded.payload.bytes, p->decoded.payload.size);
-    } else {
-        LOG_ERROR("Unable to cache packet with unknown payload type %d", p->which_payload_variant);
-        free(e);
-        return NULL;
-    }
-    if (preserveMetadata)
-        memcpy(((unsigned char *)e) + sizeof(PacketCacheEntry) + e->payload_len, &m, sizeof(m));
-
-    size += sizeof(PacketCacheEntry) + e->payload_len + (e->has_metadata ? sizeof(PacketCacheMetadata) : 0);
-    insert(e);
-    return e;
-};
-
-/**
- * Dump a list of packets into the provided buffer
- */
-void PacketCache::dump(void *dest, const PacketCacheEntry **entries, size_t num_entries)
-{
-    unsigned char *pos = (unsigned char *)dest;
-    for (size_t i = 0; i < num_entries; i++) {
-        size_t entry_len =
-            sizeof(PacketCacheEntry) + entries[i]->payload_len + (entries[i]->has_metadata ? sizeof(PacketCacheMetadata) : 0);
-        memcpy(pos, entries[i], entry_len);
-        pos += entry_len;
-    }
-}
-
-/**
- * Calculate the length of buffer needed to dump the specified entries
- */
-size_t PacketCache::dumpSize(const PacketCacheEntry **entries, size_t num_entries)
-{
-    size_t total_size = 0;
-    for (size_t i = 0; i < num_entries; i++) {
-        total_size += sizeof(PacketCacheEntry) + entries[i]->payload_len;
-        if (entries[i]->has_metadata)
-            total_size += sizeof(PacketCacheMetadata);
-    }
-    return total_size;
-}
-
-/**
- * Find a packet in the cache
- */
-PacketCacheEntry *PacketCache::find(NodeNum from, PacketId id)
-{
-    uint16_t h = PACKET_HASH(from, id);
-    PacketCacheEntry *e = buckets[PACKET_CACHE_BUCKET(h)];
-    while (e) {
-        if (e->header.from == from && e->header.id == id)
-            return e;
-        e = e->next;
-    }
-    return NULL;
-}
-
-/**
- * Find a packet in the cache by its hash
- */
-PacketCacheEntry *PacketCache::find(PacketHash h)
-{
-    PacketCacheEntry *e = buckets[PACKET_CACHE_BUCKET(h)];
-    while (e) {
-        if (PACKET_HASH(e->header.from, e->header.id) == h)
-            return e;
-        e = e->next;
-    }
-    return NULL;
-}
-
-/**
- * Load a list of packets from the provided buffer
- */
-bool PacketCache::load(void *src, PacketCacheEntry **entries, size_t num_entries)
-{
-    memset(entries, 0, sizeof(PacketCacheEntry *) * num_entries);
-    unsigned char *pos = (unsigned char *)src;
-    for (size_t i = 0; i < num_entries; i++) {
-        PacketCacheEntry e{};
-        memcpy(&e, pos, sizeof(PacketCacheEntry));
-        size_t entry_len = sizeof(PacketCacheEntry) + e.payload_len + (e.has_metadata ? sizeof(PacketCacheMetadata) : 0);
-        entries[i] = (PacketCacheEntry *)malloc(entry_len);
-        size += entry_len;
-        if (!entries[i]) {
-            LOG_ERROR("Unable to allocate memory for packet cache entry");
-            for (size_t j = 0; j < i; j++) {
-                size -= sizeof(PacketCacheEntry) + entries[j]->payload_len +
-                        (entries[j]->has_metadata ? sizeof(PacketCacheMetadata) : 0);
-                free(entries[j]);
-                entries[j] = NULL;
-            }
-            return false;
-        }
-        memcpy(entries[i], pos, entry_len);
-        pos += entry_len;
-    }
-    for (size_t i = 0; i < num_entries; i++)
-        insert(entries[i]);
-    return true;
-}
-
-/**
- * Copy the cached packet into the provided MeshPacket structure
- */
-void PacketCache::rehydrate(const PacketCacheEntry *e, meshtastic_MeshPacket *p)
-{
-    if (!e || !p)
-        return;
-
-    *p = {};
-    p->from = e->header.from;
-    p->to = e->header.to;
-    p->id = e->header.id;
-    p->channel = e->header.channel;
-    p->next_hop = e->header.next_hop;
-    p->relay_node = e->header.relay_node;
-    p->hop_limit = e->header.flags & PACKET_FLAGS_HOP_LIMIT_MASK;
-    p->want_ack = !!(e->header.flags & PACKET_FLAGS_WANT_ACK_MASK);
-    p->via_mqtt = !!(e->header.flags & PACKET_FLAGS_VIA_MQTT_MASK);
-    p->hop_start = (e->header.flags & PACKET_FLAGS_HOP_START_MASK) >> PACKET_FLAGS_HOP_START_SHIFT;
-    p->which_payload_variant = e->encrypted ? meshtastic_MeshPacket_encrypted_tag : meshtastic_MeshPacket_decoded_tag;
-
-    unsigned char *payload = ((unsigned char *)e) + sizeof(PacketCacheEntry);
-    PacketCacheMetadata m{};
-    if (e->has_metadata) {
-        memcpy(&m, (payload + e->payload_len), sizeof(m));
-        p->rx_rssi = ((int)m.rx_rssi) - 200;
-        p->rx_snr = ((float)m.rx_snr * 0.25f) - 30.0f;
-        p->rx_time = m.rx_time;
-        p->transport_mechanism = (meshtastic_MeshPacket_TransportMechanism)m.transport_mechanism;
-        p->priority = (meshtastic_MeshPacket_Priority)m.priority;
-    }
-    if (e->encrypted) {
-        memcpy(p->encrypted.bytes, payload, e->payload_len);
-        p->encrypted.size = e->payload_len;
-    } else {
-        memcpy(p->decoded.payload.bytes, payload, e->payload_len);
-        p->decoded.payload.size = e->payload_len;
-        if (e->has_metadata) {
-            // Decrypted-only metadata
-            p->decoded.portnum = (meshtastic_PortNum)m.portnum;
-            p->decoded.want_response = m.want_response;
-            p->decoded.emoji = m.emoji;
-            p->decoded.bitfield = m.bitfield;
-            if (m.reply_id)
-                p->decoded.reply_id = m.reply_id;
-            else if (m.request_id)
-                p->decoded.request_id = m.request_id;
-        }
-    }
-}
-
-/**
- * Release a cache entry
- */
-void PacketCache::release(PacketCacheEntry *e)
-{
-    if (!e)
-        return;
-    remove(e);
-    size -= sizeof(PacketCacheEntry) + e->payload_len + (e->has_metadata ? sizeof(PacketCacheMetadata) : 0);
-    free(e);
-}
-
-/**
- * Insert a new entry into the hash table
- */
-void PacketCache::insert(PacketCacheEntry *e)
-{
-    assert(e);
-    PacketHash h = PACKET_HASH(e->header.from, e->header.id);
-    PacketCacheEntry **target = &buckets[PACKET_CACHE_BUCKET(h)];
-    e->next = *target;
-    *target = e;
-    num_entries++;
-}
-
-/**
- * Remove an entry from the hash table
- */
-void PacketCache::remove(PacketCacheEntry *e)
-{
-    assert(e);
-    PacketHash h = PACKET_HASH(e->header.from, e->header.id);
-    PacketCacheEntry **target = &buckets[PACKET_CACHE_BUCKET(h)];
-    while (*target) {
-        if (*target == e) {
-            *target = e->next;
-            e->next = NULL;
-            num_entries--;
-            break;
-        } else {
-            target = &(*target)->next;
-        }
-    }
-}

src/mesh/PacketCache.h

@@ -1,75 +0,0 @@
-#pragma once
-#include "RadioInterface.h"
-
-#define PACKET_HASH(a, b) ((((a ^ b) >> 16) ^ (a ^ b)) & 0xFFFF) // 16 bit fold of packet (from, id) tuple
-typedef uint16_t PacketHash;
-
-#define PACKET_CACHE_BUCKETS 64                                    // Number of hash table buckets
-#define PACKET_CACHE_BUCKET(h) (((h >> 12) ^ (h >> 6) ^ h) & 0x3F) // Fold hash down to 6-bit bucket index
-
-typedef struct PacketCacheEntry {
-    PacketCacheEntry *next;
-    PacketHeader header;
-    uint16_t payload_len = 0;
-    union {
-        uint16_t bitfield;
-        struct {
-            uint8_t encrypted : 1;    // Payload is encrypted
-            uint8_t has_metadata : 1; // Payload includes PacketCacheMetadata
-            uint8_t : 6;              // Reserved for future use
-            uint8_t : 8;              // Reserved for future use
-        };
-    };
-} PacketCacheEntry;
-
-typedef struct PacketCacheMetadata {
-    PacketCacheMetadata() : _bitfield(0), reply_id(0), _bitfield2(0) {}
-    union {
-        uint32_t _bitfield;
-        struct {
-            uint16_t portnum : 9;       // meshtastic_MeshPacket::decoded::portnum
-            uint16_t want_response : 1; // meshtastic_MeshPacket::decoded::want_response
-            uint16_t emoji : 1;         // meshtastic_MeshPacket::decoded::emoji
-            uint16_t bitfield : 5;      // meshtastic_MeshPacket::decoded::bitfield (truncated)
-            uint8_t rx_rssi : 8;        // meshtastic_MeshPacket::rx_rssi (map via actual RSSI + 200)
-            uint8_t rx_snr : 8;         // meshtastic_MeshPacket::rx_snr (map via (p->rx_snr + 30.0f) / 0.25f)
-        };
-    };
-    union {
-        uint32_t reply_id;   // meshtastic_MeshPacket::decoded.reply_id
-        uint32_t request_id; // meshtastic_MeshPacket::decoded.request_id
-    };
-    uint32_t rx_time = 0;            // meshtastic_MeshPacket::rx_time
-    uint8_t transport_mechanism = 0; // meshtastic_MeshPacket::transport_mechanism
-    struct {
-        uint8_t _bitfield2;
-        union {
-            uint8_t priority : 7; // meshtastic_MeshPacket::priority
-            uint8_t reserved : 1; // Reserved for future use
-        };
-    };
-} PacketCacheMetadata;
-
-class PacketCache
-{
-  public:
-    PacketCacheEntry *cache(const meshtastic_MeshPacket *p, bool preserveMetadata);
-    static void dump(void *dest, const PacketCacheEntry **entries, size_t num_entries);
-    size_t dumpSize(const PacketCacheEntry **entries, size_t num_entries);
-    PacketCacheEntry *find(NodeNum from, PacketId id);
-    PacketCacheEntry *find(PacketHash h);
-    bool load(void *src, PacketCacheEntry **entries, size_t num_entries);
-    size_t getNumEntries() { return num_entries; }
-    size_t getSize() { return size; }
-    void rehydrate(const PacketCacheEntry *e, meshtastic_MeshPacket *p);
-    void release(PacketCacheEntry *e);
-
-  private:
-    PacketCacheEntry *buckets[PACKET_CACHE_BUCKETS]{};
-    size_t num_entries = 0;
-    size_t size = 0;
-    void insert(PacketCacheEntry *e);
-    void remove(PacketCacheEntry *e);
-};
-
-extern PacketCache packetCache;