Merge branch 'master' into static-buffer-gps

This reverts commit 54d64e19f7.

.clusterfuzzlite/router_fuzzer.cpp

@@ -76,7 +76,7 @@ bool loopCanSleep()
 // Called just prior to starting Meshtastic. Allows for setting config values before startup.
 void lateInitVariant()
 {
-    portduino_config.logoutputlevel = level_error;
+    settingsMap[logoutputlevel] = level_error;
     channelFile.channels[0] = meshtastic_Channel{
         .has_settings = true,
         .settings =
@@ -132,7 +132,7 @@ int portduino_main(int argc, char **argv); // Renamed "main" function from Mesht
 // Start Meshtastic in a thread and wait till it has reached the ON state.
 int LLVMFuzzerInitialize(int *argc, char ***argv)
 {
-    portduino_config.maxtophone = 5;
+    settingsMap[maxtophone] = 5;
 
     meshtasticThread = std::thread([program = *argv[0]]() {
         char nodeIdStr[12];

.devcontainer/Dockerfile

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

.devcontainer/devcontainer.json

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

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

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

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

@@ -5,12 +5,17 @@ runs:
   using: composite
   steps:
     - name: Checkout code
-      uses: actions/checkout@v6
+      uses: actions/checkout@v5
       with:
         submodules: recursive
         ref: ${{github.event.pull_request.head.ref}}
         repository: ${{github.event.pull_request.head.repo.full_name}}
 
+    - name: Uncomment build epoch
+      shell: bash
+      run: |
+        sed -i 's/#-DBUILD_EPOCH=$UNIX_TIME/-DBUILD_EPOCH=$UNIX_TIME/' platformio.ini
+
     - name: Install dependencies
       shell: bash
       run: |

.github/workflows/build_debian_src.yml

@@ -24,7 +24,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           path: meshtasticd
@@ -64,7 +64,7 @@ jobs:
           PKG_VERSION: ${{ steps.version.outputs.deb }}
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           overwrite: true

.github/workflows/build_firmware.yml

@@ -19,10 +19,8 @@ jobs:
   pio-build:
     name: build-${{ inputs.platform }}
     runs-on: ubuntu-24.04
-    outputs:
-      artifact-id: ${{ steps.upload.outputs.artifact-id }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
         with:
           submodules: recursive
           ref: ${{github.event.pull_request.head.ref}}
@@ -56,8 +54,7 @@ jobs:
           ota_firmware_target: ${{ steps.ota_dir.outputs.tgt || '' }}
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
-        id: upload
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}.zip
           overwrite: true

.github/workflows/build_one_arch.yml

@@ -1,176 +0,0 @@
-name: Build One Arch
-
-on:
-  workflow_dispatch:
-    inputs:
-      # trunk-ignore(checkov/CKV_GHA_7)
-      arch:
-        type: choice
-        options:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-          - native
-
-permissions: read-all
-
-env:
-  INPUT_ARCH: ${{ github.event.inputs.arch }}
-
-jobs:
-  setup:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-          cache: pip
-      - run: pip install -U platformio
-      - name: Generate matrix
-        id: jsonStep
-        run: |
-          TARGETS=$(./bin/generate_ci_matrix.py $INPUT_ARCH --level extra)
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "selected_arch=$TARGETS" >> $GITHUB_OUTPUT
-    outputs:
-      selected_arch: ${{ steps.jsonStep.outputs.selected_arch }}
-
-  version:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Get release version string
-        run: |
-          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-          echo "deb=$(./bin/buildinfo.py deb)" >> $GITHUB_OUTPUT
-        id: version
-        env:
-          BUILD_LOCATION: local
-    outputs:
-      long: ${{ steps.version.outputs.long }}
-      deb: ${{ steps.version.outputs.deb }}
-
-  build:
-    if: ${{ github.event_name != 'workflow_dispatch' }}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix:
-        build: ${{ fromJson(needs.setup.outputs.selected_arch) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.build.board }}
-      platform: ${{ matrix.build.arch }}
-
-  build-debian-src:
-    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    uses: ./.github/workflows/build_debian_src.yml
-    with:
-      series: UNRELEASED
-      build_location: local
-    secrets: inherit
-
-  package-pio-deps-native-tft:
-    if: ${{ inputs.arch == 'native' }}
-    uses: ./.github/workflows/package_pio_deps.yml
-    with:
-      pio_env: native-tft
-    secrets: inherit
-
-  test-native:
-    if: ${{ !contains(github.ref_name, 'event/') && github.event_name != 'workflow_dispatch' ||  !contains(github.ref_name, 'event/') && inputs.arch == 'native' }}
-    uses: ./.github/workflows/test_native.yml
-
-  gather-artifacts:
-    permissions:
-      contents: write
-      pull-requests: write
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-    runs-on: ubuntu-latest
-    needs: [version, build]
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - uses: actions/download-artifact@v6
-        with:
-          path: ./
-          pattern: firmware-${{inputs.arch}}-*
-          merge-multiple: true
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: Move files up
-        run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
-
-      - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
-          overwrite: true
-          path: |
-            ./firmware-*.bin
-            ./firmware-*.uf2
-            ./firmware-*.hex
-            ./firmware-*-ota.zip
-            ./device-*.sh
-            ./device-*.bat
-            ./littlefs-*.bin
-            ./bleota*bin
-            ./Meshtastic_nRF52_factory_erase*.uf2
-          retention-days: 30
-
-      - uses: actions/download-artifact@v6
-        with:
-          name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      # For diagnostics
-      - name: Show artifacts
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh
-          chmod +x ./output/device-update.sh
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
-          overwrite: true
-          path: ./*.elf
-          retention-days: 30
-
-      - uses: scruplelesswizard/comment-artifact@main
-        if: ${{ github.event_name == 'pull_request' }}
-        with:
-          name: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
-          description: "Download firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
-          github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build_one_target.yml

@@ -1,182 +0,0 @@
-name: Build One Target
-
-on:
-  workflow_dispatch:
-    inputs:
-      # trunk-ignore(checkov/CKV_GHA_7)
-      arch:
-        type: choice
-        options:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-          - native
-      target:
-        type: string
-        required: false
-        description: Choose the target board, e.g. nrf52_promicro_diy_tcxo. If blank, will find available targets.
-      # find-target:
-      #   type: boolean
-      #   default: true
-      #   description: 'Find the available targets'
-
-permissions: read-all
-
-jobs:
-  find-targets:
-    if: ${{ inputs.target == '' }}
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-          cache: pip
-      - run: pip install -U platformio
-      - name: Generate matrix
-        id: jsonStep
-        run: |
-          TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level extra)
-          echo "Name: $GITHUB_REF_NAME" >> $GITHUB_STEP_SUMMARY
-          echo "Base: $GITHUB_BASE_REF" >> $GITHUB_STEP_SUMMARY
-          echo "Arch: ${{matrix.arch}}" >> $GITHUB_STEP_SUMMARY
-          echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
-          echo "Targets:" >> $GITHUB_STEP_SUMMARY
-          echo $TARGETS >> $GITHUB_STEP_SUMMARY
-
-  version:
-    if: ${{ inputs.target != '' }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Get release version string
-        run: |
-          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-          echo "deb=$(./bin/buildinfo.py deb)" >> $GITHUB_OUTPUT
-        id: version
-        env:
-          BUILD_LOCATION: local
-    outputs:
-      long: ${{ steps.version.outputs.long }}
-      deb: ${{ steps.version.outputs.deb }}
-
-  build:
-    if: ${{ inputs.target != '' && inputs.arch != 'native' }}
-    needs: [version]
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ inputs.target }}
-      platform: ${{ inputs.arch }}
-
-  build-debian-src:
-    if: ${{ github.repository == 'meshtastic/firmware' && inputs.arch == 'native' }}
-    uses: ./.github/workflows/build_debian_src.yml
-    with:
-      series: UNRELEASED
-      build_location: local
-    secrets: inherit
-
-  package-pio-deps-native-tft:
-    if: ${{ inputs.arch == 'native' }}
-    uses: ./.github/workflows/package_pio_deps.yml
-    with:
-      pio_env: native-tft
-    secrets: inherit
-
-  test-native:
-    if: ${{ !contains(github.ref_name, 'event/') && github.event_name != 'workflow_dispatch' ||  !contains(github.ref_name, 'event/') && inputs.arch == 'native' && inputs.target != '' }}
-    uses: ./.github/workflows/test_native.yml
-
-  gather-artifacts:
-    permissions:
-      contents: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    needs: [version, build]
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - uses: actions/download-artifact@v6
-        with:
-          path: ./
-          pattern: firmware-*-*
-          merge-multiple: true
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: Move files up
-        run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
-
-      - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: firmware-${{inputs.target}}-${{ needs.version.outputs.long }}
-          overwrite: true
-          path: |
-            ./firmware-*.bin
-            ./firmware-*.uf2
-            ./firmware-*.hex
-            ./firmware-*-ota.zip
-            ./device-*.sh
-            ./device-*.bat
-            ./littlefs-*.bin
-            ./bleota*bin
-            ./Meshtastic_nRF52_factory_erase*.uf2
-          retention-days: 30
-
-      - uses: actions/download-artifact@v6
-        with:
-          pattern: firmware-*-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      # For diagnostics
-      - name: Show artifacts
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh
-          chmod +x ./output/device-update.sh
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: debug-elfs-${{inputs.target}}-${{ needs.version.outputs.long }}.zip
-          overwrite: true
-          path: ./*.elf
-          retention-days: 30
-
-      - uses: scruplelesswizard/comment-artifact@main
-        if: ${{ github.event_name == 'pull_request' }}
-        with:
-          name: firmware-${{inputs.target}}-${{ needs.version.outputs.long }}
-          description: "Download firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
-          github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/daily_packaging.yml

@@ -21,20 +21,18 @@ permissions:
 
 jobs:
   docker-multiarch:
-    if: github.repository == 'meshtastic/firmware'
     uses: ./.github/workflows/docker_manifest.yml
     with:
       release_channel: daily
     secrets: inherit
 
   package-ppa:
-    if: github.repository == 'meshtastic/firmware'
     strategy:
       fail-fast: false
       matrix:
         series:
-          - jammy # 22.04 LTS
-          - noble # 24.04 LTS
+          - jammy # 22.04
+          - noble # 24.04
           - plucky # 25.04
           - questing # 25.10
     uses: ./.github/workflows/package_ppa.yml
@@ -44,7 +42,6 @@ jobs:
     secrets: inherit
 
   package-obs:
-    if: github.repository == 'meshtastic/firmware'
     uses: ./.github/workflows/package_obs.yml
     with:
       obs_project: network:Meshtastic:daily
@@ -52,7 +49,6 @@ jobs:
     secrets: inherit
 
   hook-copr:
-    if: github.repository == 'meshtastic/firmware'
     uses: ./.github/workflows/hook_copr.yml
     with:
       copr_project: daily

.github/workflows/docker_build.yml

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

.github/workflows/docker_manifest.yml

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

.github/workflows/hook_copr.yml

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

.github/workflows/main_matrix.yml

@@ -3,7 +3,7 @@ concurrency:
   group: ci-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 on:
-  # # Triggers the workflow on push but only for the main branches
+  # # Triggers the workflow on push but only for the master branch
   push:
     branches:
       - master
@@ -28,14 +28,21 @@ on:
 jobs:
   setup:
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         arch:
-          - all
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
           - check
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - uses: actions/setup-python@v6
         with:
           python-version: 3.x
@@ -47,19 +54,25 @@ jobs:
           if [[ "$GITHUB_HEAD_REF" == "" ]]; then
             TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
           else  
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level pr)
+            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} pr)
           fi
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "${{matrix.arch}}=$TARGETS" >> $GITHUB_OUTPUT
-          echo "$TARGETS" >> $GITHUB_STEP_SUMMARY
+          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF Targets: $TARGETS"
+          echo "${{matrix.arch}}=$(jq -cn --argjson environments "$TARGETS" '{board: $environments}')" >> $GITHUB_OUTPUT
     outputs:
-      all: ${{ steps.jsonStep.outputs.all }}
+      esp32: ${{ steps.jsonStep.outputs.esp32 }}
+      esp32s3: ${{ steps.jsonStep.outputs.esp32s3 }}
+      esp32c3: ${{ steps.jsonStep.outputs.esp32c3 }}
+      esp32c6: ${{ steps.jsonStep.outputs.esp32c6 }}
+      nrf52840: ${{ steps.jsonStep.outputs.nrf52840 }}
+      rp2040: ${{ steps.jsonStep.outputs.rp2040 }}
+      rp2350: ${{ steps.jsonStep.outputs.rp2350 }}
+      stm32: ${{ steps.jsonStep.outputs.stm32 }}
       check: ${{ steps.jsonStep.outputs.check }}
 
   version:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - name: Get release version string
         run: |
           echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
@@ -75,30 +88,105 @@ jobs:
     needs: setup
     strategy:
       fail-fast: false
-      matrix:
-        check: ${{ fromJson(needs.setup.outputs.check) }}
+      matrix: ${{ fromJson(needs.setup.outputs.check) }}
 
     runs-on: ubuntu-latest
-    if: ${{ github.event_name != 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
+    if: ${{ github.event_name != 'workflow_dispatch' }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v5
       - name: Build base
         id: base
         uses: ./.github/actions/setup-base
-      - name: Check ${{ matrix.check.board }}
-        run: bin/check-all.sh ${{ matrix.check.board }}
+      - name: Check ${{ matrix.board }}
+        run: bin/check-all.sh ${{ matrix.board }}
 
-  build:
+  build-esp32:
     needs: [setup, version]
     strategy:
       fail-fast: false
-      matrix:
-        build: ${{ fromJson(needs.setup.outputs.all) }}
+      matrix: ${{ fromJson(needs.setup.outputs.esp32) }}
     uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.build.board }}
-      platform: ${{ matrix.build.platform }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32
+
+  build-esp32s3:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32s3) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32s3
+
+  build-esp32c3:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32c3) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c3
+
+  build-esp32c6:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.esp32c6) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: esp32c6
+
+  build-nrf52840:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.nrf52840) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: nrf52840
+
+  build-rp2040:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.rp2040) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: rp2040
+
+  build-rp2350:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.rp2350) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: rp2350
+
+  build-stm32:
+    needs: [setup, version]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.setup.outputs.stm32) }}
+    uses: ./.github/workflows/build_firmware.yml
+    with:
+      version: ${{ needs.version.outputs.long }}
+      pio_env: ${{ matrix.board }}
+      platform: stm32
 
   build-debian-src:
     if: github.repository == 'meshtastic/firmware'
@@ -109,41 +197,67 @@ jobs:
     secrets: inherit
 
   package-pio-deps-native-tft:
-    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name == 'workflow_dispatch' }}
+    if: ${{ github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/package_pio_deps.yml
     with:
       pio_env: native-tft
     secrets: inherit
 
   test-native:
-    if: ${{ !contains(github.ref_name, 'event/') && github.repository == 'meshtastic/firmware' }}
+    if: ${{ !contains(github.ref_name, 'event/') }}
     uses: ./.github/workflows/test_native.yml
 
-  docker:
-    strategy:
-      fail-fast: false
-      matrix:
-        distro: [debian, alpine]
-        platform: [linux/amd64, linux/arm64, linux/arm/v7]
-        pio_env: [native, native-tft]
-        exclude:
-          - distro: alpine
-            platform: linux/arm/v7
-          - pio_env: native-tft
-            platform: linux/arm64
-          - pio_env: native-tft
-            platform: linux/arm/v7
+  docker-deb-amd64:
     uses: ./.github/workflows/docker_build.yml
     with:
-      distro: ${{ matrix.distro }}
-      platform: ${{ matrix.platform }}
-      runs-on: ${{ contains(matrix.platform, 'arm') && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
-      pio_env: ${{ matrix.pio_env }}
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-deb-amd64-tft:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-alp-amd64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+
+  docker-alp-amd64-tft:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/amd64
+      runs-on: ubuntu-24.04
+      push: false
+      pio_env: native-tft
+
+  docker-deb-arm64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm64
+      runs-on: ubuntu-24.04-arm
+      push: false
+
+  docker-deb-armv7:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/arm/v7
+      runs-on: ubuntu-24.04-arm
       push: false
 
   gather-artifacts:
-    # trunk-ignore(checkov/CKV2_GHA_1)
-    if: github.repository == 'meshtastic/firmware'
     permissions:
       contents: write
       pull-requests: write
@@ -160,15 +274,26 @@ jobs:
           - rp2350
           - stm32
     runs-on: ubuntu-latest
-    needs: [version, build]
+    needs:
+      [
+        version,
+        build-esp32,
+        build-esp32s3,
+        build-esp32c3,
+        build-esp32c6,
+        build-nrf52840,
+        build-rp2040,
+        build-rp2350,
+        build-stm32,
+      ]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           path: ./
           pattern: firmware-${{matrix.arch}}-*
@@ -181,7 +306,7 @@ jobs:
         run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
 
       - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           overwrite: true
@@ -197,7 +322,7 @@ jobs:
             ./Meshtastic_nRF52_factory_erase*.uf2
           retention-days: 30
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -216,7 +341,7 @@ jobs:
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
       - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
           overwrite: true
@@ -232,7 +357,7 @@ jobs:
 
   release-artifacts:
     runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
+    if: ${{ github.event_name == 'workflow_dispatch' }}
     outputs:
       upload_url: ${{ steps.create_release.outputs.upload_url }}
     needs:
@@ -242,7 +367,7 @@ jobs:
       - package-pio-deps-native-tft
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
 
       - name: Setup Python
         uses: actions/setup-python@v6
@@ -261,14 +386,14 @@ jobs:
             Autogenerated by github action, developer should edit as required before publishing...
 
       - name: Download source deb
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
           merge-multiple: true
           path: ./output/debian-src
 
       - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -307,18 +432,18 @@ jobs:
           - rp2350
           - stm32
     runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware'}}
+    if: ${{ github.event_name == 'workflow_dispatch' }}
     needs: [release-artifacts, version]
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
 
       - name: Setup Python
         uses: actions/setup-python@v6
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
           merge-multiple: true
@@ -335,7 +460,7 @@ jobs:
       - name: Zip firmware
         run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
           merge-multiple: true
@@ -366,14 +491,14 @@ jobs:
         esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
 
       - name: Setup Python
         uses: actions/setup-python@v6
         with:
           python-version: 3.x
 
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v5
         with:
           pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
           merge-multiple: true

.github/workflows/merge_queue.yml

@@ -1,376 +0,0 @@
-name: Merge Queue
-# Not sure how concurrency works in merge_queue, removing for now.
-# concurrency:
-#   group: merge-queue-${{ github.head_ref || github.run_id }}
-#   cancel-in-progress: true
-on:
-  # Merge group is a special trigger that is used to trigger the workflow when a merge group is created.
-  merge_group:
-
-jobs:
-  setup:
-    strategy:
-      fail-fast: true
-      matrix:
-        arch:
-          - all
-          - check
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-          cache: pip
-      - run: pip install -U platformio
-      - name: Generate matrix
-        id: jsonStep
-        run: |
-          if [[ "$GITHUB_HEAD_REF" == "" ]]; then
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
-          else  
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level pr)
-          fi
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "${{matrix.arch}}=$TARGETS" >> $GITHUB_OUTPUT
-    outputs:
-      all: ${{ steps.jsonStep.outputs.all }}
-      check: ${{ steps.jsonStep.outputs.check }}
-
-  version:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Get release version string
-        run: |
-          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-          echo "deb=$(./bin/buildinfo.py deb)" >> $GITHUB_OUTPUT
-        id: version
-        env:
-          BUILD_LOCATION: local
-    outputs:
-      long: ${{ steps.version.outputs.long }}
-      deb: ${{ steps.version.outputs.deb }}
-
-  check:
-    needs: setup
-    strategy:
-      fail-fast: true
-      matrix:
-        check: ${{ fromJson(needs.setup.outputs.check) }}
-
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name != 'workflow_dispatch' }}
-    steps:
-      - uses: actions/checkout@v6
-      - name: Build base
-        id: base
-        uses: ./.github/actions/setup-base
-      - name: Check ${{ matrix.check.board }}
-        run: bin/check-all.sh ${{ matrix.check.board }}
-
-  build:
-    needs: [setup, version]
-    strategy:
-      matrix:
-        build: ${{ fromJson(needs.setup.outputs.all) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.build.board }}
-      platform: ${{ matrix.build.platform }}
-
-  build-debian-src:
-    if: github.repository == 'meshtastic/firmware'
-    uses: ./.github/workflows/build_debian_src.yml
-    with:
-      series: UNRELEASED
-      build_location: local
-    secrets: inherit
-
-  package-pio-deps-native-tft:
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/package_pio_deps.yml
-    with:
-      pio_env: native-tft
-    secrets: inherit
-
-  test-native:
-    if: ${{ !contains(github.ref_name, 'event/') }}
-    uses: ./.github/workflows/test_native.yml
-
-  docker:
-    strategy:
-      fail-fast: false
-      matrix:
-        distro: [debian, alpine]
-        platform: [linux/amd64, linux/arm64, linux/arm/v7]
-        pio_env: [native, native-tft]
-        exclude:
-          - distro: alpine
-            platform: linux/arm/v7
-          - pio_env: native-tft
-            platform: linux/arm64
-          - pio_env: native-tft
-            platform: linux/arm/v7
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: ${{ matrix.distro }}
-      platform: ${{ matrix.platform }}
-      runs-on: ${{ contains(matrix.platform, 'arm') && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
-      pio_env: ${{ matrix.pio_env }}
-      push: false
-
-  gather-artifacts:
-    # trunk-ignore(checkov/CKV2_GHA_1)
-    permissions:
-      contents: write
-      pull-requests: write
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-    runs-on: ubuntu-latest
-    needs: [version, build]
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - uses: actions/download-artifact@v6
-        with:
-          path: ./
-          pattern: firmware-${{matrix.arch}}-*
-          merge-multiple: true
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: Move files up
-        run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
-
-      - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          overwrite: true
-          path: |
-            ./firmware-*.bin
-            ./firmware-*.uf2
-            ./firmware-*.hex
-            ./firmware-*-ota.zip
-            ./device-*.sh
-            ./device-*.bat
-            ./littlefs-*.bin
-            ./bleota*bin
-            ./Meshtastic_nRF52_factory_erase*.uf2
-          retention-days: 30
-
-      - uses: actions/download-artifact@v6
-        with:
-          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      # For diagnostics
-      - name: Show artifacts
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh
-          chmod +x ./output/device-update.sh
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
-          overwrite: true
-          path: ./*.elf
-          retention-days: 30
-
-      - uses: scruplelesswizard/comment-artifact@main
-        if: ${{ github.event_name == 'pull_request' }}
-        with:
-          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          description: "Download firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-  release-artifacts:
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-    needs:
-      - version
-      - gather-artifacts
-      - build-debian-src
-      - package-pio-deps-native-tft
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - name: Create release
-        uses: softprops/action-gh-release@v2
-        id: create_release
-        with:
-          draft: true
-          prerelease: true
-          name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
-          tag_name: v${{ needs.version.outputs.long }}
-          body: |
-            Autogenerated by github action, developer should edit as required before publishing...
-
-      - name: Download source deb
-        uses: actions/download-artifact@v6
-        with:
-          pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
-          merge-multiple: true
-          path: ./output/debian-src
-
-      - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v6
-        with:
-          pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output/pio-deps-native-tft
-
-      - name: Zip Linux sources
-        working-directory: output
-        run: |
-          zip -j -9 -r ./meshtasticd-${{ needs.version.outputs.deb }}-src.zip ./debian-src
-          zip -9 -r ./platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip ./pio-deps-native-tft
-
-      # For diagnostics
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Add Linux sources to GtiHub Release
-        # Only run when targeting master branch with workflow_dispatch
-        if: ${{ github.ref_name == 'master' }}
-        run: |
-          gh release upload v${{ needs.version.outputs.long }} ./output/meshtasticd-${{ needs.version.outputs.deb }}-src.zip
-          gh release upload v${{ needs.version.outputs.long }} ./output/platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  release-firmware:
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    needs: [release-artifacts, version]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - uses: actions/download-artifact@v6
-        with:
-          pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh
-          chmod +x ./output/device-update.sh
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - uses: actions/download-artifact@v6
-        with:
-          name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
-          merge-multiple: true
-          path: ./elfs
-
-      - name: Zip debug elfs
-        run: zip -j -9 -r ./debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./elfs
-
-      # For diagnostics
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Add bins and debug elfs to GitHub Release
-        # Only run when targeting master branch with workflow_dispatch
-        if: ${{ github.ref_name == 'master' }}
-        run: |
-          gh release upload v${{ needs.version.outputs.long }} ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
-          gh release upload v${{ needs.version.outputs.long }} ./debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  publish-firmware:
-    runs-on: ubuntu-24.04
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    needs: [release-firmware, version]
-    env:
-      targets: |-
-        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - uses: actions/download-artifact@v6
-        with:
-          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./publish
-
-      - name: Publish firmware to meshtastic.github.io
-        uses: peaceiris/actions-gh-pages@v4
-        env:
-          # On event/* branches, use the event name as the destination prefix
-          DEST_PREFIX: ${{ contains(github.ref_name, 'event/') && format('{0}/', github.ref_name) || '' }}
-        with:
-          deploy_key: ${{ secrets.DIST_PAGES_DEPLOY_KEY }}
-          external_repository: meshtastic/meshtastic.github.io
-          publish_branch: master
-          publish_dir: ./publish
-          destination_dir: ${{ env.DEST_PREFIX }}firmware-${{ needs.version.outputs.long }}
-          keep_files: true
-          user_name: github-actions[bot]
-          user_email: github-actions[bot]@users.noreply.github.com
-          commit_message: ${{ needs.version.outputs.long }}
-          enable_jekyll: true

.github/workflows/nightly.yml

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

.github/workflows/package_obs.yml

@@ -34,7 +34,7 @@ jobs:
     needs: build-debian-src
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           path: meshtasticd
@@ -58,7 +58,7 @@ jobs:
         id: version
 
       - name: Download artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           merge-multiple: true

.github/workflows/package_pio_deps.yml

@@ -24,7 +24,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           ref: ${{github.event.pull_request.head.ref}}
@@ -56,7 +56,7 @@ jobs:
           PLATFORMIO_CORE_DIR: pio/core
 
       - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: platformio-deps-${{ inputs.pio_env }}-${{ steps.version.outputs.long }}
           overwrite: true

.github/workflows/package_ppa.yml

@@ -32,7 +32,7 @@ jobs:
     needs: build-debian-src
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           submodules: recursive
           path: meshtasticd
@@ -60,7 +60,7 @@ jobs:
         id: version
 
       - name: Download artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v5
         with:
           name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
           merge-multiple: true

.github/workflows/pr_enforce_labels.yml

@@ -10,14 +10,14 @@ permissions:
 
 jobs:
   check-label:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - name: Check for PR labels
         uses: actions/github-script@v8
         with:
           script: |
             const labels = context.payload.pull_request.labels.map(label => label.name);
-            const requiredLabels = ['bugfix', 'enhancement', 'hardware-support', 'dependencies', 'submodules', 'github_actions', 'trunk', 'cleanup'];
+            const requiredLabels = ['bugfix', 'enhancement', 'hardware-support', 'dependencies', 'submodules', 'github_actions', 'trunk'];
             const hasRequiredLabel = labels.some(label => requiredLabels.includes(label));
             if (!hasRequiredLabel) {
               core.setFailed(`PR must have at least one of the following labels before it can be merged: ${requiredLabels.join(', ')}.`);

.github/workflows/pr_tests.yml

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

.github/workflows/release_channels.yml

@@ -21,10 +21,10 @@ jobs:
       fail-fast: false
       matrix:
         series:
-          - jammy # 22.04 LTS
-          - noble # 24.04 LTS
+          - jammy # 22.04
+          - noble # 24.04
           - plucky # 25.04
-          - questing # 25.10
+          # - questing # 25.10
     uses: ./.github/workflows/package_ppa.yml
     with:
       ppa_repo: |-
@@ -60,10 +60,7 @@ jobs:
         shell: bash
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          # Always use master branch for version bumps
-          ref: master
+        uses: actions/checkout@v5
 
       - name: Setup Python
         uses: actions/setup-python@v6

.github/workflows/sec_sast_semgrep_cron.yml

@@ -21,7 +21,7 @@ jobs:
     steps:
       # step 1
       - name: clone application source code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
 
       # step 2
       - name: full scan
@@ -33,7 +33,7 @@ jobs:
 
       # step 3
       - name: save report as pipeline artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: report.sarif
           overwrite: true
@@ -41,7 +41,7 @@ jobs:
 
       # step 4
       - name: publish code scanning alerts
-        uses: github/codeql-action/upload-sarif@v4
+        uses: github/codeql-action/upload-sarif@v3
         with:
           sarif_file: report.sarif
           category: semgrep

.github/workflows/sec_sast_semgrep_pull.yml

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

.github/workflows/stale_bot.yml

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

.github/workflows/test_native.yml

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

.github/workflows/tests.yml

@@ -20,7 +20,7 @@ jobs:
     runs-on: test-runner
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
 
       # - uses: actions/setup-python@v5
       #   with:
@@ -47,9 +47,9 @@ jobs:
           pio upgrade
 
       - name: Setup Node
-        uses: actions/setup-node@v6
+        uses: actions/setup-node@v5
         with:
-          node-version: 24
+          node-version: 22
 
       - name: Setup pnpm
         uses: pnpm/action-setup@v4

.github/workflows/trunk_annotate_pr.yml

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

.github/workflows/trunk_check.yml

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

.github/workflows/trunk_format_pr.yml

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

.github/workflows/update_protobufs.yml

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

.trunk/trunk.yaml

@@ -4,31 +4,31 @@ cli:
 plugins:
   sources:
     - id: trunk
-      ref: v1.7.4
+      ref: v1.7.2
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.495
-    - renovate@42.30.4
-    - prettier@3.7.4
-    - trufflehog@3.91.2
+    - checkov@3.2.469
+    - renovate@41.94.0
+    - prettier@3.6.2
+    - trufflehog@3.90.5
     - yamllint@1.37.1
-    - bandit@1.9.2
-    - trivy@0.67.2
+    - bandit@1.8.6
+    - trivy@0.66.0
     - taplo@0.10.0
-    - ruff@0.14.7
-    - isort@7.0.0
-    - markdownlint@0.46.0
+    - ruff@0.12.11
+    - isort@6.0.1
+    - markdownlint@0.45.0
     - oxipng@9.1.5
     - svgo@4.0.0
-    - actionlint@1.7.9
+    - actionlint@1.7.7
     - flake8@7.3.0
-    - hadolint@2.14.0
+    - hadolint@2.13.1
     - shfmt@3.6.0
     - shellcheck@0.11.0
-    - black@25.11.0
+    - black@25.1.0
     - git-diff-check
-    - gitleaks@8.30.0
+    - gitleaks@8.28.0
     - clang-format@16.0.3
   ignore:
     - linters: [ALL]

Dockerfile

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

README.md

@@ -37,3 +37,4 @@ Join our community and help improve Meshtastic! 🚀
 ## Stats
 
 ![Alt](https://repobeats.axiom.co/api/embed/8025e56c482ec63541593cc5bd322c19d5c0bdcf.svg "Repobeats analytics image")
+

alpine.Dockerfile

@@ -3,13 +3,12 @@
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
-FROM python:3.14-alpine3.22 AS builder
+FROM python:3.13-alpine3.22 AS builder
 ARG PIO_ENV=native
 ENV PIP_ROOT_USER_ACTION=ignore
 
 RUN apk --no-cache add \
-        bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
-        libgpiod-dev yaml-cpp-dev bluez-dev \
+        bash g++ libstdc++-dev linux-headers zip git ca-certificates libgpiod-dev yaml-cpp-dev bluez-dev \
         libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
         libx11-dev libinput-dev libxkbcommon-dev \
     && rm -rf /var/cache/apk/* \
@@ -28,7 +27,7 @@ RUN bash ./bin/build-native.sh "$PIO_ENV" && \
 
 # ##### PRODUCTION BUILD #############
 
-FROM alpine:3.23
+FROM alpine:3.22
 LABEL org.opencontainers.image.title="Meshtastic" \
       org.opencontainers.image.description="Alpine Meshtastic daemon" \
       org.opencontainers.image.url="https://meshtastic.org" \
@@ -41,8 +40,8 @@ LABEL org.opencontainers.image.title="Meshtastic" \
 USER root
 
 RUN apk --no-cache add \
-        shadow libstdc++ libbsd libgpiod yaml-cpp libusb \
-        i2c-tools libuv libx11 libinput libxkbcommon \
+        shadow libstdc++ libgpiod yaml-cpp libusb i2c-tools libuv \
+        libx11 libinput libxkbcommon \
     && rm -rf /var/cache/apk/* \
     && mkdir -p /var/lib/meshtasticd \
     && mkdir -p /etc/meshtasticd/config.d \

arch/esp32/esp32.ini

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

arch/esp32/esp32c6.ini

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

arch/nrf52/nrf52.ini

@@ -7,7 +7,7 @@ extends = arduino_base
 platform_packages =
   ; our custom Git version until they merge our PR
   # TODO renovate
-  platformio/framework-arduinoadafruitnrf52 @ https://github.com/meshtastic/Adafruit_nRF52_Arduino#c770c8a16a351b55b86e347a3d9d7b74ad0bbf39
+  platformio/framework-arduinoadafruitnrf52 @ https://github.com/meshtastic/Adafruit_nRF52_Arduino#e13f5820002a4fb2a5e6754b42ace185277e5adf
   ; Don't renovate toolchain-gccarmnoneeabi
   platformio/toolchain-gccarmnoneeabi@~1.90301.0
 

arch/nrf52/nrf52840.ini

@@ -8,7 +8,7 @@ lib_deps =
   ${environmental_base.lib_deps}
   ${environmental_extra.lib_deps}
   # renovate: datasource=git-refs depName=Kongduino-Adafruit_nRFCrypto packageName=https://github.com/Kongduino/Adafruit_nRFCrypto gitBranch=master
-  https://github.com/Kongduino/Adafruit_nRFCrypto/archive/8cde7189b5ead9dcd49f72601b43b969c0bbc06e.zip
+  https://github.com/Kongduino/Adafruit_nRFCrypto/archive/5f838d2709461a2c981f642917aa50254a25c14c.zip
 
 ; Common NRF52 debugging settings follow.  See the Meshtastic developer docs for how to connect SWD debugging probes to your board.
 

arch/portduino/portduino.ini

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

arch/stm32/stm32.ini

@@ -2,7 +2,7 @@
 extends = arduino_base
 platform =
   # renovate: datasource=custom.pio depName=platformio/ststm32 packageName=platformio/platform/ststm32
-  platformio/ststm32@19.4.0
+  platformio/ststm32@19.3.0
 platform_packages =
   # TODO renovate
   platformio/framework-arduinoststm32@https://github.com/stm32duino/Arduino_Core_STM32/archive/2.10.1.zip
@@ -37,9 +37,6 @@ build_flags =
   -DRADIOLIB_EXCLUDE_LR11X0=1
   -DHAL_DAC_MODULE_ONLY
   -DHAL_RNG_MODULE_ENABLED
-  -Wl,--wrap=__assert_func
-  -Wl,--wrap=strerror
-  -Wl,--wrap=_tzset_unlocked_r
 
 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>

bin/analyze_map.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-"""Summarise linker map output to highlight heavy object files and libraries.
-
-Usage:
-    python bin/analyze_map.py --map .pio/build/rak4631/output.map --top 20
-
-The script parses GNU ld map files and aggregates section sizes per object file
-and per archive/library, then prints sortable tables that make it easy to spot
-modules worth trimming or hiding behind feature flags.
-"""
-from __future__ import annotations
-
-import argparse
-import collections
-import os
-import re
-import sys
-from typing import DefaultDict, Dict, Tuple
-
-
-SECTION_LINE_RE = re.compile(r"^\s+(?P<section>\S+)\s+0x[0-9A-Fa-f]+\s+0x(?P<size>[0-9A-Fa-f]+)\s+(?P<object>.+)$")
-ARCHIVE_MEMBER_RE = re.compile(r"^(?P<archive>.+)\((?P<object>[^)]+)\)$")
-
-
-def human_size(num_bytes: int) -> str:
-    """Return a friendly size string with one decimal place."""
-    if num_bytes < 1024:
-        return f"{num_bytes:,} B"
-    num = float(num_bytes)
-    for unit in ("KB", "MB", "GB"):
-        num /= 1024.0
-        if num < 1024.0:
-            return f"{num:.1f} {unit}"
-    return f"{num:.1f} TB"
-
-
-def shorten_path(path: str, root: str) -> str:
-    """Prefer repository-relative paths for readability."""
-    path = path.strip()
-    if not path:
-        return path
-
-    # Normalise Windows archives (backslashes) to POSIX style for consistency.
-    path = path.replace("\\", "/")
-
-    # Attempt to strip the root when an absolute path lives inside the repo.
-    if os.path.isabs(path):
-        try:
-            rel = os.path.relpath(path, root)
-            if not rel.startswith(".."):
-                return rel
-        except ValueError:
-            # relpath can fail on mixed drives on Windows; fall back to basename.
-            pass
-    return path
-
-
-def describe_object(raw_object: str, root: str) -> Tuple[str, str]:
-    """Return a human friendly object label and the library it belongs to."""
-    raw_object = raw_object.strip()
-    lib_label = "[app]"
-    match = ARCHIVE_MEMBER_RE.match(raw_object)
-    if match:
-        archive = shorten_path(match.group("archive"), root)
-        obj = match.group("object")
-        lib_label = os.path.basename(archive) or archive
-        label = f"{archive}:{obj}"
-    else:
-        label = shorten_path(raw_object, root)
-        # If the object lives under libs, hint at the containing directory.
-        parent = os.path.basename(os.path.dirname(label))
-        if parent:
-            lib_label = parent
-    return label, lib_label
-
-
-def parse_map(map_path: str, repo_root: str) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, Dict[str, int]]]:
-    per_object: DefaultDict[str, int] = collections.defaultdict(int)
-    per_library: DefaultDict[str, int] = collections.defaultdict(int)
-    per_object_sections: DefaultDict[str, DefaultDict[str, int]] = collections.defaultdict(lambda: collections.defaultdict(int))
-
-    try:
-        with open(map_path, "r", encoding="utf-8", errors="ignore") as handle:
-            for line in handle:
-                match = SECTION_LINE_RE.match(line)
-                if not match:
-                    continue
-
-                section = match.group("section")
-                if section.startswith("*") or section in {"LOAD", "ORIGIN"}:
-                    continue
-
-                size = int(match.group("size"), 16)
-                if size == 0:
-                    continue
-
-                obj_token = match.group("object").strip()
-                if not obj_token or obj_token.startswith("*") or "load address" in obj_token:
-                    continue
-
-                label, lib_label = describe_object(obj_token, repo_root)
-                per_object[label] += size
-                per_library[lib_label] += size
-                per_object_sections[label][section] += size
-    except FileNotFoundError:
-        raise SystemExit(f"error: map file '{map_path}' not found. Run a build first.")
-
-    return per_object, per_library, per_object_sections
-
-
-def format_section_breakdown(section_sizes: Dict[str, int], total: int, limit: int = 3) -> str:
-    items = sorted(section_sizes.items(), key=lambda kv: kv[1], reverse=True)
-    parts = []
-    for section, size in items[:limit]:
-        pct = (size / total) * 100 if total else 0
-        parts.append(f"{section} {pct:.1f}%")
-    if len(items) > limit:
-        remainder = total - sum(size for _, size in items[:limit])
-        pct = (remainder / total) * 100 if total else 0
-        parts.append(f"other {pct:.1f}%")
-    return ", ".join(parts)
-
-
-def print_report(map_path: str, top_n: int, per_object: Dict[str, int], per_library: Dict[str, int], per_object_sections: Dict[str, Dict[str, int]]):
-    total_bytes = sum(per_object.values())
-    if total_bytes == 0:
-        print("No section data found in map file.")
-        return
-
-    print(f"Map file: {map_path}")
-    print(f"Accounted size: {human_size(total_bytes)} across {len(per_object)} object files\n")
-
-    sorted_objects = sorted(per_object.items(), key=lambda kv: kv[1], reverse=True)
-    print(f"Top {min(top_n, len(sorted_objects))} object files by linked size:")
-    for idx, (obj, size) in enumerate(sorted_objects[:top_n], 1):
-        pct = (size / total_bytes) * 100
-        breakdown = format_section_breakdown(per_object_sections[obj], size)
-        print(f"{idx:2}. {human_size(size):>9}  ({size:,} B, {pct:5.2f}% of linked size)")
-        print(f"    {obj}")
-        if breakdown:
-            print(f"    sections: {breakdown}")
-    print()
-
-    sorted_libs = sorted(per_library.items(), key=lambda kv: kv[1], reverse=True)
-    print(f"Top {min(top_n, len(sorted_libs))} libraries or source roots:")
-    for idx, (lib, size) in enumerate(sorted_libs[:top_n], 1):
-        pct = (size / total_bytes) * 100
-        print(f"{idx:2}. {human_size(size):>9}  ({size:,} B, {pct:5.2f}% of linked size)  {lib}")
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Highlight heavy object files from a GNU ld map file.")
-    parser.add_argument("--map", default=".pio/build/rak4631/output.map", help="Path to the map file (default: %(default)s)")
-    parser.add_argument("--top", type=int, default=20, help="Number of entries to display per table (default: %(default)s)")
-    args = parser.parse_args()
-
-    map_path = os.path.abspath(args.map)
-    repo_root = os.path.abspath(os.getcwd())
-
-    per_object, per_library, per_object_sections = parse_map(map_path, repo_root)
-    print_report(os.path.relpath(map_path, repo_root), args.top, per_object, per_library, per_object_sections)
-
-
-if __name__ == "__main__":
-    main()

bin/build-firmware.sh

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
 
+sed -i 's/#-DBUILD_EPOCH=$UNIX_TIME/-DBUILD_EPOCH=$UNIX_TIME/' platformio.ini
+
 export PIP_BREAK_SYSTEM_PACKAGES=1
 
 if (echo $2 | grep -q "esp32"); then

bin/device-install.bat

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

bin/device-install.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
 
 PYTHON=${PYTHON:-$(which python3 python | head -n 1)}
 BPS_RESET=false
@@ -31,23 +31,21 @@ MUIDB_8MB=(
     "seeed-sensecap-indicator"
 )
 BIGDB_16MB=(
-    "dreamcatcher"
-    "elecrow-adv"
-    "ESP32-S3-Pico"
-    "heltec-v4"
-    "m5stack-cores3"
-    "mesh-tab"
-    "station-g2"
     "t-deck"
+    "mesh-tab"
     "t-energy-s3"
+    "dreamcatcher"
+    "ESP32-S3-Pico"
+    "m5stack-cores3"
+    "station-g2"
     "t-eth-elite"
-    "t-watch-s3"
     "tlora-pager"
+    "t-watch-s3"
+    "elecrow-adv"
 )
 S3_VARIANTS=(
     "s3"
     "-v3"
-    "-v4"
     "t-deck"
     "wireless-paper"
     "wireless-tracker"

bin/device-update.sh

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

bin/generate_ci_matrix.py

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

bin/kill-github-actions.sh

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

bin/org.meshtastic.meshtasticd.metainfo.xml

@@ -87,27 +87,6 @@
   </screenshots>
 
   <releases>
-    <release version="2.7.16" date="2025-11-19">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.16</url>
-    </release>
-    <release version="2.7.15" date="2025-11-13">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.15</url>
-    </release>
-    <release version="2.7.14" date="2025-11-03">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.14</url>
-    </release>
-    <release version="2.7.13" date="2025-10-11">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.13</url>
-    </release>
-    <release version="2.7.12" date="2025-10-01">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.12</url>
-    </release>
-    <release version="2.7.11" date="2025-09-24">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.11</url>
-    </release>
-    <release version="2.7.10" date="2025-09-18">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.10</url>
-    </release>
     <release version="2.7.9" date="2025-09-03">
       <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.9</url>
     </release>

bin/platformio-custom.py

@@ -6,8 +6,6 @@ from os.path import join
 import subprocess
 import json
 import re
-import time
-from datetime import datetime
 
 from readprops import readProps
 
@@ -86,7 +84,7 @@ if platform.name == "espressif32":
 
 if platform.name == "nordicnrf52":
     env.AddPostAction("$BUILD_DIR/${PROGNAME}.hex",
-                      env.VerboseAction(f"\"{sys.executable}\" ./bin/uf2conv.py \"$BUILD_DIR/firmware.hex\" -c -f 0xADA52840 -o \"$BUILD_DIR/firmware.uf2\"",
+                      env.VerboseAction(f"\"{sys.executable}\" ./bin/uf2conv.py $BUILD_DIR/firmware.hex -c -f 0xADA52840 -o $BUILD_DIR/firmware.uf2",
                                         "Generating UF2 file"))
 
 Import("projenv")
@@ -127,16 +125,11 @@ for pref in userPrefs:
         pref_flags.append("-D" + pref + "=" + env.StringifyMacro(userPrefs[pref]) + "")
 
 # General options that are passed to the C and C++ compilers
-# Calculate unix epoch for current day (midnight)
-current_date = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-build_epoch = int(current_date.timestamp())
-
 flags = [
         "-DAPP_VERSION=" + verObj["long"],
         "-DAPP_VERSION_SHORT=" + verObj["short"],
         "-DAPP_ENV=" + env.get("PIOENV"),
         "-DAPP_REPO=" + repo_owner,
-        "-DBUILD_EPOCH=" + str(build_epoch),
     ] + pref_flags
 
 print ("Using flags:")

bin/web.version

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

boards/ThinkNode-M3.json

@@ -1,53 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
-    },
-    "core": "nRF5",
-    "cpu": "cortex-m4",
-    "extra_flags": "-DNRF52840_XXAA",
-    "f_cpu": "64000000L",
-    "hwids": [
-      ["0x239A", "0x4405"],
-      ["0x239A", "0x0029"],
-      ["0x239A", "0x002A"]
-    ],
-    "usb_product": "elecrow_eink",
-    "mcu": "nrf52840",
-    "variant": "ELECROW-ThinkNode-M3",
-    "variants_dir": "variants",
-    "bsp": {
-      "name": "adafruit"
-    },
-    "softdevice": {
-      "sd_flags": "-DS140",
-      "sd_name": "s140",
-      "sd_version": "6.1.1",
-      "sd_fwid": "0x00B6"
-    },
-    "bootloader": {
-      "settings_addr": "0xFF000"
-    }
-  },
-  "connectivity": ["bluetooth"],
-  "debug": {
-    "jlink_device": "nRF52840_xxAA",
-    "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
-  },
-  "frameworks": ["arduino"],
-  "name": "elecrow nrf",
-  "upload": {
-    "maximum_ram_size": 248832,
-    "maximum_size": 815104,
-    "speed": 115200,
-    "protocol": "nrfutil",
-    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
-    "use_1200bps_touch": true,
-    "require_upload_port": true,
-    "wait_for_upload_port": true
-  },
-  "url": "",
-  "vendor": "ELECROW"
-}

boards/ThinkNode-M6.json

@@ -1,53 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
-    },
-    "core": "nRF5",
-    "cpu": "cortex-m4",
-    "extra_flags": "-DARDUINO_NRF52840_ELECROW_M6 -DNRF52840_XXAA",
-    "f_cpu": "64000000L",
-    "hwids": [
-      ["0x239A", "0x4405"],
-      ["0x239A", "0x0029"],
-      ["0x239A", "0x002A"]
-    ],
-    "usb_product": "elecrow_thinknode_m6",
-    "mcu": "nrf52840",
-    "variant": "ELECROW-ThinkNode-M6",
-    "variants_dir": "variants",
-    "bsp": {
-      "name": "adafruit"
-    },
-    "softdevice": {
-      "sd_flags": "-DS140",
-      "sd_name": "s140",
-      "sd_version": "6.1.1",
-      "sd_fwid": "0x00B6"
-    },
-    "bootloader": {
-      "settings_addr": "0xFF000"
-    }
-  },
-  "connectivity": ["bluetooth"],
-  "debug": {
-    "jlink_device": "nRF52840_xxAA",
-    "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
-  },
-  "frameworks": ["arduino"],
-  "name": "ELECROW ThinkNode M6",
-  "upload": {
-    "maximum_ram_size": 248832,
-    "maximum_size": 815104,
-    "speed": 115200,
-    "protocol": "nrfutil",
-    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
-    "use_1200bps_touch": true,
-    "require_upload_port": true,
-    "wait_for_upload_port": true
-  },
-  "url": "https://www.elecrow.com/thinknode-m6-outdoor-solar-power-for-lora-powered-by-nrf52840-supports-gps.html",
-  "vendor": "ELECROW"
-}

boards/heltec_v4.json

@@ -1,43 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "esp32s3_out.ld",
-      "partitions": "default_16MB.csv",
-      "memory_type": "qio_qspi"
-    },
-    "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=1"
-    ],
-    "f_cpu": "240000000L",
-    "f_flash": "80000000L",
-    "flash_mode": "qio",
-    "psram_type": "qspi",
-    "hwids": [["0x303A", "0x1001"]],
-    "mcu": "esp32s3",
-    "variant": "heltec_v4"
-  },
-  "connectivity": ["wifi", "bluetooth", "lora"],
-  "debug": {
-    "default_tool": "esp-builtin",
-    "onboard_tools": ["esp-builtin"],
-    "openocd_target": "esp32s3.cfg"
-  },
-  "frameworks": ["arduino", "espidf"],
-  "name": "heltec_wifi_lora_32 v4 (16 MB FLASH, 2 MB PSRAM)",
-  "upload": {
-    "flash_size": "16MB",
-    "maximum_ram_size": 2097152,
-    "maximum_size": 16777216,
-    "use_1200bps_touch": true,
-    "wait_for_upload_port": true,
-    "require_upload_port": true,
-    "speed": 921600
-  },
-  "url": "https://heltec.org/",
-  "vendor": "heltec"
-}

boards/heltec_wireless_tracker_v2.json

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

boards/muzi-base.json

@@ -1,56 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
-    },
-    "core": "nRF5",
-    "cpu": "cortex-m4",
-    "extra_flags": "-DARDUINO_NRF52840_MUZI_BASE -DNRF52840_XXAA",
-    "f_cpu": "64000000L",
-    "hwids": [["0x239A", "0xcafe"]],
-    "mcu": "nrf52840",
-    "variant": "muzi-base",
-    "variants_dir": "variants",
-    "bsp": {
-      "name": "adafruit"
-    },
-    "softdevice": {
-      "sd_flags": "-DS140",
-      "sd_name": "s140",
-      "sd_version": "6.1.1",
-      "sd_fwid": "0x00B6"
-    },
-    "bootloader": {
-      "settings_addr": "0xFF000"
-    }
-  },
-  "connectivity": ["bluetooth"],
-  "debug": {
-    "jlink_device": "nRF52840_xxAA",
-    "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
-  },
-  "frameworks": ["arduino"],
-  "name": "Muzi Base",
-  "url": "https://muzi.works/",
-  "vendor": "MuziWorks",
-  "upload": {
-    "maximum_ram_size": 248832,
-    "maximum_size": 815104,
-    "speed": 115200,
-    "protocol": "nrfutil",
-    "protocols": [
-      "jlink",
-      "nrfjprog",
-      "nrfutil",
-      "blackmagic",
-      "cmsis-dap",
-      "mbed",
-      "stlink"
-    ],
-    "use_1200bps_touch": true,
-    "require_upload_port": true,
-    "wait_for_upload_port": true
-  }
-}

boards/r1-neo.json

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

boards/t5-epaper-s3.json

@@ -1,38 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "esp32s3_out.ld",
-      "memory_type": "qio_opi",
-      "partitions": "default_16MB.csv"
-    },
-    "core": "esp32",
-    "extra_flags": [
-      "-DBOARD_HAS_PSRAM",
-      "-DARDUINO_RUNNING_CORE=1",
-      "-DARDUINO_EVENT_RUNNING_CORE=0",
-      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1"
-    ],
-    "f_cpu": "240000000L",
-    "f_flash": "80000000L",
-    "flash_mode": "qio",
-    "hwids": [["0x303A", "0x1001"]],
-    "mcu": "esp32s3",
-    "variant": "esp32s3"
-  },
-  "connectivity": ["wifi", "bluetooth", "lora"],
-  "debug": {
-    "openocd_target": "esp32s3.cfg"
-  },
-  "frameworks": ["arduino", "espidf"],
-  "name": "LilyGo T5-ePaper-S3",
-  "upload": {
-    "flash_size": "16MB",
-    "maximum_ram_size": 327680,
-    "maximum_size": 16777216,
-    "require_upload_port": true,
-    "speed": 921600
-  },
-  "url": "https://lilygo.cc/products/t5-e-paper-s3-pro",
-  "vendor": "LILYGO"
-}

debian/changelog

@@ -1,38 +1,50 @@
-meshtasticd (2.7.16.0) unstable; urgency=medium
-
-  * Version 2.7.16
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Wed, 19 Nov 2025 16:12:32 +0000
-
-
-meshtasticd (2.7.15.0) unstable; urgency=medium
-
-  * Version 2.7.15
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Thu, 13 Nov 2025 12:31:57 +0000
-
-meshtasticd (2.7.14.0) unstable; urgency=medium
-
-  * Version 2.7.14
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Mon, 03 Nov 2025 16:11:31 +0000
-
-meshtasticd (2.7.13.0) unstable; urgency=medium
-
-  * Version 2.7.13
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Sat, 11 Oct 2025 15:27:28 +0000
-
-meshtasticd (2.7.12.0) unstable; urgency=medium
+meshtasticd (2.7.9.0) UNRELEASED; urgency=medium
 
   [ Austin Lane ]
   * Initial packaging
-  * Version 2.5.19
+  * GitHub Actions Automatic version bump
+  * GitHub Actions Automatic version bump
+  * GitHub Actions Automatic version bump
+  * GitHub Actions Automatic version bump
 
   [  ]
   * GitHub Actions Automatic version bump
 
-  [ GitHub Actions ]
-  * Version 2.7.12
+  [  ]
+  * GitHub Actions Automatic version bump
 
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Wed, 01 Oct 2025 19:51:41 +0000
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [ Ubuntu ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+  [  ]
+  * GitHub Actions Automatic version bump
+
+ --  <github-actions[bot]@users.noreply.github.com>  Wed, 03 Sep 2025 23:39:17 +0000

debian/ci_changelog.sh

@@ -1,8 +1,7 @@
 #!/usr/bin/bash
-export DEBFULLNAME="GitHub Actions"
 export DEBEMAIL="github-actions[bot]@users.noreply.github.com"
 PKG_VERSION=$(python3 bin/buildinfo.py short)
 
 dch --newversion "$PKG_VERSION.0" \
-	--distribution unstable \
-	"Version $PKG_VERSION"
+	--distribution UNRELEASED \
+	"GitHub Actions Automatic version bump"

debian/control

@@ -3,7 +3,6 @@ Section: misc
 Priority: optional
 Maintainer: Austin Lane <vidplace7@gmail.com>
 Build-Depends: debhelper-compat (= 13),
-               libc6-dev (>= 2.38) | libbsd-dev,
                lsb-release,
                tar,
                gzip,

debian/meshtasticd.postinst

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

debian/meshtasticd.postrm

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

meshtasticd.spec.rpkg

@@ -49,13 +49,6 @@ BuildRequires: pkgconfig(x11)
 BuildRequires: pkgconfig(libinput)
 BuildRequires: pkgconfig(xkbcommon-x11)
 
-# libbsd is needed on older Fedora/RHEL to provide 'strlcpy'
-%if 0%{?fedora} >= 39 || 0%{?rhel} >= 10
-BuildRequires: glibc-devel >= 2.38
-%else
-BuildRequires: pkgconfig(libbsd-overlay)
-%endif
-
 Requires:      systemd-udev
 
 %description

platformio.ini

@@ -53,16 +53,14 @@ build_flags = -Wno-missing-field-initializers
 	-DMESHTASTIC_EXCLUDE_POWERSTRESS=1 ; exclude power stress test module from main firmware
 	-DMESHTASTIC_EXCLUDE_GENERIC_THREAD_MODULE=1
 	-D MAX_THREADS=40 ; As we've split modules, we have more threads to manage
-	#-DBUILD_EPOCH=$UNIX_TIME ; set in platformio-custom.py now
+	#-DBUILD_EPOCH=$UNIX_TIME
 	#-D OLED_PL=1
-	#-D DEBUG_HEAP=1 ; uncomment to add free heap space / memory leak debugging logs
-	#-D DEBUG_LOOP_TIMING=1 ; uncomment to add main loop timing logs
 
 monitor_speed = 115200
 monitor_filters = direct
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-esp8266-oled-ssd1306 packageName=https://github.com/meshtastic/esp8266-oled-ssd1306 gitBranch=master
-	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/2887bf4a19f64d92c984dcc8fd5ca7429e425e4a.zip
+	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/9573abb64dc9c94f3051348f2bf4fc5cedf03c22.zip
 	# renovate: datasource=git-refs depName=meshtastic-OneButton packageName=https://github.com/meshtastic/OneButton gitBranch=master
 	https://github.com/meshtastic/OneButton/archive/fa352d668c53f290cfa480a5f79ad422cd828c70.zip
 	# renovate: datasource=git-refs depName=meshtastic-arduino-fsm packageName=https://github.com/meshtastic/arduino-fsm gitBranch=master
@@ -70,7 +68,7 @@ lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-TinyGPSPlus packageName=https://github.com/meshtastic/TinyGPSPlus gitBranch=master
 	https://github.com/meshtastic/TinyGPSPlus/archive/71a82db35f3b973440044c476d4bcdc673b104f4.zip
 	# renovate: datasource=git-refs depName=meshtastic-ArduinoThread packageName=https://github.com/meshtastic/ArduinoThread gitBranch=master
-	https://github.com/meshtastic/ArduinoThread/archive/b841b0415721f1341ea41cccfb4adccfaf951567.zip
+	https://github.com/meshtastic/ArduinoThread/archive/7c3ee9e1951551b949763b1f5280f8db1fa4068d.zip
 	# renovate: datasource=custom.pio depName=Nanopb packageName=nanopb/library/Nanopb
 	nanopb/Nanopb@0.4.91
 	# renovate: datasource=custom.pio depName=ErriezCRC32 packageName=erriez/library/ErriezCRC32
@@ -90,7 +88,7 @@ framework = arduino
 lib_deps =
 	${env.lib_deps}
 	# renovate: datasource=custom.pio depName=NonBlockingRTTTL packageName=end2endzone/library/NonBlockingRTTTL
-	end2endzone/NonBlockingRTTTL@1.4.0
+	end2endzone/NonBlockingRTTTL@1.3.0
 build_flags = ${env.build_flags} -Os
 build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/>
 
@@ -115,19 +113,18 @@ lib_deps =
 [radiolib_base]
 lib_deps =
 	# renovate: datasource=custom.pio depName=RadioLib packageName=jgromes/library/RadioLib
-	# jgromes/RadioLib@7.4.0
-	https://github.com/jgromes/RadioLib/archive/536c7267362e2c1345be7054ba45e503252975ff.zip
+	jgromes/RadioLib@7.2.1
 
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/4fb5f24787caa841b58dbf623a52c4c5861d6722.zip
+	https://github.com/meshtastic/device-ui/archive/3677476c8a823ee85056b5fb1d146a3e193f8276.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
 lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit BusIO packageName=adafruit/library/Adafruit BusIO
-	adafruit/Adafruit BusIO@1.17.4
+	adafruit/Adafruit BusIO@1.17.2
 	# renovate: datasource=custom.pio depName=Adafruit Unified Sensor packageName=adafruit/library/Adafruit Unified Sensor
 	adafruit/Adafruit Unified Sensor@1.1.15
 	# renovate: datasource=custom.pio depName=Adafruit BMP280 packageName=adafruit/library/Adafruit BMP280 Library
@@ -165,11 +162,11 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=QMC5883L Compass packageName=mprograms/library/QMC5883LCompass
 	mprograms/QMC5883LCompass@1.2.3
 	# renovate: datasource=custom.pio depName=DFRobot_RTU packageName=dfrobot/library/DFRobot_RTU
-	dfrobot/DFRobot_RTU@1.0.6
+	dfrobot/DFRobot_RTU@1.0.3
 	# renovate: datasource=git-refs depName=DFRobot_RainfallSensor packageName=https://github.com/DFRobot/DFRobot_RainfallSensor gitBranch=master
 	https://github.com/DFRobot/DFRobot_RainfallSensor/archive/38fea5e02b40a5430be6dab39a99a6f6347d667e.zip
 	# renovate: datasource=custom.pio depName=INA226 packageName=robtillaart/library/INA226
-	robtillaart/INA226@0.6.5
+	robtillaart/INA226@0.6.4
 	# renovate: datasource=custom.pio depName=SparkFun MAX3010x packageName=sparkfun/library/SparkFun MAX3010x Pulse and Proximity Sensor Library
 	sparkfun/SparkFun MAX3010x Pulse and Proximity Sensor Library@1.1.2
 	# renovate: datasource=custom.pio depName=SparkFun 9DoF IMU Breakout ICM 20948 packageName=sparkfun/library/SparkFun 9DoF IMU Breakout - ICM 20948 - Arduino Library
@@ -177,13 +174,11 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit LTR390 Library packageName=adafruit/library/Adafruit LTR390 Library
 	adafruit/Adafruit LTR390 Library@1.1.2
 	# renovate: datasource=custom.pio depName=Adafruit PCT2075 packageName=adafruit/library/Adafruit PCT2075
-	adafruit/Adafruit PCT2075@1.0.6
+	adafruit/Adafruit PCT2075@1.0.5
 	# renovate: datasource=custom.pio depName=DFRobot_BMM150 packageName=dfrobot/library/DFRobot_BMM150
 	dfrobot/DFRobot_BMM150@1.0.0
 	# renovate: datasource=custom.pio depName=Adafruit_TSL2561 packageName=adafruit/library/Adafruit TSL2561
 	adafruit/Adafruit TSL2561@1.1.2
-	# renovate: datasource=custom.pio depName=BH1750_WE packageName=wollewald/BH1750_WE@^1.1.10
-	wollewald/BH1750_WE@^1.1.10
 
 ; (not included in native / portduino)
 [environmental_extra]
@@ -213,6 +208,6 @@ lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-DFRobot_LarkWeatherStation packageName=https://github.com/meshtastic/DFRobot_LarkWeatherStation gitBranch=master
 	https://github.com/meshtastic/DFRobot_LarkWeatherStation/archive/4de3a9cadef0f6a5220a8a906cf9775b02b0040d.zip
 	# renovate: datasource=custom.pio depName=Sensirion Core packageName=sensirion/library/Sensirion Core
-	sensirion/Sensirion Core@0.7.2
+	sensirion/Sensirion Core@0.7.1
 	# renovate: datasource=custom.pio depName=Sensirion I2C SCD4x packageName=sensirion/library/Sensirion I2C SCD4x
 	sensirion/Sensirion I2C SCD4x@1.1.0

renovate.json

@@ -8,7 +8,6 @@
     "replacements:all",
     "workarounds:all"
   ],
-  "baseBranchPatterns": ["master"],
   "forkProcessing": "enabled",
   "ignoreDeps": [
     "protobufs"

src/AmbientLightingThread.h

@@ -183,9 +183,9 @@ class AmbientLightingThread : public concurrency::OSThread
 #endif
 #endif
             pixels.show();
-            // LOG_DEBUG("Init NeoPixel Ambient light w/ brightness(current)=%d, red=%d, green=%d, blue=%d",
-            //        moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
-            //        moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init NeoPixel Ambient light w/ brightness(current)=%d, red=%d, green=%d, blue=%d",
+                      moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
+                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef RGBLED_CA
             analogWrite(RGBLED_RED, 255 - moduleConfig.ambient_lighting.red);

src/AudioThread.h

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

src/DebugConfiguration.cpp

@@ -146,7 +146,7 @@ inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *mess
 {
     int result;
 #ifdef ARCH_PORTDUINO
-    bool utf = !portduino_config.ascii_logs;
+    bool utf = !settingsMap[ascii_logs];
 #else
     bool utf = true;
 #endif

src/DebugConfiguration.h

@@ -2,12 +2,6 @@
 
 #include "configuration.h"
 
-// Forward declarations
-#if defined(DEBUG_HEAP)
-class MemGet;
-extern MemGet memGet;
-#endif
-
 // DEBUG LED
 #ifndef LED_STATE_ON
 #define LED_STATE_ON 1
@@ -29,7 +23,6 @@ extern MemGet memGet;
 #define MESHTASTIC_LOG_LEVEL_ERROR "ERROR"
 #define MESHTASTIC_LOG_LEVEL_CRIT "CRIT "
 #define MESHTASTIC_LOG_LEVEL_TRACE "TRACE"
-#define MESHTASTIC_LOG_LEVEL_HEAP "HEAP"
 
 #include "SerialConsole.h"
 
@@ -69,25 +62,6 @@ extern MemGet memGet;
 #endif
 #endif
 
-#if defined(DEBUG_HEAP)
-#define LOG_HEAP(...) DEBUG_PORT.log(MESHTASTIC_LOG_LEVEL_HEAP, __VA_ARGS__)
-
-// Macro-based heap debugging
-#define DEBUG_HEAP_BEFORE auto heapBefore = memGet.getFreeHeap();
-#define DEBUG_HEAP_AFTER(context, ptr)                                                                                           \
-    do {                                                                                                                         \
-        auto heapAfter = memGet.getFreeHeap();                                                                                   \
-        if (heapBefore != heapAfter) {                                                                                           \
-            LOG_HEAP("Alloc in %s pointer 0x%x, size: %u, free: %u", context, ptr, heapBefore - heapAfter, heapAfter);           \
-        }                                                                                                                        \
-    } while (0)
-
-#else
-#define LOG_HEAP(...)
-#define DEBUG_HEAP_BEFORE
-#define DEBUG_HEAP_AFTER(context, ptr)
-#endif
-
 /// A C wrapper for LOG_DEBUG that can be used from arduino C libs that don't know about C++ or meshtastic
 extern "C" void logLegacy(const char *level, const char *fmt, ...);
 

src/DisplayFormatters.cpp

@@ -38,46 +38,4 @@ const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaC
         return useShortName ? "Custom" : "Invalid";
         break;
     }
-}
-
-const char *DisplayFormatters::getDeviceRole(meshtastic_Config_DeviceConfig_Role role)
-{
-    switch (role) {
-    case meshtastic_Config_DeviceConfig_Role_CLIENT:
-        return "Client";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE:
-        return "Client Mute";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN:
-        return "Client Hidden";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_CLIENT_BASE:
-        return "Client Base";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND:
-        return "Lost and Found";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_TRACKER:
-        return "Tracker";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_SENSOR:
-        return "Sensor";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_TAK:
-        return "TAK";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_TAK_TRACKER:
-        return "TAK Tracker";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_ROUTER:
-        return "Router";
-        break;
-    case meshtastic_Config_DeviceConfig_Role_ROUTER_LATE:
-        return "Router Late";
-        break;
-    default:
-        return "Unknown";
-        break;
-    }
 }

src/DisplayFormatters.h

@@ -6,5 +6,4 @@ class DisplayFormatters
   public:
     static const char *getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName,
                                                  bool usePreset);
-    static const char *getDeviceRole(meshtastic_Config_DeviceConfig_Role role);
 };

src/GPSStatus.h

@@ -22,9 +22,6 @@ class GPSStatus : public Status
 
     meshtastic_Position p = meshtastic_Position_init_default;
 
-    /// Time of last valid GPS fix (millis since boot)
-    uint32_t lastFixMillis = 0;
-
   public:
     GPSStatus() { statusType = STATUS_TYPE_GPS; }
 
@@ -86,9 +83,6 @@ class GPSStatus : public Status
 
     uint32_t getNumSatellites() const { return p.sats_in_view; }
 
-    /// Return millis() when the last GPS fix occurred (0 = never)
-    uint32_t getLastFixMillis() const { return lastFixMillis; }
-
     bool matches(const GPSStatus *newStatus) const
     {
 #ifdef GPS_DEBUG
@@ -120,9 +114,6 @@ class GPSStatus : public Status
 
         if (isDirty) {
             if (hasLock) {
-                // Record time of last valid GPS fix
-                lastFixMillis = millis();
-
                 // In debug logs, identify position by @timestamp:stage (stage 3 = notify)
                 LOG_DEBUG("New GPS pos@%x:3 lat=%f lon=%f alt=%d pdop=%.2f track=%.2f speed=%.2f sats=%d", p.timestamp,
                           p.latitude_i * 1e-7, p.longitude_i * 1e-7, p.altitude, p.PDOP * 1e-2, p.ground_track * 1e-5,

src/NodeStatus.h

@@ -14,16 +14,16 @@ class NodeStatus : public Status
     CallbackObserver<NodeStatus, const NodeStatus *> statusObserver =
         CallbackObserver<NodeStatus, const NodeStatus *>(this, &NodeStatus::updateStatus);
 
-    uint16_t numOnline = 0;
-    uint16_t numTotal = 0;
+    uint8_t numOnline = 0;
+    uint8_t numTotal = 0;
 
-    uint16_t lastNumTotal = 0;
+    uint8_t lastNumTotal = 0;
 
   public:
     bool forceUpdate = false;
 
     NodeStatus() { statusType = STATUS_TYPE_NODE; }
-    NodeStatus(uint16_t numOnline, uint16_t numTotal, bool forceUpdate = false) : Status()
+    NodeStatus(uint8_t numOnline, uint8_t numTotal, bool forceUpdate = false) : Status()
     {
         this->forceUpdate = forceUpdate;
         this->numOnline = numOnline;
@@ -34,11 +34,11 @@ class NodeStatus : public Status
 
     void observe(Observable<const NodeStatus *> *source) { statusObserver.observe(source); }
 
-    uint16_t getNumOnline() const { return numOnline; }
+    uint8_t getNumOnline() const { return numOnline; }
 
-    uint16_t getNumTotal() const { return numTotal; }
+    uint8_t getNumTotal() const { return numTotal; }
 
-    uint16_t getLastNumTotal() const { return lastNumTotal; }
+    uint8_t getLastNumTotal() const { return lastNumTotal; }
 
     bool matches(const NodeStatus *newStatus) const
     {
@@ -56,7 +56,7 @@ class NodeStatus : public Status
             numTotal = newStatus->getNumTotal();
         }
         if (isDirty || newStatus->forceUpdate) {
-            LOG_DEBUG("Node status update: %u online, %u total", numOnline, numTotal);
+            LOG_DEBUG("Node status update: %d online, %d total", numOnline, numTotal);
             onNewStatus.notifyObservers(this);
         }
         return 0;

src/Power.cpp

@@ -194,7 +194,7 @@ static HasBatteryLevel *batteryLevel; // Default to NULL for no battery level se
 
 #ifdef BATTERY_PIN
 
-void battery_adcEnable()
+static void adcEnable()
 {
 #ifdef ADC_CTRL // enable adc voltage divider when we need to read
 #ifdef ADC_USE_PULLUP
@@ -214,7 +214,7 @@ void battery_adcEnable()
 #endif
 }
 
-static void battery_adcDisable()
+static void adcDisable()
 {
 #ifdef ADC_CTRL // disable adc voltage divider when we need to read
 #ifdef ADC_USE_PULLUP
@@ -278,11 +278,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
                 break;
             }
         }
-#if defined(BATTERY_CHARGING_INV)
-        // bit of trickery to show 99% up until the charge finishes
-        if (!digitalRead(BATTERY_CHARGING_INV) && battery_SOC > 99)
-            battery_SOC = 99;
-#endif
         return clamp((int)(battery_SOC), 0, 100);
     }
 
@@ -325,7 +320,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
             uint32_t raw = 0;
             float scaled = 0;
 
-            battery_adcEnable();
+            adcEnable();
 #ifdef ARCH_ESP32 // ADC block for espressif platforms
             raw = espAdcRead();
             scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
@@ -337,7 +332,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
             raw = raw / BATTERY_SENSE_SAMPLES;
             scaled = operativeAdcMultiplier * ((1000 * AREF_VOLTAGE) / pow(2, BATTERY_SENSE_RESOLUTION_BITS)) * raw;
 #endif
-            battery_adcDisable();
+            adcDisable();
 
             if (!initial_read_done) {
                 // Flush the smoothing filter with an ADC reading, if the reading is plausibly correct
@@ -460,8 +455,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
         }
         // if it's not HIGH - check the battery
 #endif
-#elif defined(MUZI_BASE)
-        return NRF_POWER->USBREGSTATUS & POWER_USBREGSTATUS_VBUSDETECT_Msk;
 #endif
         return getBattVoltage() > chargingVolt;
     }
@@ -477,8 +470,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
 #endif
 #ifdef EXT_CHRG_DETECT
         return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value;
-#elif defined(BATTERY_CHARGING_INV)
-        return !digitalRead(BATTERY_CHARGING_INV);
 #else
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !defined(DISABLE_INA_CHARGING_DETECTION)
         if (hasINA()) {
@@ -571,7 +562,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
                    config.power.device_battery_ina_address) {
             if (!ina226Sensor.isInitialized())
                 return ina226Sensor.runOnce() > 0;
-            return ina226Sensor.isRunning();
         } else if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_INA260].first ==
                    config.power.device_battery_ina_address) {
             if (!ina260Sensor.isInitialized())
@@ -701,24 +691,7 @@ bool Power::setup()
 #ifdef NRF_APM
     found = true;
 #endif
-#ifdef EXT_PWR_DETECT
-    attachInterrupt(
-        EXT_PWR_DETECT,
-        []() {
-            power->setIntervalFromNow(0);
-            runASAP = true;
-        },
-        CHANGE);
-#endif
-#ifdef BATTERY_CHARGING_INV
-    attachInterrupt(
-        BATTERY_CHARGING_INV,
-        []() {
-            power->setIntervalFromNow(0);
-            runASAP = true;
-        },
-        CHANGE);
-#endif
+
     enabled = found;
     low_voltage_counter = 0;
 
@@ -775,8 +748,6 @@ void Power::shutdown()
     if (screen) {
 #ifdef T_DECK_PRO
         screen->showSimpleBanner("Device is powered off.\nConnect USB to start!", 0); // T-Deck Pro has no power button
-#elif defined(USE_EINK)
-        screen->showSimpleBanner("Shutting Down...", 2250); // dismiss after 3 seconds to avoid the banner on the sleep screen
 #else
         screen->showSimpleBanner("Shutting Down...", 0); // stays on screen
 #endif
@@ -857,11 +828,8 @@ void Power::readPowerStatus()
 
     // Notify any status instances that are observing us
     const PowerStatus powerStatus2 = PowerStatus(hasBattery, usbPowered, isChargingNow, batteryVoltageMv, batteryChargePercent);
-    if (millis() > lastLogTime + 50 * 1000) {
-        LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d", powerStatus2.getHasUSB(),
-                  powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
-        lastLogTime = millis();
-    }
+    LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d", powerStatus2.getHasUSB(), powerStatus2.getIsCharging(),
+              powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
     newStatus.notifyObservers(&powerStatus2);
 #ifdef DEBUG_HEAP
     if (lastheap != memGet.getFreeHeap()) {
@@ -883,9 +851,9 @@ void Power::readPowerStatus()
                 running++;
             }
         }
-        LOG_HEAP(threadlist);
-        LOG_HEAP("Heap status: %d/%d bytes free (%d), running %d/%d threads", memGet.getFreeHeap(), memGet.getHeapSize(),
-                 memGet.getFreeHeap() - lastheap, running, concurrency::mainController.size(false));
+        LOG_DEBUG(threadlist);
+        LOG_DEBUG("Heap status: %d/%d bytes free (%d), running %d/%d threads", memGet.getFreeHeap(), memGet.getHeapSize(),
+                  memGet.getFreeHeap() - lastheap, running, concurrency::mainController.size(false));
         lastheap = memGet.getFreeHeap();
     }
 #ifdef DEBUG_HEAP_MQTT
@@ -924,8 +892,13 @@ void Power::readPowerStatus()
             low_voltage_counter++;
             LOG_DEBUG("Low voltage counter: %d/10", low_voltage_counter);
             if (low_voltage_counter > 10) {
+#ifdef ARCH_NRF52
+                // We can't trigger deep sleep on NRF52, it's freezing the board
+                LOG_DEBUG("Low voltage detected, but not trigger deep sleep");
+#else
                 LOG_INFO("Low voltage detected, trigger deep sleep");
                 powerFSM.trigger(EVENT_LOW_BATTERY);
+#endif
             }
         } else {
             low_voltage_counter = 0;
@@ -1565,4 +1538,4 @@ bool Power::meshSolarInit()
 {
     return false;
 }
-#endif
+#endif

src/RedirectablePrint.cpp

@@ -4,7 +4,6 @@
 #include "concurrency/OSThread.h"
 #include "configuration.h"
 #include "main.h"
-#include "memGet.h"
 #include "mesh/generated/meshtastic/mesh.pb.h"
 #include <assert.h>
 #include <cstring>
@@ -58,7 +57,7 @@ size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_l
 #endif
 
 #ifdef ARCH_PORTDUINO
-    bool color = !portduino_config.ascii_logs;
+    bool color = !settingsMap[ascii_logs];
 #else
     bool color = true;
 #endif
@@ -100,7 +99,7 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
     size_t r = 0;
 
 #ifdef ARCH_PORTDUINO
-    bool color = !portduino_config.ascii_logs;
+    bool color = !settingsMap[ascii_logs];
 #else
     bool color = true;
 #endif
@@ -167,16 +166,6 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
         print(thread->ThreadName);
         print("] ");
     }
-
-#ifdef DEBUG_HEAP
-    // Add heap free space bytes prefix before every log message
-#ifdef ARCH_PORTDUINO
-    ::printf("[heap %u] ", memGet.getFreeHeap());
-#else
-    printf("[heap %u] ", memGet.getFreeHeap());
-#endif
-#endif // DEBUG_HEAP
-
     r += vprintf(logLevel, format, arg);
 }
 
@@ -299,7 +288,7 @@ void RedirectablePrint::log(const char *logLevel, const char *format, ...)
 #if ARCH_PORTDUINO
     // level trace is special, two possible ways to handle it.
     if (strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
-        if (portduino_config.traceFilename != "") {
+        if (settingsStrings[traceFilename] != "") {
             va_list arg;
             va_start(arg, format);
             try {
@@ -308,18 +297,18 @@ void RedirectablePrint::log(const char *logLevel, const char *format, ...)
             }
             va_end(arg);
         }
-        if (portduino_config.logoutputlevel < level_trace && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
+        if (settingsMap[logoutputlevel] < level_trace && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
             delete[] newFormat;
             return;
         }
     }
-    if (portduino_config.logoutputlevel < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
+    if (settingsMap[logoutputlevel] < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
         delete[] newFormat;
         return;
-    } else if (portduino_config.logoutputlevel < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0) {
+    } else if (settingsMap[logoutputlevel] < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0) {
         delete[] newFormat;
         return;
-    } else if (portduino_config.logoutputlevel < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0) {
+    } else if (settingsMap[logoutputlevel] < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0) {
         delete[] newFormat;
         return;
     }

src/SerialConsole.cpp

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

src/SerialConsole.h

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

src/buzz/BuzzerFeedbackThread.cpp

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

src/buzz/BuzzerFeedbackThread.h

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

src/concurrency/OSThread.cpp

@@ -86,13 +86,11 @@ void OSThread::run()
 #ifdef DEBUG_HEAP
     auto newHeap = memGet.getFreeHeap();
     if (newHeap < heap)
-        LOG_HEAP("------ Thread %s leaked heap %d -> %d (%d) ------", ThreadName.c_str(), heap, newHeap, newHeap - heap);
+        LOG_DEBUG("------ Thread %s leaked heap %d -> %d (%d) ------", ThreadName.c_str(), heap, newHeap, newHeap - heap);
     if (heap < newHeap)
-        LOG_HEAP("++++++ Thread %s freed heap %d -> %d (%d) ++++++", ThreadName.c_str(), heap, newHeap, newHeap - heap);
-#endif
-#ifdef DEBUG_LOOP_TIMING
-    LOG_DEBUG("====== Thread next run in: %d", newDelay);
+        LOG_DEBUG("++++++ Thread %s freed heap %d -> %d (%d) ++++++", ThreadName.c_str(), heap, newHeap, newHeap - heap);
 #endif
+
     runned();
 
     if (newDelay >= 0)

src/configuration.h

@@ -33,9 +33,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "pcf8563.h"
 #endif
 
-/* Offer chance for variant-specific defines */
-#include "variant.h"
-
 // -----------------------------------------------------------------------------
 // Version
 // -----------------------------------------------------------------------------
@@ -120,17 +117,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define SX126X_MAX_POWER 22
 #endif
 
-#ifdef USE_GC1109_PA
-// Power Amps are often non-linear, so we can use an array of values for the power curve
-#define NUM_PA_POINTS 22
-#define TX_GAIN_LORA 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 10, 10, 9, 9, 8, 7
-#endif
-
-#ifdef RAK13302
-#define NUM_PA_POINTS 22
-#define TX_GAIN_LORA 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8
-#endif
-
 // Default system gain to 0 if not defined
 #ifndef TX_GAIN_LORA
 #define TX_GAIN_LORA 0
@@ -228,7 +214,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define ICM20948_ADDR_ALT 0x68
 #define BHI260AP_ADDR 0x28
 #define BMM150_ADDR 0x13
-#define DA217_ADDR 0x26
 
 // -----------------------------------------------------------------------------
 // LED
@@ -250,9 +235,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // Touchscreen
 // -----------------------------------------------------------------------------
 #define FT6336U_ADDR 0x48
-#define CST328_ADDR 0x1A // same address as CST226SE
-#define CHSC6X_ADDR 0x2E
-#define CST226SE_ADDR_ALT 0x5A
+#define CST328_ADDR 0x1A
 
 // -----------------------------------------------------------------------------
 // RAK12035VB Soil Monitor (using RAK12023 up to 3 RAK12035 monitors can be connected)
@@ -271,18 +254,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // convert 24-bit color to 16-bit (56K)
 #define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))
 
+/* Step #1: offer chance for variant-specific defines */
+#include "variant.h"
+
 #if defined(VEXT_ENABLE) && !defined(VEXT_ON_VALUE)
 // Older variant.h files might not be defining this value, so stay with the old default
 #define VEXT_ON_VALUE LOW
 #endif
 
-// -----------------------------------------------------------------------------
-// Rotary encoder
-// -----------------------------------------------------------------------------
-#ifndef ROTARY_DELAY
-#define ROTARY_DELAY 5
-#endif
-
 // -----------------------------------------------------------------------------
 // GPS
 // -----------------------------------------------------------------------------
@@ -397,13 +376,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_RGB_LED
 #endif
 
-#ifndef LED_STATE_OFF
-#define LED_STATE_OFF 0
-#endif
-#ifndef LED_STATE_ON
-#define LED_STATE_ON 1
-#endif
-
 // default mapping of pins
 #if defined(PIN_BUTTON2) && !defined(CANCEL_BUTTON_PIN)
 #define ALT_BUTTON_PIN PIN_BUTTON2

src/detect/ScanI2C.cpp

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

src/detect/ScanI2C.h

@@ -14,7 +14,6 @@ class ScanI2C
         SCREEN_ST7567,
         RTC_RV3028,
         RTC_PCF8563,
-        RTC_RX8130CE,
         CARDKB,
         TDECKKB,
         BBQ10KB,
@@ -82,11 +81,7 @@ class ScanI2C
         BHI260AP,
         BMM150,
         TSL2561,
-        DRV2605,
-        BH1750,
-        DA217,
-        CHSC6X,
-        CST226SE
+        DRV2605
     } DeviceType;
 
     // typedef uint8_t DeviceAddress;

src/detect/ScanI2CConsumer.cpp

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

src/detect/ScanI2CConsumer.h

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

src/detect/ScanI2CTwoWire.cpp

@@ -106,7 +106,6 @@ uint16_t ScanI2CTwoWire::getRegisterValue(const ScanI2CTwoWire::RegisterLocation
         if (i2cBus->available())
             i2cBus->read();
     }
-    LOG_DEBUG("Register value: 0x%x", value);
     return value;
 }
 
@@ -198,9 +197,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 #ifdef PCF8563_RTC
                 SCAN_SIMPLE_CASE(PCF8563_RTC, RTC_PCF8563, "PCF8563", (uint8_t)addr.address)
 #endif
-#ifdef RX8130CE_RTC
-                SCAN_SIMPLE_CASE(RX8130CE_RTC, RTC_RX8130CE, "RX8130CE", (uint8_t)addr.address)
-#endif
 
             case CARDKB_ADDR:
                 // Do we have the RAK14006 instead?
@@ -298,7 +294,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 type = AHT10;
                 break;
 #endif
-#if !defined(M5STACK_UNITC6L)
             case INA_ADDR:
             case INA_ADDR_ALTERNATE:
             case INA_ADDR_WAVESHARE_UPS:
@@ -345,7 +340,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                     // else: probably a RAK12500/UBLOX GPS on I2C
                 }
                 break;
-#endif
             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.
@@ -378,13 +372,13 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 }
             case SHT31_4x_ADDR:     // same as OPT3001_ADDR_ALT
             case SHT31_4x_ADDR_ALT: // same as OPT3001_ADDR
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2);
-                if (registerValue == 0x5449) {
-                    type = OPT3001;
-                    logFoundDevice("OPT3001", (uint8_t)addr.address);
-                } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2) != 0) { // unique SHT4x serial number
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2);
+                if (registerValue == 0x11a2 || registerValue == 0x11da || registerValue == 0xe9c || registerValue == 0xc8d) {
                     type = SHT4X;
                     logFoundDevice("SHT4X", (uint8_t)addr.address);
+                } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
+                    type = OPT3001;
+                    logFoundDevice("OPT3001", (uint8_t)addr.address);
                 } else {
                     type = SHT31;
                     logFoundDevice("SHT31", (uint8_t)addr.address);
@@ -465,23 +459,8 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 break;
 
                 SCAN_SIMPLE_CASE(LSM6DS3_ADDR, LSM6DS3, "LSM6DS3", (uint8_t)addr.address);
+                SCAN_SIMPLE_CASE(TCA9555_ADDR, TCA9555, "TCA9555", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(VEML7700_ADDR, VEML7700, "VEML7700", (uint8_t)addr.address);
-            case TCA9555_ADDR:
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x01), 1);
-                if (registerValue == 0x13) {
-                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1);
-                    if (registerValue == 0x81) {
-                        type = DA217;
-                        logFoundDevice("DA217", (uint8_t)addr.address);
-                    } else {
-                        type = TCA9555;
-                        logFoundDevice("TCA9555", (uint8_t)addr.address);
-                    }
-                } else {
-                    type = TCA9555;
-                    logFoundDevice("TCA9555", (uint8_t)addr.address);
-                }
-                break;
             case TSL25911_ADDR:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x12), 1);
                 if (registerValue == 0x50) {
@@ -499,38 +478,8 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 SCAN_SIMPLE_CASE(DFROBOT_RAIN_ADDR, DFROBOT_RAIN, "DFRobot Rain Gauge", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(LTR390UV_ADDR, LTR390UV, "LTR390UV", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(PCT2075_ADDR, PCT2075, "PCT2075", (uint8_t)addr.address);
-            case CST328_ADDR:
-                // Do we have the CST328 or the CST226SE
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xAB), 1);
-                if (registerValue == 0xA9) {
-                    type = CST226SE;
-                    logFoundDevice("CST226SE", (uint8_t)addr.address);
-                } else {
-                    type = CST328;
-                    logFoundDevice("CST328", (uint8_t)addr.address);
-                }
-                break;
-
-                SCAN_SIMPLE_CASE(CHSC6X_ADDR, CHSC6X, "CHSC6X", (uint8_t)addr.address);
-            case LTR553ALS_ADDR:
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x86), 1); // Part ID register
-                if (registerValue == 0x92) {                                                       // LTR553ALS Part ID
-                    type = LTR553ALS;
-                    logFoundDevice("LTR553ALS", (uint8_t)addr.address);
-                } else {
-                    // Test BH1750 - send power on command
-                    i2cBus->beginTransmission(addr.address);
-                    i2cBus->write(0x01); // Power On command
-                    uint8_t bh1750_error = i2cBus->endTransmission();
-                    if (bh1750_error == 0) {
-                        type = BH1750;
-                        logFoundDevice("BH1750", (uint8_t)addr.address);
-                    } else {
-                        LOG_INFO("Device found at address 0x%x was not able to be enumerated", (uint8_t)addr.address);
-                    }
-                }
-                break;
-
+                SCAN_SIMPLE_CASE(CST328_ADDR, CST328, "CST328", (uint8_t)addr.address);
+                SCAN_SIMPLE_CASE(LTR553ALS_ADDR, LTR553ALS, "LTR553ALS", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(BHI260AP_ADDR, BHI260AP, "BHI260AP", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(SCD4X_ADDR, SCD4X, "SCD4X", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(BMM150_ADDR, BMM150, "BMM150", (uint8_t)addr.address);
@@ -539,12 +488,8 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 #endif
 
             case MLX90614_ADDR_DEF:
-                // Do we have the MLX90614 or the MPR121KB or the CST226SE
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x06), 1);
-                if (registerValue == 0xAB) {
-                    type = CST226SE;
-                    logFoundDevice("CST226SE", (uint8_t)addr.address);
-                } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0e), 1) == 0x5a) {
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0e), 1);
+                if (registerValue == 0x5a) {
                     type = MLX90614;
                     logFoundDevice("MLX90614", (uint8_t)addr.address);
                 } else {
@@ -562,11 +507,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
             case ICM20948_ADDR:     // same as BMX160_ADDR
             case ICM20948_ADDR_ALT: // same as MPU6050_ADDR
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1);
-#ifdef HAS_ICM20948
-                type = ICM20948;
-                logFoundDevice("ICM20948", (uint8_t)addr.address);
-                break;
-#endif
                 if (registerValue == 0xEA) {
                     type = ICM20948;
                     logFoundDevice("ICM20948", (uint8_t)addr.address);
@@ -635,7 +575,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
     scanPort(port, nullptr, 0);
 }
 
-TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address)
+TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address) const
 {
     if (address.port == ScanI2C::I2CPort::WIRE) {
         return &Wire;

src/detect/ScanI2CTwoWire.h

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

src/gps/GPS.cpp

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

src/gps/GPS.h

@@ -16,9 +16,6 @@
 #define GPS_EN_ACTIVE 1
 #endif
 
-static constexpr uint32_t GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS = 10 * 1000UL;
-static constexpr uint32_t GPS_FIX_HOLD_MAX_MS = 20000;
-
 typedef enum {
     GNSS_MODEL_ATGM336H,
     GNSS_MODEL_MTK,
@@ -34,8 +31,7 @@ typedef enum {
     GNSS_MODEL_MTK_PA1616S,
     GNSS_MODEL_AG3335,
     GNSS_MODEL_AG3352,
-    GNSS_MODEL_LS20031,
-    GNSS_MODEL_CM121
+    GNSS_MODEL_LS20031
 } GnssModel_t;
 
 typedef enum {
@@ -154,8 +150,6 @@ class GPS : private concurrency::OSThread
     TinyGPSPlus reader;
     uint8_t fixQual = 0; // fix quality from GPGGA
     uint32_t lastChecksumFailCount = 0;
-    uint8_t currentStep = 0;
-    int32_t currentDelay = 2000;
 
 #ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
     // (20210908) TinyGps++ can only read the GPGSA "FIX TYPE" field
@@ -178,6 +172,8 @@ class GPS : private concurrency::OSThread
      */
     bool hasValidLocation = false; // default to false, until we complete our first read
 
+    bool isInPowersave = false;
+
     bool shouldPublish = false; // If we've changed GPS state, this will force a publish the next loop()
 
     bool hasGPS = false; // Do we have a GPS we are talking to
@@ -240,7 +236,7 @@ class GPS : private concurrency::OSThread
 
     virtual int32_t runOnce() override;
 
-    GnssModel_t getProbeResponse(unsigned long timeout, const std::vector<ChipInfo> &responseMap, int serialSpeed);
+    GnssModel_t getProbeResponse(unsigned long timeout, const std::vector<ChipInfo> &responseMap);
 
     // Get GNSS model
     GnssModel_t probe(int serialSpeed);

src/gps/RTC.cpp

@@ -9,9 +9,6 @@
 static RTCQuality currentQuality = RTCQualityNone;
 uint32_t lastSetFromPhoneNtpOrGps = 0;
 
-static uint32_t lastTimeValidationWarning = 0;
-static const uint32_t TIME_VALIDATION_WARNING_INTERVAL_MS = 15000; // 15 seconds
-
 RTCQuality getRTCQuality()
 {
     return currentQuality;
@@ -51,9 +48,7 @@ RTCSetResult readFromRTC()
 
 #ifdef BUILD_EPOCH
         if (tv.tv_sec < BUILD_EPOCH) {
-            if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
-                LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
-            }
+            LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
             return RTCSetResultInvalidTime;
         }
 #endif
@@ -92,10 +87,7 @@ RTCSetResult readFromRTC()
 
 #ifdef BUILD_EPOCH
         if (tv.tv_sec < BUILD_EPOCH) {
-            if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
-                LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
-                lastTimeValidationWarning = millis();
-            }
+            LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
             return RTCSetResultInvalidTime;
         }
 #endif
@@ -109,39 +101,6 @@ RTCSetResult readFromRTC()
         }
         return RTCSetResultSuccess;
     }
-#elif defined(RX8130CE_RTC)
-    if (rtc_found.address == RX8130CE_RTC) {
-        uint32_t now = millis();
-#ifdef MUZI_BASE
-        ArtronShop_RX8130CE rtc(&Wire1);
-#else
-        ArtronShop_RX8130CE rtc(&Wire);
-#endif
-        tm t;
-        if (rtc.getTime(&t)) {
-            tv.tv_sec = gm_mktime(&t);
-            tv.tv_usec = 0;
-
-            uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms
-            LOG_DEBUG("Read RTC time from RX8130CE getDateTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)", t.tm_year + 1900,
-                      t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch);
-#ifdef BUILD_EPOCH
-            if (tv.tv_sec < BUILD_EPOCH) {
-                if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
-                    LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
-                    lastTimeValidationWarning = millis();
-                }
-                return RTCSetResultInvalidTime;
-            }
-#endif
-            if (currentQuality == RTCQualityNone) {
-                timeStartMsec = now;
-                zeroOffsetSecs = tv.tv_sec;
-                currentQuality = RTCQualityDevice;
-            }
-            return RTCSetResultSuccess;
-        }
-    }
 #else
     if (!gettimeofday(&tv, NULL)) {
         uint32_t now = millis();
@@ -171,20 +130,11 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
     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) {
-        if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
-            LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
-            lastTimeValidationWarning = millis();
-        }
+        LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
         return RTCSetResultInvalidTime;
-    } else if ((uint64_t)tv->tv_sec > ((uint64_t)BUILD_EPOCH + FORTY_YEARS)) {
-        if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
-            // Calculate max allowed time safely to avoid overflow in logging
-            uint64_t maxAllowedTime = (uint64_t)BUILD_EPOCH + FORTY_YEARS;
-            uint32_t maxAllowedPrintable = (maxAllowedTime > UINT32_MAX) ? UINT32_MAX : (uint32_t)maxAllowedTime;
-            LOG_WARN("Ignore time (%ld) too far in the future (build epoch: %ld, max allowed: %ld)!", printableEpoch,
-                     (uint32_t)BUILD_EPOCH, maxAllowedPrintable);
-            lastTimeValidationWarning = millis();
-        }
+    } else if (tv->tv_sec > (BUILD_EPOCH + FORTY_YEARS)) {
+        LOG_WARN("Ignore time (%ld) too far in the future (build epoch: %ld, max allowed: %ld)!", printableEpoch, BUILD_EPOCH,
+                 BUILD_EPOCH + FORTY_YEARS);
         return RTCSetResultInvalidTime;
     }
 #endif
@@ -247,21 +197,6 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
             LOG_DEBUG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
                       t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
         }
-#elif defined(RX8130CE_RTC)
-        if (rtc_found.address == RX8130CE_RTC) {
-#ifdef MUZI_BASE
-            ArtronShop_RX8130CE rtc(&Wire1);
-#else
-            ArtronShop_RX8130CE rtc(&Wire);
-#endif
-            tm *t = gmtime(&tv->tv_sec);
-            if (rtc.setTime(*t)) {
-                LOG_DEBUG("RX8130CE setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1,
-                          t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
-            } else {
-                LOG_WARN("Failed to set time for RX8130CE");
-            }
-        }
 #elif defined(ARCH_ESP32)
         settimeofday(tv, NULL);
 #endif
@@ -317,20 +252,11 @@ RTCSetResult perhapsSetRTC(RTCQuality q, struct tm &t)
     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) {
-        if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
-            LOG_WARN("Ignore time (%lu) before build epoch (%lu)!", printableEpoch, BUILD_EPOCH);
-            lastTimeValidationWarning = millis();
-        }
+        LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
         return RTCSetResultInvalidTime;
-    } else if ((uint64_t)tv.tv_sec > ((uint64_t)BUILD_EPOCH + FORTY_YEARS)) {
-        if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
-            // Calculate max allowed time safely to avoid overflow in logging
-            uint64_t maxAllowedTime = (uint64_t)BUILD_EPOCH + FORTY_YEARS;
-            uint32_t maxAllowedPrintable = (maxAllowedTime > UINT32_MAX) ? UINT32_MAX : (uint32_t)maxAllowedTime;
-            LOG_WARN("Ignore time (%lu) too far in the future (build epoch: %lu, max allowed: %lu)!", printableEpoch,
-                     (uint32_t)BUILD_EPOCH, maxAllowedPrintable);
-            lastTimeValidationWarning = millis();
-        }
+    } else if (tv.tv_sec > (BUILD_EPOCH + FORTY_YEARS)) {
+        LOG_WARN("Ignore time (%ld) too far in the future (build epoch: %ld, max allowed: %ld)!", printableEpoch, BUILD_EPOCH,
+                 BUILD_EPOCH + FORTY_YEARS);
         return RTCSetResultInvalidTime;
     }
 #endif
@@ -390,40 +316,14 @@ uint32_t getValidTime(RTCQuality minQuality, bool local)
 time_t gm_mktime(struct tm *tm)
 {
 #if !MESHTASTIC_EXCLUDE_TZ
-    time_t result = 0;
-
-    // First, get us to the start of tm->year, by calcuating the number of days since the Unix epoch.
-    int year = 1900 + tm->tm_year; // tm_year is years since 1900
-    int year_minus_one = year - 1;
-    int days_before_this_year = 0;
-    days_before_this_year += year_minus_one * 365;
-    // leap days: every 4 years, except 100s, but including 400s.
-    days_before_this_year += year_minus_one / 4 - year_minus_one / 100 + year_minus_one / 400;
-    // subtract from 1970-01-01 to get days since epoch
-    days_before_this_year -= 719162; // (1969 * 365 + 1969 / 4 - 1969 / 100 + 1969 / 400);
-
-    // Now, within this tm->year, compute the days *before* this tm->month starts.
-    int days_before_month[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; // non-leap year
-    int days_this_year_before_this_month = days_before_month[tm->tm_mon];                // tm->tm_mon is 0..11
-
-    // If this is a leap year, and we're past February, add a day:
-    if (tm->tm_mon >= 2 && (year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0)) {
-        days_this_year_before_this_month += 1;
+    setenv("TZ", "GMT0", 1);
+    time_t res = mktime(tm);
+    if (*config.device.tzdef) {
+        setenv("TZ", config.device.tzdef, 1);
+    } else {
+        setenv("TZ", "UTC0", 1);
     }
-
-    // And within this month:
-    int days_this_month_before_today = tm->tm_mday - 1; // tm->tm_mday is 1..31
-
-    // Now combine them all together, and convert days to seconds:
-    result += (days_before_this_year + days_this_year_before_this_month + days_this_month_before_today);
-    result *= 86400L;
-
-    // Finally, add in the hours, minutes, and seconds of today:
-    result += tm->tm_hour * 3600;
-    result += tm->tm_min * 60;
-    result += tm->tm_sec;
-
-    return result;
+    return res;
 #else
     return mktime(tm);
 #endif

src/gps/RTC.h

@@ -4,10 +4,6 @@
 #include "sys/time.h"
 #include <Arduino.h>
 
-#ifdef RX8130CE_RTC
-#include <ArtronShop_RX8130CE.h>
-#endif
-
 enum RTCQuality {
 
     /// We haven't had our RTC set yet
@@ -60,5 +56,5 @@ time_t gm_mktime(struct tm *tm);
 #define SEC_PER_HOUR 3600
 #define SEC_PER_MIN 60
 #ifdef BUILD_EPOCH
-static constexpr uint64_t FORTY_YEARS = (40ULL * 365 * SEC_PER_DAY); // Use 64-bit arithmetic to prevent overflow
+#define FORTY_YEARS (40UL * 365 * SEC_PER_DAY) // probably time to update your firmware
 #endif

src/graphics/EInkDisplay2.cpp

@@ -1,6 +1,6 @@
 #include "configuration.h"
 
-#if defined(USE_EINK) && !defined(USE_EINK_PARALLELDISPLAY)
+#ifdef USE_EINK
 #include "EInkDisplay2.h"
 #include "SPILock.h"
 #include "main.h"
@@ -243,7 +243,7 @@ bool EInkDisplay::connect()
         adafruitDisplay->setRotation(1);
         adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
     }
-#elif defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK) || defined(HELTEC_MESH_SOLAR_EINK)
+#elif defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK)
     {
         spi1 = &SPI1;
         spi1->begin();

src/graphics/EInkDisplay2.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if defined(USE_EINK) && !defined(USE_EINK_PARALLELDISPLAY)
+#ifdef USE_EINK
 
 #include "GxEPD2_BW.h"
 #include <OLEDDisplay.h>
@@ -84,7 +84,7 @@ class EInkDisplay : public OLEDDisplay
     SPIClass *hspi = NULL;
 #endif
 
-#if defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK) || defined(HELTEC_MESH_SOLAR_EINK)
+#if defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK)
     SPIClass *spi1 = NULL;
 #endif
 

src/graphics/EInkParallelDisplay.cpp

@@ -1,424 +0,0 @@
-#include "EInkParallelDisplay.h"
-
-#ifdef USE_EINK_PARALLELDISPLAY
-
-#include "Wire.h"
-#include "variant.h"
-#include <Arduino.h>
-#include <atomic>
-#include <stdlib.h>
-#include <string.h>
-
-#include "FastEPD.h"
-
-// Thresholds for choosing partial vs full update
-#ifndef EPD_PARTIAL_THRESHOLD_ROWS
-#define EPD_PARTIAL_THRESHOLD_ROWS 128 // if changed region <= this many rows, prefer partial
-#endif
-#ifndef EPD_FULLSLOW_PERIOD
-#define EPD_FULLSLOW_PERIOD 100 // every N full updates do a slow (CLEAR_SLOW) full refresh
-#endif
-#ifndef EPD_RESPONSIVE_MIN_MS
-#define EPD_RESPONSIVE_MIN_MS 1000 // simple rate-limit (ms) for responsive updates
-#endif
-
-EInkParallelDisplay::EInkParallelDisplay(uint16_t width, uint16_t height, EpdRotation rot) : epaper(nullptr), rotation(rot)
-{
-    LOG_INFO("init EInkParallelDisplay");
-    // Set dimensions in OLEDDisplay base class
-    this->geometry = GEOMETRY_RAWMODE;
-    this->displayWidth = width;
-    this->displayHeight = height;
-
-    // Round shortest side up to nearest byte, to prevent truncation causing an undersized buffer
-    uint16_t shortSide = min(width, height);
-    uint16_t longSide = max(width, height);
-    if (shortSide % 8 != 0)
-        shortSide = (shortSide | 7) + 1;
-
-    this->displayBufferSize = longSide * (shortSide / 8);
-
-#ifdef EINK_LIMIT_GHOSTING_PX
-    // allocate dirty pixel buffer same size as epaper buffers (rowBytes * height)
-    size_t rowBytes = (this->displayWidth + 7) / 8;
-    dirtyPixelsSize = rowBytes * this->displayHeight;
-    dirtyPixels = (uint8_t *)calloc(dirtyPixelsSize, 1);
-    ghostPixelCount = 0;
-#endif
-}
-
-EInkParallelDisplay::~EInkParallelDisplay()
-{
-#ifdef EINK_LIMIT_GHOSTING_PX
-    if (dirtyPixels) {
-        free(dirtyPixels);
-        dirtyPixels = nullptr;
-    }
-#endif
-    // If an async full update is running, wait for it to finish
-    if (asyncFullRunning.load()) {
-        // wait a short while for task to finish
-        for (int i = 0; i < 50 && asyncFullRunning.load(); ++i) {
-            delay(50);
-        }
-        if (asyncTaskHandle) {
-            // Let it finish or delete it
-            vTaskDelete(asyncTaskHandle);
-            asyncTaskHandle = nullptr;
-        }
-    }
-
-    delete epaper;
-}
-
-/*
- * Called by the OLEDDisplay::init() path.
- */
-bool EInkParallelDisplay::connect()
-{
-    LOG_INFO("Do EPD init");
-    if (!epaper) {
-        epaper = new FASTEPD;
-#if defined(T5_S3_EPAPER_PRO_V1)
-        epaper->initPanel(BB_PANEL_LILYGO_T5PRO, 28000000);
-#elif defined(T5_S3_EPAPER_PRO_V2)
-        epaper->initPanel(BB_PANEL_LILYGO_T5PRO_V2, 28000000);
-        epaper->ioPinMode(0, OUTPUT);
-        epaper->ioWrite(0, HIGH);
-#else
-#error "unsupported EPD device!"
-#endif
-    }
-
-    // epaper->setRotation(rotation); // does not work, messes up width/height
-    epaper->setMode(BB_MODE_1BPP);
-    epaper->clearWhite();
-    epaper->fullUpdate(true);
-
-#ifdef EINK_LIMIT_GHOSTING_PX
-    // After a full/clear the dirty tracking should be reset
-    resetGhostPixelTracking();
-#endif
-
-    return true;
-}
-
-/*
- * sendCommand - simple passthrough (not required for epd_driver-based path)
- */
-void EInkParallelDisplay::sendCommand(uint8_t com)
-{
-    LOG_DEBUG("EInkParallelDisplay::sendCommand %d", (int)com);
-}
-
-/*
- * Start a background task that will perform a blocking fullUpdate(). This lets
- * display() return quickly while the heavy refresh runs in the background.
- */
-void EInkParallelDisplay::startAsyncFullUpdate(int clearMode)
-{
-    if (asyncFullRunning.load())
-        return; // already running
-
-    asyncFullRunning.store(true);
-    // pass 'this' as parameter
-    BaseType_t rc = xTaskCreatePinnedToCore(EInkParallelDisplay::asyncFullUpdateTask, "epd_full", 4096 / sizeof(StackType_t),
-                                            this, 2, &asyncTaskHandle,
-#if CONFIG_FREERTOS_UNICORE
-                                            0
-#else
-                                            1
-#endif
-    );
-    if (rc != pdPASS) {
-        LOG_WARN("Failed to create async full-update task, falling back to blocking update");
-        epaper->fullUpdate(clearMode, false);
-        epaper->backupPlane();
-        asyncFullRunning.store(false);
-        asyncTaskHandle = nullptr;
-    }
-}
-
-/*
- * FreeRTOS task entry: runs the full update and then backs up plane.
- */
-void EInkParallelDisplay::asyncFullUpdateTask(void *pvParameters)
-{
-    EInkParallelDisplay *self = static_cast<EInkParallelDisplay *>(pvParameters);
-    if (!self) {
-        vTaskDelete(nullptr);
-        return;
-    }
-
-    // choose CLEAR_SLOW occasionally
-    int clearMode = CLEAR_FAST;
-    if (self->fastRefreshCount >= EPD_FULLSLOW_PERIOD) {
-        clearMode = CLEAR_SLOW;
-        self->fastRefreshCount = 0;
-    } else {
-        // when running async full, treat it as a full so reset fast count
-        self->fastRefreshCount = 0;
-    }
-
-    self->epaper->fullUpdate(clearMode, false);
-    self->epaper->backupPlane();
-
-#ifdef EINK_LIMIT_GHOSTING_PX
-    // A full refresh clears ghosting state
-    self->resetGhostPixelTracking();
-#endif
-
-    self->asyncFullRunning.store(false);
-    self->asyncTaskHandle = nullptr;
-
-    // delete this task
-    vTaskDelete(nullptr);
-}
-
-/*
- * Convert the OLEDDisplay buffer (vertical byte layout) into the 1bpp horizontal-bytes
- * buffer used by the FASTEPD library. For performance we write directly into FASTEPD's
- * currentBuffer() while comparing against previousBuffer() to detect changed rows.
- * After conversion we call FASTEPD::partialUpdate() or FASTEPD::fullUpdate() according
- * to a heuristic so only the minimal region is refreshed.
- */
-void EInkParallelDisplay::display(void)
-{
-    const uint16_t w = this->displayWidth;
-    const uint16_t h = this->displayHeight;
-
-    // Simple rate limiting: avoid very-frequent responsive updates
-    uint32_t nowMs = millis();
-    if (lastUpdateMs != 0 && (nowMs - lastUpdateMs) < EPD_RESPONSIVE_MIN_MS) {
-        LOG_DEBUG("rate-limited, skipping update");
-        return;
-    }
-
-    // bytes per row in epd format (one byte = 8 horizontal pixels)
-    const uint32_t rowBytes = (w + 7) / 8;
-
-    // Get pointers to internal buffers
-    uint8_t *cur = epaper->currentBuffer();
-    uint8_t *prev = epaper->previousBuffer(); // may be NULL on first init
-
-    // Track changed row range while converting
-    int newTop = h;     // min changed row (initialized to out-of-range)
-    int newBottom = -1; // max changed row
-
-#ifdef FAST_EPD_PARTIAL_UPDATE_BUG
-    // Track changed byte column range (for clipped fullUpdate fallback)
-    int newLeftByte = (int)rowBytes;
-    int newRightByte = -1;
-#endif
-
-    // Compute a quick hash of the incoming OLED buffer (so we can skip identical frames)
-    uint32_t imageHash = 0;
-    uint32_t bufBytes = (w / 8) * h; // vertical-byte layout size
-    for (uint32_t bi = 0; bi < bufBytes; ++bi) {
-        imageHash ^= ((uint32_t)buffer[bi]) << (bi & 31);
-    }
-    if (imageHash == previousImageHash) {
-        // LOG_DEBUG("image identical to previous, skipping update");
-        return;
-    }
-
-#ifdef EINK_LIMIT_GHOSTING_PX
-    // reset ghost count for this conversion pass; we'll mark bits that change
-    ghostPixelCount = 0;
-#endif
-
-    // Convert: OLED buffer layout -> FASTEPD 1bpp horizontal-bytes layout into cur,
-    // comparing against prev when available to detect changes.
-    for (uint32_t y = 0; y < h; ++y) {
-        const uint32_t base = (y >> 3) * w;               // (y/8) * width
-        const uint8_t bitMask = (uint8_t)(1u << (y & 7)); // mask for this row in vertical-byte layout
-        const uint32_t rowBase = y * rowBytes;
-
-        // process full 8-pixel bytes
-        for (uint32_t xb = 0; xb < rowBytes; ++xb) {
-            uint32_t x0 = xb * 8;
-            // read up to 8 source bytes (vertical-byte per column)
-            uint8_t b0 = (x0 + 0 < w) ? buffer[base + x0 + 0] : 0;
-            uint8_t b1 = (x0 + 1 < w) ? buffer[base + x0 + 1] : 0;
-            uint8_t b2 = (x0 + 2 < w) ? buffer[base + x0 + 2] : 0;
-            uint8_t b3 = (x0 + 3 < w) ? buffer[base + x0 + 3] : 0;
-            uint8_t b4 = (x0 + 4 < w) ? buffer[base + x0 + 4] : 0;
-            uint8_t b5 = (x0 + 5 < w) ? buffer[base + x0 + 5] : 0;
-            uint8_t b6 = (x0 + 6 < w) ? buffer[base + x0 + 6] : 0;
-            uint8_t b7 = (x0 + 7 < w) ? buffer[base + x0 + 7] : 0;
-
-            // build output byte: MSB = leftmost pixel
-            uint8_t out = 0;
-            out |= (uint8_t)((b0 & bitMask) ? 0x80 : 0x00);
-            out |= (uint8_t)((b1 & bitMask) ? 0x40 : 0x00);
-            out |= (uint8_t)((b2 & bitMask) ? 0x20 : 0x00);
-            out |= (uint8_t)((b3 & bitMask) ? 0x10 : 0x00);
-            out |= (uint8_t)((b4 & bitMask) ? 0x08 : 0x00);
-            out |= (uint8_t)((b5 & bitMask) ? 0x04 : 0x00);
-            out |= (uint8_t)((b6 & bitMask) ? 0x02 : 0x00);
-            out |= (uint8_t)((b7 & bitMask) ? 0x01 : 0x00);
-
-            // handle partial byte at end of row by masking off invalid bits
-            uint8_t mask = 0xFF;
-            uint32_t bitsRemain = (w > x0) ? (w - x0) : 0;
-            if (bitsRemain > 0 && bitsRemain < 8) {
-                mask = (uint8_t)(0xFF << (8 - bitsRemain));
-                out &= mask;
-            }
-
-            // invert to FASTEPD polarity
-            out = (~out) & mask;
-
-            uint32_t pos = rowBase + xb;
-            uint8_t prevVal = prev ? (prev[pos] & mask) : 0x00;
-            // Consider this byte changed if previous buffer differs (or prev is null)
-            bool changed = (prev == nullptr) || (prevVal != out);
-
-#ifdef EINK_LIMIT_GHOSTING_PX
-            if (changed && prev)
-                markDirtyBits(prev, pos, mask, out);
-#endif
-
-            // mark row changed only if the previous buffer differs
-            if (changed) {
-                if (y < (uint32_t)newTop)
-                    newTop = y;
-                if ((int)y > newBottom)
-                    newBottom = y;
-#ifdef FAST_EPD_PARTIAL_UPDATE_BUG
-                // record changed column bytes
-                if ((int)xb < newLeftByte)
-                    newLeftByte = (int)xb;
-                if ((int)xb > newRightByte)
-                    newRightByte = (int)xb;
-#endif
-            }
-
-            // Always write the computed value into the current buffer (avoid leaving stale bytes)
-            cur[pos] = (cur[pos] & ~mask) | out;
-        }
-    }
-
-    // If nothing changed, avoid any panel update
-    if (newBottom < 0) {
-        LOG_DEBUG("no pixel changes detected, skipping update (conv)");
-        previousImageHash = imageHash; // still remember that frame
-        return;
-    }
-
-    // Choose partial vs full update using heuristic
-    // Decide if we should force a full update after many fast updates
-    bool forceFull = (fastRefreshCount >= EPD_FULLSLOW_PERIOD);
-
-#ifdef EINK_LIMIT_GHOSTING_PX
-    // If ghost pixels exceed limit, force a full update to clear ghosting
-    if (ghostPixelCount > ghostPixelLimit) {
-        LOG_WARN("ghost pixels %u > limit %u, forcing full refresh", ghostPixelCount, ghostPixelLimit);
-        forceFull = true;
-    }
-#endif
-
-    // Compute pixel bounds from newTop/newBottom
-    int startRow = (newTop / 8) * 8;
-    int endRow = (newBottom / 8) * 8 + 7;
-
-    LOG_DEBUG("EPD update rows=%d..%d alignedRows=%d..%d rowBytes=%u", newTop, newBottom, startRow, endRow, rowBytes);
-
-    if (epaper->getMode() == BB_MODE_1BPP && !forceFull && (newBottom - newTop) <= EPD_PARTIAL_THRESHOLD_ROWS) {
-        // Prefer partial update path if driver is reliable; otherwise use clipped fullUpdate fallback.
-#ifdef FAST_EPD_PARTIAL_UPDATE_BUG
-        // Workaround for FastEPD partial update bug: use clipped fullUpdate instead
-        // Build a pixel rectangle for a clipped fullUpdate using the changed columns
-        int startCol = (newLeftByte <= newRightByte) ? (newLeftByte * 8) : 0;
-        int endCol = (newLeftByte <= newRightByte) ? ((newRightByte + 1) * 8 - 1) : (w - 1);
-
-        BB_RECT rect{startCol, startRow, endCol - startCol + 1, endRow - startRow + 1};
-        // LOG_DEBUG("Using clipped fullUpdate rect x=%d y=%d w=%d h=%d", rect.x, rect.y, rect.w, rect.h);
-        epaper->fullUpdate(CLEAR_FAST, false, &rect);
-#else
-        // Use rows for partial update
-        LOG_DEBUG("calling partialUpdate startRow=%d endRow=%d", startRow, endRow);
-        epaper->partialUpdate(true, startRow, endRow);
-#endif
-        epaper->backupPlane();
-        fastRefreshCount++;
-    } else {
-        // Full update: run async if possible (startAsyncFullUpdate will fall back to blocking)
-        startAsyncFullUpdate(forceFull ? CLEAR_SLOW : CLEAR_FAST);
-    }
-
-    lastUpdateMs = millis();
-    previousImageHash = imageHash;
-
-    // Keep same behavior as before
-    lastDrawMsec = millis();
-}
-
-#ifdef EINK_LIMIT_GHOSTING_PX
-// markDirtyBits: mark per-bit dirty flags and update ghostPixelCount
-void EInkParallelDisplay::markDirtyBits(const uint8_t *prevBuf, uint32_t pos, uint8_t mask, uint8_t out)
-{
-    // defensive: need dirtyPixels allocated and prevBuf valid
-    if (!dirtyPixels || !prevBuf)
-        return;
-
-    // 'out' is in FASTEPD polarity (1 = black, 0 = white)
-    uint8_t newBlack = out & mask;    // bits that will be black now
-    uint8_t newWhite = (~out) & mask; // bits that will be white now
-
-    // previously recorded dirty bits for this byte
-    uint8_t before = dirtyPixels[pos];
-
-    // Ghost bits: bits that were previously marked dirty and are now being driven white
-    uint8_t ghostBits = before & newWhite;
-    if (ghostBits) {
-        ghostPixelCount += __builtin_popcount((unsigned)ghostBits);
-    }
-
-    // Only mark bits dirty when they turn black now (accumulate until a full refresh)
-    uint8_t newlyDirty = newBlack & (~before);
-    if (newlyDirty) {
-        dirtyPixels[pos] |= newlyDirty;
-    }
-}
-
-// reset ghost tracking (call after a full refresh)
-void EInkParallelDisplay::resetGhostPixelTracking()
-{
-    if (!dirtyPixels)
-        return;
-    memset(dirtyPixels, 0, dirtyPixelsSize);
-    ghostPixelCount = 0;
-}
-#endif
-
-/*
- * forceDisplay: use lastDrawMsec
- */
-bool EInkParallelDisplay::forceDisplay(uint32_t msecLimit)
-{
-    uint32_t now = millis();
-    if (lastDrawMsec == 0 || (now - lastDrawMsec) > msecLimit) {
-        display();
-        return true;
-    }
-    return false;
-}
-
-void EInkParallelDisplay::endUpdate()
-{
-    {
-        // ensure any async full update is started/completed
-        if (asyncFullRunning.load()) {
-            // nothing to do; background task will run and call backupPlane when done
-        } else {
-            epaper->fullUpdate(CLEAR_FAST, false);
-            epaper->backupPlane();
-#ifdef EINK_LIMIT_GHOSTING_PX
-            resetGhostPixelTracking();
-#endif
-        }
-    }
-}
-
-#endif

src/graphics/EInkParallelDisplay.h

@@ -1,69 +0,0 @@
-#pragma once
-
-#include "configuration.h"
-
-#ifdef USE_EINK_PARALLELDISPLAY
-#include <OLEDDisplay.h>
-
-#include <atomic>
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-class FASTEPD;
-
-/**
- * Adapter for E-Ink 8-bit parallel displays (EPD), specifically devices supported by FastEPD library
- */
-class EInkParallelDisplay : public OLEDDisplay
-{
-  public:
-    enum EpdRotation {
-        EPD_ROT_LANDSCAPE = 0,
-        EPD_ROT_PORTRAIT = 90,
-        EPD_ROT_INVERTED_LANDSCAPE = 180,
-        EPD_ROT_INVERTED_PORTRAIT = 270,
-    };
-
-    EInkParallelDisplay(uint16_t width, uint16_t height, EpdRotation rotation);
-    virtual ~EInkParallelDisplay();
-
-    // OLEDDisplay virtuals
-    bool connect() override;
-    void sendCommand(uint8_t com) override;
-    int getBufferOffset(void) override { return 0; }
-
-    void display(void) override;
-    bool forceDisplay(uint32_t msecLimit = 1000);
-    void endUpdate();
-
-  protected:
-    uint32_t lastDrawMsec = 0;
-    FASTEPD *epaper;
-
-  private:
-    // Async full-refresh support
-    std::atomic<bool> asyncFullRunning{false};
-    TaskHandle_t asyncTaskHandle = nullptr;
-    void startAsyncFullUpdate(int clearMode);
-    static void asyncFullUpdateTask(void *pvParameters);
-
-#ifdef EINK_LIMIT_GHOSTING_PX
-    // helpers
-    void resetGhostPixelTracking();
-    void markDirtyBits(const uint8_t *prevBuf, uint32_t pos, uint8_t mask, uint8_t out);
-    void countGhostPixelsAndMaybePromote(int &newTop, int &newBottom, bool &forceFull);
-
-    // per-bit dirty buffer (same format as epaper buffers): one bit == one pixel
-    uint8_t *dirtyPixels = nullptr;
-    size_t dirtyPixelsSize = 0;
-    uint32_t ghostPixelCount = 0;
-    uint32_t ghostPixelLimit = EINK_LIMIT_GHOSTING_PX;
-#endif
-
-    EpdRotation rotation;
-    uint32_t previousImageHash = 0;
-    uint32_t lastUpdateMs = 0;
-    int fastRefreshCount = 0;
-};
-
-#endif

src/graphics/Panel_sdl.cpp

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

src/graphics/Panel_sdl.hpp

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

src/graphics/Screen.cpp

@@ -25,9 +25,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "PowerMon.h"
 #include "Throttle.h"
 #include "configuration.h"
-#include "meshUtils.h"
 #if HAS_SCREEN
-#include "EInkParallelDisplay.h"
 #include <OLEDDisplay.h>
 
 #include "DisplayFormatters.h"
@@ -60,6 +58,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "mesh-pb-constants.h"
 #include "mesh/Channels.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
+#include "meshUtils.h"
 #include "modules/ExternalNotificationModule.h"
 #include "modules/TextMessageModule.h"
 #include "modules/WaypointModule.h"
@@ -84,11 +83,6 @@ extern uint16_t TFT_MESH;
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 
-#if defined(T_LORA_PAGER)
-// KB backlight control
-#include "input/cardKbI2cImpl.h"
-#endif
-
 using namespace meshtastic; /** @todo remove */
 
 namespace graphics
@@ -101,7 +95,7 @@ namespace graphics
 #define NUM_EXTRA_FRAMES 3 // text message and debug frame
 // if defined a pixel will blink to show redraws
 // #define SHOW_REDRAWS
-#define ASCII_BELL '\x07'
+
 // A text message frame + debug frame + all the node infos
 FrameCallback *normalFrames;
 static uint32_t targetFramerate = IDLE_FRAMERATE;
@@ -222,44 +216,6 @@ void Screen::showNumberPicker(const char *message, uint32_t durationMs, uint8_t
     ui->update();
 }
 
-void Screen::showTextInput(const char *header, const char *initialText, uint32_t durationMs,
-                           std::function<void(const std::string &)> textCallback)
-{
-    LOG_INFO("showTextInput called with header='%s', durationMs=%d", header ? header : "NULL", durationMs);
-
-    if (NotificationRenderer::virtualKeyboard) {
-        delete NotificationRenderer::virtualKeyboard;
-        NotificationRenderer::virtualKeyboard = nullptr;
-    }
-
-    NotificationRenderer::textInputCallback = nullptr;
-
-    NotificationRenderer::virtualKeyboard = new VirtualKeyboard();
-    if (header) {
-        NotificationRenderer::virtualKeyboard->setHeader(header);
-    }
-    if (initialText) {
-        NotificationRenderer::virtualKeyboard->setInputText(initialText);
-    }
-
-    // Set up callback with safer cleanup mechanism
-    NotificationRenderer::textInputCallback = textCallback;
-    NotificationRenderer::virtualKeyboard->setCallback([textCallback](const std::string &text) { textCallback(text); });
-
-    // Store the message and set the expiration timestamp (use same pattern as other notifications)
-    strncpy(NotificationRenderer::alertBannerMessage, header ? header : "Text Input", 255);
-    NotificationRenderer::alertBannerMessage[255] = '\0';
-    NotificationRenderer::alertBannerUntil = (durationMs == 0) ? 0 : millis() + durationMs;
-    NotificationRenderer::pauseBanner = false;
-    NotificationRenderer::current_notification_type = notificationTypeEnum::text_input;
-
-    // Set the overlay using the same pattern as other notification types
-    static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-    ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
-    ui->setTargetFPS(60);
-    ui->update();
-}
-
 static void drawModuleFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     uint8_t module_frame;
@@ -325,7 +281,7 @@ static int8_t prevFrame = -1;
 // Combined dynamic node list frame cycling through LastHeard, HopSignal, and Distance modes
 // Uses a single frame and changes data every few seconds (E-Ink variant is separate)
 
-#if defined(ESP_PLATFORM) && (defined(USE_ST7789) || defined(USE_ST7796))
+#if defined(ESP_PLATFORM) && defined(USE_ST7789)
 SPIClass SPI1(HSPI);
 #endif
 
@@ -357,47 +313,26 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
 #else
     dispdev = new ST7789Spi(&SPI1, ST7789_RESET, ST7789_RS, ST7789_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT);
 #endif
-#elif defined(USE_ST7796)
-#ifdef ESP_PLATFORM
-    dispdev = new ST7796Spi(&SPI1, ST7796_RESET, ST7796_RS, ST7796_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT, ST7796_SDA,
-                            ST7796_MISO, ST7796_SCK, TFT_SPI_FREQUENCY);
-#else
-    dispdev = new ST7796Spi(&SPI1, ST7796_RESET, ST7796_RS, ST7796_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT);
-#endif
-#if defined(USE_ST7789)
     static_cast<ST7789Spi *>(dispdev)->setRGB(TFT_MESH);
-#elif defined(USE_ST7796)
-    static_cast<ST7796Spi *>(dispdev)->setRGB(TFT_MESH);
-#endif
 #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(USE_SPISSD1306)
-    dispdev = new SSD1306Spi(SSD1306_RESET, SSD1306_RS, SSD1306_NSS, GEOMETRY_64_48);
-    if (!dispdev->init()) {
-        LOG_DEBUG("Error: SSD1306 not detected!");
-    } else {
-        static_cast<SSD1306Spi *>(dispdev)->setHorizontalOffset(32);
-        LOG_INFO("SSD1306 init success");
-    }
 #elif defined(ST7735_CS) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7789_CS) ||    \
     defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS)
     dispdev = new TFTDisplay(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
-#elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY) && !defined(USE_EINK_PARALLELDISPLAY)
+#elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY)
     dispdev = new EInkDisplay(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)
     dispdev = new EInkDynamicDisplay(address.address, -1, -1, geometry,
                                      (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
-#elif defined(USE_EINK_PARALLELDISPLAY)
-    dispdev = new EInkParallelDisplay(EPD_WIDTH, EPD_HEIGHT, EInkParallelDisplay::EPD_ROT_PORTRAIT);
 #elif defined(USE_ST7567)
     dispdev = new ST7567Wire(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
 #elif ARCH_PORTDUINO
     if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-        if (portduino_config.displayPanel != no_screen) {
+        if (settingsMap[displayPanel] != no_screen) {
             LOG_DEBUG("Make TFTDisplay!");
             dispdev = new TFTDisplay(address.address, -1, -1, geometry,
                                      (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
@@ -449,14 +384,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             PMU->enablePowerOutput(XPOWERS_ALDO2);
 #endif
 
-#if defined(MUZI_BASE)
-            dispdev->init();
-            dispdev->setBrightness(brightness);
-            dispdev->flipScreenVertically();
-            dispdev->resetDisplay();
-            digitalWrite(SCREEN_12V_ENABLE, HIGH);
-            delay(100);
-#endif
 #if !ARCH_PORTDUINO
             dispdev->displayOn();
 #endif
@@ -465,7 +392,7 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             if (uiconfig.screen_brightness == 1)
                 digitalWrite(PIN_EINK_EN, HIGH);
 #elif defined(PCA_PIN_EINK_EN)
-            if (uiconfig.screen_brightness > 0)
+            if (uiconfig.screen_brightness == 1)
                 io.digitalWrite(PCA_PIN_EINK_EN, HIGH);
 #endif
 
@@ -475,7 +402,7 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 
             dispdev->displayOn();
-#if defined(HELTEC_TRACKER_V1_X) || defined(HELTEC_WIRELESS_TRACKER_V2)
+#ifdef HELTEC_TRACKER_V1_X
             ui->init();
 #endif
 #ifdef USE_ST7789
@@ -488,15 +415,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             pinMode(VTFT_LEDA, OUTPUT);
             digitalWrite(VTFT_LEDA, TFT_BACKLIGHT_ON);
 #endif
-#endif
-#ifdef USE_ST7796
-            ui->init();
-#ifdef ESP_PLATFORM
-            analogWrite(VTFT_LEDA, BRIGHTNESS_DEFAULT);
-#else
-            pinMode(VTFT_LEDA, OUTPUT);
-            digitalWrite(VTFT_LEDA, TFT_BACKLIGHT_ON);
-#endif
 #endif
             enabled = true;
             setInterval(0); // Draw ASAP
@@ -515,10 +433,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 
             dispdev->displayOff();
-
-#ifdef SCREEN_12V_ENABLE
-            digitalWrite(SCREEN_12V_ENABLE, LOW);
-#endif
 #ifdef USE_ST7789
             SPI1.end();
 #if defined(ARCH_ESP32)
@@ -535,21 +449,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
             nrf_gpio_cfg_default(ST7789_NSS);
 #endif
 #endif
-#ifdef USE_ST7796
-            SPI1.end();
-#if defined(ARCH_ESP32)
-            pinMode(VTFT_LEDA, OUTPUT);
-            digitalWrite(VTFT_LEDA, LOW);
-            pinMode(ST7796_RESET, ANALOG);
-            pinMode(ST7796_RS, ANALOG);
-            pinMode(ST7796_NSS, ANALOG);
-#else
-            nrf_gpio_cfg_default(VTFT_LEDA);
-            nrf_gpio_cfg_default(ST7796_RESET);
-            nrf_gpio_cfg_default(ST7796_RS);
-            nrf_gpio_cfg_default(ST7796_NSS);
-#endif
-#endif
 
 #ifdef T_WATCH_S3
             PMU->disablePowerOutput(XPOWERS_ALDO2);
@@ -584,7 +483,7 @@ void Screen::setup()
         static_cast<AutoOLEDWire *>(dispdev)->setDetected(model);
 #endif
 
-#if defined(USE_SH1107_128_64) || defined(USE_SH1107)
+#ifdef USE_SH1107_128_64
     static_cast<SH1106Wire *>(dispdev)->setSubtype(7);
 #endif
 
@@ -592,13 +491,6 @@ void Screen::setup()
     // Apply custom RGB color (e.g. Heltec T114/T190)
     static_cast<ST7789Spi *>(dispdev)->setRGB(TFT_MESH);
 #endif
-#if defined(MUZI_BASE)
-    dispdev->delayPoweron = true;
-#endif
-#if defined(USE_ST7796) && defined(TFT_MESH)
-    // Custom text color, if defined in variant.h
-    static_cast<ST7796Spi *>(dispdev)->setRGB(TFT_MESH);
-#endif
 
     // === Initialize display and UI system ===
     ui->init();
@@ -615,7 +507,7 @@ void Screen::setup()
     // === Apply loaded brightness ===
 #if defined(ST7789_CS)
     static_cast<TFTDisplay *>(dispdev)->setDisplayBrightness(brightness);
-#elif defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) || defined(USE_SH1107) || defined(USE_SPISSD1306)
+#elif defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) || defined(USE_SH1107)
     dispdev->setBrightness(brightness);
 #endif
     LOG_INFO("Applied screen brightness: %d", brightness);
@@ -662,9 +554,7 @@ void Screen::setup()
         static_cast<TFTDisplay *>(dispdev)->flipScreenVertically();
 #elif defined(USE_ST7789)
         static_cast<ST7789Spi *>(dispdev)->flipScreenVertically();
-#elif defined(USE_ST7796)
-        static_cast<ST7796Spi *>(dispdev)->mirrorScreen();
-#elif !defined(M5STACK_UNITC6L)
+#else
         dispdev->flipScreenVertically();
 #endif
     }
@@ -690,13 +580,13 @@ void Screen::setup()
 
 #if ARCH_PORTDUINO
     if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-        if (portduino_config.touchscreenModule) {
+        if (settingsMap[touchscreenModule]) {
             touchScreenImpl1 =
                 new TouchScreenImpl1(dispdev->getWidth(), dispdev->getHeight(), static_cast<TFTDisplay *>(dispdev)->getTouch);
             touchScreenImpl1->init();
         }
     }
-#elif HAS_TOUCHSCREEN && !defined(USE_EINK) && !HAS_CST226SE
+#elif HAS_TOUCHSCREEN && !defined(USE_EINK)
     touchScreenImpl1 =
         new TouchScreenImpl1(dispdev->getWidth(), dispdev->getHeight(), static_cast<TFTDisplay *>(dispdev)->getTouch);
     touchScreenImpl1->init();
@@ -719,19 +609,6 @@ void Screen::setup()
     MeshModule::observeUIEvents(&uiFrameEventObserver);
 }
 
-void Screen::setOn(bool on, FrameCallback einkScreensaver)
-{
-#if defined(T_LORA_PAGER)
-    if (cardKbI2cImpl)
-        cardKbI2cImpl->toggleBacklight(on);
-#endif
-    if (!on)
-        // We handle off commands immediately, because they might be called because the CPU is shutting down
-        handleSetOn(false, einkScreensaver);
-    else
-        enqueueCmd(ScreenCmd{.cmd = Cmd::SET_ON});
-}
-
 void Screen::forceDisplay(bool forceUiUpdate)
 {
     // Nasty hack to force epaper updates for 'key' frames.  FIXME, cleanup.
@@ -764,11 +641,7 @@ void Screen::forceDisplay(bool forceUiUpdate)
     }
 
     // Tell EInk class to update the display
-#if defined(USE_EINK_PARALLELDISPLAY)
-    static_cast<EInkParallelDisplay *>(dispdev)->forceDisplay();
-#elif defined(USE_EINK)
     static_cast<EInkDisplay *>(dispdev)->forceDisplay();
-#endif
 #else
     // No delay between UI frame rendering
     if (forceUiUpdate) {
@@ -819,11 +692,7 @@ int32_t Screen::runOnce()
 
 #ifndef DISABLE_WELCOME_UNSET
     if (!NotificationRenderer::isOverlayBannerShowing() && config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-#if defined(M5STACK_UNITC6L)
-        menuHandler::LoraRegionPicker();
-#else
         menuHandler::OnboardMessage();
-#endif
     }
 #endif
     if (!NotificationRenderer::isOverlayBannerShowing() && rebootAtMsec != 0) {
@@ -844,19 +713,13 @@ int32_t Screen::runOnce()
             handleSetOn(false);
             break;
         case Cmd::ON_PRESS:
-            if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleOnPress();
-            }
+            handleOnPress();
             break;
         case Cmd::SHOW_PREV_FRAME:
-            if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleShowPrevFrame();
-            }
+            handleShowPrevFrame();
             break;
         case Cmd::SHOW_NEXT_FRAME:
-            if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleShowNextFrame();
-            }
+            handleShowNextFrame();
             break;
         case Cmd::START_ALERT_FRAME: {
             showingBootScreen = false; // this should avoid the edge case where an alert triggers before the boot screen goes away
@@ -878,9 +741,7 @@ int32_t Screen::runOnce()
             NotificationRenderer::pauseBanner = false;
         case Cmd::STOP_BOOT_SCREEN:
             EINK_ADD_FRAMEFLAG(dispdev, COSMETIC); // E-Ink: Explicitly use full-refresh for next frame
-            if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                setFrames();
-            }
+            setFrames();
             break;
         case Cmd::NOOP:
             break;
@@ -916,7 +777,6 @@ int32_t Screen::runOnce()
     if (showingNormalScreen) {
         // standard screen loop handling here
         if (config.display.auto_screen_carousel_secs > 0 &&
-            NotificationRenderer::current_notification_type != notificationTypeEnum::text_input &&
             !Throttle::isWithinTimespanMs(lastScreenTransition, config.display.auto_screen_carousel_secs * 1000)) {
 
             // If an E-Ink display struggles with fast refresh, force carousel to use full refresh instead
@@ -985,10 +845,8 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
         ui->update();
     } while (ui->getUiState()->lastUpdate < startUpdate);
 
-#if defined(USE_EINK_PARALLELDISPLAY)
-    static_cast<EInkParallelDisplay *>(dispdev)->forceDisplay(0);
-#elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY)
     // Old EInkDisplay class
+#if !defined(USE_EINK_DYNAMICDISPLAY)
     static_cast<EInkDisplay *>(dispdev)->forceDisplay(0); // Screen::forceDisplay(), but override rate-limit
 #endif
 
@@ -1000,7 +858,7 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 #ifdef EINK_HASQUIRK_GHOSTING
     EINK_ADD_FRAMEFLAG(dispdev, COSMETIC); // Really ugly to see ghosting from "screen paused"
 #else
-    EINK_ADD_FRAMEFLAG(dispdev, RESPONSIVE);              // Really nice to wake screen with a fast-refresh
+    EINK_ADD_FRAMEFLAG(dispdev, RESPONSIVE); // Really nice to wake screen with a fast-refresh
 #endif
 }
 #endif
@@ -1009,11 +867,6 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 // Called when a frame should be added / removed, or custom frames should be cleared
 void Screen::setFrames(FrameFocus focus)
 {
-    // Block setFrames calls when virtual keyboard is active to prevent overlay interference
-    if (NotificationRenderer::current_notification_type == notificationTypeEnum::text_input) {
-        return;
-    }
-
     uint8_t originalPosition = ui->getUiState()->currentFrame;
     uint8_t previousFrameCount = framesetInfo.frameCount;
     FramesetInfo fsi; // Location of specific frames, for applying focus parameter
@@ -1036,95 +889,71 @@ void Screen::setFrames(FrameFocus focus)
     }
 
 #if defined(DISPLAY_CLOCK_FRAME)
-    if (!hiddenFrames.clock) {
-        fsi.positions.clock = numframes;
-#if defined(M5STACK_UNITC6L)
-        normalFrames[numframes++] = graphics::ClockRenderer::drawAnalogClockFrame;
-#else
-        normalFrames[numframes++] = uiconfig.is_clockface_analog ? graphics::ClockRenderer::drawAnalogClockFrame
-                                                                 : graphics::ClockRenderer::drawDigitalClockFrame;
-#endif
-        indicatorIcons.push_back(digital_icon_clock);
-    }
+    fsi.positions.clock = numframes;
+    normalFrames[numframes++] = uiconfig.is_clockface_analog ? graphics::ClockRenderer::drawAnalogClockFrame
+                                                             : graphics::ClockRenderer::drawDigitalClockFrame;
+    indicatorIcons.push_back(digital_icon_clock);
 #endif
 
     // Declare this early so it’s available in FOCUS_PRESERVE block
     bool willInsertTextMessage = shouldDrawMessage(&devicestate.rx_text_message);
 
-    if (!hiddenFrames.home) {
-        fsi.positions.home = numframes;
-        normalFrames[numframes++] = graphics::UIRenderer::drawDeviceFocused;
-        indicatorIcons.push_back(icon_home);
-    }
+    fsi.positions.home = numframes;
+    normalFrames[numframes++] = graphics::UIRenderer::drawDeviceFocused;
+    indicatorIcons.push_back(icon_home);
 
     fsi.positions.textMessage = numframes;
     normalFrames[numframes++] = graphics::MessageRenderer::drawTextMessageFrame;
     indicatorIcons.push_back(icon_mail);
 
 #ifndef USE_EINK
-    if (!hiddenFrames.nodelist) {
-        fsi.positions.nodelist = numframes;
-        normalFrames[numframes++] = graphics::NodeListRenderer::drawDynamicNodeListScreen;
-        indicatorIcons.push_back(icon_nodes);
-    }
+    fsi.positions.nodelist = numframes;
+    normalFrames[numframes++] = graphics::NodeListRenderer::drawDynamicNodeListScreen;
+    indicatorIcons.push_back(icon_nodes);
 #endif
 
 // Show detailed node views only on E-Ink builds
 #ifdef USE_EINK
-    if (!hiddenFrames.nodelist_lastheard) {
-        fsi.positions.nodelist_lastheard = numframes;
-        normalFrames[numframes++] = graphics::NodeListRenderer::drawLastHeardScreen;
-        indicatorIcons.push_back(icon_nodes);
-    }
-    if (!hiddenFrames.nodelist_hopsignal) {
-        fsi.positions.nodelist_hopsignal = numframes;
-        normalFrames[numframes++] = graphics::NodeListRenderer::drawHopSignalScreen;
-        indicatorIcons.push_back(icon_signal);
-    }
-    if (!hiddenFrames.nodelist_distance) {
-        fsi.positions.nodelist_distance = numframes;
-        normalFrames[numframes++] = graphics::NodeListRenderer::drawDistanceScreen;
-        indicatorIcons.push_back(icon_distance);
-    }
+    fsi.positions.nodelist_lastheard = numframes;
+    normalFrames[numframes++] = graphics::NodeListRenderer::drawLastHeardScreen;
+    indicatorIcons.push_back(icon_nodes);
+
+    fsi.positions.nodelist_hopsignal = numframes;
+    normalFrames[numframes++] = graphics::NodeListRenderer::drawHopSignalScreen;
+    indicatorIcons.push_back(icon_signal);
+
+    fsi.positions.nodelist_distance = numframes;
+    normalFrames[numframes++] = graphics::NodeListRenderer::drawDistanceScreen;
+    indicatorIcons.push_back(icon_distance);
 #endif
 #if HAS_GPS
-    if (!hiddenFrames.nodelist_bearings) {
-        fsi.positions.nodelist_bearings = numframes;
-        normalFrames[numframes++] = graphics::NodeListRenderer::drawNodeListWithCompasses;
-        indicatorIcons.push_back(icon_list);
-    }
-    if (!hiddenFrames.gps) {
-        fsi.positions.gps = numframes;
-        normalFrames[numframes++] = graphics::UIRenderer::drawCompassAndLocationScreen;
-        indicatorIcons.push_back(icon_compass);
-    }
+    fsi.positions.nodelist_bearings = numframes;
+    normalFrames[numframes++] = graphics::NodeListRenderer::drawNodeListWithCompasses;
+    indicatorIcons.push_back(icon_list);
+
+    fsi.positions.gps = numframes;
+    normalFrames[numframes++] = graphics::UIRenderer::drawCompassAndLocationScreen;
+    indicatorIcons.push_back(icon_compass);
 #endif
-    if (RadioLibInterface::instance && !hiddenFrames.lora) {
+    if (RadioLibInterface::instance) {
         fsi.positions.lora = numframes;
         normalFrames[numframes++] = graphics::DebugRenderer::drawLoRaFocused;
         indicatorIcons.push_back(icon_radio);
     }
-    if (!hiddenFrames.system) {
-        fsi.positions.system = numframes;
-        normalFrames[numframes++] = graphics::DebugRenderer::drawSystemScreen;
-        indicatorIcons.push_back(icon_system);
+    if (!dismissedFrames.memory) {
+        fsi.positions.memory = numframes;
+        normalFrames[numframes++] = graphics::DebugRenderer::drawMemoryUsage;
+        indicatorIcons.push_back(icon_memory);
     }
 #if !defined(DISPLAY_CLOCK_FRAME)
-    if (!hiddenFrames.clock) {
-        fsi.positions.clock = numframes;
-        normalFrames[numframes++] = uiconfig.is_clockface_analog ? graphics::ClockRenderer::drawAnalogClockFrame
-                                                                 : graphics::ClockRenderer::drawDigitalClockFrame;
-        indicatorIcons.push_back(digital_icon_clock);
-    }
+    fsi.positions.clock = numframes;
+    normalFrames[numframes++] = uiconfig.is_clockface_analog ? graphics::ClockRenderer::drawAnalogClockFrame
+                                                             : graphics::ClockRenderer::drawDigitalClockFrame;
+    indicatorIcons.push_back(digital_icon_clock);
 #endif
-    if (!hiddenFrames.chirpy) {
-        fsi.positions.chirpy = numframes;
-        normalFrames[numframes++] = graphics::DebugRenderer::drawChirpy;
-        indicatorIcons.push_back(chirpy_small);
-    }
 
 #if HAS_WIFI && !defined(ARCH_PORTDUINO)
-    if (!hiddenFrames.wifi && isWifiAvailable()) {
+    if (!dismissedFrames.wifi && isWifiAvailable()) {
         fsi.positions.wifi = numframes;
         normalFrames[numframes++] = graphics::DebugRenderer::drawDebugInfoWiFiTrampoline;
         indicatorIcons.push_back(icon_wifi);
@@ -1166,29 +995,27 @@ void Screen::setFrames(FrameFocus focus)
     if (numMeshNodes > 0)
         numMeshNodes--;
 
-    if (!hiddenFrames.show_favorites) {
-        // Temporary array to hold favorite node frames
-        std::vector<FrameCallback> favoriteFrames;
+    // Temporary array to hold favorite node frames
+    std::vector<FrameCallback> favoriteFrames;
 
-        for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-            const meshtastic_NodeInfoLite *n = nodeDB->getMeshNodeByIndex(i);
-            if (n && n->num != nodeDB->getNodeNum() && n->is_favorite) {
-                favoriteFrames.push_back(graphics::UIRenderer::drawNodeInfo);
-            }
+    for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
+        const meshtastic_NodeInfoLite *n = nodeDB->getMeshNodeByIndex(i);
+        if (n && n->num != nodeDB->getNodeNum() && n->is_favorite) {
+            favoriteFrames.push_back(graphics::UIRenderer::drawNodeInfo);
         }
+    }
 
-        // Insert favorite frames *after* collecting them all
-        if (!favoriteFrames.empty()) {
-            fsi.positions.firstFavorite = numframes;
-            for (const auto &f : favoriteFrames) {
-                normalFrames[numframes++] = f;
-                indicatorIcons.push_back(icon_node);
-            }
-            fsi.positions.lastFavorite = numframes - 1;
-        } else {
-            fsi.positions.firstFavorite = 255;
-            fsi.positions.lastFavorite = 255;
+    // Insert favorite frames *after* collecting them all
+    if (!favoriteFrames.empty()) {
+        fsi.positions.firstFavorite = numframes;
+        for (const auto &f : favoriteFrames) {
+            normalFrames[numframes++] = f;
+            indicatorIcons.push_back(icon_node);
         }
+        fsi.positions.lastFavorite = numframes - 1;
+    } else {
+        fsi.positions.firstFavorite = 255;
+        fsi.positions.lastFavorite = 255;
     }
 
     fsi.frameCount = numframes;   // Total framecount is used to apply FOCUS_PRESERVE
@@ -1227,7 +1054,7 @@ void Screen::setFrames(FrameFocus focus)
         ui->switchToFrame(fsi.positions.clock);
         break;
     case FOCUS_SYSTEM:
-        ui->switchToFrame(fsi.positions.system);
+        ui->switchToFrame(fsi.positions.memory);
         break;
 
     case FOCUS_PRESERVE:
@@ -1255,101 +1082,30 @@ void Screen::setFrameImmediateDraw(FrameCallback *drawFrames)
     setFastFramerate();
 }
 
-void Screen::toggleFrameVisibility(const std::string &frameName)
-{
-#ifndef USE_EINK
-    if (frameName == "nodelist") {
-        hiddenFrames.nodelist = !hiddenFrames.nodelist;
-    }
-#endif
-#ifdef USE_EINK
-    if (frameName == "nodelist_lastheard") {
-        hiddenFrames.nodelist_lastheard = !hiddenFrames.nodelist_lastheard;
-    }
-    if (frameName == "nodelist_hopsignal") {
-        hiddenFrames.nodelist_hopsignal = !hiddenFrames.nodelist_hopsignal;
-    }
-    if (frameName == "nodelist_distance") {
-        hiddenFrames.nodelist_distance = !hiddenFrames.nodelist_distance;
-    }
-#endif
-#if HAS_GPS
-    if (frameName == "nodelist_bearings") {
-        hiddenFrames.nodelist_bearings = !hiddenFrames.nodelist_bearings;
-    }
-    if (frameName == "gps") {
-        hiddenFrames.gps = !hiddenFrames.gps;
-    }
-#endif
-    if (frameName == "lora") {
-        hiddenFrames.lora = !hiddenFrames.lora;
-    }
-    if (frameName == "clock") {
-        hiddenFrames.clock = !hiddenFrames.clock;
-    }
-    if (frameName == "show_favorites") {
-        hiddenFrames.show_favorites = !hiddenFrames.show_favorites;
-    }
-    if (frameName == "chirpy") {
-        hiddenFrames.chirpy = !hiddenFrames.chirpy;
-    }
-}
-
-bool Screen::isFrameHidden(const std::string &frameName) const
-{
-#ifndef USE_EINK
-    if (frameName == "nodelist")
-        return hiddenFrames.nodelist;
-#endif
-#ifdef USE_EINK
-    if (frameName == "nodelist_lastheard")
-        return hiddenFrames.nodelist_lastheard;
-    if (frameName == "nodelist_hopsignal")
-        return hiddenFrames.nodelist_hopsignal;
-    if (frameName == "nodelist_distance")
-        return hiddenFrames.nodelist_distance;
-#endif
-#if HAS_GPS
-    if (frameName == "nodelist_bearings")
-        return hiddenFrames.nodelist_bearings;
-    if (frameName == "gps")
-        return hiddenFrames.gps;
-#endif
-    if (frameName == "lora")
-        return hiddenFrames.lora;
-    if (frameName == "clock")
-        return hiddenFrames.clock;
-    if (frameName == "show_favorites")
-        return hiddenFrames.show_favorites;
-    if (frameName == "chirpy")
-        return hiddenFrames.chirpy;
-
-    return false;
-}
-
 // Dismisses the currently displayed screen frame, if possible
 // Relevant for text message, waypoint, others in future?
 // Triggered with a CardKB keycombo
-void Screen::hideCurrentFrame()
+void Screen::dismissCurrentFrame()
 {
     uint8_t currentFrame = ui->getUiState()->currentFrame;
     bool dismissed = false;
+
     if (currentFrame == framesetInfo.positions.textMessage && devicestate.has_rx_text_message) {
-        LOG_INFO("Hide Text Message");
+        LOG_INFO("Dismiss Text Message");
         devicestate.has_rx_text_message = false;
         memset(&devicestate.rx_text_message, 0, sizeof(devicestate.rx_text_message));
     } else if (currentFrame == framesetInfo.positions.waypoint && devicestate.has_rx_waypoint) {
-        LOG_DEBUG("Hide Waypoint");
+        LOG_DEBUG("Dismiss Waypoint");
         devicestate.has_rx_waypoint = false;
-        hiddenFrames.waypoint = true;
+        dismissedFrames.waypoint = true;
         dismissed = true;
     } else if (currentFrame == framesetInfo.positions.wifi) {
-        LOG_DEBUG("Hide WiFi Screen");
-        hiddenFrames.wifi = true;
+        LOG_DEBUG("Dismiss WiFi Screen");
+        dismissedFrames.wifi = true;
         dismissed = true;
-    } else if (currentFrame == framesetInfo.positions.lora) {
-        LOG_INFO("Hide LoRa");
-        hiddenFrames.lora = true;
+    } else if (currentFrame == framesetInfo.positions.memory) {
+        LOG_INFO("Dismiss Memory");
+        dismissedFrames.memory = true;
         dismissed = true;
     }
 
@@ -1382,8 +1138,7 @@ void Screen::blink()
         delay(50);
         count = count - 1;
     }
-    // The dispdev->setBrightness does not work for t-deck display, it seems to run the setBrightness function in
-    // OLEDDisplay.
+    // The dispdev->setBrightness does not work for t-deck display, it seems to run the setBrightness function in OLEDDisplay.
     dispdev->setBrightness(brightness);
 }
 
@@ -1471,10 +1226,6 @@ void Screen::handleShowNextFrame()
 
 void Screen::setFastFramerate()
 {
-#if defined(M5STACK_UNITC6L)
-    dispdev->clear();
-    dispdev->display();
-#endif
     // We are about to start a transition so speed up fps
     targetFramerate = SCREEN_TRANSITION_FRAMERATE;
 
@@ -1493,9 +1244,6 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
         }
         nodeDB->updateGUI = false;
         break;
-    case STATUS_TYPE_POWER:
-        forceDisplay(true);
-        break;
     }
 
     return 0;
@@ -1509,7 +1257,7 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
             // Outgoing message (likely sent from phone)
             devicestate.has_rx_text_message = false;
             memset(&devicestate.rx_text_message, 0, sizeof(devicestate.rx_text_message));
-            hiddenFrames.textMessage = true;
+            dismissedFrames.textMessage = true;
             hasUnreadMessage = false; // Clear unread state when user replies
 
             setFrames(FOCUS_PRESERVE); // Stay on same frame, silently update frame list
@@ -1526,61 +1274,36 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
             }
             // === Prepare banner content ===
             const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet->from);
-            const meshtastic_Channel channel =
-                channels.getByIndex(packet->channel ? packet->channel : channels.getPrimaryIndex());
             const char *longName = (node && node->has_user) ? node->user.long_name : nullptr;
 
             const char *msgRaw = reinterpret_cast<const char *>(packet->decoded.payload.bytes);
 
             char banner[256];
 
+            // Check for bell character in message to determine alert type
             bool isAlert = false;
-
-            if (moduleConfig.external_notification.alert_bell || moduleConfig.external_notification.alert_bell_vibra ||
-                moduleConfig.external_notification.alert_bell_buzzer)
-                // Check for bell character to determine if this message is an alert
-                for (size_t i = 0; i < packet->decoded.payload.size && i < 100; i++) {
-                    if (msgRaw[i] == ASCII_BELL) {
-                        isAlert = true;
-                        break;
-                    }
+            for (size_t i = 0; i < packet->decoded.payload.size && i < 100; i++) {
+                if (msgRaw[i] == '\x07') {
+                    isAlert = true;
+                    break;
                 }
+            }
 
-            // Unlike generic messages, alerts (when enabled via the ext notif module) ignore any
-            // 'mute' preferences set to any specific node or channel.
             if (isAlert) {
                 if (longName && longName[0]) {
                     snprintf(banner, sizeof(banner), "Alert Received from\n%s", longName);
                 } else {
                     strcpy(banner, "Alert Received");
                 }
-                screen->showSimpleBanner(banner, 3000);
-            } else if (!channel.settings.has_module_settings || !channel.settings.module_settings.is_muted) {
+            } else {
                 if (longName && longName[0]) {
-#if defined(M5STACK_UNITC6L)
-                    strcpy(banner, "New Message");
-#else
                     snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
-#endif
-
                 } else {
                     strcpy(banner, "New Message");
                 }
-#if defined(M5STACK_UNITC6L)
-                screen->setOn(true);
-                screen->showSimpleBanner(banner, 1500);
-                if (config.device.buzzer_mode != meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY ||
-                    (isAlert && moduleConfig.external_notification.alert_bell_buzzer) ||
-                    (!isBroadcast(packet->to) && isToUs(packet))) {
-                    // Beep if not in DIRECT_MSG_ONLY mode or if in DIRECT_MSG_ONLY mode and either
-                    // - packet contains an alert and alert bell buzzer is enabled
-                    // - packet is a non-broadcast that is addressed to this node
-                    playLongBeep();
-                }
-#else
-                screen->showSimpleBanner(banner, 3000);
-#endif
             }
+
+            screen->showSimpleBanner(banner, 3000);
         }
     }
 
@@ -1590,11 +1313,6 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
 // Triggered by MeshModules
 int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 {
-    // Block UI frame events when virtual keyboard is active
-    if (NotificationRenderer::current_notification_type == notificationTypeEnum::text_input) {
-        return 0;
-    }
-
     if (showingNormalScreen) {
         // Regenerate the frameset, potentially honoring a module's internal requestFocus() call
         if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET)
@@ -1617,16 +1335,6 @@ int Screen::handleInputEvent(const InputEvent *event)
     if (!screenOn)
         return 0;
 
-    // Handle text input notifications specially - pass input to virtual keyboard
-    if (NotificationRenderer::current_notification_type == notificationTypeEnum::text_input) {
-        NotificationRenderer::inEvent = *event;
-        static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-        ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
-        setFastFramerate(); // Draw ASAP
-        ui->update();
-        return 0;
-    }
-
 #ifdef USE_EINK // the screen is the last input handler, so if an event makes it here, we can assume it will prompt a screen draw.
     EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Use fast-refresh for next frame, no skip please
     EINK_ADD_FRAMEFLAG(dispdev, BLOCKING);    // Edge case: if this frame is promoted to COSMETIC, wait for update
@@ -1664,7 +1372,7 @@ int Screen::handleInputEvent(const InputEvent *event)
             } else if (event->inputEvent == INPUT_BROKER_SELECT) {
                 if (this->ui->getUiState()->currentFrame == framesetInfo.positions.home) {
                     menuHandler::homeBaseMenu();
-                } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.system) {
+                } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.memory) {
                     menuHandler::systemBaseMenu();
 #if HAS_GPS
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.gps && gps) {
@@ -1673,16 +1381,12 @@ int Screen::handleInputEvent(const InputEvent *event)
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.clock) {
                     menuHandler::clockMenu();
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.lora) {
-                    menuHandler::loraMenu();
+                    menuHandler::LoraRegionPicker();
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.textMessage) {
                     if (devicestate.rx_text_message.from) {
                         menuHandler::messageResponseMenu();
                     } else {
-#if defined(M5STACK_UNITC6L)
-                        menuHandler::textMessageMenu();
-#else
                         menuHandler::textMessageBaseMenu();
-#endif
                     }
                 } else if (framesetInfo.positions.firstFavorite != 255 &&
                            this->ui->getUiState()->currentFrame >= framesetInfo.positions.firstFavorite &&
@@ -1741,15 +1445,13 @@ bool shouldWakeOnReceivedMessage()
     /*
     The goal here is to determine when we do NOT wake up the screen on message received:
     - Any ext. notifications are turned on
-    - If role is not CLIENT / CLIENT_MUTE / CLIENT_HIDDEN / CLIENT_BASE
+    - If role is not client / client_mute
     - If the battery level is very low
     */
     if (moduleConfig.external_notification.enabled) {
         return false;
     }
-    if (!IS_ONE_OF(config.device.role, meshtastic_Config_DeviceConfig_Role_CLIENT,
-                   meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE, meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN,
-                   meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
+    if (!meshtastic_Config_DeviceConfig_Role_CLIENT && !meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE) {
         return false;
     }
     if (powerStatus && powerStatus->getBatteryChargePercent() < 10) {