WIP

.devcontainer/devcontainer.json

@@ -13,13 +13,16 @@
   },
   "customizations": {
     "vscode": {
-      "extensions": ["ms-vscode.cpptools", "platformio.platformio-ide"]
+      "extensions": [
+        "ms-vscode.cpptools",
+        "platformio.platformio-ide",
+      ]
     }
   },
 
   // Use 'forwardPorts' to make a list of ports inside the container available locally.
-  "forwardPorts": [4403],
+  "forwardPorts": [ 4403 ],
 
   // Run commands to prepare the container for use
-  "postCreateCommand": ".devcontainer/setup.sh"
+  "postCreateCommand": ".devcontainer/setup.sh",
 }

.devcontainer/setup.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env sh
 
-git submodule update --init
+git submodule update --init

.github/ISSUE_TEMPLATE/Bug Report.yml

@@ -49,24 +49,10 @@ body:
         - Heltec V3
         - Heltec Wireless Paper
         - Heltec Wireless Tracker
-        - Heltec Mesh Node T114
-        - Heltec Vision Master E213
-        - Heltec Vision Master E290
-        - Heltec Vision Master T190
-        - Nano G1
-        - Nano G1 Explorer
-        - Nano G2 Ultra
         - Raspberry Pi Pico (W)
         - Relay v1
         - Relay v2
         - Seeed Wio Tracker 1110
-        - Seeed Card Tracker T1000-E
-        - Station G1
-        - Station G2
-        - unPhone
-        - CanaryOne
-        - Chatter
-        - Linux Native
         - DIY
         - Other
     validations:

.github/ISSUE_TEMPLATE/feature.yml

@@ -18,7 +18,6 @@ body:
         - ESP32
         - RP2040
         - Linux Native
-        - Cross-Platform
         - other
     validations:
       required: true

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

@@ -1,90 +0,0 @@
-name: Setup Build Variant Composite Action
-description: Variant build actions for Meshtastic Platform IO steps
-
-inputs:
-  board:
-    description: The board to build for
-    required: true
-  github_token:
-    description: GitHub token
-    required: true
-  build-script-path:
-    description: Path to the build script
-    required: true
-  remove-debug-flags:
-    description: A space separated list of files to remove debug flags from
-    required: false
-    default: ""
-  ota-firmware-source:
-    description: The OTA firmware file to pull
-    required: false
-    default: ""
-  ota-firmware-target:
-    description: The target path to store the OTA firmware file
-    required: false
-    default: ""
-  artifact-paths:
-    description: A newline separated list of paths to store as artifacts
-    required: false
-    default: ""
-  include-web-ui:
-    description: Include the web UI in the build
-    required: false
-    default: "false"
-
-runs:
-  using: composite
-  steps:
-    - name: Build base
-      id: base
-      uses: ./.github/actions/setup-base
-
-    - name: Pull web ui
-      if: inputs.include-web-ui == 'true'
-      uses: dsaltares/fetch-gh-release-asset@master
-      with:
-        repo: meshtastic/web
-        file: build.tar
-        target: build.tar
-        token: ${{ inputs.github_token }}
-
-    - name: Unpack web ui
-      if: inputs.include-web-ui == 'true'
-      shell: bash
-      run: |
-        tar -xf build.tar -C data/static
-        rm build.tar
-
-    - name: Remove debug flags for release
-      shell: bash
-      if: inputs.remove-debug-flags != ''
-      run: |
-        for INI_FILE in ${{ inputs.remove-debug-flags }}; do
-          sed -i '/DDEBUG_HEAP/d' ${INI_FILE}
-        done
-
-    - name: Build ${{ inputs.board }}
-      shell: bash
-      run: ${{ inputs.build-script-path }} ${{ inputs.board }}
-
-    - name: Pull OTA Firmware
-      if: inputs.ota-firmware-source != '' &&  inputs.ota-firmware-target != ''
-      uses: dsaltares/fetch-gh-release-asset@master
-      with:
-        repo: meshtastic/firmware-ota
-        file: ${{ inputs.ota-firmware-source }}
-        target: ${{ inputs.ota-firmware-target }}
-        token: ${{ inputs.github_token }}
-
-    - name: Get release version string
-      shell: bash
-      run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-      id: version
-
-    - name: Store binaries as an artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
-        overwrite: true
-        path: |
-          ${{ inputs.artifact-paths }}

.github/dependabot.yml

@@ -1,26 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: docker
-    directory: devcontainer
-    schedule:
-      interval: daily
-      time: "05:00" # trunk-ignore(yamllint/quoted-strings): required by dependabot syntax check
-      timezone: US/Pacific
-  - package-ecosystem: docker
-    directory: /
-    schedule:
-      interval: daily
-      time: "05:00" # trunk-ignore(yamllint/quoted-strings): required by dependabot syntax check
-      timezone: US/Pacific
-  - package-ecosystem: gitsubmodule
-    directory: /
-    schedule:
-      interval: daily
-      time: "05:00" # trunk-ignore(yamllint/quoted-strings): required by dependabot syntax check
-      timezone: US/Pacific
-  - package-ecosystem: github-actions
-    directory: /.github/workflows
-    schedule:
-      interval: daily
-      time: "05:00" # trunk-ignore(yamllint/quoted-strings): required by dependabot syntax check
-      timezone: US/Pacific

.github/workflows/build_esp32.yml

@@ -12,22 +12,52 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
+
+      - name: Pull web ui
+        uses: dsaltares/fetch-gh-release-asset@master
+        with:
+          repo: meshtastic/web
+          file: build.tar
+          target: build.tar
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Unpack web ui
+        run: |
+          tar -xf build.tar -C data/static
+          rm build.tar
+
+      - name: Remove debug flags for release
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        run: |
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s2.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s3.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32c3.ini
 
       - name: Build ESP32
-        id: build
-        uses: ./.github/actions/build-variant
+        run: bin/build-esp32.sh ${{ inputs.board }}
+
+      - name: Pull OTA Firmware
+        uses: dsaltares/fetch-gh-release-asset@master
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          board: ${{ inputs.board }}
-          remove-debug-flags: >-
-            ./arch/esp32/esp32.ini
-            ./arch/esp32/esp32s2.ini
-            ./arch/esp32/esp32s3.ini
-            ./arch/esp32/esp32c3.ini
-          build-script-path: bin/build-esp32.sh
-          ota-firmware-source: firmware.bin
-          ota-firmware-target: release/bleota.bin
-          artifact-paths: |
+          repo: meshtastic/firmware-ota
+          file: firmware.bin
+          target: release/bleota.bin
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get release version string
+        shell: bash
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
+          overwrite: true
+          path: |
             release/*.bin
             release/*.elf
-          include-web-ui: true

.github/workflows/build_esp32_c3.yml

@@ -14,21 +14,50 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
 
-      - name: Build ESP32-C3
-        id: build
-        uses: ./.github/actions/build-variant
+      - name: Pull web ui
+        uses: dsaltares/fetch-gh-release-asset@master
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          board: ${{ inputs.board }}
-          remove-debug-flags: >-
-            ./arch/esp32/esp32.ini
-            ./arch/esp32/esp32s2.ini
-            ./arch/esp32/esp32s3.ini
-            ./arch/esp32/esp32c3.ini
-          build-script-path: bin/build-esp32.sh
-          ota-firmware-source: firmware-c3.bin
-          ota-firmware-target: release/bleota-c3.bin
-          artifact-paths: |
+          repo: meshtastic/web
+          file: build.tar
+          target: build.tar
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Unpack web ui
+        run: |
+          tar -xf build.tar -C data/static
+          rm build.tar
+      - name: Remove debug flags for release
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        run: |
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s2.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s3.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32c3.ini
+      - name: Build ESP32
+        run: bin/build-esp32.sh ${{ inputs.board }}
+
+      - name: Pull OTA Firmware
+        uses: dsaltares/fetch-gh-release-asset@master
+        with:
+          repo: meshtastic/firmware-ota
+          file: firmware-c3.bin
+          target: release/bleota-c3.bin
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get release version string
+        shell: bash
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
+          overwrite: true
+          path: |
             release/*.bin
             release/*.elf

.github/workflows/build_esp32_c6.yml

@@ -1,35 +0,0 @@
-name: Build ESP32-C6
-
-on:
-  workflow_call:
-    inputs:
-      board:
-        required: true
-        type: string
-
-permissions: read-all
-
-jobs:
-  build-esp32-c6:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Build ESP32-C6
-        id: build
-        uses: ./.github/actions/build-variant
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          board: ${{ inputs.board }}
-          remove-debug-flags: >-
-            ./arch/esp32/esp32.ini
-            ./arch/esp32/esp32s2.ini
-            ./arch/esp32/esp32s3.ini
-            ./arch/esp32/esp32c3.ini
-            ./arch/esp32/esp32c6.ini
-          build-script-path: bin/build-esp32.sh
-          ota-firmware-source: firmware-c3.bin
-          ota-firmware-target: release/bleota-c3.bin
-          artifact-paths: |
-            release/*.bin
-            release/*.elf

.github/workflows/build_esp32_s3.yml

@@ -12,22 +12,50 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
 
-      - name: Build ESP32-S3
-        id: build
-        uses: ./.github/actions/build-variant
+      - name: Pull web ui
+        uses: dsaltares/fetch-gh-release-asset@master
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          board: ${{ inputs.board }}
-          remove-debug-flags: >-
-            ./arch/esp32/esp32.ini
-            ./arch/esp32/esp32s2.ini
-            ./arch/esp32/esp32s3.ini
-            ./arch/esp32/esp32c3.ini
-          build-script-path: bin/build-esp32.sh
-          ota-firmware-source: firmware-s3.bin
-          ota-firmware-target: release/bleota-s3.bin
-          artifact-paths: |
+          repo: meshtastic/web
+          file: build.tar
+          target: build.tar
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Unpack web ui
+        run: |
+          tar -xf build.tar -C data/static
+          rm build.tar
+      - name: Remove debug flags for release
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        run: |
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s2.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32s3.ini
+          sed -i '/DDEBUG_HEAP/d' ./arch/esp32/esp32c3.ini
+      - name: Build ESP32
+        run: bin/build-esp32.sh ${{ inputs.board }}
+
+      - name: Pull OTA Firmware
+        uses: dsaltares/fetch-gh-release-asset@master
+        with:
+          repo: meshtastic/firmware-ota
+          file: firmware-s3.bin
+          target: release/bleota-s3.bin
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get release version string
+        shell: bash
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
+          overwrite: true
+          path: |
             release/*.bin
             release/*.elf
-          include-web-ui: true

.github/workflows/build_native.yml

@@ -67,7 +67,7 @@ jobs:
       - name: Docker build and push tagged versions
         if: ${{ github.event_name == 'workflow_dispatch' }}
         continue-on-error: true # FIXME: Failing docker login auth
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
         with:
           context: .
           file: ./Dockerfile
@@ -77,7 +77,7 @@ jobs:
       - name: Docker build and push
         if: ${{ github.ref == 'refs/heads/master' && github.event_name != 'pull_request_target' && github.event_name != 'pull_request' }}
         continue-on-error: true # FIXME: Failing docker login auth
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
         with:
           context: .
           file: ./Dockerfile

.github/workflows/build_nrf52.yml

@@ -12,15 +12,23 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
 
       - name: Build NRF52
-        id: build
-        uses: ./.github/actions/build-variant
+        run: bin/build-nrf52.sh ${{ inputs.board }}
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v4
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          board: ${{ inputs.board }}
-          build-script-path: bin/build-nrf52.sh
-          artifact-paths: |
+          name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
+          overwrite: true
+          path: |
             release/*.hex
             release/*.uf2
             release/*.elf

.github/workflows/build_rpi2040.yml

@@ -12,14 +12,22 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
 
       - name: Build Raspberry Pi 2040
-        id: build
-        uses: ./.github/actions/build-variant
+        run: ./bin/build-rpi2040.sh ${{ inputs.board }}
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v4
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          board: ${{ inputs.board }}
-          build-script-path: bin/build-rpi2040.sh
-          artifact-paths: |
+          name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
+          overwrite: true
+          path: |
             release/*.uf2
             release/*.elf

.github/workflows/build_stm32.yml

@@ -12,14 +12,22 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - name: Build base
+        id: base
+        uses: ./.github/actions/setup-base
 
-      - name: Build STM32WL
-        id: build
-        uses: ./.github/actions/build-variant
+      - name: Build STM32
+        run: bin/build-stm32.sh ${{ inputs.board }}
+
+      - name: Get release version string
+        run: echo "version=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v4
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          board: ${{ inputs.board }}
-          build-script-path: bin/build-stm32.sh
-          artifact-paths: |
+          name: firmware-${{ inputs.board }}-${{ steps.version.outputs.version }}.zip
+          overwrite: true
+          path: |
             release/*.hex
             release/*.bin

.github/workflows/main_matrix.yml

@@ -1,7 +1,4 @@
 name: CI
-concurrency:
-  group: ${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
 #concurrency:
 #  group: ${{ github.ref }}
 #  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
@@ -27,7 +24,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        arch: [esp32, esp32s3, esp32c3, esp32c6, nrf52840, rp2040, stm32, check]
+        arch: [esp32, esp32s3, esp32c3, nrf52840, rp2040, stm32, check]
     runs-on: ubuntu-latest
     steps:
       - id: checkout
@@ -35,18 +32,13 @@ jobs:
         name: Checkout base
       - id: jsonStep
         run: |
-          if [[ "${{ github.ref }}" == "refs/heads/master" ]]; then
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
-          else  
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} quick)
-          fi
+          TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
           echo "$TARGETS"
           echo "${{matrix.arch}}=$(jq -cn --argjson environments "$TARGETS" '{board: $environments}')" >> $GITHUB_OUTPUT
     outputs:
       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 }}
       stm32: ${{ steps.jsonStep.outputs.stm32 }}
@@ -59,7 +51,6 @@ jobs:
       matrix: ${{ fromJson(needs.setup.outputs.check) }}
 
     runs-on: ubuntu-latest
-    if: ${{ github.event_name != 'workflow_dispatch' }}
     steps:
       - uses: actions/checkout@v4
       - name: Build base
@@ -95,15 +86,6 @@ jobs:
     with:
       board: ${{ matrix.board }}
 
-  build-esp32-c6:
-    needs: setup
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.esp32c6) }}
-    uses: ./.github/workflows/build_esp32_c6.yml
-    with:
-      board: ${{ matrix.board }}
-
   build-nrf52:
     needs: setup
     strategy:
@@ -137,12 +119,11 @@ jobs:
   package-raspbian-armv7l:
     uses: ./.github/workflows/package_raspbian_armv7l.yml
 
-  # package-native:
-  #   uses: ./.github/workflows/package_amd64.yml
+  package-native:
+    uses: ./.github/workflows/package_amd64.yml
 
   after-checks:
     runs-on: ubuntu-latest
-    if: ${{ github.event_name != 'workflow_dispatch' }}
     needs: [check]
     steps:
       - name: Checkout code
@@ -156,17 +137,17 @@ jobs:
       contents: write
       pull-requests: write
     runs-on: ubuntu-latest
-    needs: [
+    needs:
+      [
         build-esp32,
         build-esp32-s3,
         build-esp32-c3,
-        build-esp32-c6,
         build-nrf52,
         build-rpi2040,
         build-stm32,
         package-raspbian,
         package-raspbian-armv7l,
-        # package-native,
+        package-native,
       ]
     steps:
       - name: Checkout code
@@ -250,7 +231,7 @@ jobs:
   release-artifacts:
     runs-on: ubuntu-latest
     if: ${{ github.event_name == 'workflow_dispatch' }}
-    needs: [gather-artifacts]
+    needs: [gather-artifacts, after-checks]
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -270,6 +251,12 @@ jobs:
           merge-multiple: true
           path: ./output
 
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: meshtasticd_${{ steps.version.outputs.version }}_*.deb
+          merge-multiple: true
+          path: ./output
+
       - name: Display structure of downloaded files
         run: ls -R
 
@@ -279,7 +266,7 @@ jobs:
           chmod +x ./output/device-update.sh
 
       - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{ steps.version.outputs.version }}.zip ./output -x meshtasticd_*
+        run: zip -j -9 -r ./firmware-${{ steps.version.outputs.version }}.zip ./output -x *.deb
 
       - uses: actions/download-artifact@v4
         with:
@@ -327,12 +314,6 @@ jobs:
           asset_name: debug-elfs-${{ steps.version.outputs.version }}.zip
           asset_content_type: application/zip
 
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: meshtasticd_${{ steps.version.outputs.version }}_*.deb
-          merge-multiple: true
-          path: ./output
-
       - name: Add raspbian aarch64 .deb
         uses: actions/upload-release-asset@v1
         env:
@@ -353,50 +334,22 @@ jobs:
           asset_name: meshtasticd_${{ steps.version.outputs.version }}_armhf.deb
           asset_content_type: application/vnd.debian.binary-package
 
-      # - name: Add raspbian amd64 .deb
-      #   uses: actions/upload-release-asset@v1
-      #   env:
-      #     GITHUB_TOKEN: ${{ github.token }}
-      #   with:
-      #     upload_url: ${{ steps.create_release.outputs.upload_url }}
-      #     asset_path: ./output/meshtasticd_${{ steps.version.outputs.version }}_amd64.deb
-      #     asset_name: meshtasticd_${{ steps.version.outputs.version }}_amd64.deb
-      #     asset_content_type: application/vnd.debian.binary-package
+      - name: Add raspbian amd64 .deb
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./output/meshtasticd_${{ steps.version.outputs.version }}_amd64.deb
+          asset_name: meshtasticd_${{ steps.version.outputs.version }}_amd64.deb
+          asset_content_type: application/vnd.debian.binary-package
 
       - name: Bump version.properties
         run: >-
           bin/bump_version.py
 
       - name: Create version.properties pull request
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@v6
         with:
-          title: Bump version.properties
           add-paths: |
             version.properties
-
-      - name: Checkout meshtastic/meshtastic.github.io
-        uses: actions/checkout@v4
-        with:
-          repository: meshtastic/meshtastic.github.io
-          token: ${{ secrets.ARTIFACTS_TOKEN }}
-          path: meshtastic.github.io
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: Extract firmware.zip
-        run: |
-          unzip ./firmware-${{ steps.version.outputs.version }}.zip -d meshtastic.github.io/firmware-${{ steps.version.outputs.version }}
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: Commit and push changes
-        run: |
-          cd meshtastic.github.io
-          find . -type f -name 'meshtasticd_*' -exec rm -f {} +
-          git config --global user.name "github-actions[bot]"
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-          git add .
-          git commit -m "Add firmware version ${{ steps.version.outputs.version }}"
-          git push

.github/workflows/package_amd64.yml

@@ -13,7 +13,7 @@ jobs:
     uses: ./.github/workflows/build_native.yml
 
   package-native:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     needs: build-native
     steps:
       - name: Checkout code

.github/workflows/package_raspbian.yml

@@ -13,7 +13,7 @@ jobs:
     uses: ./.github/workflows/build_raspbian.yml
 
   package-raspbian:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     needs: build-raspbian
     steps:
       - name: Checkout code

.github/workflows/package_raspbian_armv7l.yml

@@ -13,7 +13,7 @@ jobs:
     uses: ./.github/workflows/build_raspbian_armv7l.yml
 
   package-raspbian_armv7l:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     needs: build-raspbian_armv7l
     steps:
       - name: Checkout code

.github/workflows/sec_sast_semgrep_cron.yml

@@ -12,7 +12,7 @@ jobs:
   semgrep-full:
     runs-on: ubuntu-latest
     container:
-      image: semgrep/semgrep
+      image: returntocorp/semgrep
 
     steps:
       # step 1

.github/workflows/sec_sast_semgrep_pull.yml

@@ -4,9 +4,9 @@ on: pull_request
 
 jobs:
   semgrep-diff:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     container:
-      image: semgrep/semgrep
+      image: returntocorp/semgrep
 
     steps:
       # step 1

.github/workflows/tests.yml

@@ -57,50 +57,35 @@ jobs:
           reporter: java-junit
 
   hardware-tests:
-    runs-on: test-runner
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      # - uses: actions/setup-python@v5
-      #   with:
-      #     python-version: '3.10'
-
-      # pipx install "setuptools<72"
       - name: Upgrade python tools
         shell: bash
         run: |
-          pipx install adafruit-nrfutil
-          pipx install poetry
-          pipx install meshtastic --pip-args=--pre
-
-      - name: Install PlatformIO from script
-        shell: bash
-        run: |
-          curl -fsSL -o get-platformio.py https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py
-          python3 get-platformio.py
+          python -m pip install --upgrade pip
+          pip install -U --no-build-isolation --no-cache-dir "setuptools<72"
+          pip install -U platformio adafruit-nrfutil --no-build-isolation
+          pip install -U poetry --no-build-isolation
+          pip install -U meshtastic --pre --no-build-isolation
 
       - name: Upgrade platformio
         shell: bash
         run: |
-          export PATH=$PATH:$HOME/.local/bin
           pio upgrade
 
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 18
-
       - name: Setup pnpm
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@v2
         with:
           version: latest
 
-      - name: Install dependencies, setup devices and run
-        shell: bash
-        run: |
-          git submodule update --init --recursive
-          cd meshtestic/
-          pnpm install
-          pnpm run setup
-          pnpm run test
+      - name: Install Dependencies
+        run: pnpm install
+
+      - name: Setup devices
+        run: pnpm run setup
+
+      - name: Execute end to end tests on connected hardware
+        run: pnpm run test

.github/workflows/update_protobufs.yml

@@ -1,4 +1,4 @@
-name: Update protobufs and regenerate classes
+name: "Update protobufs and regenerate classes"
 on: workflow_dispatch
 
 jobs:
@@ -26,9 +26,8 @@ jobs:
           ./bin/regen-protos.sh
 
       - name: Create pull request
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@v6
         with:
-          title: Update protobufs and classes
           add-paths: |
             protobufs
             src/mesh

.trunk/trunk.yaml

@@ -1,6 +1,6 @@
 version: 0.1
 cli:
-  version: 1.22.5
+  version: 1.22.3
 plugins:
   sources:
     - id: trunk
@@ -8,27 +8,27 @@ plugins:
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - trufflehog@3.82.5
+    - trufflehog@3.81.9
     - yamllint@1.35.1
-    - bandit@1.7.10
-    - checkov@3.2.255
+    - bandit@1.7.9
+    - checkov@3.2.238
     - terrascan@1.19.1
-    - trivy@0.55.2
+    - trivy@0.54.1
     #- trufflehog@3.63.2-rc0
     - taplo@0.9.3
-    - ruff@0.6.7
+    - ruff@0.6.2
     - isort@5.13.2
-    - markdownlint@0.42.0
+    - markdownlint@0.41.0
     - oxipng@9.1.2
     - svgo@3.3.2
-    - actionlint@1.7.2
+    - actionlint@1.7.1
     - flake8@7.1.1
     - hadolint@2.12.0
     - shfmt@3.6.0
     - shellcheck@0.10.0
     - black@24.8.0
     - git-diff-check
-    - gitleaks@8.19.2
+    - gitleaks@8.18.4
     - clang-format@16.0.3
     - prettier@3.3.3
   ignore:

SECURITY.md

@@ -1,12 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-| Firmware Version | Supported          |
-| ---------------- | ------------------ |
-| 2.5.x            | :white_check_mark: |
-| <= 2.4.x         | :x:                |
-
-## Reporting a Vulnerability
-
-We support the private reporting of potential security vulnerabilities. Please go to the Security tab to file a report with a description of the potential vulnerability and reproduction scripts (preferred) or steps, and our developers will review.

arch/esp32/esp32.ini

@@ -5,7 +5,7 @@ custom_esp32_kind = esp32
 platform = platformio/espressif32@6.7.0
 
 build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2xx0> -<mesh/eth/> -<mesh/raspihttp>
+  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2040> -<mesh/eth/> -<mesh/raspihttp>
 
 upload_speed = 921600
 debug_init_break = tbreak setup

arch/esp32/esp32c6.ini

@@ -1,40 +0,0 @@
-[esp32c6_base]
-extends = esp32_base
-platform = https://github.com/Jason2866/platform-espressif32.git#22faa566df8c789000f8136cd8d0aca49617af55
-build_flags =
-  ${arduino_base.build_flags}
-  -Wall
-  -Wextra
-  -Isrc/platform/esp32
-  -std=c++11
-  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
-  -DSERIAL_BUFFER_SIZE=4096
-  -DLIBPAX_ARDUINO
-  -DLIBPAX_WIFI
-  -DLIBPAX_BLE
-  -DMESHTASTIC_EXCLUDE_WEBSERVER
-  ;-DDEBUG_HEAP
-  ; TEMP
-  -DHAS_BLUETOOTH=0
-  -DMESHTASTIC_EXCLUDE_PAXCOUNTER
-  -DMESHTASTIC_EXCLUDE_BLUETOOTH
-
-lib_deps =
-  ${arduino_base.lib_deps}
-  ${networking_base.lib_deps}
-  ${environmental_base.lib_deps}
-  https://github.com/lewisxhe/XPowersLib.git#84b7373faea3118b6c37954d52f98b8a337148d6
-  https://github.com/meshtastic/ESP32_Codec2.git#633326c78ac251c059ab3a8c430fcdf25b41672f
-  rweather/Crypto@^0.4.0
-
-build_src_filter = 
- ${esp32_base.build_src_filter} -<mesh/http> 
-
-monitor_speed = 460800
-monitor_filters = esp32_c3_exception_decoder
-
-lib_ignore =
-  NonBlockingRTTTL
-  NimBLE-Arduino
-  libpax
-  

arch/nrf52/nrf52.ini

@@ -16,7 +16,7 @@ build_flags =
   -DLFS_NO_ASSERT                      ; Disable LFS assertions , see https://github.com/meshtastic/firmware/pull/3818
 
 build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/esp32/> -<platform/stm32wl> -<nimble/> -<mesh/wifi/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<platform/rp2xx0> -<mesh/eth/> -<mesh/raspihttp>
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<platform/stm32wl> -<nimble/> -<mesh/wifi/> -<mesh/api/> -<mesh/http/> -<modules/esp32> -<platform/rp2040> -<mesh/eth/> -<mesh/raspihttp>
 
 lib_deps=
   ${arduino_base.lib_deps}

arch/portduino/portduino.ini

@@ -1,6 +1,6 @@
 ; The Portduino based sim environment on top of any host OS, all hardware will be simulated
 [portduino_base]
-platform = https://github.com/meshtastic/platform-native.git#6b3796d697481c8f6e3f4aa5c111bd9979f29e64
+platform = https://github.com/meshtastic/platform-native.git#ad8112adf82ce1f5b917092cf32be07a077801a0
 framework = arduino
 
 build_src_filter = 
@@ -9,7 +9,7 @@ build_src_filter =
   -<nimble/> 
   -<platform/nrf52/> 
   -<platform/stm32wl/> 
-  -<platform/rp2xx0>
+  -<platform/rp2040>
   -<mesh/wifi/>
   -<mesh/http/>
   +<mesh/raspihttp/>

arch/rp2040/rp2040.ini

@@ -8,7 +8,7 @@ board_build.core = earlephilhower
 board_build.filesystem_size = 0.5m
 build_flags = 
   ${arduino_base.build_flags} -Wno-unused-variable 
-  -Isrc/platform/rp2xx0
+  -Isrc/platform/rp2040
   -D__PLAT_RP2040__
 #  -D _POSIX_THREADS
 build_src_filter = 

arch/rp2xx0/rp2350.ini

@@ -1,23 +0,0 @@
-; Common settings for rp2040 Processor based targets
-[rp2350_base]
-platform = https://github.com/maxgerhardt/platform-raspberrypi.git#9e55f6db5c56b9867c69fe473f388beea4546672
-extends = arduino_base
-platform_packages = framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git#a6ab6e1f95bc1428d667d55ea7173c0744acc03c ; 4.0.2+
-
-board_build.core = earlephilhower
-board_build.filesystem_size = 0.5m
-build_flags = 
-  ${arduino_base.build_flags} -Wno-unused-variable 
-  -Isrc/platform/rp2xx0
-  -D__PLAT_RP2040__
-#  -D _POSIX_THREADS
-build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<modules/esp32> -<platform/nrf52/> -<platform/stm32wl> -<mesh/eth/> -<mesh/wifi/> -<mesh/http/> -<mesh/raspihttp>
-
-lib_ignore =
-  BluetoothOTA
-
-lib_deps =
-  ${arduino_base.lib_deps}
-  ${environmental_base.lib_deps}
-  rweather/Crypto

arch/stm32/stm32.ini

@@ -22,7 +22,7 @@ build_flags =
   -fdata-sections
   
 build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/wifi/> -<mesh/http/> -<modules/esp32> -<mesh/eth/> -<input> -<buzz> -<modules/RemoteHardwareModule.cpp> -<platform/nrf52> -<platform/portduino> -<platform/rp2xx0> -<mesh/raspihttp>
+  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/wifi/> -<mesh/http/> -<modules/esp32> -<mesh/eth/> -<input> -<buzz> -<modules/RemoteHardwareModule.cpp> -<platform/nrf52> -<platform/portduino> -<platform/rp2040> -<mesh/raspihttp>
 
 board_upload.offset_address = 0x08000000
 upload_protocol = stlink

bin/config-dist.yaml

@@ -9,7 +9,6 @@ Lora:
 #  IRQ: 16
 #  Busy: 20
 #  Reset: 18
-#  SX126X_ANT_SW: 6
 
 #  Module: sx1262  # Waveshare SX1302 LISTEN ONLY AT THIS TIME!
 #  CS: 7
@@ -154,4 +153,4 @@ Webserver:
 
 General:
   MaxNodes: 200
-  MaxMessageQueue: 100
+  MaxMessageQueue: 100

bin/generate_ci_matrix.py

@@ -6,7 +6,6 @@ import configparser
 import json
 import os
 import sys
-import random
 
 rootdir = "variants/"
 
@@ -40,7 +39,5 @@ for subdir, dirs, files in os.walk(rootdir):
                             "check" in options
                         ):
                             outlist.append(section)
-if ("quick" in options) & (len(outlist) > 3):
-    print(json.dumps(random.sample(outlist, 3)))
-else:
-    print(json.dumps(outlist))
+
+print(json.dumps(outlist))

boards/heltec_mesh_node_t114.json

@@ -5,7 +5,7 @@
     },
     "core": "nRF5",
     "cpu": "cortex-m4",
-    "extra_flags": "-DHELTEC_T114 -DNRF52840_XXAA",
+    "extra_flags": "-DARDUINO_NRF52840_PCA10056 -DNRF52840_XXAA",
     "f_cpu": "64000000L",
     "hwids": [
       ["0x239A", "0x4405"],

boards/lora_isp4520.json

@@ -0,0 +1,40 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52832_s132_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DNRF52832_XXAA -DNRF52",
+    "f_cpu": "64000000L",
+    "mcu": "nrf52832",
+    "variant": "lora_isp4520",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS132",
+      "sd_name": "s132",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B7"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52832_xxAA",
+    "svd_path": "nrf52.svd",
+    "openocd_target": "nrf52840-mdk-rs"
+  },
+  "frameworks": ["arduino"],
+  "name": "lora ISP4520",
+  "upload": {
+    "maximum_ram_size": 65536,
+    "maximum_size": 524288,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"]
+  },
+  "url": "",
+  "vendor": "PsiSoft"
+}

boards/me25ls01-4y10td.json

@@ -5,7 +5,7 @@
     },
     "core": "nRF5",
     "cpu": "cortex-m4",
-    "extra_flags": "-DME25LS01_4Y10TD -DNRF52840_XXAA",
+    "extra_flags": "-DARDUINO_WIO_WM1110 -DNRF52840_XXAA",
     "f_cpu": "64000000L",
     "hwids": [
       ["0x239A", "0x8029"],

boards/ms24sf1.json

@@ -5,7 +5,7 @@
     },
     "core": "nRF5",
     "cpu": "cortex-m4",
-    "extra_flags": "-DMS24SF1 -DNRF52840_XXAA",
+    "extra_flags": "-DARDUINO_WIO_WM1110 -DNRF52840_XXAA",
     "f_cpu": "64000000L",
     "hwids": [
       ["0x239A", "0x8029"],

boards/nordic_pca10059.json

@@ -5,7 +5,7 @@
     },
     "core": "nRF5",
     "cpu": "cortex-m4",
-    "extra_flags": "-DNORDIC_PCA10059 -DNRF52840_XXAA",
+    "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
     "f_cpu": "64000000L",
     "hwids": [
       ["0x239A", "0x8029"],

boards/seeed-sensecap-indicator.json

@@ -1,42 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "esp32s3_out.ld",
-      "partitions": "default_8MB.csv",
-      "memory_type": "qio_opi"
-    },
-    "core": "esp32",
-    "extra_flags": [
-      "-DBOARD_HAS_PSRAM",
-      "-DARDUINO_USB_CDC_ON_BOOT=0",
-      "-DARDUINO_USB_MODE=1",
-      "-DARDUINO_RUNNING_CORE=1",
-      "-DARDUINO_EVENT_RUNNING_CORE=1"
-    ],
-    "f_cpu": "240000000L",
-    "f_flash": "80000000L",
-    "flash_mode": "qio",
-    "hwids": [["0x1A86", "0x7523"]],
-    "mcu": "esp32s3",
-    "variant": "esp32s3r8"
-  },
-  "connectivity": ["wifi", "bluetooth", "lora"],
-  "debug": {
-    "default_tool": "esp-builtin",
-    "onboard_tools": ["esp-builtin"],
-    "openocd_target": "esp32s3.cfg"
-  },
-  "frameworks": ["arduino"],
-  "name": "Seeed Studio SenseCAP Indicator",
-  "upload": {
-    "flash_size": "8MB",
-    "maximum_ram_size": 327680,
-    "maximum_size": 8388608,
-    "require_upload_port": true,
-    "use_1200bps_touch": true,
-    "wait_for_upload_port": true,
-    "speed": 921600
-  },
-  "url": "https://www.seeedstudio.com/Indicator-for-Meshtastic.html",
-  "vendor": "Seeed Studio"
-}

boards/seeed-xiao-s3.json

@@ -1,41 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "esp32s3_out.ld",
-      "memory_type": "qio_opi"
-    },
-    "core": "esp32",
-    "extra_flags": [
-      "-DBOARD_HAS_PSRAM",
-      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
-      "-DARDUINO_RUNNING_CORE=1",
-      "-DARDUINO_EVENT_RUNNING_CORE=0"
-    ],
-    "f_cpu": "240000000L",
-    "f_flash": "80000000L",
-    "flash_mode": "qio",
-    "hwids": [["0x2886", "0x0059"]],
-    "mcu": "esp32s3",
-    "variant": "seeed-xiao-s3"
-  },
-  "connectivity": ["wifi", "bluetooth", "lora"],
-  "debug": {
-    "default_tool": "esp-builtin",
-    "onboard_tools": ["esp-builtin"],
-    "openocd_target": "esp32s3.cfg"
-  },
-  "frameworks": ["arduino", "espidf"],
-  "name": "seeed-xiao-s3",
-  "upload": {
-    "flash_size": "8MB",
-    "maximum_ram_size": 8388608,
-    "maximum_size": 8388608,
-    "use_1200bps_touch": true,
-    "wait_for_upload_port": true,
-    "require_upload_port": true,
-    "speed": 921600
-  },
-  "url": "https://www.seeedstudio.com/XIAO-ESP32S3-Sense-p-5639.html",
-  "vendor": "Seeed Studio"
-}

platformio.ini

@@ -81,17 +81,14 @@ build_flags = -Wno-missing-field-initializers
   -DRADIOLIB_EXCLUDE_APRS
   -DRADIOLIB_EXCLUDE_LORAWAN
   -DMESHTASTIC_EXCLUDE_DROPZONE=1
-  -DMESHTASTIC_EXCLUDE_REMOTEHARDWARE=1
-  -DBUILD_EPOCH=$UNIX_TIME
   ;-D OLED_PL
 
 monitor_speed = 115200
 monitor_filters = direct
 
 lib_deps =
-  ;jgromes/RadioLib@~7.0.0
-  ;7.0.1pre needed for LR1121 support and SX127x CRC Bugfix
-  https://github.com/jgromes/RadioLib.git#38fc7a97a4c195b7c10aa94215a1c53ec18a56ef
+;  jgromes/RadioLib@~6.6.0
+  https://github.com/jgromes/RadioLib.git#3115fc2d6700a9aee05888791ac930a910f2628f
   https://github.com/meshtastic/esp8266-oled-ssd1306.git#e16cee124fe26490cb14880c679321ad8ac89c95 ; ESP8266_SSD1306
   https://github.com/mathertel/OneButton@~2.6.1 ; OneButton library for non-blocking button debounce
   https://github.com/meshtastic/arduino-fsm.git#7db3702bf0cfe97b783d6c72595e3f38e0b19159
@@ -139,7 +136,6 @@ lib_deps =
   adafruit/Adafruit MCP9808 Library@^2.0.0
   adafruit/Adafruit INA260 Library@^1.5.0
   adafruit/Adafruit INA219@^1.2.0
-  adafruit/Adafruit MAX1704X@^1.0.3
   adafruit/Adafruit SHTC3 Library@^1.0.0
   adafruit/Adafruit LPS2X@^2.0.4
   adafruit/Adafruit SHT31 Library@^2.2.2
@@ -152,16 +148,13 @@ lib_deps =
   adafruit/Adafruit SHT4x Library@^1.0.4
   adafruit/Adafruit TSL2591 Library@^1.4.5
   sparkfun/SparkFun Qwiic Scale NAU7802 Arduino Library@^1.0.5
-  sparkfun/SparkFun 9DoF IMU Breakout - ICM 20948 - Arduino Library@^1.2.13
   ClosedCube OPT3001@^1.1.2
   emotibit/EmotiBit MLX90632@^1.0.8
   dfrobot/DFRobot_RTU@^1.0.3
-
   https://github.com/boschsensortec/Bosch-BSEC2-Library#v1.7.2502
   boschsensortec/BME68x Sensor Library@^1.1.40407
   https://github.com/KodinLanewave/INA3221@^1.0.0
-  lewisxhe/SensorLib@0.2.0
+  lewisxhe/SensorLib@^0.2.0
   mprograms/QMC5883LCompass@^1.2.0
-  
   https://github.com/meshtastic/DFRobot_LarkWeatherStation#dee914270dc7cb3e43fbf034edd85a63a16a12ee
-  https://github.com/gjelsoe/STK8xxx-Accelerometer.git#v0.1.1
+  https://github.com/meshtastic/i2c-sensor#8e97122268960593c8c279df1a84a29970136a8f

src/AccelerometerThread.h

@@ -0,0 +1,297 @@
+#pragma once
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+
+#include "PowerFSM.h"
+#include "concurrency/OSThread.h"
+#include "main.h"
+#include "power.h"
+
+#include <Adafruit_LIS3DH.h>
+#include <Adafruit_LSM6DS3TRC.h>
+#include <Adafruit_MPU6050.h>
+#include <Arduino.h>
+#include <SensorBMA423.hpp>
+#include <Wire.h>
+#ifdef RAK_4631
+#include "Fusion/Fusion.h"
+#include "graphics/Screen.h"
+#include "graphics/ScreenFonts.h"
+#include <Rak_BMX160.h>
+#endif
+
+#define ACCELEROMETER_CHECK_INTERVAL_MS 100
+#define ACCELEROMETER_CLICK_THRESHOLD 40
+
+static inline int readRegister(uint8_t address, uint8_t reg, uint8_t *data, uint8_t len)
+{
+    Wire.beginTransmission(address);
+    Wire.write(reg);
+    Wire.endTransmission();
+    Wire.requestFrom((uint8_t)address, (uint8_t)len);
+    uint8_t i = 0;
+    while (Wire.available()) {
+        data[i++] = Wire.read();
+    }
+    return 0; // Pass
+}
+
+static inline int writeRegister(uint8_t address, uint8_t reg, uint8_t *data, uint8_t len)
+{
+    Wire.beginTransmission(address);
+    Wire.write(reg);
+    Wire.write(data, len);
+    return (0 != Wire.endTransmission());
+}
+
+class AccelerometerThread : public concurrency::OSThread
+{
+  public:
+    explicit AccelerometerThread(ScanI2C::DeviceType type) : OSThread("AccelerometerThread")
+    {
+        if (accelerometer_found.port == ScanI2C::I2CPort::NO_I2C) {
+            LOG_DEBUG("AccelerometerThread disabling due to no sensors found\n");
+            disable();
+            return;
+        }
+        acceleremoter_type = type;
+#ifndef RAK_4631
+        if (!config.display.wake_on_tap_or_motion && !config.device.double_tap_as_button_press) {
+            LOG_DEBUG("AccelerometerThread disabling due to no interested configurations\n");
+            disable();
+            return;
+        }
+#endif
+        init();
+    }
+
+    void start()
+    {
+        init();
+        setIntervalFromNow(0);
+    };
+
+  protected:
+    int32_t runOnce() override
+    {
+        canSleep = true; // Assume we should not keep the board awake
+
+        if (acceleremoter_type == ScanI2C::DeviceType::MPU6050 && mpu.getMotionInterruptStatus()) {
+            wakeScreen();
+        } else if (acceleremoter_type == ScanI2C::DeviceType::LIS3DH && lis.getClick() > 0) {
+            uint8_t click = lis.getClick();
+            if (!config.device.double_tap_as_button_press) {
+                wakeScreen();
+            }
+
+            if (config.device.double_tap_as_button_press && (click & 0x20)) {
+                buttonPress();
+                return 500;
+            }
+        } else if (acceleremoter_type == ScanI2C::DeviceType::BMA423 && bmaSensor.readIrqStatus() != DEV_WIRE_NONE) {
+            if (bmaSensor.isTilt() || bmaSensor.isDoubleTap()) {
+                wakeScreen();
+                return 500;
+            }
+#ifdef RAK_4631
+        } else if (acceleremoter_type == ScanI2C::DeviceType::BMX160) {
+            sBmx160SensorData_t magAccel;
+            sBmx160SensorData_t gAccel;
+
+            /* Get a new sensor event */
+            bmx160.getAllData(&magAccel, NULL, &gAccel);
+
+            // expirimental calibrate routine. Limited to between 10 and 30 seconds after boot
+            if (millis() > 12 * 1000 && millis() < 30 * 1000) {
+                if (!showingScreen) {
+                    showingScreen = true;
+                    screen->startAlert((FrameCallback)drawFrameCalibration);
+                }
+                if (magAccel.x > highestX)
+                    highestX = magAccel.x;
+                if (magAccel.x < lowestX)
+                    lowestX = magAccel.x;
+                if (magAccel.y > highestY)
+                    highestY = magAccel.y;
+                if (magAccel.y < lowestY)
+                    lowestY = magAccel.y;
+                if (magAccel.z > highestZ)
+                    highestZ = magAccel.z;
+                if (magAccel.z < lowestZ)
+                    lowestZ = magAccel.z;
+            } else if (showingScreen && millis() >= 30 * 1000) {
+                showingScreen = false;
+                screen->endAlert();
+            }
+
+            int highestRealX = highestX - (highestX + lowestX) / 2;
+
+            magAccel.x -= (highestX + lowestX) / 2;
+            magAccel.y -= (highestY + lowestY) / 2;
+            magAccel.z -= (highestZ + lowestZ) / 2;
+            FusionVector ga, ma;
+            ga.axis.x = -gAccel.x; // default location for the BMX160 is on the rear of the board
+            ga.axis.y = -gAccel.y;
+            ga.axis.z = gAccel.z;
+            ma.axis.x = -magAccel.x;
+            ma.axis.y = -magAccel.y;
+            ma.axis.z = magAccel.z * 3;
+
+            // If we're set to one of the inverted positions
+            if (config.display.compass_orientation > meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270) {
+                ma = FusionAxesSwap(ma, FusionAxesAlignmentNXNYPZ);
+                ga = FusionAxesSwap(ga, FusionAxesAlignmentNXNYPZ);
+            }
+
+            float heading = FusionCompassCalculateHeading(FusionConventionNed, ga, ma);
+
+            switch (config.display.compass_orientation) {
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_0_INVERTED:
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_0:
+                break;
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_90:
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_90_INVERTED:
+                heading += 90;
+                break;
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_180:
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_180_INVERTED:
+                heading += 180;
+                break;
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270:
+            case meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270_INVERTED:
+                heading += 270;
+                break;
+            }
+
+            screen->setHeading(heading);
+
+#endif
+        } else if (acceleremoter_type == ScanI2C::DeviceType::LSM6DS3 && lsm.shake()) {
+            wakeScreen();
+            return 500;
+        }
+
+        return ACCELEROMETER_CHECK_INTERVAL_MS;
+    }
+
+  private:
+    void init()
+    {
+        LOG_DEBUG("AccelerometerThread initializing\n");
+
+        if (acceleremoter_type == ScanI2C::DeviceType::MPU6050 && mpu.begin(accelerometer_found.address)) {
+            LOG_DEBUG("MPU6050 initializing\n");
+            // setup motion detection
+            mpu.setHighPassFilter(MPU6050_HIGHPASS_0_63_HZ);
+            mpu.setMotionDetectionThreshold(1);
+            mpu.setMotionDetectionDuration(20);
+            mpu.setInterruptPinLatch(true); // Keep it latched.  Will turn off when reinitialized.
+            mpu.setInterruptPinPolarity(true);
+        } else if (acceleremoter_type == ScanI2C::DeviceType::LIS3DH && lis.begin(accelerometer_found.address)) {
+            LOG_DEBUG("LIS3DH initializing\n");
+            lis.setRange(LIS3DH_RANGE_2_G);
+            // Adjust threshold, higher numbers are less sensitive
+            lis.setClick(config.device.double_tap_as_button_press ? 2 : 1, ACCELEROMETER_CLICK_THRESHOLD);
+        } else if (acceleremoter_type == ScanI2C::DeviceType::BMA423 &&
+                   bmaSensor.begin(accelerometer_found.address, &readRegister, &writeRegister)) {
+            LOG_DEBUG("BMA423 initializing\n");
+            bmaSensor.configAccelerometer(bmaSensor.RANGE_2G, bmaSensor.ODR_100HZ, bmaSensor.BW_NORMAL_AVG4,
+                                          bmaSensor.PERF_CONTINUOUS_MODE);
+            bmaSensor.enableAccelerometer();
+            bmaSensor.configInterrupt(BMA4_LEVEL_TRIGGER, BMA4_ACTIVE_HIGH, BMA4_PUSH_PULL, BMA4_OUTPUT_ENABLE,
+                                      BMA4_INPUT_DISABLE);
+
+#ifdef BMA423_INT
+            pinMode(BMA4XX_INT, INPUT);
+            attachInterrupt(
+                BMA4XX_INT,
+                [] {
+                    // Set interrupt to set irq value to true
+                    BMA_IRQ = true;
+                },
+                RISING); // Select the interrupt mode according to the actual circuit
+#endif
+
+#ifdef T_WATCH_S3
+            // Need to raise the wrist function, need to set the correct axis
+            bmaSensor.setReampAxes(bmaSensor.REMAP_TOP_LAYER_RIGHT_CORNER);
+#else
+            bmaSensor.setReampAxes(bmaSensor.REMAP_BOTTOM_LAYER_BOTTOM_LEFT_CORNER);
+#endif
+            // bmaSensor.enableFeature(bmaSensor.FEATURE_STEP_CNTR, true);
+            bmaSensor.enableFeature(bmaSensor.FEATURE_TILT, true);
+            bmaSensor.enableFeature(bmaSensor.FEATURE_WAKEUP, true);
+            // bmaSensor.resetPedometer();
+
+            // Turn on feature interrupt
+            bmaSensor.enablePedometerIRQ();
+            bmaSensor.enableTiltIRQ();
+            // It corresponds to isDoubleClick interrupt
+            bmaSensor.enableWakeupIRQ();
+#ifdef RAK_4631
+        } else if (acceleremoter_type == ScanI2C::DeviceType::BMX160 && bmx160.begin()) {
+            bmx160.ODR_Config(BMX160_ACCEL_ODR_100HZ, BMX160_GYRO_ODR_100HZ); // set output data rate
+
+#endif
+        } else if (acceleremoter_type == ScanI2C::DeviceType::LSM6DS3 && lsm.begin_I2C(accelerometer_found.address)) {
+            LOG_DEBUG("LSM6DS3 initializing\n");
+            // Default threshold of 2G, less sensitive options are 4, 8 or 16G
+            lsm.setAccelRange(LSM6DS_ACCEL_RANGE_2_G);
+#ifndef LSM6DS3_WAKE_THRESH
+#define LSM6DS3_WAKE_THRESH 20
+#endif
+            lsm.enableWakeup(config.display.wake_on_tap_or_motion, 1, LSM6DS3_WAKE_THRESH);
+            // Duration is number of occurances needed to trigger, higher threshold is less sensitive
+        }
+    }
+    void wakeScreen()
+    {
+        if (powerFSM.getState() == &stateDARK) {
+            LOG_INFO("Tap or motion detected. Turning on screen\n");
+            powerFSM.trigger(EVENT_INPUT);
+        }
+    }
+
+    void buttonPress()
+    {
+        LOG_DEBUG("Double-tap detected. Firing button press\n");
+        powerFSM.trigger(EVENT_PRESS);
+    }
+
+    ScanI2C::DeviceType acceleremoter_type;
+    Adafruit_MPU6050 mpu;
+    Adafruit_LIS3DH lis;
+    Adafruit_LSM6DS3TRC lsm;
+    SensorBMA423 bmaSensor;
+    bool BMA_IRQ = false;
+#ifdef RAK_4631
+    bool showingScreen = false;
+    RAK_BMX160 bmx160;
+    float highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
+
+    static void drawFrameCalibration(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+    {
+        int x_offset = display->width() / 2;
+        int y_offset = display->height() <= 80 ? 0 : 32;
+        display->setTextAlignment(TEXT_ALIGN_LEFT);
+        display->setFont(FONT_MEDIUM);
+        display->drawString(x, y, "Calibrating\nCompass");
+        int16_t compassX = 0, compassY = 0;
+        uint16_t compassDiam = graphics::Screen::getCompassDiam(display->getWidth(), display->getHeight());
+
+        // coordinates for the center of the compass/circle
+        if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
+            compassX = x + display->getWidth() - compassDiam / 2 - 5;
+            compassY = y + display->getHeight() / 2;
+        } else {
+            compassX = x + display->getWidth() - compassDiam / 2 - 5;
+            compassY = y + FONT_HEIGHT_SMALL + (display->getHeight() - FONT_HEIGHT_SMALL) / 2;
+        }
+        display->drawCircle(compassX, compassY, compassDiam / 2);
+        screen->drawCompassNorth(display, compassX, compassY, screen->getHeading() * PI / 180);
+    }
+#endif
+};
+
+#endif

src/FSCommon.cpp

@@ -370,8 +370,8 @@ void setupSDCard()
     }
 
     uint64_t cardSize = SD.cardSize() / (1024 * 1024);
-    LOG_DEBUG("SD Card Size: %lu MB\n", (uint32_t)cardSize);
-    LOG_DEBUG("Total space: %lu MB\n", (uint32_t)(SD.totalBytes() / (1024 * 1024)));
-    LOG_DEBUG("Used space: %lu MB\n", (uint32_t)(SD.usedBytes() / (1024 * 1024)));
+    LOG_DEBUG("SD Card Size: %lluMB\n", cardSize);
+    LOG_DEBUG("Total space: %llu MB\n", SD.totalBytes() / (1024 * 1024));
+    LOG_DEBUG("Used space: %llu MB\n", SD.usedBytes() / (1024 * 1024));
 #endif
 }

src/Power.cpp

@@ -13,7 +13,6 @@
 #include "power.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
-#include "Throttle.h"
 #include "buzz/buzz.h"
 #include "configuration.h"
 #include "main.h"
@@ -31,7 +30,6 @@
 #if HAS_WIFI
 #include <WiFi.h>
 #endif
-
 #endif
 
 #ifndef DELAY_FOREVER
@@ -77,15 +75,6 @@ INA219Sensor ina219Sensor;
 INA3221Sensor ina3221Sensor;
 #endif
 
-#if !MESHTASTIC_EXCLUDE_I2C && !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
-#include "modules/Telemetry/Sensor/MAX17048Sensor.h"
-#include <utility>
-extern std::pair<uint8_t, TwoWire *> nodeTelemetrySensorsMap[_meshtastic_TelemetrySensorType_MAX + 1];
-#if HAS_TELEMETRY && (!MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR || !MESHTASTIC_EXCLUDE_POWER_TELEMETRY)
-MAX17048Sensor max17048Sensor;
-#endif
-#endif
-
 #if HAS_RAKPROT && !defined(ARCH_PORTDUINO)
 RAK9154Sensor rak9154Sensor;
 #endif
@@ -147,8 +136,6 @@ using namespace meshtastic;
  */
 static HasBatteryLevel *batteryLevel; // Default to NULL for no battery level sensor
 
-#ifdef BATTERY_PIN
-
 static void adcEnable()
 {
 #ifdef ADC_CTRL // enable adc voltage divider when we need to read
@@ -173,14 +160,11 @@ static void adcDisable()
 #endif
 }
 
-#endif
-
 /**
  * A simple battery level sensor that assumes the battery voltage is attached via a voltage-divider to an analog input
  */
 class AnalogBatteryLevel : public HasBatteryLevel
 {
-  public:
     /**
      * Battery state of charge, from 0 to 100 or -1 for unknown
      */
@@ -260,7 +244,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
             config.power.adc_multiplier_override > 0 ? config.power.adc_multiplier_override : ADC_MULTIPLIER;
         // Do not call analogRead() often.
         const uint32_t min_read_interval = 5000;
-        if (!Throttle::isWithinTimespanMs(last_read_time_ms, min_read_interval)) {
+        if (millis() - last_read_time_ms > min_read_interval) {
             last_read_time_ms = millis();
 
             uint32_t raw = 0;
@@ -567,12 +551,7 @@ bool Power::analogInit()
  */
 bool Power::setup()
 {
-    // initialise one power sensor (only)
-    bool found = axpChipInit();
-    if (!found)
-        found = lipoInit();
-    if (!found)
-        found = analogInit();
+    bool found = axpChipInit() || analogInit();
 
 #ifdef NRF_APM
     found = true;
@@ -1063,82 +1042,4 @@ bool Power::axpChipInit()
 #else
     return false;
 #endif
-}
-
-#if !MESHTASTIC_EXCLUDE_I2C && !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
-
-/**
- * Wrapper class for an I2C MAX17048 Lipo battery sensor.
- */
-class LipoBatteryLevel : public HasBatteryLevel
-{
-  private:
-    MAX17048Singleton *max17048 = nullptr;
-
-  public:
-    /**
-     * Init the I2C MAX17048 Lipo battery level sensor
-     */
-    bool runOnce()
-    {
-        if (max17048 == nullptr) {
-            max17048 = MAX17048Singleton::GetInstance();
-        }
-
-        // try to start if the sensor has been detected
-        if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MAX17048].first != 0) {
-            return max17048->runOnce(nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MAX17048].second);
-        }
-        return false;
-    }
-
-    /**
-     * Battery state of charge, from 0 to 100 or -1 for unknown
-     */
-    virtual int getBatteryPercent() override { return max17048->getBusBatteryPercent(); }
-
-    /**
-     * The raw voltage of the battery in millivolts, or NAN if unknown
-     */
-    virtual uint16_t getBattVoltage() override { return max17048->getBusVoltageMv(); }
-
-    /**
-     * return true if there is a battery installed in this unit
-     */
-    virtual bool isBatteryConnect() override { return max17048->isBatteryConnected(); }
-
-    /**
-     * return true if there is an external power source detected
-     */
-    virtual bool isVbusIn() override { return max17048->isExternallyPowered(); }
-
-    /**
-     * return true if the battery is currently charging
-     */
-    virtual bool isCharging() override { return max17048->isBatteryCharging(); }
-};
-
-LipoBatteryLevel lipoLevel;
-
-/**
- * Init the Lipo battery level sensor
- */
-bool Power::lipoInit()
-{
-    bool result = lipoLevel.runOnce();
-    LOG_DEBUG("Power::lipoInit lipo sensor is %s\n", result ? "ready" : "not ready yet");
-    if (!result)
-        return false;
-    batteryLevel = &lipoLevel;
-    return true;
-}
-
-#else
-/**
- * The Lipo battery level sensor is unavailable - default to AnalogBatteryLevel
- */
-bool Power::lipoInit()
-{
-    return false;
-}
-#endif
+}

src/SafeFile.h

@@ -24,7 +24,7 @@
 class SafeFile : public Print
 {
   public:
-    explicit SafeFile(char const *filepath, bool fullAtomic = false);
+    SafeFile(char const *filepath, bool fullAtomic = false);
 
     virtual size_t write(uint8_t);
     virtual size_t write(const uint8_t *buffer, size_t size);

src/SerialConsole.cpp

@@ -1,8 +1,6 @@
 #include "SerialConsole.h"
-#include "Default.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
-#include "Throttle.h"
 #include "configuration.h"
 #include "time.h"
 
@@ -46,11 +44,10 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), con
     Port.setRX(SERIAL2_RX);
 #endif
     Port.begin(SERIAL_BAUD);
-#if defined(ARCH_NRF52) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3) || defined(ARCH_RP2040) ||   \
-    defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C6)
+#if defined(ARCH_NRF52) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3) || defined(ARCH_RP2040)
     time_t timeout = millis();
     while (!Port) {
-        if (Throttle::isWithinTimespanMs(timeout, FIVE_SECONDS_MS)) {
+        if ((millis() - timeout) < 5000) {
             delay(100);
         } else {
             break;
@@ -75,7 +72,8 @@ void SerialConsole::flush()
 // 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()
 {
-    return Throttle::isWithinTimespanMs(lastContactMsec, SERIAL_CONNECTION_TIMEOUT);
+    uint32_t now = millis();
+    return (now - lastContactMsec) < SERIAL_CONNECTION_TIMEOUT;
 }
 
 /**
@@ -122,4 +120,4 @@ void SerialConsole::log_to_serial(const char *logLevel, const char *format, va_l
         emitLogRecord(ll, thread ? thread->ThreadName.c_str() : "", format, arg);
     } else
         RedirectablePrint::log_to_serial(logLevel, format, arg);
-}
+}

src/configuration.h

@@ -69,9 +69,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef RTC_DATA_ATTR
 #define RTC_DATA_ATTR
 #endif
-#ifndef EXT_RAM_BSS_ATTR
-#define EXT_RAM_BSS_ATTR EXT_RAM_ATTR
-#endif
 
 // -----------------------------------------------------------------------------
 // Regulatory overrides
@@ -125,11 +122,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define INA_ADDR_ALTERNATE 0x41
 #define INA_ADDR_WAVESHARE_UPS 0x43
 #define INA3221_ADDR 0x42
-#define MAX1704X_ADDR 0x36
 #define QMC6310_ADDR 0x1C
 #define QMI8658_ADDR 0x6B
-#define QMC5883L_ADDR 0x0D
-#define HMC5883L_ADDR 0x1E
+#define QMC5883L_ADDR 0x1E
 #define SHTC3_ADDR 0x70
 #define LPS22HB_ADDR 0x5C
 #define LPS22HB_ADDR_ALT 0x5D
@@ -149,13 +144,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // ACCELEROMETER
 // -----------------------------------------------------------------------------
 #define MPU6050_ADDR 0x68
-#define STK8BXX_ADR 0x18
 #define LIS3DH_ADR 0x18
 #define BMA423_ADDR 0x19
 #define LSM6DS3_ADDR 0x6A
 #define BMX160_ADDR 0x69
-#define ICM20948_ADDR 0x69
-#define ICM20948_ADDR_ALT 0x68
 
 // -----------------------------------------------------------------------------
 // LED
@@ -170,7 +162,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // -----------------------------------------------------------------------------
 // IO Expander
 // -----------------------------------------------------------------------------
-#define TCA9535_ADDR 0x20
 #define TCA9555_ADDR 0x26
 
 // -----------------------------------------------------------------------------
@@ -180,11 +171,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define GPS_THREAD_INTERVAL 200
 #endif
 
-// -----------------------------------------------------------------------------
-// Touchscreen
-// -----------------------------------------------------------------------------
-#define FT6336U_ADDR 0x48
-
 // convert 24-bit color to 16-bit (56K)
 #define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))
 
@@ -216,16 +202,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MINIMUM_SAFE_FREE_HEAP 1500
 #endif
 
-#ifndef WIRE_INTERFACES_COUNT
-// Officially an NRF52 macro
-// Repurposed cross-platform to identify devices using Wire1
-#if defined(I2C_SDA1) || defined(PIN_WIRE1_SDA)
-#define WIRE_INTERFACES_COUNT 2
-#elif HAS_WIRE
-#define WIRE_INTERFACES_COUNT 1
-#endif
-#endif
-
 /* Step #3: mop up with disabled values for HAS_ options not handled by the above two */
 
 #ifndef HAS_WIFI
@@ -348,4 +324,4 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 
 #include "DebugConfiguration.h"
-#include "RF95Configuration.h"
+#include "RF95Configuration.h"

src/detect/LoRaRadioType.h

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

src/detect/ScanI2C.cpp

@@ -37,8 +37,8 @@ ScanI2C::FoundDevice ScanI2C::firstKeyboard() const
 
 ScanI2C::FoundDevice ScanI2C::firstAccelerometer() const
 {
-    ScanI2C::DeviceType types[] = {MPU6050, LIS3DH, BMA423, LSM6DS3, BMX160, STK8BAXX, ICM20948};
-    return firstOfOrNONE(7, types);
+    ScanI2C::DeviceType types[] = {MPU6050, LIS3DH, BMA423, LSM6DS3, BMX160};
+    return firstOfOrNONE(5, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::find(ScanI2C::DeviceType) const

src/detect/ScanI2C.h

@@ -28,7 +28,6 @@ class ScanI2C
         INA260,
         INA219,
         INA3221,
-        MAX17048,
         MCP9808,
         SHT31,
         SHT4X,
@@ -37,14 +36,12 @@ class ScanI2C
         QMC6310,
         QMI8658,
         QMC5883L,
-        HMC5883L,
         PMSA0031,
         MPU6050,
         LIS3DH,
         BMA423,
         BQ24295,
         LSM6DS3,
-        TCA9535,
         TCA9555,
         VEML7700,
         RCWL9620,
@@ -56,9 +53,7 @@ class ScanI2C
         BMX160,
         DFROBOT_LARK,
         NAU7802,
-        FT6336U,
-        STK8BAXX,
-        ICM20948
+        CUSTOM_SENSOR,
     } DeviceType;
 
     // typedef uint8_t DeviceAddress;
@@ -69,9 +64,8 @@ class ScanI2C
     } I2CPort;
 
     typedef struct DeviceAddress {
-        // set default values for ADDRESS_NONE
-        I2CPort port = I2CPort::NO_I2C;
-        uint8_t address = 0;
+        I2CPort port;
+        uint8_t address;
 
         explicit DeviceAddress(I2CPort port, uint8_t address);
         DeviceAddress();

src/detect/ScanI2CTwoWire.cpp

@@ -7,6 +7,7 @@
 #include "linux/LinuxHardwareI2C.h"
 #endif
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
+#include "I2CDefinitions.h"
 #include "main.h" // atecc
 #endif
 
@@ -162,13 +163,13 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
     Melopero_RV3028 rtc;
 #endif
 
-#if WIRE_INTERFACES_COUNT == 2
+#ifdef I2C_SDA1
     if (port == I2CPort::WIRE1) {
         i2cBus = &Wire1;
     } else {
 #endif
         i2cBus = &Wire;
-#if WIRE_INTERFACES_COUNT == 2
+#ifdef I2C_SDA1
     }
 #endif
 
@@ -313,33 +314,17 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 }
                 break;
             case MCP9808_ADDR:
-                // We need to check for STK8BAXX first, since register 0x07 is new data flag for the z-axis and can produce some
-                // weird result. and register 0x00 doesn't seems to be colliding with MCP9808 and LIS3DH chips.
-                {
-                    // Check register 0x00 for 0x8700 response to ID STK8BA53 chip.
-                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 2);
-                    if (registerValue == 0x8700) {
-                        type = STK8BAXX;
-                        LOG_INFO("STK8BAXX accelerometer found\n");
-                        break;
-                    }
-
-                    // Check register 0x07 for 0x0400 response to ID MCP9808 chip.
-                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x07), 2);
-                    if (registerValue == 0x0400) {
-                        type = MCP9808;
-                        LOG_INFO("MCP9808 sensor found\n");
-                        break;
-                    }
-
-                    // Check register 0x0F for 0x3300 response to ID LIS3DH chip.
-                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0F), 2);
-                    if (registerValue == 0x3300 || registerValue == 0x3333) { // RAK4631 WisBlock has LIS3DH register at 0x3333
-                        type = LIS3DH;
-                        LOG_INFO("LIS3DH accelerometer found\n");
-                    }
-                    break;
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x07), 2);
+                if (registerValue == 0x0400) {
+                    type = MCP9808;
+                    LOG_INFO("MCP9808 sensor found\n");
+                } else {
+                    type = LIS3DH;
+                    LOG_INFO("LIS3DH accelerometer found\n");
                 }
+
+                break;
+
             case SHT31_4x_ADDR:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2);
                 if (registerValue == 0x11a2 || registerValue == 0x11da || registerValue == 0xe9c) {
@@ -381,37 +366,19 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 break;
 
                 SCAN_SIMPLE_CASE(QMC5883L_ADDR, QMC5883L, "QMC5883L Highrate 3-Axis magnetic sensor found\n")
-                SCAN_SIMPLE_CASE(HMC5883L_ADDR, HMC5883L, "HMC5883L 3-Axis digital compass found\n")
+
                 SCAN_SIMPLE_CASE(PMSA0031_ADDR, PMSA0031, "PMSA0031 air quality sensor found\n")
+                SCAN_SIMPLE_CASE(MPU6050_ADDR, MPU6050, "MPU6050 accelerometer found\n");
+                SCAN_SIMPLE_CASE(BMX160_ADDR, BMX160, "BMX160 accelerometer found\n");
                 SCAN_SIMPLE_CASE(BMA423_ADDR, BMA423, "BMA423 accelerometer found\n");
                 SCAN_SIMPLE_CASE(LSM6DS3_ADDR, LSM6DS3, "LSM6DS3 accelerometer found at address 0x%x\n", (uint8_t)addr.address);
-                SCAN_SIMPLE_CASE(TCA9535_ADDR, TCA9535, "TCA9535 I2C expander found\n");
                 SCAN_SIMPLE_CASE(TCA9555_ADDR, TCA9555, "TCA9555 I2C expander found\n");
                 SCAN_SIMPLE_CASE(VEML7700_ADDR, VEML7700, "VEML7700 light sensor found\n");
                 SCAN_SIMPLE_CASE(TSL25911_ADDR, TSL2591, "TSL2591 light sensor found\n");
                 SCAN_SIMPLE_CASE(OPT3001_ADDR, OPT3001, "OPT3001 light sensor found\n");
                 SCAN_SIMPLE_CASE(MLX90632_ADDR, MLX90632, "MLX90632 IR temp sensor found\n");
                 SCAN_SIMPLE_CASE(NAU7802_ADDR, NAU7802, "NAU7802 based scale found\n");
-                SCAN_SIMPLE_CASE(FT6336U_ADDR, FT6336U, "FT6336U touchscreen found\n");
-                SCAN_SIMPLE_CASE(MAX1704X_ADDR, MAX17048, "MAX17048 lipo fuel gauge found\n");
-
-            case ICM20948_ADDR:     // same as BMX160_ADDR
-            case ICM20948_ADDR_ALT: // same as MPU6050_ADDR
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1);
-                if (registerValue == 0xEA) {
-                    type = ICM20948;
-                    LOG_INFO("ICM20948 9-dof motion processor found\n");
-                    break;
-                } else if (addr.address == BMX160_ADDR) {
-                    type = BMX160;
-                    LOG_INFO("BMX160 accelerometer found\n");
-                    break;
-                } else {
-                    type = MPU6050;
-                    LOG_INFO("MPU6050 accelerometer found\n");
-                    break;
-                }
-                break;
+                SCAN_SIMPLE_CASE(MT_I2C_ADDRESS, CUSTOM_SENSOR, "Meshtastic custom I2C sensor found\n");
 
             default:
                 LOG_INFO("Device found at address 0x%x was not able to be enumerated\n", addr.address);
@@ -438,7 +405,7 @@ TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address) const
     if (address.port == ScanI2C::I2CPort::WIRE) {
         return &Wire;
     } else {
-#if WIRE_INTERFACES_COUNT == 2
+#ifdef I2C_SDA1
         return &Wire1;
 #else
         return &Wire;
@@ -450,4 +417,4 @@ size_t ScanI2CTwoWire::countDevices() const
 {
     return foundDevices.size();
 }
-#endif
+#endif

src/gps/GPS.cpp

@@ -6,8 +6,6 @@
 #include "NodeDB.h"
 #include "PowerMon.h"
 #include "RTC.h"
-#include "Throttle.h"
-#include "meshUtils.h"
 
 #include "main.h" // pmu_found
 #include "sleep.h"
@@ -28,8 +26,6 @@
 
 #if defined(NRF52840_XXAA) || defined(NRF52833_XXAA) || defined(ARCH_ESP32) || defined(ARCH_PORTDUINO)
 HardwareSerial *GPS::_serial_gps = &Serial1;
-#elif defined(ARCH_RP2040)
-SerialUART *GPS::_serial_gps = &Serial1;
 #else
 HardwareSerial *GPS::_serial_gps = NULL;
 #endif
@@ -62,8 +58,7 @@ const char *getGPSPowerStateString(GPSPowerState state)
     case GPS_OFF:
         return "OFF";
     default:
-        assert(false);  // Unhandled enum value..
-        return "FALSE"; // to make new ESP-IDF happy
+        assert(false); // Unhandled enum value..
     }
 }
 
@@ -171,21 +166,18 @@ GPS_RESPONSE GPS::getACK(const char *message, uint32_t waitMillis)
             b = _serial_gps->read();
 
 #ifdef GPS_DEBUG
-            LOG_DEBUG("%c", (b >= 32 && b <= 126) ? b : '.');
+            LOG_DEBUG("%02X", (char *)buffer);
 #endif
             buffer[bytesRead] = b;
             bytesRead++;
             if ((bytesRead == 767) || (b == '\r')) {
                 if (strnstr((char *)buffer, message, bytesRead) != nullptr) {
 #ifdef GPS_DEBUG
-                    LOG_DEBUG("\r\nFound: %s\r\n", message); // Log the found message
+                    LOG_DEBUG("\r");
 #endif
                     return GNSS_RESPONSE_OK;
                 } else {
                     bytesRead = 0;
-#ifdef GPS_DEBUG
-                    LOG_DEBUG("\r\n");
-#endif
                 }
             }
         }
@@ -209,7 +201,7 @@ GPS_RESPONSE GPS::getACKCas(uint8_t class_id, uint8_t msg_id, uint32_t waitMilli
     // ACK-NACK| 0xBA | 0xCE | 0x04 | 0x00 | 0x05 | 0x00 | 0xXX | 0xXX | 0x00 | 0x00 | 0xXX | 0xXX | 0xXX | 0xXX |
     // ACK-ACK | 0xBA | 0xCE | 0x04 | 0x00 | 0x05 | 0x01 | 0xXX | 0xXX | 0x00 | 0x00 | 0xXX | 0xXX | 0xXX | 0xXX |
 
-    while (Throttle::isWithinTimespanMs(startTime, waitMillis)) {
+    while (millis() - startTime < waitMillis) {
         if (_serial_gps->available()) {
             buffer[bufferPos++] = _serial_gps->read();
 
@@ -278,7 +270,7 @@ GPS_RESPONSE GPS::getACK(uint8_t class_id, uint8_t msg_id, uint32_t waitMillis)
         buf[9] += buf[8];
     }
 
-    while (Throttle::isWithinTimespanMs(startTime, waitMillis)) {
+    while (millis() - startTime < waitMillis) {
         if (ack > 9) {
 #ifdef GPS_DEBUG
             LOG_DEBUG("\n");
@@ -333,9 +325,9 @@ int GPS::getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t
 {
     uint16_t ubxFrameCounter = 0;
     uint32_t startTime = millis();
-    uint16_t needRead = 0;
+    uint16_t needRead;
 
-    while (Throttle::isWithinTimespanMs(startTime, waitMillis)) {
+    while (millis() - startTime < waitMillis) {
         if (_serial_gps->available()) {
             int c = _serial_gps->read();
             switch (ubxFrameCounter) {
@@ -406,9 +398,9 @@ int GPS::getACK(uint8_t *buffer, uint16_t size, uint8_t requestedClass, uint8_t
 
 bool GPS::setup()
 {
+    int msglen = 0;
 
     if (!didSerialInit) {
-        int msglen = 0;
         if (tx_gpio && gnssModel == GNSS_MODEL_UNKNOWN) {
 
             // if GPS_BAUDRATE is specified in variant (i.e. not 9600), skip to the specified rate.
@@ -513,110 +505,283 @@ bool GPS::setup()
             delay(250);
             _serial_gps->write("$CFGMSG,6,1,0\r\n");
             delay(250);
-        } else if (IS_ONE_OF(gnssModel, GNSS_MODEL_AG3335, GNSS_MODEL_AG3352)) {
+        } else if (gnssModel == GNSS_MODEL_AG3335) {
 
             _serial_gps->write("$PAIR066,1,0,1,0,0,1*3B\r\n"); // Enable GPS+GALILEO+NAVIC
 
             // Configure NMEA (sentences will output once per fix)
-            _serial_gps->write("$PAIR062,0,1*3F\r\n"); // GGA ON
+            _serial_gps->write("$PAIR062,0,0*3F\r\n"); // GGA ON
             _serial_gps->write("$PAIR062,1,0*3F\r\n"); // GLL OFF
-            _serial_gps->write("$PAIR062,2,0*3C\r\n"); // GSA OFF
+            _serial_gps->write("$PAIR062,2,1*3D\r\n"); // GSA ON
             _serial_gps->write("$PAIR062,3,0*3D\r\n"); // GSV OFF
-            _serial_gps->write("$PAIR062,4,1*3B\r\n"); // RMC ON
+            _serial_gps->write("$PAIR062,4,0*3B\r\n"); // RMC ON
             _serial_gps->write("$PAIR062,5,0*3B\r\n"); // VTG OFF
-            _serial_gps->write("$PAIR062,6,0*38\r\n"); // ZDA ON
+            _serial_gps->write("$PAIR062,6,1*39\r\n"); // ZDA ON
 
             delay(250);
             _serial_gps->write("$PAIR513*3D\r\n"); // save configuration
-        } else if (gnssModel == GNSS_MODEL_UBLOX6) {
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x02, _message_DISABLE_TXT_INFO, "Unable to disable text info messages.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x39, _message_JAM_6_7, "Unable to enable interference resistance.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5, "Unable to configure NAVX5 settings.\n", 500);
 
-            // Turn off unwanted NMEA messages, set update rate
-            SEND_UBX_PACKET(0x06, 0x08, _message_1HZ, "Unable to set GPS update rate.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GLL, "Unable to disable NMEA GLL.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GSA, "Unable to Enable NMEA GSA.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GSV, "Unable to disable NMEA GSV.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_VTG, "Unable to disable NMEA VTG.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_RMC, "Unable to enable NMEA RMC.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GGA, "Unable to enable NMEA GGA.\n", 500);
+        } else if (gnssModel == GNSS_MODEL_UBLOX) {
+            // Configure GNSS system to GPS+SBAS+GLONASS (Module may restart after this command)
+            // We need set it because by default it is GPS only, and we want to use GLONASS too
+            // Also we need SBAS for better accuracy and extra features
+            // ToDo: Dynamic configure GNSS systems depending of LoRa region
 
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x11, _message_CFG_RXM_ECO, "Unable to enable powersaving ECO mode for Neo-6.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x3B, _message_CFG_PM2, "Unable to enable powersaving details for GPS.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_AID, "Unable to disable UBX-AID.\n", 500);
+            if (strncmp(info.hwVersion, "000A0000", 8) != 0) {
+                if (strncmp(info.hwVersion, "00040007", 8) != 0) {
+                    // The original ublox Neo-6 is GPS only and doesn't support the UBX-CFG-GNSS message
+                    // Max7 seems to only support GPS *or* GLONASS
+                    // Neo-7 is supposed to support GPS *and* GLONASS but NAKs the CFG-GNSS command to do it
+                    // So treat all the u-blox 7 series as GPS only
+                    // M8 can support 3 constallations at once so turn on GPS, GLONASS and Galileo (or BeiDou)
 
-            msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE);
-            _serial_gps->write(UBXscratch, msglen);
-            if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
-                LOG_WARN("Unable to save GNSS module configuration.\n");
-            } else {
-                LOG_INFO("GNSS module configuration saved!\n");
-            }
-        } else if (IS_ONE_OF(gnssModel, GNSS_MODEL_UBLOX7, GNSS_MODEL_UBLOX8, GNSS_MODEL_UBLOX9)) {
-            if (gnssModel == GNSS_MODEL_UBLOX7) {
-                LOG_DEBUG("Setting GPS+SBAS\n");
-                msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_7), _message_GNSS_7);
-                _serial_gps->write(UBXscratch, msglen);
-            } else { // 8,9
-                msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_8), _message_GNSS_8);
-                _serial_gps->write(UBXscratch, msglen);
-            }
+                    if (strncmp(info.hwVersion, "00070000", 8) == 0) {
+                        LOG_DEBUG("Setting GPS+SBAS\n");
+                        msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_7), _message_GNSS_7);
+                        _serial_gps->write(UBXscratch, msglen);
+                    } else {
+                        msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_8), _message_GNSS_8);
+                        _serial_gps->write(UBXscratch, msglen);
+                    }
 
-            if (getACK(0x06, 0x3e, 800) == GNSS_RESPONSE_NAK) {
-                // It's not critical if the module doesn't acknowledge this configuration.
-                LOG_INFO("Unable to reconfigure GNSS - defaults maintained. Is this module GPS-only?\n");
-            } else {
-                if (gnssModel == GNSS_MODEL_UBLOX7) {
-                    LOG_INFO("GNSS configured for GPS+SBAS.\n");
-                } else { // 8,9
-                    LOG_INFO("GNSS configured for GPS+SBAS+GLONASS+Galileo.\n");
+                    if (getACK(0x06, 0x3e, 800) == GNSS_RESPONSE_NAK) {
+                        // It's not critical if the module doesn't acknowledge this configuration.
+                        LOG_INFO("Unable to reconfigure GNSS - defaults maintained. Is this module GPS-only?\n");
+                    } else {
+                        if (strncmp(info.hwVersion, "00070000", 8) == 0) {
+                            LOG_INFO("GNSS configured for GPS+SBAS. Pause for 0.75s before sending next command.\n");
+                        } else {
+                            LOG_INFO(
+                                "GNSS configured for GPS+SBAS+GLONASS+Galileo. Pause for 0.75s before sending next command.\n");
+                        }
+                        // Documentation say, we need wait atleast 0.5s after reconfiguration of GNSS module, before sending next
+                        // commands for the M8 it tends to be more... 1 sec should be enough ;>)
+                        delay(1000);
+                    }
                 }
-                // Documentation say, we need wait atleast 0.5s after reconfiguration of GNSS module, before sending next
-                // commands for the M8 it tends to be more... 1 sec should be enough ;>)
-                delay(1000);
-            }
-
-            // Disable Text Info messages //6,7,8,9
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x02, _message_DISABLE_TXT_INFO, "Unable to disable text info messages.\n", 500);
-
-            if (gnssModel == GNSS_MODEL_UBLOX8) { // 8
+                // Disable Text Info messages
+                msglen = makeUBXPacket(0x06, 0x02, sizeof(_message_DISABLE_TXT_INFO), _message_DISABLE_TXT_INFO);
                 clearBuffer();
-                SEND_UBX_PACKET(0x06, 0x39, _message_JAM_8, "Unable to enable interference resistance.\n", 500);
-
-                clearBuffer();
-                SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5_8, "Unable to configure NAVX5_8 settings.\n", 500);
-            } else { // 6,7,9
-                SEND_UBX_PACKET(0x06, 0x39, _message_JAM_6_7, "Unable to enable interference resistance.\n", 500);
-                SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5, "Unable to configure NAVX5 settings.\n", 500);
-            }
-            // Turn off unwanted NMEA messages, set update rate
-            SEND_UBX_PACKET(0x06, 0x08, _message_1HZ, "Unable to set GPS update rate.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GLL, "Unable to disable NMEA GLL.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GSA, "Unable to Enable NMEA GSA.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GSV, "Unable to disable NMEA GSV.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_VTG, "Unable to disable NMEA VTG.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_RMC, "Unable to enable NMEA RMC.\n", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GGA, "Unable to enable NMEA GGA.\n", 500);
-
-            if (uBloxProtocolVersion >= 18) {
-                clearBuffer();
-                SEND_UBX_PACKET(0x06, 0x86, _message_PMS, "Unable to enable powersaving for GPS.\n", 500);
-                SEND_UBX_PACKET(0x06, 0x3B, _message_CFG_PM2, "Unable to enable powersaving details for GPS.\n", 500);
-
-                // For M8 we want to enable NMEA vserion 4.10 so we can see the additional sats.
-                if (gnssModel == GNSS_MODEL_UBLOX8) {
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x02, 500) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable text info messages.\n");
+                }
+                // ToDo add M10 tests for below
+                if (strncmp(info.hwVersion, "00080000", 8) == 0) {
+                    msglen = makeUBXPacket(0x06, 0x39, sizeof(_message_JAM_8), _message_JAM_8);
                     clearBuffer();
-                    SEND_UBX_PACKET(0x06, 0x17, _message_NMEA, "Unable to enable NMEA 4.10.\n", 500);
+                    _serial_gps->write(UBXscratch, msglen);
+                    if (getACK(0x06, 0x39, 500) != GNSS_RESPONSE_OK) {
+                        LOG_WARN("Unable to enable interference resistance.\n");
+                    }
+
+                    msglen = makeUBXPacket(0x06, 0x23, sizeof(_message_NAVX5_8), _message_NAVX5_8);
+                    clearBuffer();
+                    _serial_gps->write(UBXscratch, msglen);
+                    if (getACK(0x06, 0x23, 500) != GNSS_RESPONSE_OK) {
+                        LOG_WARN("Unable to configure NAVX5_8 settings.\n");
+                    }
+                } else {
+                    msglen = makeUBXPacket(0x06, 0x39, sizeof(_message_JAM_6_7), _message_JAM_6_7);
+                    _serial_gps->write(UBXscratch, msglen);
+                    if (getACK(0x06, 0x39, 500) != GNSS_RESPONSE_OK) {
+                        LOG_WARN("Unable to enable interference resistance.\n");
+                    }
+
+                    msglen = makeUBXPacket(0x06, 0x23, sizeof(_message_NAVX5), _message_NAVX5);
+                    _serial_gps->write(UBXscratch, msglen);
+                    if (getACK(0x06, 0x23, 500) != GNSS_RESPONSE_OK) {
+                        LOG_WARN("Unable to configure NAVX5 settings.\n");
+                    }
+                }
+                // Turn off unwanted NMEA messages, set update rate
+
+                msglen = makeUBXPacket(0x06, 0x08, sizeof(_message_1HZ), _message_1HZ);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x08, 500) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to set GPS update rate.\n");
+                }
+
+                msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_GLL), _message_GLL);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x01, 500) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable NMEA GLL.\n");
+                }
+
+                msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_GSA), _message_GSA);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x01, 500) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to Enable NMEA GSA.\n");
+                }
+
+                msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_GSV), _message_GSV);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x01, 500) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable NMEA GSV.\n");
+                }
+
+                msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_VTG), _message_VTG);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x01, 500) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable NMEA VTG.\n");
+                }
+
+                msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_RMC), _message_RMC);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x01, 500) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to enable NMEA RMC.\n");
+                }
+
+                msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_GGA), _message_GGA);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x01, 500) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to enable NMEA GGA.\n");
+                }
+
+                if (uBloxProtocolVersion >= 18) {
+                    msglen = makeUBXPacket(0x06, 0x86, sizeof(_message_PMS), _message_PMS);
+                    clearBuffer();
+                    _serial_gps->write(UBXscratch, msglen);
+                    if (getACK(0x06, 0x86, 500) != GNSS_RESPONSE_OK) {
+                        LOG_WARN("Unable to enable powersaving for GPS.\n");
+                    }
+                    msglen = makeUBXPacket(0x06, 0x3B, sizeof(_message_CFG_PM2), _message_CFG_PM2);
+                    _serial_gps->write(UBXscratch, msglen);
+                    if (getACK(0x06, 0x3B, 500) != GNSS_RESPONSE_OK) {
+                        LOG_WARN("Unable to enable powersaving details for GPS.\n");
+                    }
+                    // For M8 we want to enable NMEA vserion 4.10 so we can see the additional sats.
+                    if (strncmp(info.hwVersion, "00080000", 8) == 0) {
+                        msglen = makeUBXPacket(0x06, 0x17, sizeof(_message_NMEA), _message_NMEA);
+                        clearBuffer();
+                        _serial_gps->write(UBXscratch, msglen);
+                        if (getACK(0x06, 0x17, 500) != GNSS_RESPONSE_OK) {
+                            LOG_WARN("Unable to enable NMEA 4.10.\n");
+                        }
+                    }
+                } else {
+                    if (strncmp(info.hwVersion, "00040007", 8) == 0) { // This PSM mode is only for Neo-6
+                        msglen = makeUBXPacket(0x06, 0x11, 0x2, _message_CFG_RXM_ECO);
+                        _serial_gps->write(UBXscratch, msglen);
+                        if (getACK(0x06, 0x11, 500) != GNSS_RESPONSE_OK) {
+                            LOG_WARN("Unable to enable powersaving ECO mode for Neo-6.\n");
+                        }
+                        msglen = makeUBXPacket(0x06, 0x3B, sizeof(_message_CFG_PM2), _message_CFG_PM2);
+                        _serial_gps->write(UBXscratch, msglen);
+                        if (getACK(0x06, 0x3B, 500) != GNSS_RESPONSE_OK) {
+                            LOG_WARN("Unable to enable powersaving details for GPS.\n");
+                        }
+                        msglen = makeUBXPacket(0x06, 0x01, sizeof(_message_AID), _message_AID);
+                        _serial_gps->write(UBXscratch, msglen);
+                        if (getACK(0x06, 0x01, 500) != GNSS_RESPONSE_OK) {
+                            LOG_WARN("Unable to disable UBX-AID.\n");
+                        }
+                    } else {
+                        msglen = makeUBXPacket(0x06, 0x11, 0x2, _message_CFG_RXM_PSM);
+                        _serial_gps->write(UBXscratch, msglen);
+                        if (getACK(0x06, 0x11, 500) != GNSS_RESPONSE_OK) {
+                            LOG_WARN("Unable to enable powersaving mode for GPS.\n");
+                        }
+
+                        msglen = makeUBXPacket(0x06, 0x3B, sizeof(_message_CFG_PM2), _message_CFG_PM2);
+                        _serial_gps->write(UBXscratch, msglen);
+                        if (getACK(0x06, 0x3B, 500) != GNSS_RESPONSE_OK) {
+                            LOG_WARN("Unable to enable powersaving details for GPS.\n");
+                        }
+                    }
                 }
             } else {
-                SEND_UBX_PACKET(0x06, 0x11, _message_CFG_RXM_PSM, "Unable to enable powersaving mode for GPS.\n", 500);
-                SEND_UBX_PACKET(0x06, 0x3B, _message_CFG_PM2, "Unable to enable powersaving details for GPS.\n", 500);
-            }
+                // LOG_INFO("u-blox M10 hardware found.\n");
+                delay(1000);
+                // First disable all NMEA messages in RAM layer
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_DISABLE_NMEA_RAM), _message_VALSET_DISABLE_NMEA_RAM);
+                clearBuffer();
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable NMEA messages for M10 GPS RAM.\n");
+                }
+                delay(250);
+                // Next disable unwanted NMEA messages in BBR layer
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_DISABLE_NMEA_BBR), _message_VALSET_DISABLE_NMEA_BBR);
+                clearBuffer();
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable NMEA messages for M10 GPS BBR.\n");
+                }
+                delay(250);
+                // Disable Info txt messages in RAM layer
+                msglen =
+                    makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_DISABLE_TXT_INFO_RAM), _message_VALSET_DISABLE_TXT_INFO_RAM);
+                clearBuffer();
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable Info messages for M10 GPS RAM.\n");
+                }
+                delay(250);
+                // Next disable Info txt messages in BBR layer
+                msglen =
+                    makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_DISABLE_TXT_INFO_BBR), _message_VALSET_DISABLE_TXT_INFO_BBR);
+                clearBuffer();
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable Info messages for M10 GPS BBR.\n");
+                }
+                // Do M10 configuration for Power Management.
 
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_PM_RAM), _message_VALSET_PM_RAM);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to enable powersaving for M10 GPS RAM.\n");
+                }
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_PM_BBR), _message_VALSET_PM_BBR);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to enable powersaving for M10 GPS BBR.\n");
+                }
+
+                delay(250);
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_ITFM_RAM), _message_VALSET_ITFM_RAM);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to enable Jamming detection M10 GPS RAM.\n");
+                }
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_ITFM_BBR), _message_VALSET_ITFM_BBR);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to enable Jamming detection M10 GPS BBR.\n");
+                }
+
+                // Here is where the init commands should go to do further M10 initialization.
+                delay(250);
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_DISABLE_SBAS_RAM), _message_VALSET_DISABLE_SBAS_RAM);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable SBAS M10 GPS RAM.\n");
+                }
+                delay(750); // will cause a receiver restart so wait a bit
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_DISABLE_SBAS_BBR), _message_VALSET_DISABLE_SBAS_BBR);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to disable SBAS M10 GPS BBR.\n");
+                }
+                delay(750); // will cause a receiver restart so wait a bit
+                // Done with initialization, Now enable wanted NMEA messages in BBR layer so they will survive a periodic sleep.
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_ENABLE_NMEA_BBR), _message_VALSET_ENABLE_NMEA_BBR);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to enable messages for M10 GPS BBR.\n");
+                }
+                delay(250);
+                // Next enable wanted NMEA messages in RAM layer
+                msglen = makeUBXPacket(0x06, 0x8A, sizeof(_message_VALSET_ENABLE_NMEA_RAM), _message_VALSET_ENABLE_NMEA_RAM);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x8A, 300) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to enable messages for M10 GPS RAM.\n");
+                }
+                // As the M10 has no flash, the best we can do to preserve the config is to set it in RAM and BBR.
+                // BBR will survive a restart, and power off for a while, but modules with small backup
+                // batteries or super caps will not retain the config for a long power off time.
+            }
             msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE);
             _serial_gps->write(UBXscratch, msglen);
             if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
@@ -624,55 +789,6 @@ bool GPS::setup()
             } else {
                 LOG_INFO("GNSS module configuration saved!\n");
             }
-        } else if (gnssModel == GNSS_MODEL_UBLOX10) {
-            delay(1000);
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_NMEA_RAM, "Unable to disable NMEA messages in M10 RAM.\n", 300);
-            delay(750);
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_NMEA_BBR, "Unable to disable NMEA messages in M10 BBR.\n", 300);
-            delay(750);
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_TXT_INFO_RAM,
-                            "Unable to disable Info messages for M10 GPS RAM.\n", 300);
-            delay(750);
-            // Next disable Info txt messages in BBR layer
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_TXT_INFO_BBR,
-                            "Unable to disable Info messages for M10 GPS BBR.\n", 300);
-            delay(750);
-            // Do M10 configuration for Power Management.
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_PM_RAM, "Unable to enable powersaving for M10 GPS RAM.\n", 300);
-            delay(750);
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_PM_BBR, "Unable to enable powersaving for M10 GPS BBR.\n", 300);
-            delay(750);
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ITFM_RAM, "Unable to enable Jamming detection M10 GPS RAM.\n", 300);
-            delay(750);
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ITFM_BBR, "Unable to enable Jamming detection M10 GPS BBR.\n", 300);
-            delay(750);
-            // Here is where the init commands should go to do further M10 initialization.
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_SBAS_RAM, "Unable to disable SBAS M10 GPS RAM.\n", 300);
-            delay(750); // will cause a receiver restart so wait a bit
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_SBAS_BBR, "Unable to disable SBAS M10 GPS BBR.\n", 300);
-            delay(750); // will cause a receiver restart so wait a bit
-
-            // Done with initialization, Now enable wanted NMEA messages in BBR layer so they will survive a periodic sleep.
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ENABLE_NMEA_BBR, "Unable to enable messages for M10 GPS BBR.\n", 300);
-            delay(750);
-            // Next enable wanted NMEA messages in RAM layer
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ENABLE_NMEA_RAM, "Unable to enable messages for M10 GPS RAM.\n", 500);
-            delay(750);
-
-            // As the M10 has no flash, the best we can do to preserve the config is to set it in RAM and BBR.
-            // BBR will survive a restart, and power off for a while, but modules with small backup
-            // batteries or super caps will not retain the config for a long power off time.
-            msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE_10), _message_SAVE_10);
-            _serial_gps->write(UBXscratch, msglen);
-            if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
-                LOG_WARN("Unable to save GNSS module configuration.\n");
-            } else {
-                LOG_INFO("GNSS module configuration saved!\n");
-            }
         }
         didSerialInit = true;
     }
@@ -828,7 +944,7 @@ void GPS::setPowerPMU(bool on)
 void GPS::setPowerUBLOX(bool on, uint32_t sleepMs)
 {
     // Abort: if not UBLOX hardware
-    if (!IS_ONE_OF(gnssModel, GNSS_MODEL_UBLOX6, GNSS_MODEL_UBLOX7, GNSS_MODEL_UBLOX8, GNSS_MODEL_UBLOX9, GNSS_MODEL_UBLOX10))
+    if (gnssModel != GNSS_MODEL_UBLOX)
         return;
 
     // If waking
@@ -851,7 +967,7 @@ void GPS::setPowerUBLOX(bool on, uint32_t sleepMs)
         }
 
         // Determine hardware version
-        if (gnssModel == GNSS_MODEL_UBLOX10) {
+        if (strncmp(info.hwVersion, "000A0000", 8) != 0) {
             // Encode the sleep time in millis into the packet
             for (int i = 0; i < 4; i++)
                 gps->_message_PMREQ[0 + i] = sleepMs >> (i * 8);
@@ -910,29 +1026,26 @@ void GPS::down()
         // Check whether the GPS hardware is capable of GPS_SOFTSLEEP
         // If not, fallback to GPS_HARDSLEEP instead
         bool softsleepSupported = false;
-        // U-blox is supported via PMREQ
-        if (IS_ONE_OF(gnssModel, GNSS_MODEL_UBLOX6, GNSS_MODEL_UBLOX7, GNSS_MODEL_UBLOX8, GNSS_MODEL_UBLOX9, GNSS_MODEL_UBLOX10))
+        if (gnssModel == GNSS_MODEL_UBLOX) // U-blox is supported via PMREQ
             softsleepSupported = true;
 #ifdef PIN_GPS_STANDBY // L76B, L76K and clones have a standby pin
         softsleepSupported = true;
 #endif
 
-        if (softsleepSupported) {
-            // How long does gps_update_interval need to be, for GPS_HARDSLEEP to become more efficient than GPS_SOFTSLEEP?
-            // Heuristic equation. A compromise manually fitted to power observations from U-blox NEO-6M and M10050
-            // https://www.desmos.com/calculator/6gvjghoumr
-            // This is not particularly accurate, but probably an impromevement over a single, fixed threshold
-            uint32_t hardsleepThreshold = (2750 * pow(predictedSearchDuration / 1000, 1.22));
-            LOG_DEBUG("gps_update_interval >= %us needed to justify hardsleep\n", hardsleepThreshold / 1000);
+        // How long does gps_update_interval need to be, for GPS_HARDSLEEP to become more efficient than GPS_SOFTSLEEP?
+        // Heuristic equation. A compromise manually fitted to power observations from U-blox NEO-6M and M10050
+        // https://www.desmos.com/calculator/6gvjghoumr
+        // This is not particularly accurate, but probably an impromevement over a single, fixed threshold
+        uint32_t hardsleepThreshold = (2750 * pow(predictedSearchDuration / 1000, 1.22));
+        LOG_DEBUG("gps_update_interval >= %us needed to justify hardsleep\n", hardsleepThreshold / 1000);
+
+        // If update interval too short: softsleep (if supported by hardware)
+        if (softsleepSupported && updateInterval < hardsleepThreshold)
+            setPowerState(GPS_SOFTSLEEP, sleepTime);
 
-            // If update interval too short: softsleep (if supported by hardware)
-            if (updateInterval < hardsleepThreshold) {
-                setPowerState(GPS_SOFTSLEEP, sleepTime);
-                return;
-            }
-        }
         // If update interval long enough (or softsleep unsupported): hardsleep instead
-        setPowerState(GPS_HARDSLEEP, sleepTime);
+        else
+            setPowerState(GPS_HARDSLEEP, sleepTime);
     }
 }
 
@@ -988,9 +1101,7 @@ int32_t GPS::runOnce()
         // if we have received valid NMEA claim we are connected
         setConnected();
     } else {
-        if ((config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) &&
-            IS_ONE_OF(gnssModel, GNSS_MODEL_UBLOX6, GNSS_MODEL_UBLOX7, GNSS_MODEL_UBLOX8, GNSS_MODEL_UBLOX9,
-                      GNSS_MODEL_UBLOX10)) {
+        if ((config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) && (gnssModel == GNSS_MODEL_UBLOX)) {
             // reset the GPS on next bootup
             if (devicestate.did_gps_reset && scheduling.elapsedSearchMs() > 60 * 1000UL && !hasFlow()) {
                 LOG_DEBUG("GPS is not communicating, trying factory reset on next bootup.\n");
@@ -1084,19 +1195,18 @@ int GPS::prepareDeepSleep(void *unused)
 
 GnssModel_t GPS::probe(int serialSpeed)
 {
-#if defined(ARCH_NRF52) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32WL)
+#if defined(ARCH_NRF52) || defined(ARCH_PORTDUINO) || defined(ARCH_RP2040) || defined(ARCH_STM32WL)
     _serial_gps->end();
     _serial_gps->begin(serialSpeed);
-#elif defined(ARCH_RP2040)
-    _serial_gps->end();
-    _serial_gps->setFIFOSize(256);
-    _serial_gps->begin(serialSpeed);
 #else
     if (_serial_gps->baudRate() != serialSpeed) {
         LOG_DEBUG("Setting Baud to %i\n", serialSpeed);
         _serial_gps->updateBaudRate(serialSpeed);
     }
 #endif
+#ifdef GNSS_AIROHA
+    return GNSS_MODEL_AG3335;
+#endif
 
     memset(&info, 0, sizeof(struct uBloxGnssModelInfo));
     uint8_t buffer[768] = {0};
@@ -1115,12 +1225,7 @@ GnssModel_t GPS::probe(int serialSpeed)
     PROBE_SIMPLE("ATGM332D", "$PCAS06,1*1A", "$GPTXT,01,01,02,HW=ATGM332D", GNSS_MODEL_ATGM336H, 500);
 
     /* 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
-    PROBE_SIMPLE("AG3335", "$PAIR021*39", "$PAIR021,AG3335", GNSS_MODEL_AG3335, 500);
-    PROBE_SIMPLE("AG3352", "$PAIR021*39", "$PAIR021,AG3352", GNSS_MODEL_AG3352, 500);
-    PROBE_SIMPLE("LC86", "$PQTMVERNO*58", "$PQTMVERNO,LC86", GNSS_MODEL_AG3352, 500);
+    PROBE_SIMPLE("AG3335", "PAIR020*38", "$PAIR020,AG3335", GNSS_MODEL_AG3335, 500);
 
     PROBE_SIMPLE("L76K", "$PCAS06,0*1B", "$GPTXT,01,01,02,SW=", GNSS_MODEL_MTK, 500);
 
@@ -1155,13 +1260,9 @@ GnssModel_t GPS::probe(int serialSpeed)
         _serial_gps->write(_message_prt, sizeof(_message_prt));
         delay(500);
         serialSpeed = 9600;
-#if defined(ARCH_NRF52) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32WL)
+#if defined(ARCH_NRF52) || defined(ARCH_PORTDUINO) || defined(ARCH_RP2040) || defined(ARCH_STM32WL)
         _serial_gps->end();
         _serial_gps->begin(serialSpeed);
-#elif defined(ARCH_RP2040)
-        _serial_gps->end();
-        _serial_gps->setFIFOSize(256);
-        _serial_gps->begin(serialSpeed);
 #else
         _serial_gps->updateBaudRate(serialSpeed);
 #endif
@@ -1219,9 +1320,9 @@ GnssModel_t GPS::probe(int serialSpeed)
                 strncpy((char *)buffer, &(info.extension[i][4]), sizeof(buffer));
                 // LOG_DEBUG("GetModel:%s\n", (char *)buffer);
                 if (strlen((char *)buffer)) {
-                    LOG_INFO("%s detected, using GNSS_MODEL_UBLOX\n", (char *)buffer);
+                    LOG_INFO("UBlox GNSS probe succeeded, using UBlox %s GNSS Module\n", (char *)buffer);
                 } else {
-                    LOG_INFO("Generic Ublox detected, using GNSS_MODEL_UBLOX\n");
+                    LOG_INFO("UBlox GNSS probe succeeded, using UBlox GNSS Module\n");
                 }
             } else if (!strncmp(info.extension[i], "PROTVER", 7)) {
                 char *ptr = nullptr;
@@ -1236,20 +1337,9 @@ GnssModel_t GPS::probe(int serialSpeed)
                 }
             }
         }
-        if (strncmp(info.hwVersion, "00040007", 8) == 0) {
-            return GNSS_MODEL_UBLOX6;
-        } else if (strncmp(info.hwVersion, "00070000", 8) == 0) {
-            return GNSS_MODEL_UBLOX7;
-        } else if (strncmp(info.hwVersion, "00080000", 8) == 0) {
-            return GNSS_MODEL_UBLOX8;
-        } else if (strncmp(info.hwVersion, "00190000", 8) == 0) {
-            return GNSS_MODEL_UBLOX9;
-        } else if (strncmp(info.hwVersion, "000A0000", 8) == 0) {
-            return GNSS_MODEL_UBLOX10;
-        }
     }
 
-    return GNSS_MODEL_UNKNOWN;
+    return GNSS_MODEL_UBLOX;
 }
 
 GPS *GPS::createGps()
@@ -1333,9 +1423,6 @@ GPS *GPS::createGps()
         LOG_DEBUG("Using GPIO%d for GPS RX\n", new_gps->rx_gpio);
         LOG_DEBUG("Using GPIO%d for GPS TX\n", new_gps->tx_gpio);
         _serial_gps->begin(GPS_BAUDRATE, SERIAL_8N1, new_gps->rx_gpio, new_gps->tx_gpio);
-#elif defined(ARCH_RP2040)
-        _serial_gps->setFIFOSize(256);
-        _serial_gps->begin(GPS_BAUDRATE);
 #else
         _serial_gps->begin(GPS_BAUDRATE);
 #endif
@@ -1423,15 +1510,16 @@ bool GPS::lookForTime()
 
 #ifdef GNSS_AIROHA
     uint8_t fix = reader.fixQuality();
+    uint32_t now = millis();
     if (fix > 0) {
         if (lastFixStartMsec > 0) {
-            if (Throttle::isWithinTimespanMs(lastFixStartMsec, GPS_FIX_HOLD_TIME)) {
+            if ((now - lastFixStartMsec) < GPS_FIX_HOLD_TIME) {
                 return false;
             } else {
                 clearBuffer();
             }
         } else {
-            lastFixStartMsec = millis();
+            lastFixStartMsec = now;
             return false;
         }
     } else {
@@ -1446,7 +1534,7 @@ The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of s
 (midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
 */
         struct tm t;
-        t.tm_sec = ti.second() + round(ti.age() / 1000);
+        t.tm_sec = ti.second();
         t.tm_min = ti.minute();
         t.tm_hour = ti.hour();
         t.tm_mday = d.day();
@@ -1454,8 +1542,8 @@ The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of s
         t.tm_year = d.year() - 1900;
         t.tm_isdst = false;
         if (t.tm_mon > -1) {
-            LOG_DEBUG("NMEA GPS time %02d-%02d-%02d %02d:%02d:%02d age %d\n", d.year(), d.month(), t.tm_mday, t.tm_hour, t.tm_min,
-                      t.tm_sec, ti.age());
+            LOG_DEBUG("NMEA GPS time %02d-%02d-%02d %02d:%02d:%02d\n", d.year(), d.month(), t.tm_mday, t.tm_hour, t.tm_min,
+                      t.tm_sec);
             perhapsSetRTC(RTCQualityGPS, t);
             return true;
         } else
@@ -1475,15 +1563,16 @@ bool GPS::lookForLocation()
 #ifdef GNSS_AIROHA
     if ((config.position.gps_update_interval * 1000) >= (GPS_FIX_HOLD_TIME * 2)) {
         uint8_t fix = reader.fixQuality();
+        uint32_t now = millis();
         if (fix > 0) {
             if (lastFixStartMsec > 0) {
-                if (Throttle::isWithinTimespanMs(lastFixStartMsec, GPS_FIX_HOLD_TIME)) {
+                if ((now - lastFixStartMsec) < GPS_FIX_HOLD_TIME) {
                     return false;
                 } else {
                     clearBuffer();
                 }
             } else {
-                lastFixStartMsec = millis();
+                lastFixStartMsec = now;
                 return false;
             }
         } else {

src/gps/GPS.h

@@ -26,16 +26,11 @@ struct uBloxGnssModelInfo {
 typedef enum {
     GNSS_MODEL_ATGM336H,
     GNSS_MODEL_MTK,
-    GNSS_MODEL_UBLOX6,
-    GNSS_MODEL_UBLOX7,
-    GNSS_MODEL_UBLOX8,
-    GNSS_MODEL_UBLOX9,
-    GNSS_MODEL_UBLOX10,
+    GNSS_MODEL_UBLOX,
     GNSS_MODEL_UC6580,
     GNSS_MODEL_UNKNOWN,
     GNSS_MODEL_MTK_L76B,
-    GNSS_MODEL_AG3335,
-    GNSS_MODEL_AG3352
+    GNSS_MODEL_AG3335
 } GnssModel_t;
 
 typedef enum {
@@ -106,7 +101,7 @@ class GPS : private concurrency::OSThread
 
   public:
     /** If !NULL we will use this serial port to construct our GPS */
-#if defined(ARCH_RP2040)
+#if defined(RPI_PICO_WAVESHARE)
     static SerialUART *_serial_gps;
 #else
     static HardwareSerial *_serial_gps;
@@ -134,7 +129,6 @@ class GPS : private concurrency::OSThread
     static const uint8_t _message_GGA[];
     static const uint8_t _message_PMS[];
     static const uint8_t _message_SAVE[];
-    static const uint8_t _message_SAVE_10[];
 
     // VALSET Commands for M10
     static const uint8_t _message_VALSET_PM[];
@@ -315,4 +309,4 @@ class GPS : private concurrency::OSThread
 };
 
 extern GPS *gps;
-#endif // Exclude GPS
+#endif // Exclude GPS

src/gps/RTC.cpp

@@ -2,7 +2,6 @@
 #include "configuration.h"
 #include "detect/ScanI2C.h"
 #include "main.h"
-#include <Throttle.h>
 #include <sys/time.h>
 #include <time.h>
 
@@ -30,7 +29,7 @@ void readFromRTC()
     if (rtc_found.address == RV3028_RTC) {
         uint32_t now = millis();
         Melopero_RV3028 rtc;
-#if WIRE_INTERFACES_COUNT == 2
+#ifdef I2C_SDA1
         rtc.initI2C(rtc_found.port == ScanI2C::I2CPort::WIRE1 ? Wire1 : Wire);
 #else
         rtc.initI2C();
@@ -44,10 +43,7 @@ void readFromRTC()
         t.tm_sec = rtc.getSecond();
         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 RV3028 getTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)\n", t.tm_year + 1900, t.tm_mon + 1,
-                  t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch);
+        LOG_DEBUG("Read RTC time from RV3028 as %ld\n", tv.tv_sec);
         timeStartMsec = now;
         zeroOffsetSecs = tv.tv_sec;
         if (currentQuality == RTCQualityNone) {
@@ -59,7 +55,7 @@ void readFromRTC()
         uint32_t now = millis();
         PCF8563_Class rtc;
 
-#if WIRE_INTERFACES_COUNT == 2
+#ifdef I2C_SDA1
         rtc.begin(rtc_found.port == ScanI2C::I2CPort::WIRE1 ? Wire1 : Wire);
 #else
         rtc.begin();
@@ -75,10 +71,7 @@ void readFromRTC()
         t.tm_sec = tc.second;
         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 PCF8563 getDateTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)\n", t.tm_year + 1900,
-                  t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch);
+        LOG_DEBUG("Read RTC time from PCF8563 as %ld\n", tv.tv_sec);
         timeStartMsec = now;
         zeroOffsetSecs = tv.tv_sec;
         if (currentQuality == RTCQualityNone) {
@@ -88,8 +81,7 @@ void readFromRTC()
 #else
     if (!gettimeofday(&tv, NULL)) {
         uint32_t now = millis();
-        uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms
-        LOG_DEBUG("Read RTC time as %ld\n", printableEpoch);
+        LOG_DEBUG("Read RTC time as %ld\n", tv.tv_sec);
         timeStartMsec = now;
         zeroOffsetSecs = tv.tv_sec;
     }
@@ -109,13 +101,6 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpdate)
 {
     static uint32_t lastSetMsec = 0;
     uint32_t now = millis();
-    uint32_t printableEpoch = tv->tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms
-#ifdef BUILD_EPOCH
-    if (tv->tv_sec < BUILD_EPOCH) {
-        LOG_WARN("Ignoring time (%ld) before build epoch (%ld)!\n", printableEpoch, BUILD_EPOCH);
-        return false;
-    }
-#endif
 
     bool shouldSet;
     if (forceUpdate) {
@@ -125,13 +110,10 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpdate)
     } else if (q > currentQuality) {
         shouldSet = true;
         LOG_DEBUG("Upgrading time to quality %s\n", RtcName(q));
-    } else if (q == RTCQualityGPS) {
+    } else if (q >= RTCQualityNTP && (now - lastSetMsec) > (12 * 60 * 60 * 1000UL)) {
+        // Every 12 hrs we will slam in a new GPS or Phone GPS / NTP time, to correct for local RTC clock drift
         shouldSet = true;
-        LOG_DEBUG("Reapplying GPS time: %ld secs\n", printableEpoch);
-    } else if (q == RTCQualityNTP && !Throttle::isWithinTimespanMs(lastSetMsec, (12 * 60 * 60 * 1000UL))) {
-        // Every 12 hrs we will slam in a new NTP or Phone GPS / NTP time, to correct for local RTC clock drift
-        shouldSet = true;
-        LOG_DEBUG("Reapplying external time to correct clock drift %ld secs\n", printableEpoch);
+        LOG_DEBUG("Reapplying external time to correct clock drift %ld secs\n", tv->tv_sec);
     } else {
         shouldSet = false;
         LOG_DEBUG("Current RTC quality: %s. Ignoring time of RTC quality of %s\n", RtcName(currentQuality), RtcName(q));
@@ -151,29 +133,29 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpdate)
 #ifdef RV3028_RTC
         if (rtc_found.address == RV3028_RTC) {
             Melopero_RV3028 rtc;
-#if WIRE_INTERFACES_COUNT == 2
+#ifdef I2C_SDA1
             rtc.initI2C(rtc_found.port == ScanI2C::I2CPort::WIRE1 ? Wire1 : Wire);
 #else
             rtc.initI2C();
 #endif
             tm *t = gmtime(&tv->tv_sec);
             rtc.setTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_wday, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
-            LOG_DEBUG("RV3028_RTC setTime %02d-%02d-%02d %02d:%02d:%02d (%ld)\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
-                      t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
+            LOG_DEBUG("RV3028_RTC setTime %02d-%02d-%02d %02d:%02d:%02d %ld\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
+                      t->tm_hour, t->tm_min, t->tm_sec, tv->tv_sec);
         }
 #elif defined(PCF8563_RTC)
         if (rtc_found.address == PCF8563_RTC) {
             PCF8563_Class rtc;
 
-#if WIRE_INTERFACES_COUNT == 2
+#ifdef I2C_SDA1
             rtc.begin(rtc_found.port == ScanI2C::I2CPort::WIRE1 ? Wire1 : Wire);
 #else
             rtc.begin();
 #endif
             tm *t = gmtime(&tv->tv_sec);
             rtc.setDateTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
-            LOG_DEBUG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)\n", t->tm_year + 1900, t->tm_mon + 1,
-                      t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
+            LOG_DEBUG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d %ld\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
+                      t->tm_hour, t->tm_min, t->tm_sec, tv->tv_sec);
         }
 #elif defined(ARCH_ESP32)
         settimeofday(tv, NULL);
@@ -290,4 +272,4 @@ time_t gm_mktime(struct tm *tm)
 #else
     return mktime(tm);
 #endif
-}
+}

src/gps/ubx.h

@@ -1,10 +1,3 @@
-#define SEND_UBX_PACKET(TYPE, ID, DATA, ERRMSG, TIMEOUT)                                                                         \
-    msglen = makeUBXPacket(TYPE, ID, sizeof(DATA), DATA);                                                                        \
-    _serial_gps->write(UBXscratch, msglen);                                                                                      \
-    if (getACK(TYPE, ID, TIMEOUT) != GNSS_RESPONSE_OK) {                                                                         \
-        LOG_WARN(#ERRMSG);                                                                                                       \
-    }
-
 // Power Management
 
 uint8_t GPS::_message_PMREQ[] PROGMEM = {
@@ -323,13 +316,6 @@ const uint8_t GPS::_message_SAVE[] = {
     0x17                    // deviceMask: BBR, Flash, EEPROM, and SPI Flash
 };
 
-const uint8_t GPS::_message_SAVE_10[] = {
-    0x00, 0x00, 0x00, 0x00, // clearMask: no sections cleared
-    0xFF, 0xFF, 0x00, 0x00, // saveMask: save all sections
-    0x00, 0x00, 0x00, 0x00, // loadMask: no sections loaded
-    0x01                    // deviceMask: only save to BBR
-};
-
 // As the M10 has no flash, the best we can do to preserve the config is to set it in RAM and BBR.
 // BBR will survive a restart, and power off for a while, but modules with small backup
 // batteries or super caps will not retain the config for a long power off time.
@@ -349,36 +335,36 @@ const uint8_t GPS::_message_SAVE_10[] = {
 // has details on low-power modes
 
 /*
-OPERATEMODE E1 2 (0 | 1 | 2)
-POSUPDATEPERIOD U4 5
-ACQPERIOD U4 10
-GRIDOFFSET U4 0
-ONTIME U2 1
-MINACQTIME U1 0
-MAXACQTIME U1 0
-DONOTENTEROFF L 1
-WAITTIMEFIX  L 1
-UPDATEEPH L 1
-EXTINTWAKE L 0 no ext ints
-EXTINTBACKUP L 0 no ext ints
-EXTINTINACTIVE L 0 no ext ints
-EXTINTACTIVITY U4 0 no ext ints
-LIMITPEAKCURRENT L 1
+CFG-PM2 has been replaced by many CFG-PM commands
+CFG-PMS has been removed
+
+CFG-PM-OPERATEMODE E1 (0 | 1 | 2) -> 1 (PSMOO), because sporadic position updates are required instead of continous tracking <10s
+(PSMCT) CFG-PM-POSUPDATEPERIOD U4 -> 0ms, no self-timed wakup because receiver power mode is controlled via "software standby
+mode" by legacy UBX-RXM-PMREQ request CFG-PM-ACQPERIOD U4 -> 0ms, because receiver power mode is controlled via "software standby
+mode" by legacy UBX-RXM-PMREQ request CFG-PM-ONTIME U4 -> 0ms, optional I guess CFG-PM-EXTINTBACKUP L -> 1, force receiver into
+BACKUP mode when EXTINT (should be connected to GPS_EN_PIN) pin is "low"
+
+This is required because the receiver never enters low power mode if microcontroller is in deep-sleep.
+Maybe the changing UART_RX levels trigger a wakeup but even with UBX-RXM-PMREQ[12] = 0x00 (all external wakeup sources disabled)
+the receivcer remains in aquisition state -> potentially a bug
+
+Workaround: Control the EXTINT pin by the GPS_EN_PIN signal
+
+As mentioned in the M10 operational issues down below, power save won't allow the use of BDS B1C.
+CFG-SIGNAL-BDS_B1C_ENA L -> 0
 
 // Ram layer config message:
-// b5 62 06 8a 26 00 00 01 00 00 01 00 d0 20 02 02 00 d0 40 05 00 00 00 05 00 d0 30 01 00 08 00 d0 10 01 09 00 d0 10 01 10 00 d0
-// 10 01 8b de
+// 01 01 00 00 01 00 D0 20 01 02 00 D0 40 00 00 00 00 03 00 D0 40 00 00 00 00 05 00 D0 30 00 00 0D 00 D0 10 01
 
 // BBR layer config message:
-// b5 62 06 8a 26 00 00 02 00 00 01 00 d0 20 02 02 00 d0 40 05 00 00 00 05 00 d0 30 01 00 08 00 d0 10 01 09 00 d0 10 01 10 00 d0
-// 10 01 8c 03
+// 01 02 00 00 01 00 D0 20 01 02 00 D0 40 00 00 00 00 03 00 D0 40 00 00 00 00 05 00 D0 30 00 00 0D 00 D0 10 01
 */
-const uint8_t GPS::_message_VALSET_PM_RAM[] = {0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0xd0, 0x20, 0x02, 0x02, 0x00, 0xd0, 0x40,
-                                               0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0xd0, 0x30, 0x01, 0x00, 0x08, 0x00, 0xd0,
-                                               0x10, 0x01, 0x09, 0x00, 0xd0, 0x10, 0x01, 0x10, 0x00, 0xd0, 0x10, 0x01};
-const uint8_t GPS::_message_VALSET_PM_BBR[] = {0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0xd0, 0x20, 0x02, 0x02, 0x00, 0xd0, 0x40,
-                                               0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0xd0, 0x30, 0x01, 0x00, 0x08, 0x00, 0xd0,
-                                               0x10, 0x01, 0x09, 0x00, 0xd0, 0x10, 0x01, 0x10, 0x00, 0xd0, 0x10, 0x01};
+const uint8_t GPS::_message_VALSET_PM_RAM[] = {0x01, 0x01, 0x00, 0x00, 0x0F, 0x00, 0x31, 0x10, 0x00, 0x01, 0x00, 0xD0, 0x20, 0x01,
+                                               0x02, 0x00, 0xD0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0xD0, 0x40, 0x00, 0x00,
+                                               0x00, 0x00, 0x05, 0x00, 0xD0, 0x30, 0x00, 0x00, 0x0D, 0x00, 0xD0, 0x10, 0x01};
+const uint8_t GPS::_message_VALSET_PM_BBR[] = {0x01, 0x02, 0x00, 0x00, 0x0F, 0x00, 0x31, 0x10, 0x00, 0x01, 0x00, 0xD0, 0x20, 0x01,
+                                               0x02, 0x00, 0xD0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0xD0, 0x40, 0x00, 0x00,
+                                               0x00, 0x00, 0x05, 0x00, 0xD0, 0x30, 0x00, 0x00, 0x0D, 0x00, 0xD0, 0x10, 0x01};
 
 /*
 CFG-ITFM replaced by 5 valset messages which can be combined into one for RAM and one for BBR

src/graphics/EInkDynamicDisplay.cpp

@@ -1,4 +1,3 @@
-#include "Throttle.h"
 #include "configuration.h"
 
 #if defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
@@ -232,13 +231,15 @@ void EInkDynamicDisplay::checkForPromotion()
 // Is it too soon for another frame of this type?
 void EInkDynamicDisplay::checkRateLimiting()
 {
+    uint32_t now = millis();
+
     // Sanity check: millis() overflow - just let the update run..
-    if (previousRunMs > millis())
+    if (previousRunMs > now)
         return;
 
     // Skip update: too soon for BACKGROUND
     if (frameFlags == BACKGROUND) {
-        if (Throttle::isWithinTimespanMs(previousRunMs, EINK_LIMIT_RATE_BACKGROUND_SEC * 1000)) {
+        if (now - previousRunMs < EINK_LIMIT_RATE_BACKGROUND_SEC * 1000) {
             refresh = SKIPPED;
             reason = EXCEEDED_RATELIMIT_FULL;
             return;
@@ -251,7 +252,7 @@ void EInkDynamicDisplay::checkRateLimiting()
 
     // Skip update: too soon for RESPONSIVE
     if (frameFlags & RESPONSIVE) {
-        if (Throttle::isWithinTimespanMs(previousRunMs, EINK_LIMIT_RATE_RESPONSIVE_SEC * 1000)) {
+        if (now - previousRunMs < EINK_LIMIT_RATE_RESPONSIVE_SEC * 1000) {
             refresh = SKIPPED;
             reason = EXCEEDED_RATELIMIT_FAST;
             LOG_DEBUG("refresh=SKIPPED, reason=EXCEEDED_RATELIMIT_FAST, frameFlags=0x%x\n", frameFlags);

src/graphics/Screen.cpp

@@ -22,7 +22,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "Screen.h"
 #include "../userPrefs.h"
 #include "PowerMon.h"
-#include "Throttle.h"
 #include "configuration.h"
 #if HAS_SCREEN
 #include <OLEDDisplay.h>
@@ -48,7 +47,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "modules/AdminModule.h"
 #include "modules/ExternalNotificationModule.h"
 #include "modules/TextMessageModule.h"
-#include "modules/WaypointModule.h"
 #include "sleep.h"
 #include "target_specific.h"
 
@@ -58,11 +56,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #ifdef ARCH_ESP32
 #include "esp_task_wdt.h"
-#include "modules/StoreForwardModule.h"
+#include "modules/esp32/StoreForwardModule.h"
 #endif
 
 #if ARCH_PORTDUINO
-#include "modules/StoreForwardModule.h"
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 
@@ -120,7 +117,6 @@ static bool heartbeat = false;
 #define SCREEN_HEIGHT display->getHeight()
 
 #include "graphics/ScreenFonts.h"
-#include <Throttle.h>
 
 #define getStringCenteredX(s) ((SCREEN_WIDTH - display->getStringWidth(s)) / 2)
 
@@ -1008,55 +1004,55 @@ static void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state
 
     display->setColor(WHITE);
 #ifndef EXCLUDE_EMOJI
-    if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\U0001F44D") == 0) {
+    if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\U0001F44D") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - thumbs_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - thumbs_height) / 2 + 2 + 5, thumbs_width, thumbs_height,
                          thumbup);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\U0001F44E") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\U0001F44E") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - thumbs_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - thumbs_height) / 2 + 2 + 5, thumbs_width, thumbs_height,
                          thumbdown);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "❓") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"❓") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - question_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - question_height) / 2 + 2 + 5, question_width, question_height,
                          question);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "‼️") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"‼️") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - bang_width) / 2, y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - bang_height) / 2 + 2 + 5,
                          bang_width, bang_height, bang);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\U0001F4A9") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\U0001F4A9") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - poo_width) / 2, y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - poo_height) / 2 + 2 + 5,
                          poo_width, poo_height, poo);
     } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\xf0\x9f\xa4\xa3") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - haha_width) / 2, y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - haha_height) / 2 + 2 + 5,
                          haha_width, haha_height, haha);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\U0001F44B") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\U0001F44B") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - wave_icon_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - wave_icon_height) / 2 + 2 + 5, wave_icon_width,
                          wave_icon_height, wave_icon);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\U0001F920") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\U0001F920") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - cowboy_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - cowboy_height) / 2 + 2 + 5, cowboy_width, cowboy_height,
                          cowboy);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\U0001F42D") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\U0001F42D") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - deadmau5_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - deadmau5_height) / 2 + 2 + 5, deadmau5_width, deadmau5_height,
                          deadmau5);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\xE2\x98\x80\xEF\xB8\x8F") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\xE2\x98\x80\xEF\xB8\x8F") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - sun_width) / 2, y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - sun_height) / 2 + 2 + 5,
                          sun_width, sun_height, sun);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\u2614") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\u2614") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - rain_width) / 2, y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - rain_height) / 2 + 2 + 10,
                          rain_width, rain_height, rain);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "☁️") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"☁️") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - cloud_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - cloud_height) / 2 + 2 + 5, cloud_width, cloud_height, cloud);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "🌫️") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"🌫️") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - fog_width) / 2, y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - fog_height) / 2 + 2 + 5,
                          fog_width, fog_height, fog);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "\xf0\x9f\x98\x88") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"\xf0\x9f\x98\x88") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - devil_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - devil_height) / 2 + 2 + 5, devil_width, devil_height, devil);
-    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), "♥️") == 0) {
+    } else if (strcmp(reinterpret_cast<const char *>(mp.decoded.payload.bytes), u8"♥️") == 0) {
         display->drawXbm(x + (SCREEN_WIDTH - heart_width) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - heart_height) / 2 + 2 + 5, heart_width, heart_height, heart);
     } else {
@@ -1097,8 +1093,8 @@ static void drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const NodeStat
 {
     char usersString[20];
     snprintf(usersString, sizeof(usersString), "%d/%d", nodeStatus->getNumOnline(), nodeStatus->getNumTotal());
-#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) || defined(ST7789_CS) ||           \
-     defined(USE_ST7789) || defined(HX8357_CS)) &&                                                                               \
+#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7735_CS) || defined(ST7789_CS) || defined(USE_ST7789) ||          \
+     defined(HX8357_CS)) &&                                                                                                      \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
     display->drawFastImage(x, y + 3, 8, 8, imgUser);
 #else
@@ -1289,8 +1285,8 @@ static int8_t prevFrame = -1;
 // Draw the arrow pointing to a node's location
 void Screen::drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t compassY, uint16_t compassDiam, float headingRadian)
 {
-    Point tip(0.0f, 0.5f), tail(0.0f, -0.35f); // pointing up initially
-    float arrowOffsetX = 0.14f, arrowOffsetY = 1.0f;
+    Point tip(0.0f, 0.5f), tail(0.0f, -0.5f); // pointing up initially
+    float arrowOffsetX = 0.2f, arrowOffsetY = 0.2f;
     Point leftArrow(tip.x - arrowOffsetX, tip.y - arrowOffsetY), rightArrow(tip.x + arrowOffsetX, tip.y - arrowOffsetY);
 
     Point *arrowPoints[] = {&tip, &tail, &leftArrow, &rightArrow};
@@ -1300,19 +1296,9 @@ void Screen::drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t com
         arrowPoints[i]->scale(compassDiam * 0.6);
         arrowPoints[i]->translate(compassX, compassY);
     }
-    /* Old arrow
     display->drawLine(tip.x, tip.y, tail.x, tail.y);
     display->drawLine(leftArrow.x, leftArrow.y, tip.x, tip.y);
     display->drawLine(rightArrow.x, rightArrow.y, tip.x, tip.y);
-    display->drawLine(leftArrow.x, leftArrow.y, tail.x, tail.y);
-    display->drawLine(rightArrow.x, rightArrow.y, tail.x, tail.y);
-    */
-#ifdef USE_EINK
-    display->drawTriangle(tip.x, tip.y, rightArrow.x, rightArrow.y, tail.x, tail.y);
-#else
-    display->fillTriangle(tip.x, tip.y, rightArrow.x, rightArrow.y, tail.x, tail.y);
-#endif
-    display->drawTriangle(tip.x, tip.y, leftArrow.x, leftArrow.y, tail.x, tail.y);
 }
 
 // Get a string representation of the time passed since something happened
@@ -1350,27 +1336,22 @@ void Screen::drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t co
     // If north is supposed to be at the top of the compass we want rotation to be +0
     if (config.display.compass_north_top)
         myHeading = -0;
-    /* N sign points currently not deleted*/
-    Point N1(-0.04f, 0.65f), N2(0.04f, 0.65f); // N sign points (N1-N4)
+
+    Point N1(-0.04f, 0.65f), N2(0.04f, 0.65f);
     Point N3(-0.04f, 0.55f), N4(0.04f, 0.55f);
-    Point NC1(0.00f, 0.50f); // north circle center point
-    Point *rosePoints[] = {&N1, &N2, &N3, &N4, &NC1};
+    Point *rosePoints[] = {&N1, &N2, &N3, &N4};
 
     uint16_t compassDiam = Screen::getCompassDiam(SCREEN_WIDTH, SCREEN_HEIGHT);
 
-    for (int i = 0; i < 5; i++) {
+    for (int i = 0; i < 4; i++) {
         // North on compass will be negative of heading
         rosePoints[i]->rotate(-myHeading);
         rosePoints[i]->scale(compassDiam);
         rosePoints[i]->translate(compassX, compassY);
     }
-
-    /* changed the N sign to a small circle on the compass circle.
     display->drawLine(N1.x, N1.y, N3.x, N3.y);
     display->drawLine(N2.x, N2.y, N4.x, N4.y);
     display->drawLine(N1.x, N1.y, N4.x, N4.y);
-    */
-    display->drawCircle(NC1.x, NC1.y, 4); // North sign circle, 4px radius is sufficient for all displays.
 }
 
 uint16_t Screen::getCompassDiam(uint32_t displayWidth, uint32_t displayHeight)
@@ -1534,8 +1515,7 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
 #elif defined(USE_SSD1306)
     dispdev = new SSD1306Wire(address.address, -1, -1, geometry,
                               (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
-#elif defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ST7701_CS) || defined(ST7789_CS) || defined(RAK14014) ||          \
-    defined(HX8357_CS)
+#elif defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(RAK14014) || defined(HX8357_CS)
     dispdev = new TFTDisplay(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
 #elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY)
@@ -1674,11 +1654,6 @@ void Screen::setup()
     static_cast<SH1106Wire *>(dispdev)->setSubtype(7);
 #endif
 
-#if defined(USE_ST7789) && defined(TFT_MESH)
-    // Heltec T114 and T190: honor a custom text color, if defined in variant.h
-    static_cast<ST7789Spi *>(dispdev)->setRGB(TFT_MESH);
-#endif
-
     // Initialising the UI will init the display too.
     ui->init();
 
@@ -1732,11 +1707,8 @@ void Screen::setup()
     // Standard behaviour is to FLIP the screen (needed on T-Beam). If this config item is set, unflip it, and thereby logically
     // flip it. If you have a headache now, you're welcome.
     if (!config.display.flip_screen) {
-#if defined(ST7701_CS) || defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ST7701_CS) || defined(ST7789_CS) ||           \
-    defined(RAK14014) || defined(HX8357_CS)
+#if defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(RAK14014) || defined(HX8357_CS)
         static_cast<TFTDisplay *>(dispdev)->flipScreenVertically();
-#elif defined(USE_ST7789)
-        static_cast<ST7789Spi *>(dispdev)->flipScreenVertically();
 #else
         dispdev->flipScreenVertically();
 #endif
@@ -1953,7 +1925,7 @@ int32_t Screen::runOnce()
     if (showingNormalScreen) {
         // standard screen loop handling here
         if (config.display.auto_screen_carousel_secs > 0 &&
-            !Throttle::isWithinTimespanMs(lastScreenTransition, config.display.auto_screen_carousel_secs * 1000)) {
+            (millis() - lastScreenTransition) > (config.display.auto_screen_carousel_secs * 1000)) {
 
 // If an E-Ink display struggles with fast refresh, force carousel to use full refresh instead
 // Carousel is potentially a major source of E-Ink display wear
@@ -2114,13 +2086,8 @@ void Screen::setFrames(FrameFocus focus)
         // Check if the module being drawn has requested focus
         // We will honor this request later, if setFrames was triggered by a UIFrameEvent
         MeshModule *m = *i;
-        if (m->isRequestingFocus()) {
+        if (m->isRequestingFocus())
             fsi.positions.focusedModule = numframes;
-        }
-
-        // Identify the position of specific modules, if we need to know this later
-        if (m == waypointModule)
-            fsi.positions.waypoint = numframes;
 
         numframes++;
     }
@@ -2139,8 +2106,8 @@ void Screen::setFrames(FrameFocus focus)
 #endif
 
     // If we have a text message - show it next, unless it's a phone message and we aren't using any special modules
+    fsi.positions.textMessage = numframes;
     if (devicestate.has_rx_text_message && shouldDrawMessage(&devicestate.rx_text_message)) {
-        fsi.positions.textMessage = numframes;
         normalFrames[numframes++] = drawTextMessageFrame;
     }
 
@@ -2202,7 +2169,7 @@ void Screen::setFrames(FrameFocus focus)
 
     case FOCUS_PRESERVE:
         // If we can identify which type of frame "originalPosition" was, can move directly to it in the new frameset
-        const FramesetInfo &oldFsi = this->framesetInfo;
+        FramesetInfo &oldFsi = this->framesetInfo;
         if (originalPosition == oldFsi.positions.log)
             ui->switchToFrame(fsi.positions.log);
         else if (originalPosition == oldFsi.positions.settings)
@@ -2242,31 +2209,6 @@ void Screen::setFrameImmediateDraw(FrameCallback *drawFrames)
     setFastFramerate();
 }
 
-// Dismisses the currently displayed screen frame, if possible
-// Relevant for text message, waypoint, others in future?
-// Triggered with a CardKB keycombo
-void Screen::dismissCurrentFrame()
-{
-    uint8_t currentFrame = ui->getUiState()->currentFrame;
-    bool dismissed = false;
-
-    if (currentFrame == framesetInfo.positions.textMessage && devicestate.has_rx_text_message) {
-        LOG_INFO("Dismissing Text Message\n");
-        devicestate.has_rx_text_message = false;
-        dismissed = true;
-    }
-
-    else if (currentFrame == framesetInfo.positions.waypoint && devicestate.has_rx_waypoint) {
-        LOG_DEBUG("Dismissing Waypoint\n");
-        devicestate.has_rx_waypoint = false;
-        dismissed = true;
-    }
-
-    // If we did make changes to dismiss, we now need to regenerate the frameset
-    if (dismissed)
-        setFrames();
-}
-
 void Screen::handleStartFirmwareUpdateScreen()
 {
     LOG_DEBUG("showing firmware screen\n");
@@ -2476,10 +2418,10 @@ void DebugInfo::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     // Draw our hardware ID to assist with bluetooth pairing. Either prefix with Info or S&F Logo
     if (moduleConfig.store_forward.enabled) {
 #ifdef ARCH_ESP32
-        if (!Throttle::isWithinTimespanMs(storeForwardModule->lastHeartbeat,
-                                          (storeForwardModule->heartbeatInterval * 1200))) { // no heartbeat, overlap a bit
-#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) || defined(ST7789_CS) ||           \
-     defined(USE_ST7789) || defined(HX8357_CS)) &&                                                                               \
+        if (millis() - storeForwardModule->lastHeartbeat >
+            (storeForwardModule->heartbeatInterval * 1200)) { // no heartbeat, overlap a bit
+#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7735_CS) || defined(ST7789_CS) || defined(USE_ST7789) ||          \
+     defined(HX8357_CS)) &&                                                                                                      \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
             display->drawFastImage(x + SCREEN_WIDTH - 14 - display->getStringWidth(ourId), y + 3 + FONT_HEIGHT_SMALL, 12, 8,
                                    imgQuestionL1);
@@ -2490,8 +2432,8 @@ void DebugInfo::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
                                    imgQuestion);
 #endif
         } else {
-#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) || defined(ST7789_CS) ||           \
-     defined(USE_ST7789) || defined(HX8357_CS)) &&                                                                               \
+#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7735_CS) || defined(ST7789_CS) || defined(USE_ST7789) ||          \
+     defined(HX8357_CS)) &&                                                                                                      \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
             display->drawFastImage(x + SCREEN_WIDTH - 18 - display->getStringWidth(ourId), y + 3 + FONT_HEIGHT_SMALL, 16, 8,
                                    imgSFL1);
@@ -2505,8 +2447,8 @@ void DebugInfo::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 #endif
     } else {
         // TODO: Raspberry Pi supports more than just the one screen size
-#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) || defined(ST7789_CS) ||           \
-     defined(USE_ST7789) || defined(HX8357_CS) || ARCH_PORTDUINO) &&                                                             \
+#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7735_CS) || defined(ST7789_CS) || defined(USE_ST7789) ||          \
+     defined(HX8357_CS) || ARCH_PORTDUINO) &&                                                                                    \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
         display->drawFastImage(x + SCREEN_WIDTH - 14 - display->getStringWidth(ourId), y + 3 + FONT_HEIGHT_SMALL, 12, 8,
                                imgInfoL1);
@@ -2779,23 +2721,12 @@ int Screen::handleInputEvent(const InputEvent *event)
     }
 #endif
 
-    // Use left or right input from a keyboard to move between frames,
-    // so long as a mesh module isn't using these events for some other purpose
-    if (showingNormalScreen) {
-
-        // Ask any MeshModules if they're handling keyboard input right now
-        bool inputIntercepted = false;
-        for (MeshModule *module : moduleFrames) {
-            if (module->interceptingKeyboardInput())
-                inputIntercepted = true;
-        }
-
-        // If no modules are using the input, move between frames
-        if (!inputIntercepted) {
-            if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT))
-                showPrevFrame();
-            else if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT))
-                showNextFrame();
+    if (showingNormalScreen && moduleFrames.size() == 0) {
+        // LOG_DEBUG("Screen::handleInputEvent from %s\n", event->source);
+        if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_LEFT)) {
+            showPrevFrame();
+        } else if (event->inputEvent == static_cast<char>(meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_RIGHT)) {
+            showNextFrame();
         }
     }
 

src/graphics/Screen.h

@@ -454,9 +454,6 @@ class Screen : public concurrency::OSThread
 
     void setWelcomeFrames();
 
-    // Dismiss the currently focussed frame, if possible (e.g. text message, waypoint)
-    void dismissCurrentFrame();
-
 #ifdef USE_EINK
     /// Draw an image to remain on E-Ink display after screen off
     void setScreensaverFrames(FrameCallback einkScreensaver = NULL);
@@ -506,14 +503,11 @@ class Screen : public concurrency::OSThread
     void handleStartFirmwareUpdateScreen();
 
     // Info collected by setFrames method.
-    // Index location of specific frames.
-    // - Used to apply the FrameFocus parameter of setFrames
-    // - Used to dismiss the currently shown frame (txt; waypoint) by CardKB combo
+    // Index location of specific frames. Used to apply the FrameFocus parameter of setFrames
     struct FramesetInfo {
         struct FramePositions {
             uint8_t fault = 0;
             uint8_t textMessage = 0;
-            uint8_t waypoint = 0;
             uint8_t focusedModule = 0;
             uint8_t log = 0;
             uint8_t settings = 0;

src/graphics/ScreenFonts.h

@@ -12,8 +12,8 @@
 #include "graphics/fonts/OLEDDisplayFontsUA.h"
 #endif
 
-#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) || defined(ST7789_CS) ||           \
-     defined(USE_ST7789) || defined(HX8357_CS)) &&                                                                               \
+#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7735_CS) || defined(ST7789_CS) || defined(USE_ST7789) ||          \
+     defined(HX8357_CS)) &&                                                                                                      \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 // The screen is bigger so use bigger fonts
 #define FONT_SMALL ArialMT_Plain_16  // Height: 19

src/graphics/TFTDisplay.cpp

@@ -500,126 +500,10 @@ class LGFX : public lgfx::LGFX_Device
 
 static LGFX *tft = nullptr;
 
-#elif defined(ST7701_CS)
-#include <LovyanGFX.hpp> // Graphics and font library for ST7701 driver chip
-#include <lgfx/v1/platforms/esp32s3/Bus_RGB.hpp>
-#include <lgfx/v1/platforms/esp32s3/Panel_RGB.hpp>
-
-class LGFX : public lgfx::LGFX_Device
-{
-    lgfx::Panel_ST7701 _panel_instance;
-    lgfx::Bus_RGB _bus_instance;
-    lgfx::Light_PWM _light_instance;
-    lgfx::Touch_FT5x06 _touch_instance;
-
-  public:
-    LGFX(void)
-    {
-        {
-            auto cfg = _panel_instance.config();
-            cfg.memory_width = 800;
-            cfg.memory_height = 480;
-            cfg.panel_width = TFT_WIDTH;
-            cfg.panel_height = TFT_HEIGHT;
-            cfg.offset_x = TFT_OFFSET_X;
-            cfg.offset_y = TFT_OFFSET_Y;
-            _panel_instance.config(cfg);
-        }
-
-        {
-            auto cfg = _panel_instance.config_detail();
-            cfg.pin_cs = ST7701_CS;
-            cfg.pin_sclk = ST7701_SCK;
-            cfg.pin_mosi = ST7701_SDA;
-            // cfg.use_psram = 1;
-            _panel_instance.config_detail(cfg);
-        }
-
-        {
-            auto cfg = _bus_instance.config();
-            cfg.panel = &_panel_instance;
-#ifdef SENSECAP_INDICATOR
-            cfg.pin_d0 = GPIO_NUM_15; // B0
-            cfg.pin_d1 = GPIO_NUM_14; // B1
-            cfg.pin_d2 = GPIO_NUM_13; // B2
-            cfg.pin_d3 = GPIO_NUM_12; // B3
-            cfg.pin_d4 = GPIO_NUM_11; // B4
-
-            cfg.pin_d5 = GPIO_NUM_10; // G0
-            cfg.pin_d6 = GPIO_NUM_9;  // G1
-            cfg.pin_d7 = GPIO_NUM_8;  // G2
-            cfg.pin_d8 = GPIO_NUM_7;  // G3
-            cfg.pin_d9 = GPIO_NUM_6;  // G4
-            cfg.pin_d10 = GPIO_NUM_5; // G5
-
-            cfg.pin_d11 = GPIO_NUM_4; // R0
-            cfg.pin_d12 = GPIO_NUM_3; // R1
-            cfg.pin_d13 = GPIO_NUM_2; // R2
-            cfg.pin_d14 = GPIO_NUM_1; // R3
-            cfg.pin_d15 = GPIO_NUM_0; // R4
-
-            cfg.pin_henable = GPIO_NUM_18;
-            cfg.pin_vsync = GPIO_NUM_17;
-            cfg.pin_hsync = GPIO_NUM_16;
-            cfg.pin_pclk = GPIO_NUM_21;
-            cfg.freq_write = 12000000;
-
-            cfg.hsync_polarity = 0;
-            cfg.hsync_front_porch = 10;
-            cfg.hsync_pulse_width = 8;
-            cfg.hsync_back_porch = 50;
-
-            cfg.vsync_polarity = 0;
-            cfg.vsync_front_porch = 10;
-            cfg.vsync_pulse_width = 8;
-            cfg.vsync_back_porch = 20;
-
-            cfg.pclk_active_neg = 0;
-            cfg.de_idle_high = 1;
-            cfg.pclk_idle_high = 0;
-#endif
-            _bus_instance.config(cfg);
-        }
-        _panel_instance.setBus(&_bus_instance);
-
-        {
-            auto cfg = _light_instance.config();
-            cfg.pin_bl = ST7701_BL;
-            _light_instance.config(cfg);
-        }
-        _panel_instance.light(&_light_instance);
-
-        {
-            auto cfg = _touch_instance.config();
-            cfg.pin_cs = -1;
-            cfg.x_min = 0;
-            cfg.x_max = 479;
-            cfg.y_min = 0;
-            cfg.y_max = 479;
-            cfg.pin_int = -1; // don't use SCREEN_TOUCH_INT;
-            cfg.pin_rst = SCREEN_TOUCH_RST;
-            cfg.bus_shared = true;
-            cfg.offset_rotation = TFT_OFFSET_ROTATION;
-
-            cfg.i2c_port = TOUCH_I2C_PORT;
-            cfg.i2c_addr = TOUCH_SLAVE_ADDRESS;
-            cfg.pin_sda = I2C_SDA;
-            cfg.pin_scl = I2C_SCL;
-            cfg.freq = 400000;
-            _touch_instance.config(cfg);
-            _panel_instance.setTouch(&_touch_instance);
-        }
-
-        setPanel(&_panel_instance);
-    }
-};
-
-static LGFX *tft = nullptr;
-
 #endif
 
-#if defined(ST7701_CS) || defined(ST7735_CS) || defined(ST7789_CS) || defined(ILI9341_DRIVER) || defined(RAK14014) ||            \
-    defined(HX8357_CS) || (ARCH_PORTDUINO && HAS_SCREEN != 0)
+#if defined(ST7735_CS) || defined(ST7789_CS) || defined(ILI9341_DRIVER) || defined(RAK14014) || defined(HX8357_CS) ||            \
+    (ARCH_PORTDUINO && HAS_SCREEN != 0)
 #include "SPILock.h"
 #include "TFTDisplay.h"
 #include <SPI.h>
@@ -825,6 +709,7 @@ bool TFTDisplay::connect()
 
 #ifdef UNPHONE
     unphone.backlight(true); // using unPhone library
+    LOG_INFO("Power to TFT Backlight\n");
 #endif
 
     tft->init();
@@ -840,7 +725,7 @@ bool TFTDisplay::connect()
     attachInterrupt(digitalPinToInterrupt(SCREEN_TOUCH_INT), rak14014_tpIntHandle, FALLING);
 #elif defined(T_DECK) || defined(PICOMPUTER_S3) || defined(CHATTER_2)
     tft->setRotation(1); // T-Deck has the TFT in landscape
-#elif defined(T_WATCH_S3) || defined(SENSECAP_INDICATOR)
+#elif defined(T_WATCH_S3)
     tft->setRotation(2); // T-Watch S3 left-handed orientation
 #else
     tft->setRotation(3); // Orient horizontal and wide underneath the silkscreen name label

src/graphics/images.h

@@ -20,8 +20,8 @@ const uint8_t bluetoothConnectedIcon[36] PROGMEM = {0xfe, 0x01, 0xff, 0x03, 0x03
                                                     0xfe, 0x31, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0xf0, 0x3f, 0xe0, 0x1f};
 #endif
 
-#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) || defined(ST7789_CS) ||           \
-     defined(USE_ST7789) || defined(HX8357_CS) || ARCH_PORTDUINO) &&                                                             \
+#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7735_CS) || defined(ST7789_CS) || defined(USE_ST7789) ||          \
+     defined(HX8357_CS) || ARCH_PORTDUINO) &&                                                                                    \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 const uint8_t imgQuestionL1[] PROGMEM = {0xff, 0x01, 0x01, 0x32, 0x7b, 0x49, 0x49, 0x6f, 0x26, 0x01, 0x01, 0xff};
 const uint8_t imgQuestionL2[] PROGMEM = {0x0f, 0x08, 0x08, 0x08, 0x06, 0x0f, 0x0f, 0x06, 0x08, 0x08, 0x08, 0x0f};

src/input/ExpressLRSFiveWay.cpp

@@ -1,5 +1,5 @@
+
 #include "ExpressLRSFiveWay.h"
-#include "Throttle.h"
 
 #ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
 
@@ -76,10 +76,11 @@ void ExpressLRSFiveWay::update(int *keyValue, bool *keyLongPressed)
     *keyValue = NO_PRESS;
 
     int newKey = readKey();
+    uint32_t now = millis();
     if (keyInProcess == NO_PRESS) {
         // New key down
         if (newKey != NO_PRESS) {
-            keyDownStart = millis();
+            keyDownStart = now;
             // DBGLN("down=%u", newKey);
         }
     } else {
@@ -87,7 +88,7 @@ void ExpressLRSFiveWay::update(int *keyValue, bool *keyLongPressed)
         if (newKey == NO_PRESS) {
             // DBGLN("up=%u", keyInProcess);
             if (!isLongPressed) {
-                if (!Throttle::isWithinTimespanMs(keyDownStart, KEY_DEBOUNCE_MS)) {
+                if ((now - keyDownStart) > KEY_DEBOUNCE_MS) {
                     *keyValue = keyInProcess;
                     *keyLongPressed = false;
                 }
@@ -100,7 +101,7 @@ void ExpressLRSFiveWay::update(int *keyValue, bool *keyLongPressed)
         }
         // else still pressing, waiting for long if not already signaled
         else if (!isLongPressed) {
-            if (!Throttle::isWithinTimespanMs(keyDownStart, KEY_LONG_PRESS_MS)) {
+            if ((now - keyDownStart) > KEY_LONG_PRESS_MS) {
                 *keyValue = keyInProcess;
                 *keyLongPressed = true;
                 isLongPressed = true;

src/input/InputBroker.h

@@ -11,7 +11,6 @@
 #define INPUT_BROKER_MSG_GPS_TOGGLE 0x9e
 #define INPUT_BROKER_MSG_MUTE_TOGGLE 0xac
 #define INPUT_BROKER_MSG_SEND_PING 0xaf
-#define INPUT_BROKER_MSG_DISMISS_FRAME 0x8b
 #define INPUT_BROKER_MSG_LEFT 0xb4
 #define INPUT_BROKER_MSG_UP 0xb5
 #define INPUT_BROKER_MSG_DOWN 0xb6

src/input/ScanAndSelect.cpp

@@ -6,7 +6,6 @@
 
 #include "ScanAndSelect.h"
 #include "modules/CannedMessageModule.h"
-#include <Throttle.h>
 
 // Config
 static const char name[] = "scanAndSelect"; // should match "allow input source" string
@@ -76,7 +75,7 @@ int32_t ScanAndSelectInput::runOnce()
         else {
             // Duration enough for long press
             // Long press not yet fired (prevent repeat firing while held)
-            if (!longPressFired && Throttle::isWithinTimespanMs(downSinceMs, durationLongMs)) {
+            if (!longPressFired && now - downSinceMs > durationLongMs) {
                 longPressFired = true;
                 longPress();
             }
@@ -92,7 +91,7 @@ int32_t ScanAndSelectInput::runOnce()
         // Long press event didn't already fire
         if (held && !longPressFired) {
             // Duration enough for short press
-            if (!Throttle::isWithinTimespanMs(downSinceMs, durationShortMs)) {
+            if (now - downSinceMs > durationShortMs) {
                 shortPress();
             }
         }

src/input/SerialKeyboard.cpp

@@ -1,6 +1,5 @@
 #include "SerialKeyboard.h"
 #include "configuration.h"
-#include <Throttle.h>
 
 #ifdef INPUTBROKER_SERIAL_TYPE
 #define CANNED_MESSAGE_MODULE_ENABLE 1 // in case it's not set in the variant file
@@ -74,7 +73,7 @@ int32_t SerialKeyboard::runOnce()
         // Serial.print ("X");
         // Serial.println (shiftRegister2, BIN);
 
-        if (!Throttle::isWithinTimespanMs(lastPressTime, 500)) {
+        if (millis() - lastPressTime > 500) {
             quickPress = 0;
         }
 

src/input/cardKbI2cImpl.cpp

@@ -9,14 +9,14 @@ CardKbI2cImpl::CardKbI2cImpl() : KbI2cBase("cardKB") {}
 
 void CardKbI2cImpl::init()
 {
-#if !MESHTASTIC_EXCLUDE_I2C && !defined(ARCH_PORTDUINO)
+#ifndef ARCH_PORTDUINO
     if (cardkb_found.address == 0x00) {
         LOG_DEBUG("Rescanning for I2C keyboard\n");
         uint8_t i2caddr_scan[] = {CARDKB_ADDR, TDECK_KB_ADDR, BBQ10_KB_ADDR};
         uint8_t i2caddr_asize = 3;
         auto i2cScanner = std::unique_ptr<ScanI2CTwoWire>(new ScanI2CTwoWire());
 
-#if WIRE_INTERFACES_COUNT == 2
+#if defined(I2C_SDA1)
         i2cScanner->scanPort(ScanI2C::I2CPort::WIRE1, i2caddr_scan, i2caddr_asize);
 #endif
         i2cScanner->scanPort(ScanI2C::I2CPort::WIRE, i2caddr_scan, i2caddr_asize);
@@ -57,4 +57,4 @@ void CardKbI2cImpl::init()
     }
 #endif
     inputBroker->registerSource(this);
-}
+}

src/input/kbI2cBase.cpp

@@ -33,7 +33,7 @@ int32_t KbI2cBase::runOnce()
     if (!i2cBus) {
         switch (cardkb_found.port) {
         case ScanI2C::WIRE1:
-#if WIRE_INTERFACES_COUNT == 2
+#ifdef I2C_SDA1
             LOG_DEBUG("Using I2C Bus 1 (the second one)\n");
             i2cBus = &Wire1;
             if (cardkb_found.address == BBQ10_KB_ADDR) {
@@ -296,7 +296,6 @@ int32_t KbI2cBase::runOnce()
             case 0xac: // fn+m      INPUT_BROKER_MSG_MUTE_TOGGLE
             case 0x9e: // fn+g      INPUT_BROKER_MSG_GPS_TOGGLE
             case 0xaf: // fn+space  INPUT_BROKER_MSG_SEND_PING
-            case 0x8b: // fn+del    INPUT_BROKEN_MSG_DISMISS_FRAME
                 // just pass those unmodified
                 e.inputEvent = ANYKEY;
                 e.kbchar = c;

src/main.cpp

@@ -11,16 +11,16 @@
 #include "airtime.h"
 #include "buzz.h"
 
+#include "error.h"
+#include "power.h"
+// #include "debug.h"
 #include "FSCommon.h"
 #include "Led.h"
 #include "RTC.h"
 #include "SPILock.h"
-#include "Throttle.h"
 #include "concurrency/OSThread.h"
 #include "concurrency/Periodic.h"
 #include "detect/ScanI2C.h"
-#include "error.h"
-#include "power.h"
 
 #if !MESHTASTIC_EXCLUDE_I2C
 #include "detect/ScanI2CTwoWire.h"
@@ -32,13 +32,13 @@
 #include "graphics/Screen.h"
 #include "main.h"
 #include "mesh/generated/meshtastic/config.pb.h"
-#include "meshUtils.h"
 #include "modules/Modules.h"
 #include "shutdown.h"
 #include "sleep.h"
 #include "target_specific.h"
 #include <memory>
 #include <utility>
+// #include <driver/rtc_io.h>
 
 #ifdef ARCH_ESP32
 #if !MESHTASTIC_EXCLUDE_WEBSERVER
@@ -72,7 +72,6 @@ NRF52Bluetooth *nrf52Bluetooth = nullptr;
 #include "LLCC68Interface.h"
 #include "LR1110Interface.h"
 #include "LR1120Interface.h"
-#include "LR1121Interface.h"
 #include "RF95Interface.h"
 #include "SX1262Interface.h"
 #include "SX1268Interface.h"
@@ -103,8 +102,8 @@ NRF52Bluetooth *nrf52Bluetooth = nullptr;
 #include "AmbientLightingThread.h"
 #include "PowerFSMThread.h"
 
-#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C
-#include "motion/AccelerometerThread.h"
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+#include "AccelerometerThread.h"
 AccelerometerThread *accelerometerThread = nullptr;
 #endif
 
@@ -323,19 +322,15 @@ void setup()
 #ifdef BUTTON_PIN
 #ifdef ARCH_ESP32
 
-#if ESP_ARDUINO_VERSION_MAJOR >= 3
-#ifdef BUTTON_NEED_PULLUP
-    pinMode(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN, INPUT_PULLUP);
-#else
-    pinMode(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN, INPUT); // default to BUTTON_PIN
-#endif
-#else
-    pinMode(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN, INPUT); // default to BUTTON_PIN
+    // If the button is connected to GPIO 12, don't enable the ability to use
+    // meshtasticAdmin on the device.
+    pinMode(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN, INPUT);
+
 #ifdef BUTTON_NEED_PULLUP
     gpio_pullup_en((gpio_num_t)(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN));
     delay(10);
 #endif
-#endif
+
 #endif
 #endif
 
@@ -365,8 +360,6 @@ void setup()
     Wire1.begin();
 #elif defined(I2C_SDA1) && !defined(ARCH_RP2040)
     Wire1.begin(I2C_SDA1, I2C_SCL1);
-#elif WIRE_INTERFACES_COUNT == 2
-    Wire1.begin();
 #endif
 
 #if defined(I2C_SDA) && defined(ARCH_RP2040)
@@ -397,7 +390,7 @@ void setup()
 #endif
 
 #ifdef AQ_SET_PIN
-    // RAK-12039 set pin for Air quality sensor. Detectable on I2C after ~3 seconds, so we need to rescan later
+    // RAK-12039 set pin for Air quality sensor
     pinMode(AQ_SET_PIN, OUTPUT);
     digitalWrite(AQ_SET_PIN, HIGH);
 #endif
@@ -434,8 +427,6 @@ void setup()
 #elif defined(I2C_SDA1) && !defined(ARCH_RP2040)
     Wire1.begin(I2C_SDA1, I2C_SCL1);
     i2cScanner->scanPort(ScanI2C::I2CPort::WIRE1);
-#elif defined(NRF52840_XXAA) && (WIRE_INTERFACES_COUNT == 2)
-    i2cScanner->scanPort(ScanI2C::I2CPort::WIRE1);
 #endif
 
 #if defined(I2C_SDA) && defined(ARCH_RP2040)
@@ -561,7 +552,6 @@ void setup()
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::INA260, meshtastic_TelemetrySensorType_INA260)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::INA219, meshtastic_TelemetrySensorType_INA219)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::INA3221, meshtastic_TelemetrySensorType_INA3221)
-    SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::MAX17048, meshtastic_TelemetrySensorType_MAX17048)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::MCP9808, meshtastic_TelemetrySensorType_MCP9808)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::MCP9808, meshtastic_TelemetrySensorType_MCP9808)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::SHT31, meshtastic_TelemetrySensorType_SHT31)
@@ -570,7 +560,6 @@ void setup()
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::QMC6310, meshtastic_TelemetrySensorType_QMC6310)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::QMI8658, meshtastic_TelemetrySensorType_QMI8658)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::QMC5883L, meshtastic_TelemetrySensorType_QMC5883L)
-    SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::HMC5883L, meshtastic_TelemetrySensorType_QMC5883L)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::PMSA0031, meshtastic_TelemetrySensorType_PMSA003I)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::RCWL9620, meshtastic_TelemetrySensorType_RCWL9620)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::VEML7700, meshtastic_TelemetrySensorType_VEML7700)
@@ -580,7 +569,7 @@ void setup()
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::SHT4X, meshtastic_TelemetrySensorType_SHT4X)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::AHT10, meshtastic_TelemetrySensorType_AHT10)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::DFROBOT_LARK, meshtastic_TelemetrySensorType_DFROBOT_LARK)
-    SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::ICM20948, meshtastic_TelemetrySensorType_ICM20948)
+    SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::CUSTOM_SENSOR, meshtastic_TelemetrySensorType_CUSTOM_SENSOR)
 
     i2cScanner.reset();
 #endif
@@ -598,9 +587,6 @@ void setup()
 
     // Hello
     printInfo();
-#ifdef BUILD_EPOCH
-    LOG_INFO("Build timestamp: %ld\n", BUILD_EPOCH);
-#endif
 
 #ifdef ARCH_ESP32
     esp32Setup();
@@ -632,13 +618,7 @@ void setup()
     buttonThread = new ButtonThread();
 #endif
 
-    // only play start melody when role is not tracker or sensor
-    if (config.power.is_power_saving == true &&
-        IS_ONE_OF(config.device.role, meshtastic_Config_DeviceConfig_Role_TRACKER,
-                  meshtastic_Config_DeviceConfig_Role_TAK_TRACKER, meshtastic_Config_DeviceConfig_Role_SENSOR))
-        LOG_DEBUG("Tracker/Sensor: Skipping start melody\n");
-    else
-        playStartMelody();
+    playStartMelody();
 
     // fixed screen override?
     if (config.display.oled != meshtastic_Config_DisplayConfig_OledType_OLED_AUTO)
@@ -654,7 +634,7 @@ void setup()
 #endif
 
 #if !MESHTASTIC_EXCLUDE_I2C
-#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
     if (acc_info.type != ScanI2C::DeviceType::NONE) {
         accelerometerThread = new AccelerometerThread(acc_info.type);
     }
@@ -766,8 +746,8 @@ void setup()
 #if !MESHTASTIC_EXCLUDE_I2C
 // Don't call screen setup until after nodedb is setup (because we need
 // the current region name)
-#if defined(ST7701_CS) || defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) ||            \
-    defined(HX8357_CS) || defined(USE_ST7789)
+#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS) ||            \
+    defined(USE_ST7789)
     screen->setup();
 #elif defined(ARCH_PORTDUINO)
     if (screen_found.port != ScanI2C::I2CPort::NO_I2C || settingsMap[displayPanel]) {
@@ -781,6 +761,12 @@ void setup()
 
     screen->print("Started...\n");
 
+#ifdef SX126X_ANT_SW
+    // make analog PA vs not PA switch on SX126x eval board work properly
+    pinMode(SX126X_ANT_SW, OUTPUT);
+    digitalWrite(SX126X_ANT_SW, 1);
+#endif
+
 #ifdef PIN_PWR_DELAY_MS
     // This may be required to give the peripherals time to power up.
     delay(PIN_PWR_DELAY_MS);
@@ -886,7 +872,7 @@ void setup()
 #endif
 
 #if defined(RF95_IRQ)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+    if (!rIf) {
         rIf = new RF95Interface(RadioLibHAL, LORA_CS, RF95_IRQ, RF95_RESET, RF95_DIO1);
         if (!rIf->init()) {
             LOG_WARN("Failed to find RF95 radio\n");
@@ -900,7 +886,7 @@ void setup()
 #endif
 
 #if defined(USE_SX1262) && !defined(ARCH_PORTDUINO) && !defined(TCXO_OPTIONAL)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+    if (!rIf) {
         rIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
         if (!rIf->init()) {
             LOG_WARN("Failed to find SX1262 radio\n");
@@ -914,7 +900,7 @@ void setup()
 #endif
 
 #if defined(USE_SX1262) && !defined(ARCH_PORTDUINO) && defined(TCXO_OPTIONAL)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+    if (!rIf) {
         // Try using the specified TCXO voltage
         rIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
         if (!rIf->init()) {
@@ -930,7 +916,7 @@ void setup()
         }
     }
 
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+    if (!rIf) {
         // If specified TCXO voltage fails, attempt to use DIO3 as a reference instea
         rIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
         if (!rIf->init()) {
@@ -948,7 +934,7 @@ void setup()
 #endif
 
 #if defined(USE_SX1268)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+    if (!rIf) {
         rIf = new SX1268Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
         if (!rIf->init()) {
             LOG_WARN("Failed to find SX1268 radio\n");
@@ -962,7 +948,7 @@ void setup()
 #endif
 
 #if defined(USE_LLCC68)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+    if (!rIf) {
         rIf = new LLCC68Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
         if (!rIf->init()) {
             LOG_WARN("Failed to find LLCC68 radio\n");
@@ -976,43 +962,27 @@ void setup()
 #endif
 
 #if defined(USE_LR1110)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        rIf = new LR1110Interface(RadioLibHAL, LR1110_SPI_NSS_PIN, LR1110_IRQ_PIN, LR1110_NRESET_PIN, LR1110_BUSY_PIN);
+    if (!rIf) {
+        rIf = new LR1110Interface(RadioLibHAL, LR1110_SPI_NSS_PIN, LR1110_IRQ_PIN, LR1110_NRESER_PIN, LR1110_BUSY_PIN);
         if (!rIf->init()) {
             LOG_WARN("Failed to find LR1110 radio\n");
             delete rIf;
             rIf = NULL;
         } else {
             LOG_INFO("LR1110 Radio init succeeded, using LR1110 radio\n");
-            radioType = LR1110_RADIO;
         }
     }
 #endif
 
 #if defined(USE_LR1120)
     if (!rIf) {
-        rIf = new LR1120Interface(RadioLibHAL, LR1120_SPI_NSS_PIN, LR1120_IRQ_PIN, LR1120_NRESET_PIN, LR1120_BUSY_PIN);
+        rIf = new LR1120Interface(RadioLibHAL, LR1120_SPI_NSS_PIN, LR1120_IRQ_PIN, LR1120_NRESER_PIN, LR1120_BUSY_PIN);
         if (!rIf->init()) {
             LOG_WARN("Failed to find LR1120 radio\n");
             delete rIf;
             rIf = NULL;
         } else {
             LOG_INFO("LR1120 Radio init succeeded, using LR1120 radio\n");
-            radioType = LR1120_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_LR1121)
-    if (!rIf) {
-        rIf = new LR1121Interface(RadioLibHAL, LR1121_SPI_NSS_PIN, LR1121_IRQ_PIN, LR1121_NRESET_PIN, LR1121_BUSY_PIN);
-        if (!rIf->init()) {
-            LOG_WARN("Failed to find LR1121 radio\n");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("LR1121 Radio init succeeded, using LR1121 radio\n");
-            radioType = LR1121_RADIO;
         }
     }
 #endif
@@ -1124,9 +1094,6 @@ extern meshtastic_DeviceMetadata getDeviceMetadata()
     deviceMetadata.position_flags = config.position.position_flags;
     deviceMetadata.hw_model = HW_VENDOR;
     deviceMetadata.hasRemoteHardware = moduleConfig.remote_hardware.enabled;
-#if !(MESHTASTIC_EXCLUDE_PKI)
-    deviceMetadata.hasPKC = true;
-#endif
     return deviceMetadata;
 }
 #ifndef PIO_UNIT_TESTING
@@ -1134,6 +1101,10 @@ void loop()
 {
     runASAP = false;
 
+    // axpDebugOutput.loop();
+
+    // heap_caps_check_integrity_all(true); // FIXME - disable this expensive check
+
 #ifdef ARCH_ESP32
     esp32Loop();
 #endif
@@ -1142,21 +1113,33 @@ void loop()
 #endif
     powerCommandsCheck();
 
+    // For debugging
+    // if (rIf) ((RadioLibInterface *)rIf)->isActivelyReceiving();
+
 #ifdef DEBUG_STACK
     static uint32_t lastPrint = 0;
-    if (!Throttle::isWithinTimespanMs(lastPrint, 10 * 1000L)) {
+    if (millis() - lastPrint > 10 * 1000L) {
         lastPrint = millis();
         meshtastic::printThreadInfo("main");
     }
 #endif
 
+    // TODO: This should go into a thread handled by FreeRTOS.
+    // handleWebResponse();
+
     service->loop();
 
     long delayMsec = mainController.runOrDelay();
 
+    /* if (mainController.nextThread && delayMsec)
+        LOG_DEBUG("Next %s in %ld\n", mainController.nextThread->ThreadName.c_str(),
+                  mainController.nextThread->tillRun(millis())); */
+
     // We want to sleep as long as possible here - because it saves power
     if (!runASAP && loopCanSleep()) {
+        // if(delayMsec > 100) LOG_DEBUG("sleeping %ld\n", delayMsec);
         mainDelay.delay(delayMsec);
     }
+    // if (didWake) LOG_DEBUG("wake!\n");
 }
 #endif

src/main.h

@@ -56,8 +56,8 @@ extern AudioThread *audioThread;
 // Global Screen singleton.
 extern graphics::Screen *screen;
 
-#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C
-#include "motion/AccelerometerThread.h"
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+#include "AccelerometerThread.h"
 extern AccelerometerThread *accelerometerThread;
 #endif
 
@@ -86,4 +86,4 @@ void nrf52Setup(), esp32Setup(), nrf52Loop(), esp32Loop(), rp2040Setup(), clearB
 meshtastic_DeviceMetadata getDeviceMetadata();
 
 // We default to 4MHz SPI, SPI mode 0
-extern SPISettings spiSettings;
+extern SPISettings spiSettings;

src/memGet.cpp

@@ -57,8 +57,6 @@ uint32_t MemGet::getFreePsram()
 {
 #ifdef ARCH_ESP32
     return ESP.getFreePsram();
-#elif defined(ARCH_PORTDUINO)
-    return 4194252;
 #else
     return 0;
 #endif
@@ -73,8 +71,6 @@ uint32_t MemGet::getPsramSize()
 {
 #ifdef ARCH_ESP32
     return ESP.getPsramSize();
-#elif defined(ARCH_PORTDUINO)
-    return 4194252;
 #else
     return 0;
 #endif

src/mesh/CryptoEngine.cpp

@@ -70,9 +70,8 @@ bool CryptoEngine::encryptCurve25519(uint32_t toNode, uint32_t fromNode, uint64_
     long extraNonceTmp = random();
     auth = bytesOut + numBytes;
     extraNonce = (uint32_t *)(auth + 8);
-    memcpy(extraNonce, &extraNonceTmp,
-           4); // do not use dereference on potential non aligned pointers : *extraNonce = extraNonceTmp;
-    LOG_INFO("Random nonce value: %d\n", extraNonceTmp);
+    *extraNonce = extraNonceTmp;
+    LOG_INFO("Random nonce value: %d\n", *extraNonce);
     meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(toNode);
     if (node->num < 1 || node->user.public_key.size == 0) {
         LOG_DEBUG("Node %d or their public_key not found\n", toNode);
@@ -81,15 +80,14 @@ bool CryptoEngine::encryptCurve25519(uint32_t toNode, uint32_t fromNode, uint64_
     if (!crypto->setDHKey(toNode)) {
         return false;
     }
-    initNonce(fromNode, packetNum, extraNonceTmp);
+    initNonce(fromNode, packetNum, *extraNonce);
 
     // Calculate the shared secret with the destination node and encrypt
     printBytes("Attempting encrypt using nonce: ", nonce, 13);
-    printBytes("Attempting encrypt using shared_key starting with: ", shared_key, 8);
+    printBytes("Attempting encrypt using shared_key: ", shared_key, 32);
     aes_ccm_ae(shared_key, 32, nonce, 8, bytes, numBytes, nullptr, 0, bytesOut,
                auth); // this can write up to 15 bytes longer than numbytes past bytesOut
-    memcpy(extraNonce, &extraNonceTmp,
-           4); // do not use dereference on potential non aligned pointers : *extraNonce = extraNonceTmp;
+    *extraNonce = extraNonceTmp;
     return true;
 }
 
@@ -101,12 +99,11 @@ bool CryptoEngine::encryptCurve25519(uint32_t toNode, uint32_t fromNode, uint64_
  */
 bool CryptoEngine::decryptCurve25519(uint32_t fromNode, uint64_t packetNum, size_t numBytes, uint8_t *bytes, uint8_t *bytesOut)
 {
-    uint8_t *auth;       // set to last 8 bytes of text?
-    uint32_t extraNonce; // pointer was not really used
+    uint8_t *auth; // set to last 8 bytes of text?
+    uint32_t *extraNonce;
     auth = bytes + numBytes - 12;
-#ifndef PIO_UNIT_TESTING
-    memcpy(&extraNonce, auth + 8, 4); // do not use dereference on potential non aligned pointers : (uint32_t *)(auth + 8);
-    LOG_INFO("Random nonce value: %d\n", extraNonce);
+    extraNonce = (uint32_t *)(auth + 8);
+    LOG_INFO("Random nonce value: %d\n", *extraNonce);
     meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(fromNode);
 
     if (node == nullptr || node->num < 1 || node->user.public_key.size == 0) {
@@ -118,10 +115,9 @@ bool CryptoEngine::decryptCurve25519(uint32_t fromNode, uint64_t packetNum, size
     if (!crypto->setDHKey(fromNode)) {
         return false;
     }
-#endif
-    initNonce(fromNode, packetNum, extraNonce);
+    initNonce(fromNode, packetNum, *extraNonce);
     printBytes("Attempting decrypt using nonce: ", nonce, 13);
-    printBytes("Attempting decrypt using shared_key starting with: ", shared_key, 8);
+    printBytes("Attempting decrypt using shared_key: ", shared_key, 32);
     return aes_ccm_ad(shared_key, 32, nonce, 8, bytes, numBytes - 12, nullptr, 0, auth, bytesOut);
 }
 
@@ -141,12 +137,11 @@ bool CryptoEngine::setDHKey(uint32_t nodeNum)
         LOG_DEBUG("Node %d or their public_key not found\n", nodeNum);
         return false;
     }
-    printBytes("Generating DH with remote pubkey: ", node->user.public_key.bytes, 32);
-    printBytes("And local pubkey: ", config.security.public_key.bytes, 32);
+
     if (!setDHPublicKey(node->user.public_key.bytes))
         return false;
 
-    // printBytes("DH Output: ", shared_key, 32);
+    printBytes("DH Output: ", shared_key, 32);
 
     /**
      * D.J. Bernstein reccomends hashing the shared key. We want to do this because there are
@@ -171,12 +166,12 @@ bool CryptoEngine::setDHKey(uint32_t nodeNum)
 void CryptoEngine::hash(uint8_t *bytes, size_t numBytes)
 {
     SHA256 hash;
-    size_t posn;
+    size_t posn, len;
     uint8_t size = numBytes;
     uint8_t inc = 16;
     hash.reset();
     for (posn = 0; posn < size; posn += inc) {
-        size_t len = size - posn;
+        len = size - posn;
         if (len > inc)
             len = inc;
         hash.update(bytes + posn, len);

src/mesh/Default.h

@@ -3,8 +3,6 @@
 #include <cstdint>
 #define ONE_DAY 24 * 60 * 60
 #define ONE_MINUTE_MS 60 * 1000
-#define THIRTY_SECONDS_MS 30 * 1000
-#define FIVE_SECONDS_MS 5 * 1000
 
 #define default_gps_update_interval IF_ROUTER(ONE_DAY, 2 * 60)
 #define default_telemetry_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 30 * 60)

src/mesh/InterfacesTemplates.cpp

@@ -14,7 +14,6 @@ template class SX126xInterface<LLCC68>;
 template class SX128xInterface<SX1280>;
 template class LR11x0Interface<LR1110>;
 template class LR11x0Interface<LR1120>;
-template class LR11x0Interface<LR1121>;
 #ifdef ARCH_STM32WL
 template class SX126xInterface<STM32WLx>;
 #endif

src/mesh/LR1120Interface.cpp

@@ -6,9 +6,4 @@ LR1120Interface::LR1120Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, R
                                  RADIOLIB_PIN_TYPE busy)
     : LR11x0Interface(hal, cs, irq, rst, busy)
 {
-}
-
-bool LR1120Interface::wideLora()
-{
-    return true;
 }

src/mesh/LR1120Interface.h

@@ -10,5 +10,4 @@ class LR1120Interface : public LR11x0Interface<LR1120>
   public:
     LR1120Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
                     RADIOLIB_PIN_TYPE busy);
-    bool wideLora() override;
 };

src/mesh/LR1121Interface.cpp

@@ -1,14 +0,0 @@
-#include "LR1121Interface.h"
-#include "configuration.h"
-#include "error.h"
-
-LR1121Interface::LR1121Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
-                                 RADIOLIB_PIN_TYPE busy)
-    : LR11x0Interface(hal, cs, irq, rst, busy)
-{
-}
-
-bool LR1121Interface::wideLora()
-{
-    return true;
-}

src/mesh/LR1121Interface.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include "LR11x0Interface.h"
-
-/**
- * Our adapter for LR1121 wideband radios
- */
-class LR1121Interface : public LR11x0Interface<LR1121>
-{
-  public:
-    LR1121Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
-                    RADIOLIB_PIN_TYPE busy);
-    bool wideLora() override;
-};

src/mesh/LR11x0Interface.cpp

@@ -1,32 +1,15 @@
 #include "LR11x0Interface.h"
-#include "Throttle.h"
 #include "configuration.h"
 #include "error.h"
 #include "mesh/NodeDB.h"
-#ifdef LR11X0_DIO_AS_RF_SWITCH
-#include "rfswitch.h"
-#else
-static const uint32_t rfswitch_dio_pins[] = {RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC};
-static const Module::RfSwitchMode_t rfswitch_table[] = {
-    {LR11x0::MODE_STBY, {}},  {LR11x0::MODE_RX, {}},   {LR11x0::MODE_TX, {}},   {LR11x0::MODE_TX_HP, {}},
-    {LR11x0::MODE_TX_HF, {}}, {LR11x0::MODE_GNSS, {}}, {LR11x0::MODE_WIFI, {}}, END_OF_MODE_TABLE,
-};
-#endif
-
 #ifdef ARCH_PORTDUINO
 #include "PortduinoGlue.h"
 #endif
 
 // Particular boards might define a different max power based on what their hardware can do, default to max power output if not
 // specified (may be dangerous if using external PA and LR11x0 power config forgotten)
-#ifndef LR1110_MAX_POWER
-#define LR1110_MAX_POWER 22
-#endif
-
-// the 2.4G part maxes at 13dBm
-
-#ifndef LR1120_MAX_POWER
-#define LR1120_MAX_POWER 13
+#ifndef LR11X0_MAX_POWER
+#define LR11X0_MAX_POWER 22
 #endif
 
 template <typename T>
@@ -62,15 +45,59 @@ template <typename T> bool LR11x0Interface<T>::init()
 
     RadioLibInterface::init();
 
-    if (power > LR1110_MAX_POWER) // Clamp power to maximum defined level
-        power = LR1110_MAX_POWER;
-
-    if ((power > LR1120_MAX_POWER) &&
-        (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) // clamp again if wide freq range
-        power = LR1120_MAX_POWER;
+    if (power > LR11X0_MAX_POWER) // Clamp power to maximum defined level
+        power = LR11X0_MAX_POWER;
 
     limitPower();
 
+#ifdef TRACKER_T1000_E // Tracker T1000E uses DIO5, DIO6, DIO7, DIO8 for RF switching
+
+    static const uint32_t rfswitch_dio_pins[] = {RADIOLIB_LR11X0_DIO5, RADIOLIB_LR11X0_DIO6, RADIOLIB_LR11X0_DIO7,
+                                                 RADIOLIB_LR11X0_DIO8, RADIOLIB_NC};
+
+    static const Module::RfSwitchMode_t rfswitch_table[] = {
+        // mode             DIO5  DIO6  DIO7  DIO8
+        {LR11x0::MODE_STBY, {LOW, LOW, LOW, LOW}},  {LR11x0::MODE_RX, {HIGH, LOW, LOW, HIGH}},
+        {LR11x0::MODE_TX, {HIGH, HIGH, LOW, HIGH}}, {LR11x0::MODE_TX_HP, {LOW, HIGH, LOW, HIGH}},
+        {LR11x0::MODE_TX_HF, {LOW, LOW, LOW, LOW}}, {LR11x0::MODE_GNSS, {LOW, LOW, HIGH, LOW}},
+        {LR11x0::MODE_WIFI, {LOW, LOW, LOW, LOW}},  END_OF_MODE_TABLE,
+    };
+
+#else
+
+    // set RF switch configuration for Wio WM1110
+    // Wio WM1110 uses DIO5 and DIO6 for RF switching
+
+    static const uint32_t rfswitch_dio_pins[] = {RADIOLIB_LR11X0_DIO5, RADIOLIB_LR11X0_DIO6, RADIOLIB_NC, RADIOLIB_NC,
+                                                 RADIOLIB_NC};
+
+    static const Module::RfSwitchMode_t rfswitch_table[] = {
+        // mode                  DIO5  DIO6
+        {LR11x0::MODE_STBY, {LOW, LOW}},  {LR11x0::MODE_RX, {HIGH, LOW}},
+        {LR11x0::MODE_TX, {HIGH, HIGH}},  {LR11x0::MODE_TX_HP, {LOW, HIGH}},
+        {LR11x0::MODE_TX_HF, {LOW, LOW}}, {LR11x0::MODE_GNSS, {LOW, LOW}},
+        {LR11x0::MODE_WIFI, {LOW, LOW}},  END_OF_MODE_TABLE,
+    };
+
+#endif
+
+// We need to do this before begin() call
+#ifdef LR11X0_DIO_AS_RF_SWITCH
+    LOG_DEBUG("Setting DIO RF switch\n");
+    bool dioAsRfSwitch = true;
+#elif defined(ARCH_PORTDUINO)
+    bool dioAsRfSwitch = false;
+    if (settingsMap[dio2_as_rf_switch]) {
+        LOG_DEBUG("Setting DIO RF switch\n");
+        dioAsRfSwitch = true;
+    }
+#else
+    bool dioAsRfSwitch = false;
+#endif
+
+    if (dioAsRfSwitch)
+        lora.setRfSwitchTable(rfswitch_dio_pins, rfswitch_table);
+
     int res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage);
     // \todo Display actual typename of the adapter, not just `LR11x0`
     LOG_INFO("LR11x0 init result %d\n", res);
@@ -94,23 +121,6 @@ template <typename T> bool LR11x0Interface<T>::init()
     // FIXME: May want to set depending on a definition, currently all LR1110 variant files use the DC-DC regulator option
     if (res == RADIOLIB_ERR_NONE)
         res = lora.setRegulatorDCDC();
-
-#ifdef LR11X0_DIO_AS_RF_SWITCH
-    bool dioAsRfSwitch = true;
-#elif defined(ARCH_PORTDUINO)
-    bool dioAsRfSwitch = false;
-    if (settingsMap[dio2_as_rf_switch]) {
-        dioAsRfSwitch = true;
-    }
-#else
-    bool dioAsRfSwitch = false;
-#endif
-
-    if (dioAsRfSwitch) {
-        lora.setRfSwitchTable(rfswitch_dio_pins, rfswitch_table);
-        LOG_DEBUG("Setting DIO RF switch\n", res);
-    }
-
     if (res == RADIOLIB_ERR_NONE) {
         if (config.lora.sx126x_rx_boosted_gain) { // the name is unfortunate but historically accurate
             res = lora.setRxBoostedGainMode(true);
@@ -162,10 +172,8 @@ template <typename T> bool LR11x0Interface<T>::reconfigure()
     if (err != RADIOLIB_ERR_NONE)
         RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
 
-    if (power > LR1110_MAX_POWER) // This chip has lower power limits than some
-        power = LR1110_MAX_POWER;
-    if ((power > LR1120_MAX_POWER) && (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) // 2.4G power limit
-        power = LR1120_MAX_POWER;
+    if (power > LR11X0_MAX_POWER) // This chip has lower power limits than some
+        power = LR11X0_MAX_POWER;
 
     err = lora.setOutputPower(power);
     assert(err == RADIOLIB_ERR_NONE);
@@ -262,8 +270,29 @@ template <typename T> bool LR11x0Interface<T>::isActivelyReceiving()
 {
     // The IRQ status will be cleared when we start our read operation. Check if we've started a header, but haven't yet
     // received and handled the interrupt for reading the packet/handling errors.
-    return receiveDetected(lora.getIrqStatus(), RADIOLIB_LR11X0_IRQ_SYNC_WORD_HEADER_VALID,
-                           RADIOLIB_LR11X0_IRQ_PREAMBLE_DETECTED);
+
+    uint16_t irq = lora.getIrqStatus();
+    bool detected = (irq & (RADIOLIB_LR11X0_IRQ_SYNC_WORD_HEADER_VALID | RADIOLIB_LR11X0_IRQ_PREAMBLE_DETECTED));
+    // Handle false detections
+    if (detected) {
+        uint32_t now = millis();
+        if (!activeReceiveStart) {
+            activeReceiveStart = now;
+        } else if ((now - activeReceiveStart > 2 * preambleTimeMsec) && !(irq & RADIOLIB_LR11X0_IRQ_SYNC_WORD_HEADER_VALID)) {
+            // The HEADER_VALID flag should be set by now if it was really a packet, so ignore PREAMBLE_DETECTED flag
+            activeReceiveStart = 0;
+            LOG_DEBUG("Ignore false preamble detection.\n");
+            return false;
+        } else if (now - activeReceiveStart > maxPacketTimeMsec) {
+            // We should have gotten an RX_DONE IRQ by now if it was really a packet, so ignore HEADER_VALID flag
+            activeReceiveStart = 0;
+            LOG_DEBUG("Ignore false header detection.\n");
+            return false;
+        }
+    }
+
+    // if (detected) LOG_DEBUG("rx detected\n");
+    return detected;
 }
 
 template <typename T> bool LR11x0Interface<T>::sleep()

src/mesh/LR11x0Interface.h

@@ -65,4 +65,7 @@ template <class T> class LR11x0Interface : public RadioLibInterface
     virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) override;
 
     virtual void setStandby() override;
+
+  private:
+    uint32_t activeReceiveStart = 0;
 };

src/mesh/MeshModule.h

@@ -79,8 +79,7 @@ class MeshModule
                                                                     meshtastic_AdminMessage *response);
 #if HAS_SCREEN
     virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) { return; }
-    virtual bool isRequestingFocus();                          // Checked by screen, when regenerating frameset
-    virtual bool interceptingKeyboardInput() { return false; } // Can screen use keyboard for nav, or is module handling input?
+    virtual bool isRequestingFocus(); // Checked by screen, when regenerating frameset
 #endif
   protected:
     const char *name;

src/mesh/MeshService.h

@@ -13,9 +13,9 @@
 #if defined(ARCH_PORTDUINO) && !HAS_RADIO
 #include "../platform/portduino/SimRadio.h"
 #endif
-#if defined(ARCH_ESP32) || defined(ARCH_PORTDUINO)
+#ifdef ARCH_ESP32
 #if !MESHTASTIC_EXCLUDE_STOREFORWARD
-#include "modules/StoreForwardModule.h"
+#include "modules/esp32/StoreForwardModule.h"
 #endif
 #endif
 
@@ -92,9 +92,6 @@ class MeshService
     /// Return the next MqttClientProxyMessage packet destined to the phone.
     meshtastic_MqttClientProxyMessage *getMqttClientProxyMessageForPhone() { return toPhoneMqttProxyQueue.dequeuePtr(0); }
 
-    /// Return the next ClientNotification packet destined to the phone.
-    meshtastic_ClientNotification *getClientNotificationForPhone() { return toPhoneClientNotificationQueue.dequeuePtr(0); }
-
     // search the queue for a request id and return the matching nodenum
     NodeNum getNodenumFromRequestId(uint32_t request_id);
 

src/mesh/NodeDB.cpp

@@ -32,13 +32,12 @@
 #if HAS_WIFI
 #include "mesh/wifi/WiFiAPClient.h"
 #endif
-#include "modules/StoreForwardModule.h"
+#include "modules/esp32/StoreForwardModule.h"
 #include <Preferences.h>
 #include <nvs_flash.h>
 #endif
 
 #ifdef ARCH_PORTDUINO
-#include "modules/StoreForwardModule.h"
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 
@@ -50,7 +49,7 @@
 NodeDB *nodeDB = nullptr;
 
 // we have plenty of ram so statically alloc this tempbuf (for now)
-EXT_RAM_BSS_ATTR meshtastic_DeviceState devicestate;
+EXT_RAM_ATTR meshtastic_DeviceState devicestate;
 meshtastic_MyNodeInfo &myNodeInfo = devicestate.my_node;
 meshtastic_LocalConfig config;
 meshtastic_LocalModuleConfig moduleConfig;
@@ -122,8 +121,6 @@ NodeDB::NodeDB()
     owner.hw_model = HW_VENDOR;
     // Ensure user (nodeinfo) role is set to whatever we're configured to
     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));
 
     // Include our owner in the node db under our nodenum
     meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
@@ -246,7 +243,7 @@ bool NodeDB::factoryReset(bool eraseBleBonds)
 #endif
     // second, install default state (this will deal with the duplicate mac address issue)
     installDefaultDeviceState();
-    installDefaultConfig(!eraseBleBonds); // Also preserve the private key if we're not erasing BLE bonds
+    installDefaultConfig();
     installDefaultModuleConfig();
     installDefaultChannels();
     // third, write everything to disk
@@ -269,13 +266,8 @@ bool NodeDB::factoryReset(bool eraseBleBonds)
     return true;
 }
 
-void NodeDB::installDefaultConfig(bool preserveKey = false)
+void NodeDB::installDefaultConfig()
 {
-    uint8_t private_key_temp[32];
-    bool shouldPreserveKey = preserveKey && config.has_security && config.security.private_key.size > 0;
-    if (shouldPreserveKey) {
-        memcpy(private_key_temp, config.security.private_key.bytes, config.security.private_key.size);
-    }
     LOG_INFO("Installing default LocalConfig\n");
     memset(&config, 0, sizeof(meshtastic_LocalConfig));
     config.version = DEVICESTATE_CUR_VER;
@@ -316,14 +308,8 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #else
     config.security.admin_key[0].size = 0;
 #endif
-    if (shouldPreserveKey) {
-        config.security.private_key.size = 32;
-        memcpy(config.security.private_key.bytes, private_key_temp, config.security.private_key.size);
-        printBytes("Restored key", config.security.private_key.bytes, config.security.private_key.size);
-    } else {
-        config.security.private_key.size = 0;
-    }
     config.security.public_key.size = 0;
+    config.security.private_key.size = 0;
 #ifdef PIN_GPS_EN
     config.position.gps_en_gpio = PIN_GPS_EN;
 #endif
@@ -473,7 +459,7 @@ void NodeDB::installDefaultModuleConfig()
 
     moduleConfig.has_detection_sensor = true;
     moduleConfig.detection_sensor.enabled = false;
-    moduleConfig.detection_sensor.detection_trigger_type = meshtastic_ModuleConfig_DetectionSensorConfig_TriggerType_LOGIC_HIGH;
+    moduleConfig.detection_sensor.detection_triggered_high = true;
     moduleConfig.detection_sensor.minimum_broadcast_secs = 45;
 
     moduleConfig.has_ambient_lighting = true;
@@ -655,13 +641,10 @@ void NodeDB::pickNewNodeNum()
     }
 
     meshtastic_NodeInfoLite *found;
-    while (((found = getMeshNode(nodeNum)) && memcmp(found->user.macaddr, ourMacAddr, sizeof(ourMacAddr)) != 0) ||
-           (nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED)) {
+    while ((nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED) ||
+           ((found = getMeshNode(nodeNum)) && memcmp(found->user.macaddr, ourMacAddr, sizeof(ourMacAddr)) != 0)) {
         NodeNum candidate = random(NUM_RESERVED, LONG_MAX); // try a new random choice
-        if (found)
-            LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, by MAC ending in 0x%02x%02x vs our 0x%02x%02x, so "
-                     "trying for 0x%x\n",
-                     nodeNum, found->user.macaddr[4], found->user.macaddr[5], ourMacAddr[4], ourMacAddr[5], candidate);
+        LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, so trying for 0x%x\n", nodeNum, candidate);
         nodeNum = candidate;
     }
     LOG_DEBUG("Using nodenum 0x%x \n", nodeNum);
@@ -727,7 +710,7 @@ void NodeDB::loadFromDisk()
     //} else {
     if (devicestate.version < DEVICESTATE_MIN_VER) {
         LOG_WARN("Devicestate %d is old, discarding\n", devicestate.version);
-        installDefaultDeviceState();
+        factoryReset();
     } else {
         LOG_INFO("Loaded saved devicestate version %d, with nodecount: %d\n", devicestate.version,
                  devicestate.node_db_lite.size());
@@ -743,7 +726,7 @@ void NodeDB::loadFromDisk()
     } else {
         if (config.version < DEVICESTATE_MIN_VER) {
             LOG_WARN("config %d is old, discarding\n", config.version);
-            installDefaultConfig(true);
+            installDefaultConfig();
         } else {
             LOG_INFO("Loaded saved config version %d\n", config.version);
         }
@@ -1056,7 +1039,7 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
     if (p.public_key.size > 0) {
         printBytes("Incoming Pubkey: ", p.public_key.bytes, 32);
         if (info->user.public_key.size > 0) { // if we have a key for this user already, don't overwrite with a new one
-            LOG_INFO("Public Key set for node, not updating!\n");
+            LOG_INFO("Public Key set for node, not updateing!\n");
             // we copy the key into the incoming packet, to prevent overwrite
             memcpy(p.public_key.bytes, info->user.public_key.bytes, 32);
         } else {
@@ -1114,10 +1097,8 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
         info->via_mqtt = mp.via_mqtt; // Store if we received this packet via MQTT
 
         // If hopStart was set and there wasn't someone messing with the limit in the middle, add hopsAway
-        if (mp.hop_start != 0 && mp.hop_limit <= mp.hop_start) {
-            info->has_hops_away = true;
+        if (mp.hop_start != 0 && mp.hop_limit <= mp.hop_start)
             info->hops_away = mp.hop_start - mp.hop_limit;
-        }
     }
 }
 
@@ -1213,4 +1194,4 @@ void recordCriticalError(meshtastic_CriticalErrorCode code, uint32_t address, co
     LOG_ERROR("A critical failure occurred, portduino is exiting...");
     exit(2);
 #endif
-}
+}

src/mesh/NodeDB.h

@@ -2,13 +2,11 @@
 
 #include "Observer.h"
 #include <Arduino.h>
-#include <algorithm>
 #include <assert.h>
 #include <vector>
 
 #include "MeshTypes.h"
 #include "NodeStatus.h"
-#include "configuration.h"
 #include "mesh-pb-constants.h"
 #include "mesh/generated/meshtastic/mesh.pb.h" // For CriticalErrorCode
 
@@ -184,8 +182,7 @@ class NodeDB
     void cleanupMeshDB();
 
     /// Reinit device state from scratch (not loading from disk)
-    void installDefaultDeviceState(), installDefaultChannels(), installDefaultConfig(bool preserveKey),
-        installDefaultModuleConfig();
+    void installDefaultDeviceState(), installDefaultChannels(), installDefaultConfig(), installDefaultModuleConfig();
 
     /// write to flash
     /// @return true if the save was successful

src/mesh/PacketHistory.cpp

@@ -5,7 +5,6 @@
 #ifdef ARCH_PORTDUINO
 #include "platform/portduino/PortduinoGlue.h"
 #endif
-#include "Throttle.h"
 
 PacketHistory::PacketHistory()
 {
@@ -23,17 +22,18 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
         return false; // Not a floodable message ID, so we don't care
     }
 
+    uint32_t now = millis();
+
     PacketRecord r;
     r.id = p->id;
     r.sender = getFrom(p);
-    r.rxTimeMsec = millis();
+    r.rxTimeMsec = now;
 
     auto found = recentPackets.find(r);
     bool seenRecently = (found != recentPackets.end()); // found not equal to .end() means packet was seen recently
 
-    if (seenRecently &&
-        !Throttle::isWithinTimespanMs(found->rxTimeMsec, FLOOD_EXPIRE_TIME)) { // Check whether found packet has already expired
-        recentPackets.erase(found); // Erase and pretend packet has not been seen recently
+    if (seenRecently && (now - found->rxTimeMsec) >= FLOOD_EXPIRE_TIME) { // Check whether found packet has already expired
+        recentPackets.erase(found);                                       // Erase and pretend packet has not been seen recently
         found = recentPackets.end();
         seenRecently = false;
     }
@@ -64,10 +64,12 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
  */
 void PacketHistory::clearExpiredRecentPackets()
 {
+    uint32_t now = millis();
+
     LOG_DEBUG("recentPackets size=%ld\n", recentPackets.size());
 
     for (auto it = recentPackets.begin(); it != recentPackets.end();) {
-        if (!Throttle::isWithinTimespanMs(it->rxTimeMsec, FLOOD_EXPIRE_TIME)) {
+        if ((now - it->rxTimeMsec) >= FLOOD_EXPIRE_TIME) {
             it = recentPackets.erase(it); // erase returns iterator pointing to element immediately following the one erased
         } else {
             ++it;

src/mesh/PhoneAPI.cpp

@@ -8,7 +8,6 @@
 #include "FSCommon.h"
 #include "MeshService.h"
 #include "NodeDB.h"
-#include "PacketHistory.h"
 #include "PhoneAPI.h"
 #include "PowerFSM.h"
 #include "RadioInterface.h"
@@ -26,13 +25,10 @@
 #if !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #endif
-#include "Throttle.h"
-#include <RTC.h>
 
 PhoneAPI::PhoneAPI()
 {
     lastContactMsec = millis();
-    std::fill(std::begin(recentToRadioPacketIds), std::end(recentToRadioPacketIds), 0);
 }
 
 PhoneAPI::~PhoneAPI()
@@ -64,11 +60,9 @@ void PhoneAPI::handleStartConfig()
 
 void PhoneAPI::close()
 {
-    LOG_INFO("PhoneAPI::close()\n");
-
     if (state != STATE_SEND_NOTHING) {
         state = STATE_SEND_NOTHING;
-        resetReadIndex();
+
         unobserve(&service->fromNumChanged);
 #ifdef FSCom
         unobserve(&xModem.packetReady);
@@ -76,17 +70,8 @@ void PhoneAPI::close()
         releasePhonePacket(); // Don't leak phone packets on shutdown
         releaseQueueStatusPhonePacket();
         releaseMqttClientProxyPhonePacket();
-        releaseClientNotification();
+
         onConnectionChanged(false);
-        fromRadioScratch = {};
-        toRadioScratch = {};
-        nodeInfoForPhone = {};
-        packetForPhone = NULL;
-        filesManifest.clear();
-        fromRadioNum = 0;
-        config_nonce = 0;
-        config_state = 0;
-        pauseBluetoothLogging = false;
     }
 }
 
@@ -111,6 +96,8 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
     powerFSM.trigger(EVENT_CONTACT_FROM_PHONE); // As long as the phone keeps talking to us, don't let the radio go to sleep
     lastContactMsec = millis();
 
+    // return (lastContactMsec != 0) &&
+
     memset(&toRadioScratch, 0, sizeof(toRadioScratch));
     if (pb_decode_from_bytes(buf, bufLength, &meshtastic_ToRadio_msg, &toRadioScratch)) {
         switch (toRadioScratch.which_payload_variant) {
@@ -207,7 +194,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
         auto us = nodeDB->readNextMeshNode(readIndex);
         if (us) {
             nodeInfoForPhone = TypeConversions::ConvertToNodeInfo(us);
-            nodeInfoForPhone.has_hops_away = false;
+            nodeInfoForPhone.hops_away = 0;
             nodeInfoForPhone.is_favorite = true;
             fromRadioScratch.which_payload_variant = meshtastic_FromRadio_node_info_tag;
             fromRadioScratch.node_info = nodeInfoForPhone;
@@ -416,10 +403,6 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
             fromRadioScratch.which_payload_variant = meshtastic_FromRadio_xmodemPacket_tag;
             fromRadioScratch.xmodemPacket = xmodemPacketForPhone;
             xmodemPacketForPhone = meshtastic_XModem_init_zero;
-        } else if (clientNotification) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_clientNotification_tag;
-            fromRadioScratch.clientNotification = *clientNotification;
-            releaseClientNotification();
         } else if (packetForPhone) {
             printPacket("phone downloaded packet", packetForPhone);
 
@@ -459,6 +442,13 @@ void PhoneAPI::sendConfigComplete()
     pauseBluetoothLogging = false;
 }
 
+void PhoneAPI::handleDisconnect()
+{
+    filesManifest.clear();
+    pauseBluetoothLogging = false;
+    LOG_INFO("PhoneAPI disconnect\n");
+}
+
 void PhoneAPI::releasePhonePacket()
 {
     if (packetForPhone) {
@@ -483,14 +473,6 @@ void PhoneAPI::releaseMqttClientProxyPhonePacket()
     }
 }
 
-void PhoneAPI::releaseClientNotification()
-{
-    if (clientNotification) {
-        service->releaseClientNotificationToPool(clientNotification);
-        clientNotification = NULL;
-    }
-}
-
 /**
  * Return true if we have data available to send to the phone
  */
@@ -525,9 +507,7 @@ bool PhoneAPI::available()
             queueStatusPacketForPhone = service->getQueueStatusForPhone();
         if (!mqttClientProxyMessageForPhone)
             mqttClientProxyMessageForPhone = service->getMqttClientProxyMessageForPhone();
-        if (!clientNotification)
-            clientNotification = service->getClientNotificationForPhone();
-        bool hasPacket = !!queueStatusPacketForPhone || !!mqttClientProxyMessageForPhone || !!clientNotification;
+        bool hasPacket = !!queueStatusPacketForPhone || !!mqttClientProxyMessageForPhone;
         if (hasPacket)
             return true;
 
@@ -561,60 +541,14 @@ bool PhoneAPI::available()
     return false;
 }
 
-void PhoneAPI::sendNotification(meshtastic_LogRecord_Level level, uint32_t replyId, const char *message)
-{
-    meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
-    cn->has_reply_id = true;
-    cn->reply_id = replyId;
-    cn->level = meshtastic_LogRecord_Level_WARNING;
-    cn->time = getValidTime(RTCQualityFromNet);
-    strncpy(cn->message, message, sizeof(cn->message));
-    service->sendClientNotification(cn);
-}
-
-bool PhoneAPI::wasSeenRecently(uint32_t id)
-{
-    for (int i = 0; i < 20; i++) {
-        if (recentToRadioPacketIds[i] == id) {
-            return true;
-        }
-        if (recentToRadioPacketIds[i] == 0) {
-            recentToRadioPacketIds[i] = id;
-            return false;
-        }
-    }
-    // If the array is full, shift all elements to the left and add the new id at the end
-    memmove(recentToRadioPacketIds, recentToRadioPacketIds + 1, (19) * sizeof(uint32_t));
-    recentToRadioPacketIds[19] = id;
-    return false;
-}
-
 /**
  * Handle a packet that the phone wants us to send.  It is our responsibility to free the packet to the pool
  */
 bool PhoneAPI::handleToRadioPacket(meshtastic_MeshPacket &p)
 {
     printPacket("PACKET FROM PHONE", &p);
-
-    if (p.id > 0 && wasSeenRecently(p.id)) {
-        LOG_DEBUG("Ignoring packet from phone, already seen recently\n");
-        return false;
-    }
-
-    if (p.decoded.portnum == meshtastic_PortNum_TRACEROUTE_APP && lastPortNumToRadio[p.decoded.portnum] &&
-        Throttle::isWithinTimespanMs(lastPortNumToRadio[p.decoded.portnum], THIRTY_SECONDS_MS)) {
-        LOG_WARN("Rate limiting portnum %d\n", p.decoded.portnum);
-        sendNotification(meshtastic_LogRecord_Level_WARNING, p.id, "TraceRoute can only be sent once every 30 seconds");
-        return false;
-    } else if (p.decoded.portnum == meshtastic_PortNum_POSITION_APP && lastPortNumToRadio[p.decoded.portnum] &&
-               Throttle::isWithinTimespanMs(lastPortNumToRadio[p.decoded.portnum], FIVE_SECONDS_MS)) {
-        LOG_WARN("Rate limiting portnum %d\n", p.decoded.portnum);
-        // FIXME: Figure out why this continues to happen
-        // sendNotification(meshtastic_LogRecord_Level_WARNING, p.id, "Position can only be sent once every 5 seconds");
-        return false;
-    }
-    lastPortNumToRadio[p.decoded.portnum] = millis();
     service->handleToRadio(p);
+
     return true;
 }
 

src/mesh/PhoneAPI.h

@@ -2,10 +2,8 @@
 
 #include "Observer.h"
 #include "mesh-pb-constants.h"
-#include "meshtastic/portnums.pb.h"
 #include <iterator>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 // Make sure that we never let our packets grow too large for one BLE packet
@@ -50,10 +48,6 @@ class PhoneAPI
 
     uint8_t config_state = 0;
 
-    // Hashmap of timestamps for last time we received a packet on the API per portnum
-    std::unordered_map<meshtastic_PortNum, uint32_t> lastPortNumToRadio;
-    uint32_t recentToRadioPacketIds[20]; // Last 20 ToRadio MeshPacket IDs we have seen
-
     /**
      * Each packet sent to the phone has an incrementing count
      */
@@ -105,11 +99,6 @@ class PhoneAPI
      */
     virtual bool handleToRadio(const uint8_t *buf, size_t len);
 
-    /**
-     * Send a (client)notification to the phone
-     */
-    virtual void sendNotification(meshtastic_LogRecord_Level level, uint32_t replyId, const char *message);
-
     /**
      * Get the next packet we want to send to the phone
      *
@@ -148,6 +137,11 @@ class PhoneAPI
      */
     virtual void onNowHasData(uint32_t fromRadioNum) {}
 
+    /**
+     * Subclasses can use this to find out when a client drops the link
+     */
+    virtual void handleDisconnect();
+
   private:
     void releasePhonePacket();
 
@@ -155,13 +149,9 @@ class PhoneAPI
 
     void releaseMqttClientProxyPhonePacket();
 
-    void releaseClientNotification();
-
     /// begin a new connection
     void handleStartConfig();
 
-    bool wasSeenRecently(uint32_t packetId);
-
     /**
      * Handle a packet that the phone wants us to send.  We can write to it but can not keep a reference to it
      * @return true true if a packet was queued for sending

src/mesh/ProtobufModule.h

@@ -108,7 +108,7 @@ template <class T> class ProtobufModule : protected SinglePortModule
         T *decoded = NULL;
         if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag && mp.decoded.portnum == ourPortNum) {
             memset(&scratch, 0, sizeof(scratch));
-            const meshtastic_Data &p = mp.decoded;
+            auto &p = mp.decoded;
             if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, fields, &scratch)) {
                 decoded = &scratch;
             } else {

src/mesh/RadioInterface.cpp

@@ -151,7 +151,7 @@ const RegionInfo regions[] = {
 const RegionInfo *myRegion;
 bool RadioInterface::uses_default_frequency_slot = true;
 
-static uint8_t bytes[MAX_LORA_PAYLOAD_LEN + 1];
+static uint8_t bytes[MAX_RHPACKETLEN];
 
 void initRegion()
 {
@@ -326,7 +326,7 @@ void printPacket(const char *prefix, const meshtastic_MeshPacket *p)
 
 RadioInterface::RadioInterface()
 {
-    assert(sizeof(PacketHeader) == MESHTASTIC_HEADER_LENGTH); // make sure the compiler did what we expected
+    assert(sizeof(PacketHeader) == 16); // make sure the compiler did what we expected
 }
 
 bool RadioInterface::reconfigure()

src/mesh/RadioInterface.h

@@ -9,9 +9,7 @@
 
 #define MAX_TX_QUEUE 16 // max number of packets which can be waiting for transmission
 
-#define MAX_LORA_PAYLOAD_LEN 255 // max length of 255 per Semtech's datasheets on SX12xx
-#define MESHTASTIC_HEADER_LENGTH 16
-#define MESHTASTIC_PKC_OVERHEAD 12
+#define MAX_RHPACKETLEN 256
 
 #define PACKET_FLAGS_HOP_LIMIT_MASK 0x07
 #define PACKET_FLAGS_WANT_ACK_MASK 0x08
@@ -91,7 +89,7 @@ class RadioInterface
     /**
      * A temporary buffer used for sending/receiving packets, sized to hold the biggest buffer we might need
      * */
-    uint8_t radiobuf[MAX_LORA_PAYLOAD_LEN + 1];
+    uint8_t radiobuf[MAX_RHPACKETLEN];
 
     /**
      * Enqueue a received packet for the registered receiver

src/mesh/RadioLibInterface.cpp

@@ -3,7 +3,6 @@
 #include "NodeDB.h"
 #include "PowerMon.h"
 #include "SPILock.h"
-#include "Throttle.h"
 #include "configuration.h"
 #include "error.h"
 #include "main.h"
@@ -42,7 +41,7 @@ void LockingArduinoHal::spiTransfer(uint8_t *out, size_t len, uint8_t *in)
 
             uint32_t start = millis();
             while (digitalRead(busy)) {
-                if (!Throttle::isWithinTimespanMs(start, 2000)) {
+                if (millis() - start >= 2000) {
                     LOG_ERROR("GPIO mid-transfer timeout, is it connected?");
                     return;
                 }
@@ -115,7 +114,7 @@ bool RadioLibInterface::canSendImmediately()
         }
         // If we've been trying to send the same packet more than one minute and we haven't gotten a
         // TX IRQ from the radio, the radio is probably broken.
-        if (busyTx && !Throttle::isWithinTimespanMs(lastTxStart, 60000)) {
+        if (busyTx && (millis() - lastTxStart > 60000)) {
             LOG_ERROR("Hardware Failure! busyTx for more than 60s\n");
             RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_TRANSMIT_FAILED);
             // reboot in 5 seconds when this condition occurs.
@@ -129,28 +128,6 @@ bool RadioLibInterface::canSendImmediately()
         return true;
 }
 
-bool RadioLibInterface::receiveDetected(uint16_t irq, ulong syncWordHeaderValidFlag, ulong preambleDetectedFlag)
-{
-    bool detected = (irq & (syncWordHeaderValidFlag | preambleDetectedFlag));
-    // Handle false detections
-    if (detected) {
-        if (!activeReceiveStart) {
-            activeReceiveStart = millis();
-        } else if (!Throttle::isWithinTimespanMs(activeReceiveStart, 2 * preambleTimeMsec) && !(irq & syncWordHeaderValidFlag)) {
-            // The HEADER_VALID flag should be set by now if it was really a packet, so ignore PREAMBLE_DETECTED flag
-            activeReceiveStart = 0;
-            LOG_DEBUG("Ignore false preamble detection.\n");
-            return false;
-        } else if (!Throttle::isWithinTimespanMs(activeReceiveStart, maxPacketTimeMsec)) {
-            // We should have gotten an RX_DONE IRQ by now if it was really a packet, so ignore HEADER_VALID flag
-            activeReceiveStart = 0;
-            LOG_DEBUG("Ignore false header detection.\n");
-            return false;
-        }
-    }
-    return detected;
-}
-
 /// Send a packet (possibly by enquing in a private fifo).  This routine will
 /// later free() the packet to pool.  This routine is not allowed to stall because it is called from
 /// bluetooth comms code.  If the txmit queue is empty it might return an error
@@ -167,7 +144,7 @@ ErrorCode RadioLibInterface::send(meshtastic_MeshPacket *p)
         }
 
     } else {
-        LOG_WARN("send - lora tx disabled because RegionCode_Unset\n");
+        LOG_WARN("send - lora tx disable because RegionCode_Unset\n");
         packetPool.release(p);
         return ERRNO_DISABLED;
     }
@@ -379,14 +356,6 @@ void RadioLibInterface::handleReceiveInterrupt()
 
     xmitMsec = getPacketTime(length);
 
-#ifndef DISABLE_WELCOME_UNSET
-    if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-        LOG_WARN("recv - lora rx disabled because RegionCode_Unset\n");
-        airTime->logAirtime(RX_ALL_LOG, xmitMsec);
-        return;
-    }
-#endif
-
     int state = iface->readData(radiobuf, length);
     if (state != RADIOLIB_ERR_NONE) {
         LOG_ERROR("ignoring received packet due to error=%d\n", state);

src/mesh/RadioLibInterface.h

@@ -167,10 +167,6 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     meshtastic_QueueStatus getQueueStatus();
 
   protected:
-    uint32_t activeReceiveStart = 0;
-
-    bool receiveDetected(uint16_t irq, ulong syncWordHeaderValidFlag, ulong preambleDetectedFlag);
-
     /** Do any hardware setup needed on entry into send configuration for the radio.
      * Subclasses can customize, but must also call this base method */
     virtual void configHardwareForSend();

src/mesh/Router.cpp

@@ -36,8 +36,8 @@ static MemoryDynamic<meshtastic_MeshPacket> staticPool;
 
 Allocator<meshtastic_MeshPacket> &packetPool = staticPool;
 
-static uint8_t bytes[MAX_LORA_PAYLOAD_LEN + 1] __attribute__ ((__aligned__));
-static uint8_t ScratchEncrypted[MAX_LORA_PAYLOAD_LEN + 1] __attribute__ ((__aligned__));
+static uint8_t bytes[MAX_RHPACKETLEN];
+static uint8_t ScratchEncrypted[MAX_RHPACKETLEN];
 
 /**
  * Constructor
@@ -185,12 +185,9 @@ ErrorCode Router::sendLocal(meshtastic_MeshPacket *p, RxSource src)
             handleReceived(p, src);
         }
 
-        if (!p->channel && !p->pki_encrypted) { // don't override if a channel was requested
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(p->to);
-            if (node && node->user.public_key.size == 0) {
-                p->channel = node->channel;
-                LOG_DEBUG("localSend to channel %d\n", p->channel);
-            }
+        if (!p->channel) { // don't override if a channel was requested
+            p->channel = nodeDB->getMeshNodeChannel(p->to);
+            LOG_DEBUG("localSend to channel %d\n", p->channel);
         }
 
         return send(p);
@@ -330,13 +327,13 @@ bool perhapsDecode(meshtastic_MeshPacket *p)
     // Attempt PKI decryption first
     if (p->channel == 0 && p->to == nodeDB->getNodeNum() && p->to > 0 && p->to != NODENUM_BROADCAST &&
         nodeDB->getMeshNode(p->from) != nullptr && nodeDB->getMeshNode(p->from)->user.public_key.size > 0 &&
-        nodeDB->getMeshNode(p->to)->user.public_key.size > 0 && rawSize > MESHTASTIC_PKC_OVERHEAD) {
+        nodeDB->getMeshNode(p->to)->user.public_key.size > 0 && rawSize > 12) {
         LOG_DEBUG("Attempting PKI decryption\n");
 
         if (crypto->decryptCurve25519(p->from, p->id, rawSize, ScratchEncrypted, bytes)) {
             LOG_INFO("PKI Decryption worked!\n");
             memset(&p->decoded, 0, sizeof(p->decoded));
-            rawSize -= MESHTASTIC_PKC_OVERHEAD;
+            rawSize -= 12;
             if (pb_decode_from_bytes(bytes, rawSize, &meshtastic_Data_msg, &p->decoded) &&
                 p->decoded.portnum != meshtastic_PortNum_UNKNOWN_APP) {
                 decrypted = true;
@@ -347,11 +344,8 @@ bool perhapsDecode(meshtastic_MeshPacket *p)
                 // memcpy(bytes, ScratchEncrypted, rawSize); // TODO: Rename the bytes buffers
                 // chIndex = 8;
             } else {
-                LOG_ERROR("PKC Decrypted, but pb_decode failed!\n");
                 return false;
             }
-        } else {
-            LOG_WARN("PKC decrypt attempted but failed!\n");
         }
     }
 #endif
@@ -475,7 +469,7 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
             }
         } */
 
-        if (numbytes + MESHTASTIC_HEADER_LENGTH > MAX_LORA_PAYLOAD_LEN)
+        if (numbytes > MAX_RHPACKETLEN)
             return meshtastic_Routing_Error_TOO_LARGE;
 
         // printBytes("plaintext", bytes, numbytes);
@@ -484,22 +478,12 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
 
 #if !(MESHTASTIC_EXCLUDE_PKI)
         meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(p->to);
-        // We may want to retool things so we can send a PKC packet when the client specifies a key and nodenum, even if the node
-        // is not in the local nodedb
-        if (
-            // Don't use PKC with Ham mode
-            !owner.is_licensed &&
-            // Don't use PKC if it's not explicitly requested and a non-primary channel is requested
-            !(p->pki_encrypted != true && p->channel > 0) &&
-            // Check for valid keys and single node destination
-            config.security.private_key.size == 32 && p->to != NODENUM_BROADCAST && node != nullptr &&
-            // Check for a known public key for the destination
-            (node->user.public_key.size == 32) &&
-            // Some portnums either make no sense to send with PKC
-            p->decoded.portnum != meshtastic_PortNum_TRACEROUTE_APP && p->decoded.portnum != meshtastic_PortNum_NODEINFO_APP &&
-            p->decoded.portnum != meshtastic_PortNum_ROUTING_APP && p->decoded.portnum != meshtastic_PortNum_POSITION_APP) {
+        if (!owner.is_licensed && config.security.private_key.size == 32 && p->to != NODENUM_BROADCAST && node != nullptr &&
+            node->user.public_key.size > 0 && p->decoded.portnum != meshtastic_PortNum_TRACEROUTE_APP &&
+            p->decoded.portnum != meshtastic_PortNum_NODEINFO_APP && p->decoded.portnum != meshtastic_PortNum_ROUTING_APP &&
+            p->decoded.portnum != meshtastic_PortNum_POSITION_APP) {
             LOG_DEBUG("Using PKI!\n");
-            if (numbytes + MESHTASTIC_HEADER_LENGTH + MESHTASTIC_PKC_OVERHEAD > MAX_LORA_PAYLOAD_LEN)
+            if (numbytes + 12 > MAX_RHPACKETLEN)
                 return meshtastic_Routing_Error_TOO_LARGE;
             if (p->pki_encrypted && !memfll(p->public_key.bytes, 0, 32) &&
                 memcmp(p->public_key.bytes, node->user.public_key.bytes, 32) != 0) {
@@ -508,7 +492,7 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
                 return meshtastic_Routing_Error_PKI_FAILED;
             }
             crypto->encryptCurve25519(p->to, getFrom(p), p->id, numbytes, bytes, ScratchEncrypted);
-            numbytes += MESHTASTIC_PKC_OVERHEAD;
+            numbytes += 12;
             memcpy(p->encrypted.bytes, ScratchEncrypted, numbytes);
             p->channel = 0;
             p->pki_encrypted = true;

src/mesh/SX126xInterface.cpp

@@ -6,8 +6,6 @@
 #include "PortduinoGlue.h"
 #endif
 
-#include "Throttle.h"
-
 // Particular boards might define a different max power based on what their hardware can do, default to max power output if not
 // specified (may be dangerous if using external PA and SX126x power config forgotten)
 #ifndef SX126X_MAX_POWER
@@ -27,35 +25,15 @@ SX126xInterface<T>::SX126xInterface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs
 /// \return true if initialisation succeeded.
 template <typename T> bool SX126xInterface<T>::init()
 {
-
-// Typically, the RF switch on SX126x boards is controlled by two signals, which are negations of each other (switched RFIO
-// paths). The negation is usually performed in hardware, or (suboptimal design) TXEN and RXEN are the two inputs to this style of
-// RF switch. On some boards, there is no hardware negation between CTRL and ¬CTRL, but CTRL is internally connected to DIO2, and
-// DIO2's switching is done by the SX126X itself, so the MCU can't control ¬CTRL at exactly the same time. One solution would be
-// to set ¬CTRL as SX126X_TXEN or SX126X_RXEN, but they may already be used for another purpose, such as controlling another
-// PA/LNA. Keeping ¬CTRL high seems to work, as long CTRL=1, ¬CTRL=1 has the opposite and stable RF path effect as CTRL=0 and
-// ¬CTRL=1, this depends on the RF switch, but it seems this usually works. Better hardware design, which is done most the time,
-// means this workaround is not necessary.
-#ifdef SX126X_ANT_SW // Perhaps add RADIOLIB_NC check, and beforehand define as such if it is undefined, but it is not commonly
-                     // used and not part of the 'default' set of pin definitions.
-    digitalWrite(SX126X_ANT_SW, HIGH);
-    pinMode(SX126X_ANT_SW, OUTPUT);
-#endif
-
-#ifdef SX126X_POWER_EN // Perhaps add RADIOLIB_NC check, and beforehand define as such if it is undefined, but it is not commonly
-                       // used and not part of the 'default' set of pin definitions.
-    digitalWrite(SX126X_POWER_EN, HIGH);
+#ifdef SX126X_POWER_EN
     pinMode(SX126X_POWER_EN, OUTPUT);
+    digitalWrite(SX126X_POWER_EN, HIGH);
 #endif
 
 #if ARCH_PORTDUINO
     float tcxoVoltage = 0;
     if (settingsMap[dio3_tcxo_voltage])
         tcxoVoltage = 1.8;
-    if (settingsMap[sx126x_ant_sw] != RADIOLIB_NC) {
-        digitalWrite(settingsMap[sx126x_ant_sw], HIGH);
-        pinMode(settingsMap[sx126x_ant_sw], OUTPUT);
-    }
 // FIXME: correct logic to default to not using TCXO if no voltage is specified for SX126X_DIO3_TCXO_VOLTAGE
 #elif !defined(SX126X_DIO3_TCXO_VOLTAGE)
     float tcxoVoltage =
@@ -103,19 +81,21 @@ template <typename T> bool SX126xInterface<T>::init()
     LOG_DEBUG("Current limit set to %f\n", currentLimit);
     LOG_DEBUG("Current limit set result %d\n", res);
 
-    if (res == RADIOLIB_ERR_NONE) {
 #ifdef SX126X_DIO2_AS_RF_SWITCH
-        bool dio2AsRfSwitch = true;
+    LOG_DEBUG("Setting DIO2 as RF switch\n");
+    bool dio2AsRfSwitch = true;
 #elif defined(ARCH_PORTDUINO)
-        bool dio2AsRfSwitch = false;
-        if (settingsMap[dio2_as_rf_switch]) {
-            dio2AsRfSwitch = true;
-        }
+    bool dio2AsRfSwitch = false;
+    if (settingsMap[dio2_as_rf_switch]) {
+        LOG_DEBUG("Setting DIO2 as RF switch\n");
+        dio2AsRfSwitch = true;
+    }
 #else
-        bool dio2AsRfSwitch = false;
+    LOG_DEBUG("Setting DIO2 as not RF switch\n");
+    bool dio2AsRfSwitch = false;
 #endif
+    if (res == RADIOLIB_ERR_NONE) {
         res = lora.setDio2AsRfSwitch(dio2AsRfSwitch);
-        LOG_DEBUG("Set DIO2 as %sRF switch, result: %d\n", dio2AsRfSwitch ? "" : "not ", res);
     }
 
     // If a pin isn't defined, we set it to RADIOLIB_NC, it is safe to always do external RF switching with RADIOLIB_NC as it has
@@ -318,7 +298,29 @@ template <typename T> bool SX126xInterface<T>::isActivelyReceiving()
 {
     // The IRQ status will be cleared when we start our read operation. Check if we've started a header, but haven't yet
     // received and handled the interrupt for reading the packet/handling errors.
-    return receiveDetected(lora.getIrqFlags(), RADIOLIB_SX126X_IRQ_HEADER_VALID, RADIOLIB_SX126X_IRQ_PREAMBLE_DETECTED);
+
+    uint16_t irq = lora.getIrqFlags();
+    bool detected = (irq & (RADIOLIB_SX126X_IRQ_HEADER_VALID | RADIOLIB_SX126X_IRQ_PREAMBLE_DETECTED));
+    // Handle false detections
+    if (detected) {
+        uint32_t now = millis();
+        if (!activeReceiveStart) {
+            activeReceiveStart = now;
+        } else if ((now - activeReceiveStart > 2 * preambleTimeMsec) && !(irq & RADIOLIB_SX126X_IRQ_HEADER_VALID)) {
+            // The HEADER_VALID flag should be set by now if it was really a packet, so ignore PREAMBLE_DETECTED flag
+            activeReceiveStart = 0;
+            LOG_DEBUG("Ignore false preamble detection.\n");
+            return false;
+        } else if (now - activeReceiveStart > maxPacketTimeMsec) {
+            // We should have gotten an RX_DONE IRQ by now if it was really a packet, so ignore HEADER_VALID flag
+            activeReceiveStart = 0;
+            LOG_DEBUG("Ignore false header detection.\n");
+            return false;
+        }
+    }
+
+    // if (detected) LOG_DEBUG("rx detected\n");
+    return detected;
 }
 
 template <typename T> bool SX126xInterface<T>::sleep()
@@ -341,4 +343,4 @@ template <typename T> bool SX126xInterface<T>::sleep()
 #endif
 
     return true;
-}
+}

src/mesh/SX126xInterface.h

@@ -67,4 +67,7 @@ template <class T> class SX126xInterface : public RadioLibInterface
     virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) override;
 
     virtual void setStandby() override;
+
+  private:
+    uint32_t activeReceiveStart = 0;
 };

src/mesh/SX128xInterface.cpp

@@ -1,5 +1,4 @@
 #include "SX128xInterface.h"
-#include "Throttle.h"
 #include "configuration.h"
 #include "error.h"
 #include "mesh/NodeDB.h"
@@ -290,7 +289,28 @@ template <typename T> bool SX128xInterface<T>::isChannelActive()
 /** Could we send right now (i.e. either not actively receiving or transmitting)? */
 template <typename T> bool SX128xInterface<T>::isActivelyReceiving()
 {
-    return receiveDetected(lora.getIrqStatus(), RADIOLIB_SX128X_IRQ_HEADER_VALID, RADIOLIB_SX128X_IRQ_PREAMBLE_DETECTED);
+    uint16_t irq = lora.getIrqStatus();
+    bool detected = (irq & (RADIOLIB_SX128X_IRQ_HEADER_VALID | RADIOLIB_SX128X_IRQ_PREAMBLE_DETECTED));
+
+    // Handle false detections
+    if (detected) {
+        uint32_t now = millis();
+        if (!activeReceiveStart) {
+            activeReceiveStart = now;
+        } else if ((now - activeReceiveStart > 2 * preambleTimeMsec) && !(irq & RADIOLIB_SX128X_IRQ_HEADER_VALID)) {
+            // The HEADER_VALID flag should be set by now if it was really a packet, so ignore PREAMBLE_DETECTED flag
+            activeReceiveStart = 0;
+            LOG_DEBUG("Ignore false preamble detection.\n");
+            return false;
+        } else if (now - activeReceiveStart > maxPacketTimeMsec) {
+            // We should have gotten an RX_DONE IRQ by now if it was really a packet, so ignore HEADER_VALID flag
+            activeReceiveStart = 0;
+            LOG_DEBUG("Ignore false header detection.\n");
+            return false;
+        }
+    }
+
+    return detected;
 }
 
 template <typename T> bool SX128xInterface<T>::sleep()

src/mesh/SX128xInterface.h

@@ -67,4 +67,7 @@ template <class T> class SX128xInterface : public RadioLibInterface
     virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) override;
 
     virtual void setStandby() override;
+
+  private:
+    uint32_t activeReceiveStart = 0;
 };

src/mesh/StreamAPI.cpp

@@ -1,7 +1,6 @@
 #include "StreamAPI.h"
 #include "PowerFSM.h"
 #include "RTC.h"
-#include "Throttle.h"
 #include "configuration.h"
 
 #define START1 0x94
@@ -21,9 +20,10 @@ int32_t StreamAPI::runOncePart()
  */
 int32_t StreamAPI::readStream()
 {
+    uint32_t now = millis();
     if (!stream->available()) {
         // Nothing available this time, if the computer has talked to us recently, poll often, otherwise let CPU sleep a long time
-        bool recentRx = Throttle::isWithinTimespanMs(lastRxMsec, 2000);
+        bool recentRx = (now - lastRxMsec) < 2000;
         return recentRx ? 5 : 250;
     } else {
         while (stream->available()) { // Currently we never want to block
@@ -71,7 +71,7 @@ int32_t StreamAPI::readStream()
         }
 
         // we had bytes available this time, so assume we might have them next time also
-        lastRxMsec = millis();
+        lastRxMsec = now;
         return 0;
     }
 }

src/mesh/Throttle.cpp

@@ -24,12 +24,4 @@ bool Throttle::execute(uint32_t *lastExecutionMs, uint32_t minumumIntervalMs, vo
         onDefer();
     }
     return false;
-}
-
-/// @brief Check if the last execution time is within the interval
-/// @param lastExecutionMs The last execution time in milliseconds
-/// @param timeSpanMs The interval in milliseconds of the timespan
-bool Throttle::isWithinTimespanMs(uint32_t lastExecutionMs, uint32_t timeSpanMs)
-{
-    return (millis() - lastExecutionMs) < timeSpanMs;
 }