reduce PSRAM allocated to lvgl

Merge branch 'master' into arduino-esp32-v3.2
2025-12-14 14:52:32 +00:00 · 2025-09-18 10:17:58 +02:00 · 2025-09-18 09:48:51 +02:00 · 2025-09-12 21:15:43 +02:00 · 2025-09-08 19:20:15 +02:00 · 2025-09-08 10:41:14 +02:00
103 changed files with 1147 additions and 3138 deletions
--- a/.clusterfuzzlite/router_fuzzer.cpp
+++ b/.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];
--- a/.github/workflows/build_one_arch.yml
+++ b/.github/workflows/build_one_arch.yml
@@ -1,500 +0,0 @@
-name: Build One Arch
-
-on:
-  workflow_dispatch:
-    inputs:
-      arch:
-        type: choice
-        options:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-          - native
-
-jobs:
-  setup:
-    strategy:
-      fail-fast: false
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v5
-      - 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 ${{inputs.arch}} extra)
-          else  
-            TARGETS=$(./bin/generate_ci_matrix.py ${{inputs.arch}} pr)
-          fi
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF Targets: $TARGETS"
-          echo "${{inputs.arch}}=$(jq -cn --argjson environments "$TARGETS" '{board: $environments}')" >> $GITHUB_OUTPUT
-    outputs:
-      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@v5
-      - 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-esp32:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'esp32'}}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.esp32) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.board }}
-      platform: esp32
-
-  build-esp32s3:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'esp32s3'}}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.esp32s3) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.board }}
-      platform: esp32s3
-
-  build-esp32c3:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'esp32c3'}}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.esp32c3) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.board }}
-      platform: esp32c3
-
-  build-esp32c6:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'esp32c6'}}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.esp32c6) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.board }}
-      platform: esp32c6
-
-  build-nrf52840:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'nrf52840'}}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.nrf52840) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.board }}
-      platform: nrf52840
-
-  build-rp2040:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'rp2040'}}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.rp2040) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.board }}
-      platform: rp2040
-
-  build-rp2350:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'rp2350'}}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.rp2350) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.board }}
-      platform: rp2350
-
-  build-stm32:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'stm32' }}
-    needs: [setup, version]
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.stm32) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.board }}
-      platform: stm32
-
-  build-debian-src:
-    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    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
-
-  docker-deb-amd64:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/amd64
-      runs-on: ubuntu-24.04
-      push: false
-
-  docker-deb-amd64-tft:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/amd64
-      runs-on: ubuntu-24.04
-      push: false
-      pio_env: native-tft
-
-  docker-alp-amd64:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: alpine
-      platform: linux/amd64
-      runs-on: ubuntu-24.04
-      push: false
-
-  docker-alp-amd64-tft:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: alpine
-      platform: linux/amd64
-      runs-on: ubuntu-24.04
-      push: false
-      pio_env: native-tft
-
-  docker-deb-arm64:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/arm64
-      runs-on: ubuntu-24.04-arm
-      push: false
-
-  docker-deb-armv7:
-    if: ${{ github.event_name != 'workflow_dispatch' || inputs.arch == 'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/arm/v7
-      runs-on: ubuntu-24.04-arm
-      push: false
-
-  gather-artifacts:
-    permissions:
-      contents: write
-      pull-requests: write
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-    runs-on: ubuntu-latest
-    needs:
-      [
-        version,
-        build-esp32,
-        build-esp32s3,
-        build-esp32c3,
-        build-esp32c6,
-        build-nrf52840,
-        build-rp2040,
-        build-rp2350,
-        build-stm32,
-      ]
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v5
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - uses: actions/download-artifact@v5
-        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@v4
-        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@v5
-        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@v4
-        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 }}
-
-  release-artifacts:
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-    needs:
-      - version
-      - gather-artifacts
-      - build-debian-src
-      - package-pio-deps-native-tft
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - name: Create release
-        uses: softprops/action-gh-release@v2
-        id: create_release
-        with:
-          draft: true
-          prerelease: true
-          name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
-          tag_name: v${{ needs.version.outputs.long }}
-          body: |
-            Autogenerated by github action, developer should edit as required before publishing...
-
-      - name: Download source deb
-        uses: actions/download-artifact@v5
-        with:
-          pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
-          merge-multiple: true
-          path: ./output/debian-src
-
-      - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v5
-        with:
-          pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output/pio-deps-native-tft
-
-      - name: Zip Linux sources
-        working-directory: output
-        run: |
-          zip -j -9 -r ./meshtasticd-${{ needs.version.outputs.deb }}-src.zip ./debian-src
-          zip -9 -r ./platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip ./pio-deps-native-tft
-
-      # For diagnostics
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Add Linux sources to GtiHub Release
-        # Only run when targeting master branch with workflow_dispatch
-        if: ${{ github.ref_name == 'master' }}
-        run: |
-          gh release upload v${{ needs.version.outputs.long }} ./output/meshtasticd-${{ needs.version.outputs.deb }}-src.zip
-          gh release upload v${{ needs.version.outputs.long }} ./output/platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  release-firmware:
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    needs: [release-artifacts, version]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - uses: actions/download-artifact@v5
-        with:
-          pattern: firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh
-          chmod +x ./output/device-update.sh
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - uses: actions/download-artifact@v5
-        with:
-          name: debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
-          merge-multiple: true
-          path: ./elfs
-
-      - name: Zip debug elfs
-        run: zip -j -9 -r ./debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip ./elfs
-
-      # For diagnostics
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Add bins and debug elfs to GitHub Release
-        # Only run when targeting master branch with workflow_dispatch
-        if: ${{ github.ref_name == 'master' }}
-        run: |
-          gh release upload v${{ needs.version.outputs.long }} ./firmware-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
-          gh release upload v${{ needs.version.outputs.long }} ./debug-elfs-${{inputs.arch}}-${{ needs.version.outputs.long }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  publish-firmware:
-    runs-on: ubuntu-24.04
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    needs: [release-firmware, version]
-    env:
-      targets: |-
-        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - uses: actions/download-artifact@v5
-        with:
-          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./publish
-
-      - name: Publish firmware to meshtastic.github.io
-        uses: peaceiris/actions-gh-pages@v4
-        env:
-          # On event/* branches, use the event name as the destination prefix
-          DEST_PREFIX: ${{ contains(github.ref_name, 'event/') && format('{0}/', github.ref_name) || '' }}
-        with:
-          deploy_key: ${{ secrets.DIST_PAGES_DEPLOY_KEY }}
-          external_repository: meshtastic/meshtastic.github.io
-          publish_branch: master
-          publish_dir: ./publish
-          destination_dir: ${{ env.DEST_PREFIX }}firmware-${{ needs.version.outputs.long }}
-          keep_files: true
-          user_name: github-actions[bot]
-          user_email: github-actions[bot]@users.noreply.github.com
-          commit_message: ${{ needs.version.outputs.long }}
-          enable_jekyll: true
--- a/.github/workflows/build_one_target.yml
+++ b/.github/workflows/build_one_target.yml
@@ -1,395 +0,0 @@
-name: Build One Target
-
-on:
-  workflow_dispatch:
-    inputs:
-      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'
-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@v5
-      - 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}} 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 | sed 's/[][]//g; s/", "/\n- /g; s/"//g; s/^/- /' >> $GITHUB_STEP_SUMMARY
-
-  version:
-    if: ${{ inputs.target != '' }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-      - 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-arch:
-    if: ${{ inputs.target != '' && inputs.arch != 'native' }}
-    needs: [version]
-    strategy:
-      fail-fast: false
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      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
-
-  docker-deb-amd64:
-    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/amd64
-      runs-on: ubuntu-24.04
-      push: false
-
-  docker-deb-amd64-tft:
-    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/amd64
-      runs-on: ubuntu-24.04
-      push: false
-      pio_env: native-tft
-
-  docker-alp-amd64:
-    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: alpine
-      platform: linux/amd64
-      runs-on: ubuntu-24.04
-      push: false
-
-  docker-alp-amd64-tft:
-    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: alpine
-      platform: linux/amd64
-      runs-on: ubuntu-24.04
-      push: false
-      pio_env: native-tft
-
-  docker-deb-arm64:
-    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/arm64
-      runs-on: ubuntu-24.04-arm
-      push: false
-
-  docker-deb-armv7:
-    if: ${{ inputs.target != '' && inputs.arch ==  'native' }}
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/arm/v7
-      runs-on: ubuntu-24.04-arm
-      push: false
-
-  gather-artifacts:
-    permissions:
-      contents: write
-      pull-requests: write
-    strategy:
-      fail-fast: false
-    runs-on: ubuntu-latest
-    needs: [version, build-arch]
-    steps:
-      - name: Checkout code
-        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@v5
-        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@v4
-        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@v5
-        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@v4
-        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 }}
-
-  release-artifacts:
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' && inputs.target != ''}}
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-    needs:
-      - version
-      - gather-artifacts
-      - build-debian-src
-      - package-pio-deps-native-tft
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - name: Create release
-        uses: softprops/action-gh-release@v2
-        id: create_release
-        with:
-          draft: true
-          prerelease: true
-          name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
-          tag_name: v${{ needs.version.outputs.long }}
-          body: |
-            Autogenerated by github action, developer should edit as required before publishing...
-
-      - name: Download source deb
-        uses: actions/download-artifact@v5
-        with:
-          pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
-          merge-multiple: true
-          path: ./output/debian-src
-
-      - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v5
-        with:
-          pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output/pio-deps-native-tft
-
-      - name: Zip Linux sources
-        working-directory: output
-        run: |
-          zip -j -9 -r ./meshtasticd-${{ needs.version.outputs.deb }}-src.zip ./debian-src
-          zip -9 -r ./platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip ./pio-deps-native-tft
-
-      # For diagnostics
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Add Linux sources to GtiHub Release
-        # Only run when targeting master branch with workflow_dispatch
-        if: ${{ github.ref_name == 'master' }}
-        run: |
-          gh release upload v${{ needs.version.outputs.long }} ./output/meshtasticd-${{ needs.version.outputs.deb }}-src.zip
-          gh release upload v${{ needs.version.outputs.long }} ./output/platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  release-firmware:
-    strategy:
-      fail-fast: false
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' && inputs.target != ''}}
-    needs: [release-artifacts, version]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - uses: actions/download-artifact@v5
-        with:
-          pattern: firmware-*-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh
-          chmod +x ./output/device-update.sh
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - uses: actions/download-artifact@v5
-        with:
-          pattern: debug-elfs-*-${{ needs.version.outputs.long }}.zip
-          merge-multiple: true
-          path: ./elfs
-
-      - name: Zip debug elfs
-        run: zip -j -9 -r ./debug-elfs-${{inputs.target}}-${{ needs.version.outputs.long }}.zip ./elfs
-
-      # For diagnostics
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Add bins and debug elfs to GitHub Release
-        # Only run when targeting master branch with workflow_dispatch
-        if: ${{ github.ref_name == 'master' }}
-        run: |
-          gh release upload v${{ needs.version.outputs.long }} ./firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip
-          gh release upload v${{ needs.version.outputs.long }} ./debug-elfs-${{inputs.target}}-${{ needs.version.outputs.long }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  publish-firmware:
-    runs-on: ubuntu-24.04
-    if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware' && inputs.target != '' }}
-    needs: [release-firmware, version]
-    env:
-      targets: |-
-        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - uses: actions/download-artifact@v5
-        with:
-          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./publish
-
-      - name: Publish firmware to meshtastic.github.io
-        uses: peaceiris/actions-gh-pages@v4
-        env:
-          # On event/* branches, use the event name as the destination prefix
-          DEST_PREFIX: ${{ contains(github.ref_name, 'event/') && format('{0}/', github.ref_name) || '' }}
-        with:
-          deploy_key: ${{ secrets.DIST_PAGES_DEPLOY_KEY }}
-          external_repository: meshtastic/meshtastic.github.io
-          publish_branch: master
-          publish_dir: ./publish
-          destination_dir: ${{ env.DEST_PREFIX }}firmware-${{ needs.version.outputs.long }}
-          keep_files: true
-          user_name: github-actions[bot]
-          user_email: github-actions[bot]@users.noreply.github.com
-          commit_message: ${{ needs.version.outputs.long }}
-          enable_jekyll: true
--- a/.github/workflows/daily_packaging.yml
+++ b/.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
--- a/.github/workflows/main_matrix.yml
+++ b/.github/workflows/main_matrix.yml
@@ -27,7 +27,6 @@ on:

 jobs:
  setup:
-    if: github.repository == 'meshtastic/firmware'
    strategy:
      fail-fast: false
      matrix:
@@ -71,7 +70,6 @@ jobs:
      check: ${{ steps.jsonStep.outputs.check }}

  version:
-    if: github.repository == 'meshtastic/firmware'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
@@ -93,7 +91,7 @@ jobs:
      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@v5
      - name: Build base
@@ -206,11 +204,10 @@ jobs:
    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-deb-amd64:
-    if: github.repository == 'meshtastic/firmware'
    uses: ./.github/workflows/docker_build.yml
    with:
      distro: debian
@@ -219,7 +216,6 @@ jobs:
      push: false

  docker-deb-amd64-tft:
-    if: github.repository == 'meshtastic/firmware'
    uses: ./.github/workflows/docker_build.yml
    with:
      distro: debian
@@ -229,7 +225,6 @@ jobs:
      pio_env: native-tft

  docker-alp-amd64:
-    if: github.repository == 'meshtastic/firmware'
    uses: ./.github/workflows/docker_build.yml
    with:
      distro: alpine
@@ -238,7 +233,6 @@ jobs:
      push: false

  docker-alp-amd64-tft:
-    if: github.repository == 'meshtastic/firmware'
    uses: ./.github/workflows/docker_build.yml
    with:
      distro: alpine
@@ -248,7 +242,6 @@ jobs:
      pio_env: native-tft

  docker-deb-arm64:
-    if: github.repository == 'meshtastic/firmware'
    uses: ./.github/workflows/docker_build.yml
    with:
      distro: debian
@@ -257,7 +250,6 @@ jobs:
      push: false

  docker-deb-armv7:
-    if: github.repository == 'meshtastic/firmware'
    uses: ./.github/workflows/docker_build.yml
    with:
      distro: debian
@@ -267,7 +259,6 @@ jobs:

  gather-artifacts:
    # trunk-ignore(checkov/CKV2_GHA_1)
-    if: github.repository == 'meshtastic/firmware'
    permissions:
      contents: write
      pull-requests: write
@@ -367,7 +358,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:
@@ -442,7 +433,7 @@ 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
--- a/.github/workflows/merge_queue.yml
+++ b/.github/workflows/merge_queue.yml
@@ -27,8 +27,8 @@ jobs:
          - check
    runs-on: ubuntu-24.04
    steps:
-      - uses: actions/checkout@v5
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
        with:
          python-version: 3.x
          cache: pip
@@ -57,7 +57,7 @@ jobs:
  version:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Get release version string
        run: |
          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
@@ -78,7 +78,7 @@ jobs:
    runs-on: ubuntu-latest
    if: ${{ github.event_name != 'workflow_dispatch' }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Build base
        id: base
        uses: ./.github/actions/setup-base
@@ -274,12 +274,12 @@ jobs:
      ]
    steps:
      - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
        with:
          ref: ${{github.event.pull_request.head.ref}}
          repository: ${{github.event.pull_request.head.repo.full_name}}

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
        with:
          path: ./
          pattern: firmware-${{matrix.arch}}-*
@@ -308,7 +308,7 @@ jobs:
            ./Meshtastic_nRF52_factory_erase*.uf2
          retention-days: 30

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
        with:
          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
          merge-multiple: true
@@ -353,10 +353,10 @@ jobs:
      - package-pio-deps-native-tft
    steps:
      - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: 3.x

@@ -372,14 +372,14 @@ jobs:
            Autogenerated by github action, developer should edit as required before publishing...

      - name: Download source deb
-        uses: actions/download-artifact@v5
+        uses: actions/download-artifact@v4
        with:
          pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
          merge-multiple: true
          path: ./output/debian-src

      - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v5
+        uses: actions/download-artifact@v4
        with:
          pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
          merge-multiple: true
@@ -422,14 +422,14 @@ jobs:
    needs: [release-artifacts, version]
    steps:
      - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: 3.x

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
        with:
          pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
          merge-multiple: true
@@ -446,7 +446,7 @@ jobs:
      - name: Zip firmware
        run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
        with:
          name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
          merge-multiple: true
@@ -477,14 +477,14 @@ jobs:
        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
    steps:
      - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: 3.x

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
        with:
          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
          merge-multiple: true
--- a/.github/workflows/release_channels.yml
+++ b/.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: |-
--- a/.gitignore
+++ b/.gitignore
@@ -39,5 +39,14 @@ release/
 src/mesh/raspihttp/certificate.pem
 src/mesh/raspihttp/private_key.pem

+# pioarduino platform
+managed_components/*
+arduino-lib-builder*
+dependencies.lock
+idf_component.yml
+CMakeLists.txt
+sdkconfig.*
+.dummy/*
+
 # Ignore logo (set at build time with platformio-custom.py)
 data/boot/logo.*
--- a/.trunk/trunk.yaml
+++ b/.trunk/trunk.yaml
@@ -9,7 +9,7 @@ plugins:
 lint:
  enabled:
    - checkov@3.2.471
-    - renovate@41.115.6
+    - renovate@41.115.2
    - prettier@3.6.2
    - trufflehog@3.90.6
    - yamllint@1.37.1
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -10,10 +10,5 @@
  },
  "[powershell]": {
    "editor.defaultFormatter": "ms-vscode.powershell"
-  },
-  "files.associations": {
-    "deque": "cpp",
-    "string": "cpp",
-    "vector": "cpp"
  }
 }
--- a/8MB_no_ota.csv
+++ b/8MB_no_ota.csv
@@ -0,0 +1,6 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+nvs,      data, nvs,     0x9000,  0x5000,
+otadata,  data, ota,     0xe000,  0x2000,
+app0,     app,  ota_0,   0x10000, 0x660000,
+spiffs,   data, spiffs,  0x670000,0x180000,
+coredump, data, coredump,0x7F0000,0x10000,
--- a/arch/esp32/esp32.ini
+++ b/arch/esp32/esp32.ini
@@ -52,8 +52,8 @@ lib_deps =
  https://github.com/meshtastic/esp32_https_server/archive/3223704846752e6d545139204837bdb2a55459ca.zip
  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
  h2zero/NimBLE-Arduino@^1.4.3
-  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
-  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
+  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/mverch67/libpax gitBranch=master
+  https://github.com/mverch67/libpax/archive/6f52ee989301cdabaeef00bcbf93bff55708ce2f.zip
  # renovate: datasource=github-tags depName=XPowersLib packageName=lewisxhe/XPowersLib
  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
--- a/bin/device-install.sh
+++ b/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
--- a/bin/device-update.sh
+++ b/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
--- a/bin/org.meshtastic.meshtasticd.metainfo.xml
+++ b/bin/org.meshtastic.meshtasticd.metainfo.xml
@@ -87,9 +87,6 @@
  </screenshots>

  <releases>
-    <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>
--- a/boards/seeed-sensecap-indicator.json
+++ b/boards/seeed-sensecap-indicator.json
@@ -16,6 +16,7 @@
    "f_cpu": "240000000L",
    "f_flash": "80000000L",
    "f_boot": "120000000L",
+    "boot_freq": "120000000L",
    "boot": "qio",
    "flash_mode": "qio",
    "psram_type": "opi",
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,6 +1,50 @@
-meshtasticd (2.7.10.0) UNRELEASED; 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

- -- Austin Lane <vidplace7@gmail.com>  Thu, 02 Jan 2025 12:00:00 +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
+
+  [  ]
+  * 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
--- a/platformio.ini
+++ b/platformio.ini
@@ -55,7 +55,6 @@ build_flags = -Wno-missing-field-initializers
 	-D MAX_THREADS=40 ; As we've split modules, we have more threads to manage
 	#-DBUILD_EPOCH=$UNIX_TIME ; set in platformio-custom.py now
 	#-D OLED_PL=1
-	#-D DEBUG_HEAP=1 ; uncomment to add free heap space / memory leak debugging logs

 monitor_speed = 115200
 monitor_filters = direct
@@ -88,8 +87,9 @@ check_flags =
 framework = arduino
 lib_deps =
 	${env.lib_deps}
-	# renovate: datasource=custom.pio depName=NonBlockingRTTTL packageName=end2endzone/library/NonBlockingRTTTL
-	end2endzone/NonBlockingRTTTL@1.3.0
+	# renovate: datasource=custom.pio depName=NonBlockingRTTTL packageName=mverch67/library/NonBlockingRTTTL
+	https://github.com/mverch67/NonBlockingRTTTL/archive/ad1c2fb12bc81db546c6a94e963acb3382d3689e.zip ; TODO
+
 build_flags = ${env.build_flags} -Os
 build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/>

@@ -100,8 +100,6 @@ lib_deps =
 	thingsboard/TBPubSubClient@2.12.1
 	# renovate: datasource=custom.pio depName=NTPClient packageName=arduino-libraries/library/NTPClient
 	arduino-libraries/NTPClient@3.2.1
-	# renovate: datasource=custom.pio depName=Syslog packageName=arcao/library/Syslog
-	arcao/Syslog@2.0.0

 ; Minimal networking libs for nrf52 (excludes Syslog to save flash)
 [nrf52_networking_base]
@@ -125,7 +123,7 @@ lib_deps =
 [environmental_base]
 lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit BusIO packageName=adafruit/library/Adafruit BusIO
-	adafruit/Adafruit BusIO@1.17.3
+	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
--- a/2
+++ b/2
--- a/src/DebugConfiguration.cpp
+++ b/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
--- a/src/DisplayFormatters.cpp
+++ b/src/DisplayFormatters.cpp
@@ -38,49 +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;
-    case meshtastic_Config_DeviceConfig_Role_REPEATER:
-        return "Repeater";
-        break;
-    default:
-        return "Unknown";
-        break;
-    }
 }
--- a/src/DisplayFormatters.h
+++ b/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);
 };
--- a/src/GPSStatus.h
+++ b/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,
--- a/src/RedirectablePrint.cpp
+++ b/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;
    }
--- a/src/configuration.h
+++ b/src/configuration.h
@@ -262,13 +262,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define VEXT_ON_VALUE LOW
 #endif

-// -----------------------------------------------------------------------------
-// Rotary encoder
-// -----------------------------------------------------------------------------
-#ifndef ROTARY_DELAY
-#define ROTARY_DELAY 5
-#endif
-
 // -----------------------------------------------------------------------------
 // GPS
 // -----------------------------------------------------------------------------
--- a/src/gps/GPS.cpp
+++ b/src/gps/GPS.cpp
@@ -516,7 +516,6 @@ bool GPS::setup()
                }
            }
            // Rare Serial Speeds
-#ifndef CONFIG_IDF_TARGET_ESP32C6
            if (probeTries == GPS_PROBETRIES) {
                LOG_DEBUG("Probe for GPS at %d", rareSerialSpeeds[speedSelect]);
                gnssModel = probe(rareSerialSpeeds[speedSelect]);
@@ -527,7 +526,6 @@ bool GPS::setup()
                    }
                }
            }
-#endif
        }

        if (gnssModel != GNSS_MODEL_UNKNOWN) {
@@ -809,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;
    }
@@ -1249,15 +1239,9 @@ GnssModel_t GPS::probe(int serialSpeed)
    _serial_gps->write("$PUBX,40,GSV,0,0,0,0,0,0*59\r\n");
    _serial_gps->write("$PUBX,40,VTG,0,0,0,0,0,0*5E\r\n");
    delay(20);
-    // Close NMEA sequences on CM121
-    _serial_gps->write("$CFGMSG,0,1,0,1*1B\r\n");
-    _serial_gps->write("$CFGMSG,0,2,0,1*18\r\n");
-    _serial_gps->write("$CFGMSG,0,3,0,1*19\r\n");
-    delay(20);

-    // Unicore UFirebirdII Series: UC6580, UM620, UM621, UM670A, UM680A, or UM681A,or CM121
-    std::vector<ChipInfo> unicore = {
-        {"UC6580", "UC6580", GNSS_MODEL_UC6580}, {"UM600", "UM600", GNSS_MODEL_UC6580}, {"CM121", "CM121", GNSS_MODEL_CM121}};
+    // 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 = {
@@ -1456,7 +1440,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
--- a/src/gps/GPS.h
+++ b/src/gps/GPS.h
@@ -31,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 {
--- a/src/graphics/Screen.cpp
+++ b/src/graphics/Screen.cpp
@@ -25,7 +25,6 @@ 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 <OLEDDisplay.h>

@@ -59,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"
@@ -340,7 +340,7 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
                             (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);
@@ -588,7 +588,7 @@ 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();
@@ -901,95 +901,75 @@ void Screen::setFrames(FrameFocus focus)
    }

 #if defined(DISPLAY_CLOCK_FRAME)
-    if (!hiddenFrames.clock) {
-        fsi.positions.clock = numframes;
+    fsi.positions.clock = numframes;
 #if defined(M5STACK_UNITC6L)
-        normalFrames[numframes++] = graphics::ClockRenderer::drawAnalogClockFrame;
+    normalFrames[numframes++] = graphics::ClockRenderer::drawAnalogClockFrame;
 #else
-        normalFrames[numframes++] = uiconfig.is_clockface_analog ? graphics::ClockRenderer::drawAnalogClockFrame
-                                                                 : graphics::ClockRenderer::drawDigitalClockFrame;
+    normalFrames[numframes++] = uiconfig.is_clockface_analog ? graphics::ClockRenderer::drawAnalogClockFrame
+                                                             : graphics::ClockRenderer::drawDigitalClockFrame;
 #endif
-        indicatorIcons.push_back(digital_icon_clock);
-    }
+    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(small_chirpy);
-    }

 #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);
@@ -1031,29 +1011,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
@@ -1092,7 +1070,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:
@@ -1120,101 +1098,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;
    }

@@ -1370,7 +1277,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
@@ -1495,7 +1402,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) {
@@ -1504,7 +1411,7 @@ 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();
@@ -1572,15 +1479,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) {
--- a/src/graphics/Screen.h
+++ b/src/graphics/Screen.h
@@ -593,11 +593,7 @@ class Screen : public concurrency::OSThread
    void setSSLFrames();

    // Dismiss the currently focussed frame, if possible (e.g. text message, waypoint)
-    void hideCurrentFrame();
-
-    // Menu-driven Show / Hide Toggle
-    void toggleFrameVisibility(const std::string &frameName);
-    bool isFrameHidden(const std::string &frameName) const;
+    void dismissCurrentFrame();

 #ifdef USE_EINK
    /// Draw an image to remain on E-Ink display after screen off
@@ -659,7 +655,7 @@ class Screen : public concurrency::OSThread
            uint8_t settings = 255;
            uint8_t wifi = 255;
            uint8_t deviceFocused = 255;
-            uint8_t system = 255;
+            uint8_t memory = 255;
            uint8_t gps = 255;
            uint8_t home = 255;
            uint8_t textMessage = 255;
@@ -669,7 +665,6 @@ class Screen : public concurrency::OSThread
            uint8_t nodelist_distance = 255;
            uint8_t nodelist_bearings = 255;
            uint8_t clock = 255;
-            uint8_t chirpy = 255;
            uint8_t firstFavorite = 255;
            uint8_t lastFavorite = 255;
            uint8_t lora = 255;
@@ -678,29 +673,12 @@ class Screen : public concurrency::OSThread
        uint8_t frameCount = 0;
    } framesetInfo;

-    struct hiddenFrames {
+    struct DismissedFrames {
        bool textMessage = false;
        bool waypoint = false;
        bool wifi = false;
-        bool system = false;
-        bool home = false;
-        bool clock = false;
-#ifndef USE_EINK
-        bool nodelist = false;
-#endif
-#ifdef USE_EINK
-        bool nodelist_lastheard = false;
-        bool nodelist_hopsignal = false;
-        bool nodelist_distance = false;
-#endif
-#if HAS_GPS
-        bool nodelist_bearings = false;
-        bool gps = false;
-#endif
-        bool lora = false;
-        bool show_favorites = false;
-        bool chirpy = true;
-    } hiddenFrames;
+        bool memory = false;
+    } dismissedFrames;

    /// Try to start drawing ASAP
    void setFastFramerate();
--- a/src/graphics/SharedUIDisplay.cpp
+++ b/src/graphics/SharedUIDisplay.cpp
@@ -1,7 +1,6 @@
 #include "graphics/SharedUIDisplay.h"
 #include "RTC.h"
 #include "graphics/ScreenFonts.h"
-#include "graphics/draw/UIRenderer.h"
 #include "main.h"
 #include "meshtastic/config.pb.h"
 #include "power.h"
@@ -17,10 +16,6 @@ void determineResolution(int16_t screenheight, int16_t screenwidth)
        isHighResolution = true;
    }

-    if (screenwidth > 128 && screenheight <= 64) {
-        isHighResolution = false;
-    }
-
    // Special case for Heltec Wireless Tracker v1.1
    if (screenwidth == 160 && screenheight == 80) {
        isHighResolution = false;
@@ -58,7 +53,7 @@ void drawRoundedHighlight(OLEDDisplay *display, int16_t x, int16_t y, int16_t w,
 // *************************
 // * Common Header Drawing *
 // *************************
-void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr, bool force_no_invert, bool show_date)
+void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr, bool battery_only)
 {
    constexpr int HEADER_OFFSET_Y = 1;
    y += HEADER_OFFSET_Y;
@@ -74,7 +69,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
    const int screenW = display->getWidth();
    const int screenH = display->getHeight();

-    if (!force_no_invert) {
+    if (!battery_only) {
        // === Inverted Header Background ===
        if (isInverted) {
            display->setColor(BLACK);
@@ -192,28 +187,13 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
    int timeStrWidth = display->getStringWidth("12:34"); // Default alignment
    int timeX = screenW - xOffset - timeStrWidth + 4;

-    if (rtc_sec > 0) {
+    if (rtc_sec > 0 && !battery_only) {
        // === Build Time String ===
        long hms = (rtc_sec % SEC_PER_DAY + SEC_PER_DAY) % SEC_PER_DAY;
        int hour = hms / SEC_PER_HOUR;
        int minute = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
        snprintf(timeStr, sizeof(timeStr), "%d:%02d", hour, minute);

-        // === Build Date String ===
-        char datetimeStr[25];
-        UIRenderer::formatDateTime(datetimeStr, sizeof(datetimeStr), rtc_sec, display, false);
-        char dateLine[40];
-
-        if (isHighResolution) {
-            snprintf(dateLine, sizeof(dateLine), "%s", datetimeStr);
-        } else {
-            if (hasUnreadMessage) {
-                snprintf(dateLine, sizeof(dateLine), "%s", &datetimeStr[5]);
-            } else {
-                snprintf(dateLine, sizeof(dateLine), "%s", &datetimeStr[2]);
-            }
-        }
-
        if (config.display.use_12h_clock) {
            bool isPM = hour >= 12;
            hour %= 12;
@@ -222,11 +202,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
            snprintf(timeStr, sizeof(timeStr), "%d:%02d%s", hour, minute, isPM ? "p" : "a");
        }

-        if (show_date) {
-            timeStrWidth = display->getStringWidth(dateLine);
-        } else {
-            timeStrWidth = display->getStringWidth(timeStr);
-        }
+        timeStrWidth = display->getStringWidth(timeStr);
        timeX = screenW - xOffset - timeStrWidth + 3;

        // === Show Mail or Mute Icon to the Left of Time ===
@@ -253,7 +229,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                int iconW = 16, iconH = 12;
                int iconX = iconRightEdge - iconW;
                int iconY = textY + (FONT_HEIGHT_SMALL - iconH) / 2 - 1;
-                if (isInverted && !force_no_invert) {
+                if (isInverted) {
                    display->setColor(WHITE);
                    display->fillRect(iconX - 1, iconY - 1, iconW + 3, iconH + 2);
                    display->setColor(BLACK);
@@ -268,7 +244,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
            } else {
                int iconX = iconRightEdge - (mail_width - 2);
                int iconY = textY + (FONT_HEIGHT_SMALL - mail_height) / 2;
-                if (isInverted && !force_no_invert) {
+                if (isInverted) {
                    display->setColor(WHITE);
                    display->fillRect(iconX - 1, iconY - 1, mail_width + 2, mail_height + 2);
                    display->setColor(BLACK);
@@ -311,17 +287,10 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
            }
        }

-        if (show_date) {
-            // === Draw Date ===
-            display->drawString(timeX, textY, dateLine);
-            if (isBold)
-                display->drawString(timeX - 1, textY, dateLine);
-        } else {
-            // === Draw Time ===
-            display->drawString(timeX, textY, timeStr);
-            if (isBold)
-                display->drawString(timeX - 1, textY, timeStr);
-        }
+        // === Draw Time ===
+        display->drawString(timeX, textY, timeStr);
+        if (isBold)
+            display->drawString(timeX - 1, textY, timeStr);

    } else {
        // === No Time Available: Mail/Mute Icon Moves to Far Right ===
--- a/src/graphics/SharedUIDisplay.h
+++ b/src/graphics/SharedUIDisplay.h
@@ -49,8 +49,7 @@ void determineResolution(int16_t screenheight, int16_t screenwidth);
 void drawRoundedHighlight(OLEDDisplay *display, int16_t x, int16_t y, int16_t w, int16_t h, int16_t r);

 // Shared battery/time/mail header
-void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr = "", bool force_no_invert = false,
-                      bool show_date = false);
+void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr = "", bool battery_only = false);

 const int *getTextPositions(OLEDDisplay *display);

--- a/src/graphics/TFTDisplay.cpp
+++ b/src/graphics/TFTDisplay.cpp
@@ -767,24 +767,24 @@ class LGFX : public lgfx::LGFX_Device

    LGFX(void)
    {
-        if (portduino_config.displayPanel == st7789)
+        if (settingsMap[displayPanel] == st7789)
            _panel_instance = new lgfx::Panel_ST7789;
-        else if (portduino_config.displayPanel == st7735)
+        else if (settingsMap[displayPanel] == st7735)
            _panel_instance = new lgfx::Panel_ST7735;
-        else if (portduino_config.displayPanel == st7735s)
+        else if (settingsMap[displayPanel] == st7735s)
            _panel_instance = new lgfx::Panel_ST7735S;
-        else if (portduino_config.displayPanel == st7796)
+        else if (settingsMap[displayPanel] == st7796)
            _panel_instance = new lgfx::Panel_ST7796;
-        else if (portduino_config.displayPanel == ili9341)
+        else if (settingsMap[displayPanel] == ili9341)
            _panel_instance = new lgfx::Panel_ILI9341;
-        else if (portduino_config.displayPanel == ili9342)
+        else if (settingsMap[displayPanel] == ili9342)
            _panel_instance = new lgfx::Panel_ILI9342;
-        else if (portduino_config.displayPanel == ili9488)
+        else if (settingsMap[displayPanel] == ili9488)
            _panel_instance = new lgfx::Panel_ILI9488;
-        else if (portduino_config.displayPanel == hx8357d)
+        else if (settingsMap[displayPanel] == hx8357d)
            _panel_instance = new lgfx::Panel_HX8357D;
 #if defined(LGFX_SDL)
-        else if (portduino_config.displayPanel == x11) {
+        else if (settingsMap[displayPanel] == x11) {
            _panel_instance = new lgfx::Panel_sdl;
        }
 #endif
@@ -795,61 +795,61 @@ class LGFX : public lgfx::LGFX_Device

        auto buscfg = _bus_instance.config();
        buscfg.spi_mode = 0;
-        buscfg.spi_host = portduino_config.display_spi_dev_int;
+        buscfg.spi_host = settingsMap[displayspidev];

-        buscfg.pin_dc = portduino_config.displayDC.pin; // Set SPI DC pin number (-1 = disable)
+        buscfg.pin_dc = settingsMap[displayDC]; // Set SPI DC pin number (-1 = disable)

        _bus_instance.config(buscfg);            // applies the set value to the bus.
        _panel_instance->setBus(&_bus_instance); // set the bus on the panel.

        auto cfg = _panel_instance->config(); // Gets a structure for display panel settings.
-        LOG_DEBUG("Width: %d, Height: %d", portduino_config.displayWidth, portduino_config.displayHeight);
-        cfg.pin_cs = portduino_config.displayCS.pin; // Pin number where CS is connected (-1 = disable)
-        cfg.pin_rst = portduino_config.displayReset.pin;
-        if (portduino_config.displayRotate) {
-            cfg.panel_width = portduino_config.displayHeight; // actual displayable width
-            cfg.panel_height = portduino_config.displayWidth; // actual displayable height
+        LOG_DEBUG("Width: %d, Height: %d", settingsMap[displayWidth], settingsMap[displayHeight]);
+        cfg.pin_cs = settingsMap[displayCS]; // Pin number where CS is connected (-1 = disable)
+        cfg.pin_rst = settingsMap[displayReset];
+        if (settingsMap[displayRotate]) {
+            cfg.panel_width = settingsMap[displayHeight]; // actual displayable width
+            cfg.panel_height = settingsMap[displayWidth]; // actual displayable height
        } else {
-            cfg.panel_width = portduino_config.displayWidth;   // actual displayable width
-            cfg.panel_height = portduino_config.displayHeight; // actual displayable height
+            cfg.panel_width = settingsMap[displayWidth];   // actual displayable width
+            cfg.panel_height = settingsMap[displayHeight]; // actual displayable height
        }
-        cfg.offset_x = portduino_config.displayOffsetX;             // Panel offset amount in X direction
-        cfg.offset_y = portduino_config.displayOffsetY;             // Panel offset amount in Y direction
-        cfg.offset_rotation = portduino_config.displayOffsetRotate; // Rotation direction value offset 0~7 (4~7 is mirrored)
-        cfg.invert = portduino_config.displayInvert;                // Set to true if the light/darkness of the panel is reversed
+        cfg.offset_x = settingsMap[displayOffsetX];             // Panel offset amount in X direction
+        cfg.offset_y = settingsMap[displayOffsetY];             // Panel offset amount in Y direction
+        cfg.offset_rotation = settingsMap[displayOffsetRotate]; // Rotation direction value offset 0~7 (4~7 is mirrored)
+        cfg.invert = settingsMap[displayInvert];                // Set to true if the light/darkness of the panel is reversed

        _panel_instance->config(cfg);

        // Configure settings for touch  control.
-        if (portduino_config.touchscreenModule) {
-            if (portduino_config.touchscreenModule == xpt2046) {
+        if (settingsMap[touchscreenModule]) {
+            if (settingsMap[touchscreenModule] == xpt2046) {
                _touch_instance = new lgfx::Touch_XPT2046;
-            } else if (portduino_config.touchscreenModule == stmpe610) {
+            } else if (settingsMap[touchscreenModule] == stmpe610) {
                _touch_instance = new lgfx::Touch_STMPE610;
-            } else if (portduino_config.touchscreenModule == ft5x06) {
+            } else if (settingsMap[touchscreenModule] == ft5x06) {
                _touch_instance = new lgfx::Touch_FT5x06;
            }
            auto touch_cfg = _touch_instance->config();

-            touch_cfg.pin_cs = portduino_config.touchscreenCS.pin;
+            touch_cfg.pin_cs = settingsMap[touchscreenCS];
            touch_cfg.x_min = 0;
-            touch_cfg.x_max = portduino_config.displayHeight - 1;
+            touch_cfg.x_max = settingsMap[displayHeight] - 1;
            touch_cfg.y_min = 0;
-            touch_cfg.y_max = portduino_config.displayWidth - 1;
-            touch_cfg.pin_int = portduino_config.touchscreenIRQ.pin;
+            touch_cfg.y_max = settingsMap[displayWidth] - 1;
+            touch_cfg.pin_int = settingsMap[touchscreenIRQ];
            touch_cfg.bus_shared = true;
-            touch_cfg.offset_rotation = portduino_config.touchscreenRotate;
-            if (portduino_config.touchscreenI2CAddr != -1) {
-                touch_cfg.i2c_addr = portduino_config.touchscreenI2CAddr;
+            touch_cfg.offset_rotation = settingsMap[touchscreenRotate];
+            if (settingsMap[touchscreenI2CAddr] != -1) {
+                touch_cfg.i2c_addr = settingsMap[touchscreenI2CAddr];
            } else {
-                touch_cfg.spi_host = portduino_config.touchscreen_spi_dev_int;
+                touch_cfg.spi_host = settingsMap[touchscreenspidev];
            }

            _touch_instance->config(touch_cfg);
            _panel_instance->setTouch(_touch_instance);
        }
 #if defined(LGFX_SDL)
-        if (portduino_config.displayPanel == x11) {
+        if (settingsMap[displayPanel] == x11) {
            lgfx::Panel_sdl *sdl_panel_ = (lgfx::Panel_sdl *)_panel_instance;
            sdl_panel_->setup();
            sdl_panel_->addKeyCodeMapping(SDLK_RETURN, SDL_SCANCODE_KP_ENTER);
@@ -1115,10 +1115,10 @@ TFTDisplay::TFTDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY g
    backlightEnable = p;

 #if ARCH_PORTDUINO
-    if (portduino_config.displayRotate) {
-        setGeometry(GEOMETRY_RAWMODE, portduino_config.displayWidth, portduino_config.displayWidth);
+    if (settingsMap[displayRotate]) {
+        setGeometry(GEOMETRY_RAWMODE, settingsMap[configNames::displayWidth], settingsMap[configNames::displayHeight]);
    } else {
-        setGeometry(GEOMETRY_RAWMODE, portduino_config.displayHeight, portduino_config.displayHeight);
+        setGeometry(GEOMETRY_RAWMODE, settingsMap[configNames::displayHeight], settingsMap[configNames::displayWidth]);
    }

 #elif defined(SCREEN_ROTATE)
@@ -1240,7 +1240,7 @@ void TFTDisplay::sdlLoop()
 #if defined(LGFX_SDL)
    static int lastPressed = 0;
    static int shuttingDown = false;
-    if (portduino_config.displayPanel == x11) {
+    if (settingsMap[displayPanel] == x11) {
        lgfx::Panel_sdl *sdl_panel_ = (lgfx::Panel_sdl *)tft->_panel_instance;
        if (sdl_panel_->loop() && !shuttingDown) {
            LOG_WARN("Window Closed!");
@@ -1288,8 +1288,8 @@ void TFTDisplay::sendCommand(uint8_t com)
        backlightEnable->set(true);
 #if ARCH_PORTDUINO
        display(true);
-        if (portduino_config.displayBacklight.pin > 0)
-            digitalWrite(portduino_config.displayBacklight.pin, TFT_BACKLIGHT_ON);
+        if (settingsMap[displayBacklight] > 0)
+            digitalWrite(settingsMap[displayBacklight], TFT_BACKLIGHT_ON);
 #elif !defined(RAK14014) && !defined(M5STACK) && !defined(UNPHONE)
        tft->wakeup();
        tft->powerSaveOff();
@@ -1312,8 +1312,8 @@ void TFTDisplay::sendCommand(uint8_t com)
        backlightEnable->set(false);
 #if ARCH_PORTDUINO
        tft->clear();
-        if (portduino_config.displayBacklight.pin > 0)
-            digitalWrite(portduino_config.displayBacklight.pin, !TFT_BACKLIGHT_ON);
+        if (settingsMap[displayBacklight] > 0)
+            digitalWrite(settingsMap[displayBacklight], !TFT_BACKLIGHT_ON);
 #elif !defined(RAK14014) && !defined(M5STACK) && !defined(UNPHONE)
        tft->sleep();
        tft->powerSaveOn();
--- a/src/graphics/draw/ClockRenderer.cpp
+++ b/src/graphics/draw/ClockRenderer.cpp
@@ -190,8 +190,7 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
    // === Set Title, Blank for Clock
    const char *titleStr = "";
    // === Header ===
-    graphics::drawCommonHeader(display, x, y, titleStr, true, true);
-    int line = 0;
+    graphics::drawCommonHeader(display, x, y, titleStr, true);

 #ifdef T_WATCH_S3
    if (nimbleBluetooth && nimbleBluetooth->isConnected()) {
@@ -295,7 +294,6 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
        display->drawString(startingHourMinuteTextX + xOffset, (display->getHeight() - hourMinuteTextY) - yOffset - 2,
                            isPM ? "pm" : "am");
    }
-
 #ifndef USE_EINK
    xOffset = (isHighResolution) ? 18 : 10;
    display->drawString(startingHourMinuteTextX + timeStringWidth - xOffset, (display->getHeight() - hourMinuteTextY) - yOffset,
@@ -315,8 +313,7 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
    // === Set Title, Blank for Clock
    const char *titleStr = "";
    // === Header ===
-    graphics::drawCommonHeader(display, x, y, titleStr, true, true);
-    int line = 0;
+    graphics::drawCommonHeader(display, x, y, titleStr, true);

 #ifdef T_WATCH_S3
    if (nimbleBluetooth && nimbleBluetooth->isConnected()) {
--- a/src/graphics/draw/DebugRenderer.cpp
+++ b/src/graphics/draw/DebugRenderer.cpp
@@ -330,7 +330,8 @@ void drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 #if HAS_GPS
    if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
        // Line 3
-        if (uiconfig.gps_format != meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS) // if DMS then don't draw altitude
+        if (config.display.gps_format !=
+            meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DMS) // if DMS then don't draw altitude
            UIRenderer::drawGpsAltitude(display, x, y + FONT_HEIGHT_SMALL * 2, gpsStatus);

        // Line 4
@@ -394,18 +395,8 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
    int textWidth = display->getStringWidth(shortnameble);
    int nameX = (SCREEN_WIDTH - textWidth);
    display->drawString(nameX, getTextPositions(display)[line++], shortnameble);
-
-    // === Second Row: Role ===
-    auto role = DisplayFormatters::getDeviceRole(config.device.role);
-    char device_role[25];
-    snprintf(device_role, sizeof(device_role), "Role: %s", role);
-    textWidth = display->getStringWidth(device_role);
-    nameX = (SCREEN_WIDTH - textWidth) / 2;
-    display->drawString(nameX, getTextPositions(display)[line++], device_role);
-
-    // === Third Row: Radio Preset ===
+    // === Second Row: Radio Preset ===
    auto mode = DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false, config.lora.use_preset);
-
    char regionradiopreset[25];
    const char *region = myRegion ? myRegion->name : NULL;
    if (region != nullptr) {
@@ -419,7 +410,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
    nameX = (SCREEN_WIDTH - textWidth) / 2;
    display->drawString(nameX, getTextPositions(display)[line++], regionradiopreset);

-    // === Fourth Row: Frequency / ChanNum ===
+    // === Third Row: Frequency / ChanNum ===
    char frequencyslot[35];
    char freqStr[16];
    float freq = RadioLibInterface::instance->getFreq();
@@ -446,7 +437,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
    display->drawString(nameX, getTextPositions(display)[line++], frequencyslot);

 #if !defined(M5STACK_UNITC6L)
-    // === Fifth Row: Channel Utilization ===
+    // === Fourth Row: Channel Utilization ===
    const char *chUtil = "ChUtil:";
    char chUtilPercentage[10];
    snprintf(chUtilPercentage, sizeof(chUtilPercentage), "%2.0f%%", airTime->channelUtilizationPercent());
@@ -463,7 +454,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
    int total_line_content_width = (chUtil_x + chutil_bar_width + display->getStringWidth(chUtilPercentage) + extraoffset) / 2;
    int starting_position = centerofscreen - total_line_content_width;

-    display->drawString(starting_position, getTextPositions(display)[line], chUtil);
+    display->drawString(starting_position, getTextPositions(display)[line++], chUtil);

    // Force 56% or higher to show a full 100% bar, text would still show related percent.
    if (chutil_percent >= 61) {
@@ -500,7 +491,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
        display->fillRect(starting_position + chUtil_x, chUtil_y, fillRight, chutil_bar_height);
    }

-    display->drawString(starting_position + chUtil_x + chutil_bar_width + extraoffset, getTextPositions(display)[line++],
+    display->drawString(starting_position + chUtil_x + chutil_bar_width + extraoffset, getTextPositions(display)[4],
                        chUtilPercentage);
 #endif
 }
@@ -508,7 +499,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
 // ****************************
 // *      System Screen       *
 // ****************************
-void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+void drawMemoryUsage(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
    display->clear();
    display->setFont(FONT_SMALL);
@@ -664,33 +655,6 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
    }
 #endif
 }
-
-// ****************************
-// * Chirpy Screen      *
-// ****************************
-void drawChirpy(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
-{
-    display->clear();
-    display->setTextAlignment(TEXT_ALIGN_LEFT);
-    display->setFont(FONT_SMALL);
-    int line = 1;
-    int iconX = SCREEN_WIDTH - chirpy_width - (chirpy_width / 3);
-    int iconY = (SCREEN_HEIGHT - chirpy_height) / 2;
-    int textX_offset = 10;
-    if (isHighResolution) {
-        iconX = SCREEN_WIDTH - chirpy_width_hirez - (chirpy_width_hirez / 3);
-        iconY = (SCREEN_HEIGHT - chirpy_height_hirez) / 2;
-        textX_offset = textX_offset * 4;
-        display->drawXbm(iconX, iconY, chirpy_width_hirez, chirpy_height_hirez, chirpy_hirez);
-    } else {
-        display->drawXbm(iconX, iconY, chirpy_width, chirpy_height, chirpy);
-    }
-
-    int textX = (display->getWidth() / 2) - textX_offset - (display->getStringWidth("Hello") / 2);
-    display->drawString(textX, getTextPositions(display)[line++], "Hello");
-    textX = (display->getWidth() / 2) - textX_offset - (display->getStringWidth("World!") / 2);
-    display->drawString(textX, getTextPositions(display)[line++], "World!");
-}
 } // namespace DebugRenderer
 } // namespace graphics
 #endif
--- a/src/graphics/draw/DebugRenderer.h
+++ b/src/graphics/draw/DebugRenderer.h
@@ -31,11 +31,8 @@ void drawDebugInfoWiFiTrampoline(OLEDDisplay *display, OLEDDisplayUiState *state
 // LoRa information display
 void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);

-// System screen display
-void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
-
-// Chirpy screen display
-void drawChirpy(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+// Memory screen display
+void drawMemoryUsage(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 } // namespace DebugRenderer

 } // namespace graphics
--- a/src/graphics/draw/MenuHandler.cpp
+++ b/src/graphics/draw/MenuHandler.cpp
@@ -26,26 +26,6 @@ menuHandler::screenMenus menuHandler::menuQueue = menu_none;
 bool test_enabled = false;
 uint8_t test_count = 0;

-void menuHandler::loraMenu()
-{
-    static const char *optionsArray[] = {"Back", "Region Picker", "Device Role"};
-    enum optionsNumbers { Back = 0, lora_picker = 1, device_role_picker = 2 };
-    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "LoRa Actions";
-    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 3;
-    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == Back) {
-            // No action
-        } else if (selected == lora_picker) {
-            menuHandler::menuQueue = menuHandler::lora_picker;
-        } else if (selected == device_role_picker) {
-            menuHandler::menuQueue = menuHandler::device_role_picker;
-        }
-    };
-    screen->showOverlayBanner(bannerOptions);
-}
-
 void menuHandler::OnboardMessage()
 {
    static const char *optionsArray[] = {"OK", "Got it!"};
@@ -143,40 +123,6 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
    screen->showOverlayBanner(bannerOptions);
 }

-void menuHandler::DeviceRolePicker()
-{
-    static const char *optionsArray[] = {"Back", "Client", "Client Mute", "Lost and Found", "Tracker"};
-    enum optionsNumbers {
-        Back = 0,
-        devicerole_client = 1,
-        devicerole_clientmute = 2,
-        devicerole_lostandfound = 3,
-        devicerole_tracker = 4
-    };
-    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Device Role";
-    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 5;
-    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == Back) {
-            menuHandler::menuQueue = menuHandler::lora_Menu;
-            screen->runNow();
-            return;
-        } else if (selected == devicerole_client) {
-            config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
-        } else if (selected == devicerole_clientmute) {
-            config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE;
-        } else if (selected == devicerole_lostandfound) {
-            config.device.role = meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND;
-        } else if (selected == devicerole_tracker) {
-            config.device.role = meshtastic_Config_DeviceConfig_Role_TRACKER;
-        }
-        service->reloadConfig(SEGMENT_CONFIG);
-        rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
-    };
-    screen->showOverlayBanner(bannerOptions);
-}
-
 void menuHandler::TwelveHourPicker()
 {
    static const char *optionsArray[] = {"Back", "12-hour", "24-hour"};
@@ -374,7 +320,7 @@ void menuHandler::messageResponseMenu()
    bannerOptions.optionsCount = options;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Dismiss) {
-            screen->hideCurrentFrame();
+            screen->dismissCurrentFrame();
        } else if (selected == Preset) {
            if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
@@ -415,11 +361,8 @@ void menuHandler::homeBaseMenu()
    optionsArray[options] = "Sleep Screen";
    optionsEnumArray[options++] = Sleep;
 #endif
-    if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
-        optionsArray[options] = "Send Position";
-    } else {
-        optionsArray[options] = "Send Node Info";
-    }
+
+    optionsArray[options] = "Send Position";
    optionsEnumArray[options++] = Position;
 #if defined(M5STACK_UNITC6L)
    optionsArray[options] = "New Preset";
@@ -512,7 +455,7 @@ void menuHandler::textMessageBaseMenu()

 void menuHandler::systemBaseMenu()
 {
-    enum optionsNumbers { Back, Notifications, ScreenOptions, Bluetooth, PowerMenu, FrameToggles, Test, enumEnd };
+    enum optionsNumbers { Back, Notifications, ScreenOptions, Bluetooth, PowerMenu, Test, enumEnd };
    static const char *optionsArray[enumEnd] = {"Back"};
    static int optionsEnumArray[enumEnd] = {Back};
    int options = 1;
@@ -524,9 +467,6 @@ void menuHandler::systemBaseMenu()
    optionsArray[options] = "Screen Options";
    optionsEnumArray[options++] = ScreenOptions;
 #endif
-
-    optionsArray[options] = "Frame Visiblity Toggle";
-    optionsEnumArray[options++] = FrameToggles;
 #if defined(M5STACK_UNITC6L)
    optionsArray[options] = "Bluetooth";
 #else
@@ -564,9 +504,6 @@ void menuHandler::systemBaseMenu()
        } else if (selected == PowerMenu) {
            menuHandler::menuQueue = menuHandler::power_menu;
            screen->runNow();
-        } else if (selected == FrameToggles) {
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
        } else if (selected == Test) {
            menuHandler::menuQueue = menuHandler::test_menu;
            screen->runNow();
@@ -633,17 +570,18 @@ void menuHandler::favoriteBaseMenu()

 void menuHandler::positionBaseMenu()
 {
-    enum optionsNumbers { Back, GPSToggle, GPSFormat, CompassMenu, CompassCalibrate, enumEnd };
+    enum optionsNumbers { Back, GPSToggle, CompassMenu, CompassCalibrate, enumEnd };

-    static const char *optionsArray[enumEnd] = {"Back", "GPS Toggle", "GPS Format", "Compass"};
-    static int optionsEnumArray[enumEnd] = {Back, GPSToggle, GPSFormat, CompassMenu};
-    int options = 4;
+    static const char *optionsArray[enumEnd] = {"Back", "GPS Toggle", "Compass"};
+    static int optionsEnumArray[enumEnd] = {Back, GPSToggle, CompassMenu};
+    int options = 3;

+#if !MESHTASTIC_EXCLUDE_I2C
    if (accelerometerThread) {
        optionsArray[options] = "Compass Calibrate";
        optionsEnumArray[options++] = CompassCalibrate;
    }
-
+#endif
    BannerOverlayOptions bannerOptions;
    bannerOptions.message = "Position Action";
    bannerOptions.optionsArrayPtr = optionsArray;
@@ -653,14 +591,13 @@ void menuHandler::positionBaseMenu()
        if (selected == GPSToggle) {
            menuQueue = gps_toggle_menu;
            screen->runNow();
-        } else if (selected == GPSFormat) {
-            menuQueue = gps_format_menu;
-            screen->runNow();
        } else if (selected == CompassMenu) {
            menuQueue = compass_point_north_menu;
            screen->runNow();
+#if !MESHTASTIC_EXCLUDE_I2C
        } else if (selected == CompassCalibrate) {
            accelerometerThread->calibrate(30);
+#endif
        }
    };
    screen->showOverlayBanner(bannerOptions);
@@ -782,51 +719,6 @@ void menuHandler::GPSToggleMenu()
    bannerOptions.InitialSelected = config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED ? 1 : 2;
    screen->showOverlayBanner(bannerOptions);
 }
-void menuHandler::GPSFormatMenu()
-{
-
-    static const char *optionsArray[] = {"Back",
-                                         isHighResolution ? "Decimal Degrees" : "DEC",
-                                         isHighResolution ? "Degrees Minutes Seconds" : "DMS",
-                                         isHighResolution ? "Universal Transverse Mercator" : "UTM",
-                                         isHighResolution ? "Military Grid Reference System" : "MGRS",
-                                         isHighResolution ? "Open Location Code" : "OLC",
-                                         isHighResolution ? "Ordnance Survey Grid Ref" : "OSGR",
-                                         isHighResolution ? "Maidenhead Locator" : "MLS"};
-    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "GPS Format";
-    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 8;
-    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == 1) {
-            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC;
-            service->reloadConfig(SEGMENT_CONFIG);
-        } else if (selected == 2) {
-            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS;
-            service->reloadConfig(SEGMENT_CONFIG);
-        } else if (selected == 3) {
-            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_UTM;
-            service->reloadConfig(SEGMENT_CONFIG);
-        } else if (selected == 4) {
-            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_MGRS;
-            service->reloadConfig(SEGMENT_CONFIG);
-        } else if (selected == 5) {
-            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC;
-            service->reloadConfig(SEGMENT_CONFIG);
-        } else if (selected == 6) {
-            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_OSGR;
-            service->reloadConfig(SEGMENT_CONFIG);
-        } else if (selected == 7) {
-            uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS;
-            service->reloadConfig(SEGMENT_CONFIG);
-        } else {
-            menuQueue = position_base_menu;
-            screen->runNow();
-        }
-    };
-    bannerOptions.InitialSelected = uiconfig.gps_format + 1;
-    screen->showOverlayBanner(bannerOptions);
-}
 #endif

 void menuHandler::BluetoothToggleMenu()
@@ -1122,33 +1014,16 @@ void menuHandler::traceRouteMenu()
 void menuHandler::testMenu()
 {

-    enum optionsNumbers { Back, NumberPicker, ShowChirpy };
-    static const char *optionsArray[4] = {"Back"};
-    static int optionsEnumArray[4] = {Back};
-    int options = 1;
-
-    optionsArray[options] = "Number Picker";
-    optionsEnumArray[options++] = NumberPicker;
-
-    optionsArray[options] = screen->isFrameHidden("chirpy") ? "Show Chirpy" : "Hide Chirpy";
-    optionsEnumArray[options++] = ShowChirpy;
-
+    static const char *optionsArray[] = {"Back", "Number Picker"};
    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Hidden Test Menu";
+    std::string message = "Test to Run?\n";
+    bannerOptions.message = message.c_str();
    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = options;
-    bannerOptions.optionsEnumPtr = optionsEnumArray;
+    bannerOptions.optionsCount = 2;
    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == NumberPicker) {
+        if (selected == 1) {
            menuQueue = number_test;
            screen->runNow();
-        } else if (selected == ShowChirpy) {
-            screen->toggleFrameVisibility("chirpy");
-            screen->setFrames(Screen::FOCUS_SYSTEM);
-
-        } else {
-            menuQueue = system_base_menu;
-            screen->runNow();
        }
    };
    screen->showOverlayBanner(bannerOptions);
@@ -1349,116 +1224,6 @@ void menuHandler::keyVerificationFinalPrompt()
    }
 }

-void menuHandler::FrameToggles_menu()
-{
-    enum optionsNumbers {
-        Finish,
-        nodelist,
-        nodelist_lastheard,
-        nodelist_hopsignal,
-        nodelist_distance,
-        nodelist_bearings,
-        gps,
-        lora,
-        clock,
-        show_favorites,
-        enumEnd
-    };
-    static const char *optionsArray[enumEnd] = {"Finish"};
-    static int optionsEnumArray[enumEnd] = {Finish};
-    int options = 1;
-
-    // Track last selected index (not enum value!)
-    static int lastSelectedIndex = 0;
-
-#ifndef USE_EINK
-    optionsArray[options] = screen->isFrameHidden("nodelist") ? "Show Node List" : "Hide Node List";
-    optionsEnumArray[options++] = nodelist;
-#endif
-#ifdef USE_EINK
-    optionsArray[options] = screen->isFrameHidden("nodelist_lastheard") ? "Show NL - Last Heard" : "Hide NL - Last Heard";
-    optionsEnumArray[options++] = nodelist_lastheard;
-    optionsArray[options] = screen->isFrameHidden("nodelist_hopsignal") ? "Show NL - Hops/Signal" : "Hide NL - Hops/Signal";
-    optionsEnumArray[options++] = nodelist_hopsignal;
-    optionsArray[options] = screen->isFrameHidden("nodelist_distance") ? "Show NL - Distance" : "Hide NL - Distance";
-    optionsEnumArray[options++] = nodelist_distance;
-#endif
-#if HAS_GPS
-    optionsArray[options] = screen->isFrameHidden("nodelist_bearings") ? "Show Bearings" : "Hide Bearings";
-    optionsEnumArray[options++] = nodelist_bearings;
-
-    optionsArray[options] = screen->isFrameHidden("gps") ? "Show Position" : "Hide Position";
-    optionsEnumArray[options++] = gps;
-#endif
-
-    optionsArray[options] = screen->isFrameHidden("lora") ? "Show LoRa" : "Hide LoRa";
-    optionsEnumArray[options++] = lora;
-
-    optionsArray[options] = screen->isFrameHidden("clock") ? "Show Clock" : "Hide Clock";
-    optionsEnumArray[options++] = clock;
-
-    optionsArray[options] = screen->isFrameHidden("show_favorites") ? "Show Favorites" : "Hide Favorites";
-    optionsEnumArray[options++] = show_favorites;
-
-    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Show/Hide Frames";
-    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = options;
-    bannerOptions.optionsEnumPtr = optionsEnumArray;
-    bannerOptions.InitialSelected = lastSelectedIndex; // Use index, not enum value
-
-    bannerOptions.bannerCallback = [options](int selected) mutable -> void {
-        // Find the index of selected in optionsEnumArray
-        int idx = 0;
-        for (; idx < options; ++idx) {
-            if (optionsEnumArray[idx] == selected)
-                break;
-        }
-        lastSelectedIndex = idx;
-
-        if (selected == Finish) {
-            screen->setFrames(Screen::FOCUS_DEFAULT);
-        } else if (selected == nodelist) {
-            screen->toggleFrameVisibility("nodelist");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == nodelist_lastheard) {
-            screen->toggleFrameVisibility("nodelist_lastheard");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == nodelist_hopsignal) {
-            screen->toggleFrameVisibility("nodelist_hopsignal");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == nodelist_distance) {
-            screen->toggleFrameVisibility("nodelist_distance");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == nodelist_bearings) {
-            screen->toggleFrameVisibility("nodelist_bearings");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == gps) {
-            screen->toggleFrameVisibility("gps");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == lora) {
-            screen->toggleFrameVisibility("lora");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == clock) {
-            screen->toggleFrameVisibility("clock");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        } else if (selected == show_favorites) {
-            screen->toggleFrameVisibility("show_favorites");
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
-        }
-    };
-    screen->showOverlayBanner(bannerOptions);
-}
-
 void menuHandler::handleMenuSwitch(OLEDDisplay *display)
 {
    if (menuQueue != menu_none)
@@ -1466,15 +1231,9 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
    switch (menuQueue) {
    case menu_none:
        break;
-    case lora_Menu:
-        loraMenu();
-        break;
    case lora_picker:
        LoraRegionPicker();
        break;
-    case device_role_picker:
-        DeviceRolePicker();
-        break;
    case no_timeout_lora_picker:
        LoraRegionPicker(0);
        break;
@@ -1500,9 +1259,6 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
    case gps_toggle_menu:
        GPSToggleMenu();
        break;
-    case gps_format_menu:
-        GPSFormatMenu();
-        break;
 #endif
    case compass_point_north_menu:
        compassNorthMenu();
@@ -1564,9 +1320,6 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
    case power_menu:
        powerMenu();
        break;
-    case FrameToggles:
-        FrameToggles_menu();
-        break;
    case throttle_message:
        screen->showSimpleBanner("Too Many Attempts\nTry again in 60 seconds.", 5000);
        break;
--- a/src/graphics/draw/MenuHandler.h
+++ b/src/graphics/draw/MenuHandler.h
@@ -9,9 +9,7 @@ class menuHandler
  public:
    enum screenMenus {
        menu_none,
-        lora_Menu,
        lora_picker,
-        device_role_picker,
        no_timeout_lora_picker,
        TZ_picker,
        twelve_hour_picker,
@@ -19,7 +17,6 @@ class menuHandler
        clock_menu,
        position_base_menu,
        gps_toggle_menu,
-        gps_format_menu,
        compass_point_north_menu,
        reset_node_db_menu,
        buzzermodemenupicker,
@@ -42,14 +39,11 @@ class menuHandler
        key_verification_final_prompt,
        trace_route_menu,
        throttle_message,
-        FrameToggles
    };
    static screenMenus menuQueue;

    static void OnboardMessage();
    static void LoraRegionPicker(uint32_t duration = 30000);
-    static void loraMenu();
-    static void DeviceRolePicker();
    static void handleMenuSwitch(OLEDDisplay *display);
    static void showConfirmationBanner(const char *message, std::function<void()> onConfirm);
    static void clockMenu();
@@ -64,7 +58,6 @@ class menuHandler
    static void positionBaseMenu();
    static void compassNorthMenu();
    static void GPSToggleMenu();
-    static void GPSFormatMenu();
    static void BuzzerModeMenu();
    static void switchToMUIMenu();
    static void TFTColorPickerMenu(OLEDDisplay *display);
@@ -84,7 +77,6 @@ class menuHandler
    static void screenOptionsMenu();
    static void powerMenu();
    static void textMessageMenu();
-    static void FrameToggles_menu();

  private:
    static void saveUIConfig();
--- a/src/graphics/draw/NotificationRenderer.cpp
+++ b/src/graphics/draw/NotificationRenderer.cpp
@@ -216,11 +216,9 @@ void NotificationRenderer::drawNodePicker(OLEDDisplay *display, OLEDDisplayUiSta
    }

    // Handle input
-    if (inEvent.inputEvent == INPUT_BROKER_UP || inEvent.inputEvent == INPUT_BROKER_LEFT ||
-        inEvent.inputEvent == INPUT_BROKER_ALT_PRESS) {
+    if (inEvent.inputEvent == INPUT_BROKER_UP || inEvent.inputEvent == INPUT_BROKER_ALT_PRESS) {
        curSelected--;
-    } else if (inEvent.inputEvent == INPUT_BROKER_DOWN || inEvent.inputEvent == INPUT_BROKER_RIGHT ||
-               inEvent.inputEvent == INPUT_BROKER_USER_PRESS) {
+    } else if (inEvent.inputEvent == INPUT_BROKER_DOWN || inEvent.inputEvent == INPUT_BROKER_USER_PRESS) {
        curSelected++;
    } else if (inEvent.inputEvent == INPUT_BROKER_SELECT) {
        alertBannerCallback(selectedNodenum);
@@ -335,11 +333,9 @@ void NotificationRenderer::drawAlertBannerOverlay(OLEDDisplay *display, OLEDDisp

    // Handle input
    if (alertBannerOptions > 0) {
-        if (inEvent.inputEvent == INPUT_BROKER_UP || inEvent.inputEvent == INPUT_BROKER_LEFT ||
-            inEvent.inputEvent == INPUT_BROKER_ALT_PRESS) {
+        if (inEvent.inputEvent == INPUT_BROKER_UP || inEvent.inputEvent == INPUT_BROKER_ALT_PRESS) {
            curSelected--;
-        } else if (inEvent.inputEvent == INPUT_BROKER_DOWN || inEvent.inputEvent == INPUT_BROKER_RIGHT ||
-                   inEvent.inputEvent == INPUT_BROKER_USER_PRESS) {
+        } else if (inEvent.inputEvent == INPUT_BROKER_DOWN || inEvent.inputEvent == INPUT_BROKER_USER_PRESS) {
            curSelected++;
        } else if (inEvent.inputEvent == INPUT_BROKER_SELECT) {
            if (optionsEnumPtr != nullptr) {
--- a/src/graphics/draw/UIRenderer.cpp
+++ b/src/graphics/draw/UIRenderer.cpp
@@ -116,120 +116,64 @@ void UIRenderer::drawGpsAltitude(OLEDDisplay *display, int16_t x, int16_t y, con
 }

 // Draw GPS status coordinates
-void UIRenderer::drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gps,
-                                    const char *mode)
+void UIRenderer::drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gps)
 {
-    auto gpsFormat = uiconfig.gps_format;
+    auto gpsFormat = config.display.gps_format;
    char displayLine[32];

    if (!gps->getIsConnected() && !config.position.fixed_position) {
        strcpy(displayLine, "No GPS present");
-        display->drawString(x, y, displayLine);
+        display->drawString(x + (display->getWidth() - (display->getStringWidth(displayLine))) / 2, y, displayLine);
    } else if (!gps->getHasLock() && !config.position.fixed_position) {
        strcpy(displayLine, "No GPS Lock");
-        display->drawString(x, y, displayLine);
+        display->drawString(x + (display->getWidth() - (display->getStringWidth(displayLine))) / 2, y, displayLine);
    } else {

        geoCoord.updateCoords(int32_t(gps->getLatitude()), int32_t(gps->getLongitude()), int32_t(gps->getAltitude()));

-        if (gpsFormat != meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS) {
-            char coordinateLine_1[22];
-            char coordinateLine_2[22];
-            if (gpsFormat == meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC) { // Decimal Degrees
-                snprintf(coordinateLine_1, sizeof(coordinateLine_1), "Lat: %f", geoCoord.getLatitude() * 1e-7);
-                snprintf(coordinateLine_2, sizeof(coordinateLine_2), "Lon: %f", geoCoord.getLongitude() * 1e-7);
-            } else if (gpsFormat == meshtastic_DeviceUIConfig_GpsCoordinateFormat_UTM) { // Universal Transverse Mercator
-                snprintf(coordinateLine_1, sizeof(coordinateLine_1), "%2i%1c %06u E", geoCoord.getUTMZone(),
-                         geoCoord.getUTMBand(), geoCoord.getUTMEasting());
-                snprintf(coordinateLine_2, sizeof(coordinateLine_2), "%07u N", geoCoord.getUTMNorthing());
-            } else if (gpsFormat == meshtastic_DeviceUIConfig_GpsCoordinateFormat_MGRS) { // Military Grid Reference System
-                snprintf(coordinateLine_1, sizeof(coordinateLine_1), "%2i%1c %1c%1c", geoCoord.getMGRSZone(),
-                         geoCoord.getMGRSBand(), geoCoord.getMGRSEast100k(), geoCoord.getMGRSNorth100k());
-                snprintf(coordinateLine_2, sizeof(coordinateLine_2), "%05u E %05u N", geoCoord.getMGRSEasting(),
-                         geoCoord.getMGRSNorthing());
-            } else if (gpsFormat == meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC) { // Open Location Code
-                geoCoord.getOLCCode(coordinateLine_1);
-                coordinateLine_2[0] = '\0';
-            } else if (gpsFormat == meshtastic_DeviceUIConfig_GpsCoordinateFormat_OSGR) { // Ordnance Survey Grid Reference
-                if (geoCoord.getOSGRE100k() == 'I' || geoCoord.getOSGRN100k() == 'I') { // OSGR is only valid around the UK region
-                    snprintf(coordinateLine_1, sizeof(coordinateLine_1), "%s", "Out of Boundary");
-                    coordinateLine_2[0] = '\0';
+        if (gpsFormat != meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DMS) {
+            char coordinateLine[22];
+            if (gpsFormat == meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DEC) { // Decimal Degrees
+                snprintf(coordinateLine, sizeof(coordinateLine), "%f %f", geoCoord.getLatitude() * 1e-7,
+                         geoCoord.getLongitude() * 1e-7);
+            } else if (gpsFormat == meshtastic_Config_DisplayConfig_GpsCoordinateFormat_UTM) { // Universal Transverse Mercator
+                snprintf(coordinateLine, sizeof(coordinateLine), "%2i%1c %06u %07u", geoCoord.getUTMZone(), geoCoord.getUTMBand(),
+                         geoCoord.getUTMEasting(), geoCoord.getUTMNorthing());
+            } else if (gpsFormat == meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MGRS) { // Military Grid Reference System
+                snprintf(coordinateLine, sizeof(coordinateLine), "%2i%1c %1c%1c %05u %05u", geoCoord.getMGRSZone(),
+                         geoCoord.getMGRSBand(), geoCoord.getMGRSEast100k(), geoCoord.getMGRSNorth100k(),
+                         geoCoord.getMGRSEasting(), geoCoord.getMGRSNorthing());
+            } else if (gpsFormat == meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OLC) { // Open Location Code
+                geoCoord.getOLCCode(coordinateLine);
+            } else if (gpsFormat == meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OSGR) { // Ordnance Survey Grid Reference
+                if (geoCoord.getOSGRE100k() == 'I' || geoCoord.getOSGRN100k() == 'I') // OSGR is only valid around the UK region
+                    snprintf(coordinateLine, sizeof(coordinateLine), "%s", "Out of Boundary");
+                else
+                    snprintf(coordinateLine, sizeof(coordinateLine), "%1c%1c %05u %05u", geoCoord.getOSGRE100k(),
+                             geoCoord.getOSGRN100k(), geoCoord.getOSGREasting(), geoCoord.getOSGRNorthing());
+            }
+
+            // If fixed position, display text "Fixed GPS" alternating with the coordinates.
+            if (config.position.fixed_position) {
+                if ((millis() / 10000) % 2) {
+                    display->drawString(x + (display->getWidth() - (display->getStringWidth(coordinateLine))) / 2, y,
+                                        coordinateLine);
                } else {
-                    snprintf(coordinateLine_1, sizeof(coordinateLine_1), "%1c%1c", geoCoord.getOSGRE100k(),
-                             geoCoord.getOSGRN100k());
-                    snprintf(coordinateLine_2, sizeof(coordinateLine_2), "%05u E %05u N", geoCoord.getOSGREasting(),
-                             geoCoord.getOSGRNorthing());
+                    display->drawString(x + (display->getWidth() - (display->getStringWidth("Fixed GPS"))) / 2, y, "Fixed GPS");
                }
-            } else if (gpsFormat == meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS) { // Maidenhead Locator System
-                double lat = geoCoord.getLatitude() * 1e-7;
-                double lon = geoCoord.getLongitude() * 1e-7;
-
-                // Normalize
-                if (lat > 90.0)
-                    lat = 90.0;
-                if (lat < -90.0)
-                    lat = -90.0;
-                while (lon < -180.0)
-                    lon += 360.0;
-                while (lon >= 180.0)
-                    lon -= 360.0;
-
-                double adjLon = lon + 180.0;
-                double adjLat = lat + 90.0;
-
-                char maiden[10]; // enough for 8-char + null
-
-                // Field (2 letters)
-                int lonField = int(adjLon / 20.0);
-                int latField = int(adjLat / 10.0);
-                adjLon -= lonField * 20.0;
-                adjLat -= latField * 10.0;
-
-                // Square (2 digits)
-                int lonSquare = int(adjLon / 2.0);
-                int latSquare = int(adjLat / 1.0);
-                adjLon -= lonSquare * 2.0;
-                adjLat -= latSquare * 1.0;
-
-                // Subsquare (2 letters)
-                double lonUnit = 2.0 / 24.0;
-                double latUnit = 1.0 / 24.0;
-                int lonSub = int(adjLon / lonUnit);
-                int latSub = int(adjLat / latUnit);
-
-                snprintf(maiden, sizeof(maiden), "%c%c%c%c%c%c", 'A' + lonField, 'A' + latField, '0' + lonSquare, '0' + latSquare,
-                         'A' + lonSub, 'A' + latSub);
-
-                snprintf(coordinateLine_1, sizeof(coordinateLine_1), "MH: %s", maiden);
-                coordinateLine_2[0] = '\0'; // only need one line
+            } else {
+                display->drawString(x + (display->getWidth() - (display->getStringWidth(coordinateLine))) / 2, y, coordinateLine);
            }
-
-            if (strcmp(mode, "line1") == 0) {
-                display->drawString(x, y, coordinateLine_1);
-            } else if (strcmp(mode, "line2") == 0) {
-                display->drawString(x, y, coordinateLine_2);
-            } else if (strcmp(mode, "combined") == 0) {
-                display->drawString(x, y, coordinateLine_1);
-                if (coordinateLine_2[0] != '\0') {
-                    display->drawString(x + display->getStringWidth(coordinateLine_1), y, coordinateLine_2);
-                }
-            }
-
        } else {
-            char coordinateLine_1[22];
-            char coordinateLine_2[22];
-            snprintf(coordinateLine_1, sizeof(coordinateLine_1), "Lat: %2i° %2i' %2u\" %1c", geoCoord.getDMSLatDeg(),
-                     geoCoord.getDMSLatMin(), geoCoord.getDMSLatSec(), geoCoord.getDMSLatCP());
-            snprintf(coordinateLine_2, sizeof(coordinateLine_2), "Lon: %3i° %2i' %2u\" %1c", geoCoord.getDMSLonDeg(),
-                     geoCoord.getDMSLonMin(), geoCoord.getDMSLonSec(), geoCoord.getDMSLonCP());
-            if (strcmp(mode, "line1") == 0) {
-                display->drawString(x, y, coordinateLine_1);
-            } else if (strcmp(mode, "line2") == 0) {
-                display->drawString(x, y, coordinateLine_2);
-            } else { // both
-                display->drawString(x, y, coordinateLine_1);
-                display->drawString(x, y + 10, coordinateLine_2);
-            }
+            char latLine[22];
+            char lonLine[22];
+            snprintf(latLine, sizeof(latLine), "%2i° %2i' %2u\" %1c", geoCoord.getDMSLatDeg(), geoCoord.getDMSLatMin(),
+                     geoCoord.getDMSLatSec(), geoCoord.getDMSLatCP());
+            snprintf(lonLine, sizeof(lonLine), "%3i° %2i' %2u\" %1c", geoCoord.getDMSLonDeg(), geoCoord.getDMSLonMin(),
+                     geoCoord.getDMSLonSec(), geoCoord.getDMSLonCP());
+            display->drawString(x + (display->getWidth() - (display->getStringWidth(latLine))) / 2, y - FONT_HEIGHT_SMALL * 1,
+                                latLine);
+            display->drawString(x + (display->getWidth() - (display->getStringWidth(lonLine))) / 2, y, lonLine);
        }
    }
 }
@@ -993,26 +937,7 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
    config.display.heading_bold = false;

    const char *displayLine = ""; // Initialize to empty string by default
-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-
-    bool usePhoneGPS = (ourNode && nodeDB->hasValidPosition(ourNode) &&
-                        config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED);
-
-    if (usePhoneGPS) {
-        // Phone-provided GPS is active
-        displayLine = "Phone GPS";
-        int yOffset = (isHighResolution) ? 3 : 1;
-        if (isHighResolution) {
-            NodeListRenderer::drawScaledXBitmap16x16(x, getTextPositions(display)[line] + yOffset - 5, imgSatellite_width,
-                                                     imgSatellite_height, imgSatellite, display);
-        } else {
-            display->drawXbm(x + 1, getTextPositions(display)[line] + yOffset, imgSatellite_width, imgSatellite_height,
-                             imgSatellite);
-        }
-        int xOffset = (isHighResolution) ? 6 : 0;
-        display->drawString(x + 11 + xOffset, getTextPositions(display)[line++], displayLine);
-    } else if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
-        // GPS disabled / not present
+    if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
        if (config.position.fixed_position) {
            displayLine = "Fixed GPS";
        } else {
@@ -1029,7 +954,6 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
        int xOffset = (isHighResolution) ? 6 : 0;
        display->drawString(x + 11 + xOffset, getTextPositions(display)[line++], displayLine);
    } else {
-        // Onboard GPS
        UIRenderer::drawGps(display, 0, getTextPositions(display)[line++], gpsStatus);
    }

@@ -1056,50 +980,46 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU

    // If GPS is off, no need to display these parts
    if (strcmp(displayLine, "GPS off") != 0 && strcmp(displayLine, "No GPS") != 0) {
-        // === Second Row: Last GPS Fix ===
-        if (gpsStatus->getLastFixMillis() > 0) {
-            uint32_t delta = (millis() - gpsStatus->getLastFixMillis()) / 1000; // seconds since last fix
-            uint32_t days = delta / 86400;
-            uint32_t hours = (delta % 86400) / 3600;
-            uint32_t mins = (delta % 3600) / 60;
-            uint32_t secs = delta % 60;

-            char buf[32];
-#if defined(USE_EINK)
-            // E-Ink: skip seconds, show only days/hours/mins
-            if (days > 0) {
-                snprintf(buf, sizeof(buf), "Last: %ud %uh", days, hours);
-            } else if (hours > 0) {
-                snprintf(buf, sizeof(buf), "Last: %uh %um", hours, mins);
-            } else {
-                snprintf(buf, sizeof(buf), "Last: %um", mins);
-            }
-#else
-            // Non E-Ink: include seconds where useful
-            if (days > 0) {
-                snprintf(buf, sizeof(buf), "Last: %ud %uh", days, hours);
-            } else if (hours > 0) {
-                snprintf(buf, sizeof(buf), "Last: %uh %um", hours, mins);
-            } else if (mins > 0) {
-                snprintf(buf, sizeof(buf), "Last: %um %us", mins, secs);
-            } else {
-                snprintf(buf, sizeof(buf), "Last: %us", secs);
-            }
+        // === Second Row: Date ===
+        uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true);
+        char datetimeStr[25];
+        bool showTime = false; // set to true for full datetime
+        UIRenderer::formatDateTime(datetimeStr, sizeof(datetimeStr), rtc_sec, display, showTime);
+        char fullLine[40];
+        snprintf(fullLine, sizeof(fullLine), " Date: %s", datetimeStr);
+#if !defined(M5STACK_UNITC6L)
+        display->drawString(0, getTextPositions(display)[line++], fullLine);
 #endif

-            display->drawString(0, getTextPositions(display)[line++], buf);
+        // === Third Row: Latitude ===
+        char latStr[32];
+#if defined(M5STACK_UNITC6L)
+        snprintf(latStr, sizeof(latStr), "Lat:%.5f", geoCoord.getLatitude() * 1e-7);
+        display->drawString(x, getTextPositions(display)[line++] + 2, latStr);
+#else
+        snprintf(latStr, sizeof(latStr), " Lat: %.5f", geoCoord.getLatitude() * 1e-7);
+        display->drawString(x, getTextPositions(display)[line++], latStr);
+#endif
+
+        // === Fourth Row: Longitude ===
+        char lonStr[32];
+#if defined(M5STACK_UNITC6L)
+        snprintf(lonStr, sizeof(lonStr), "Lon:%.3f", geoCoord.getLongitude() * 1e-7);
+        display->drawString(x, getTextPositions(display)[line++] + 4, lonStr);
+#else
+        snprintf(lonStr, sizeof(lonStr), " Lon: %.5f", geoCoord.getLongitude() * 1e-7);
+        display->drawString(x, getTextPositions(display)[line++], lonStr);
+
+        // === Fifth Row: Altitude ===
+        char DisplayLineTwo[32] = {0};
+        if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
+            snprintf(DisplayLineTwo, sizeof(DisplayLineTwo), " Alt: %.0fft", geoCoord.getAltitude() * METERS_TO_FEET);
        } else {
-            display->drawString(0, getTextPositions(display)[line++], "Last: ?");
-        }
-
-        // === Third Row: Line 1 GPS Info ===
-        UIRenderer::drawGpsCoordinates(display, x, getTextPositions(display)[line++], gpsStatus, "line1");
-
-        if (uiconfig.gps_format != meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC &&
-            uiconfig.gps_format != meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS) {
-            // === Fourth Row: Line 2 GPS Info ===
-            UIRenderer::drawGpsCoordinates(display, x, getTextPositions(display)[line++], gpsStatus, "line2");
+            snprintf(DisplayLineTwo, sizeof(DisplayLineTwo), " Alt: %.0im", geoCoord.getAltitude());
        }
+        display->drawString(x, getTextPositions(display)[line++], DisplayLineTwo);
+#endif
    }
 #if !defined(M5STACK_UNITC6L)
    // === Draw Compass if heading is valid ===
--- a/src/graphics/draw/UIRenderer.h
+++ b/src/graphics/draw/UIRenderer.h
@@ -1,6 +1,5 @@
 #pragma once

-#include "NodeDB.h"
 #include "graphics/Screen.h"
 #include "graphics/emotes.h"
 #include <OLEDDisplay.h>
@@ -38,8 +37,7 @@ class UIRenderer

    // GPS status functions
    static void drawGps(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
-    static void drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus,
-                                   const char *mode = "line1");
+    static void drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
    static void drawGpsAltitude(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
    static void drawGpsPowerStatus(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);

--- a/src/graphics/images.h
+++ b/src/graphics/images.h
@@ -118,8 +118,8 @@ const uint8_t icon_radio[] PROGMEM = {
    0xA9  // Row 7: #..#.#.#
 };

-// 🪙 System Icon
-const uint8_t icon_system[] PROGMEM = {
+// 🪙 Memory Icon
+const uint8_t icon_memory[] PROGMEM = {
    0x24, // Row 0: ..#..#..
    0x3C, // Row 1: ..####..
    0xC3, // Row 2: ##....##
@@ -290,78 +290,6 @@ const uint8_t analog_icon_clock[] PROGMEM = {0b11111111, 0b01000010, 0b00100100,
 #ifdef M5STACK_UNITC6L
 #include "img/icon_small.xbm"
 #else
-#define chirpy_width 38
-#define chirpy_height 50
-static unsigned char chirpy[] = {
-    0xfe, 0xff, 0xff, 0xff, 0xdf, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x80, 0xe3, 0x01,
-    0x00, 0x00, 0xc0, 0xe7, 0x01, 0x00, 0x00, 0xc0, 0xe7, 0x01, 0x00, 0x00, 0xc0, 0xe7, 0x01, 0x00, 0x00, 0x80, 0xe3, 0x01, 0x00,
-    0x00, 0x00, 0xe0, 0x81, 0xff, 0xff, 0x7f, 0xe0, 0xc1, 0xff, 0xff, 0xff, 0xe0, 0xc1, 0xff, 0xff, 0xff, 0xe0, 0xc1, 0xcf, 0x7f,
-    0xfe, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc,
-    0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0,
-    0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1,
-    0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0xcf, 0x7f, 0xfe, 0xe0, 0xc1, 0xff, 0xff, 0xff, 0xe0, 0xc1, 0xff, 0xff, 0xff, 0xe0, 0x81, 0xff,
-    0xff, 0x7f, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0xc3, 0x00, 0xe0, 0x01, 0x00, 0xc3,
-    0x00, 0xe0, 0x01, 0x80, 0xe1, 0x01, 0xe0, 0x01, 0x80, 0xe1, 0x01, 0xe0, 0x01, 0xc0, 0x30, 0x03, 0xe0, 0x01, 0xc0, 0x30, 0x03,
-    0xe0, 0x01, 0x60, 0x18, 0x06, 0xe0, 0x01, 0x60, 0x18, 0x06, 0xe0, 0x01, 0x30, 0x0c, 0x0c, 0xe0, 0x01, 0x30, 0x0c, 0x0c, 0xe0,
-    0x01, 0x18, 0x06, 0x18, 0xe0, 0x01, 0x18, 0x06, 0x18, 0xe0, 0x01, 0x0c, 0x03, 0x30, 0xe0, 0x01, 0x0c, 0x03, 0x30, 0xe0, 0x01,
-    0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0xfe, 0xff, 0xff, 0xff, 0xdf};
-
-#define chirpy_width_hirez 76
-#define chirpy_height_hirez 100
-static unsigned char chirpy_hirez[] = {
-    0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x03,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00,
-    0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc,
-    0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03,
-    0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0,
-    0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f,
-    0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0,
-    0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff,
-    0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f,
-    0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0,
-    0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff,
-    0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00,
-    0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc,
-    0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03,
-    0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0,
-    0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f,
-    0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0,
-    0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff,
-    0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f,
-    0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc,
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03,
-    0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00,
-    0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
-    0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0,
-    0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00,
-    0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f,
-    0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c,
-    0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00,
-    0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc,
-    0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03,
-    0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00,
-    0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0,
-    0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3};
-
-#define chirpy_small_image_width 8
-#define chirpy_small_image_height 8
-static unsigned char small_chirpy[] = {0x7f, 0x41, 0x55, 0x55, 0x55, 0x55, 0x41, 0x7f};
-
 #include "img/icon.xbm"
 #endif
 static_assert(sizeof(icon_bits) >= 0, "Silence unused variable warning");
--- a/src/graphics/img/icon_small.xbm
+++ b/src/graphics/img/icon_small.xbm
@@ -27,90 +27,4 @@ static uint8_t icon_bits[] = {
  0x00, 0x1c, 0x00, 0x00, 0x70, 0x00, 0x10, 0x00,
  0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00 };
-#endif
-
-// Chirpy image definitions for M5STACK_UNITC6L compatibility
-#define chirpy_width 38
-#define chirpy_height 50
-static unsigned char chirpy[] = {
-    0xfe, 0xff, 0xff, 0xff, 0xdf, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x80, 0xe3, 0x01,
-    0x00, 0x00, 0xc0, 0xe7, 0x01, 0x00, 0x00, 0xc0, 0xe7, 0x01, 0x00, 0x00, 0xc0, 0xe7, 0x01, 0x00, 0x00, 0x80, 0xe3, 0x01, 0x00,
-    0x00, 0x00, 0xe0, 0x81, 0xff, 0xff, 0x7f, 0xe0, 0xc1, 0xff, 0xff, 0xff, 0xe0, 0xc1, 0xff, 0xff, 0xff, 0xe0, 0xc1, 0xcf, 0x7f,
-    0xfe, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc,
-    0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0,
-    0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0x87, 0x3f, 0xfc, 0xe0, 0xc1,
-    0x87, 0x3f, 0xfc, 0xe0, 0xc1, 0xcf, 0x7f, 0xfe, 0xe0, 0xc1, 0xff, 0xff, 0xff, 0xe0, 0xc1, 0xff, 0xff, 0xff, 0xe0, 0x81, 0xff,
-    0xff, 0x7f, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0xc3, 0x00, 0xe0, 0x01, 0x00, 0xc3,
-    0x00, 0xe0, 0x01, 0x80, 0xe1, 0x01, 0xe0, 0x01, 0x80, 0xe1, 0x01, 0xe0, 0x01, 0xc0, 0x30, 0x03, 0xe0, 0x01, 0xc0, 0x30, 0x03,
-    0xe0, 0x01, 0x60, 0x18, 0x06, 0xe0, 0x01, 0x60, 0x18, 0x06, 0xe0, 0x01, 0x30, 0x0c, 0x0c, 0xe0, 0x01, 0x30, 0x0c, 0x0c, 0xe0,
-    0x01, 0x18, 0x06, 0x18, 0xe0, 0x01, 0x18, 0x06, 0x18, 0xe0, 0x01, 0x0c, 0x03, 0x30, 0xe0, 0x01, 0x0c, 0x03, 0x30, 0xe0, 0x01,
-    0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0xfe, 0xff, 0xff, 0xff, 0xdf};
-
-#define chirpy_width_hirez 76
-#define chirpy_height_hirez 100
-static unsigned char chirpy_hirez[] = {
-    0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x03,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00,
-    0xfc, 0x03, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0xfc,
-    0x03, 0xe0, 0x1f, 0xff, 0xff, 0xff, 0xf8, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03,
-    0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0,
-    0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f,
-    0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe,
-    0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff,
-    0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f,
-    0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0,
-    0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f,
-    0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00,
-    0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc,
-    0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03,
-    0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0,
-    0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f,
-    0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe,
-    0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff,
-    0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f,
-    0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0,
-    0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f,
-    0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00,
-    0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc,
-    0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03,
-    0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0,
-    0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x0f, 0xfe, 0xff, 0x7f, 0xf0, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0x1f,
-    0xff, 0xff, 0xff, 0xf8, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0xfc, 0x03, 0xe0, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0x7f, 0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x86, 0x61, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x86, 0x61, 0x00,
-    0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x86, 0x61, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x80, 0x87, 0xe1, 0x01, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x80, 0x87, 0xe1, 0x01, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0, 0x83, 0xc1, 0x03, 0x00, 0x00,
-    0xfc, 0x03, 0x00, 0x00, 0xc0, 0x83, 0xc1, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xe0, 0x01, 0x80, 0x07, 0x00, 0x00, 0xfc,
-    0x03, 0x00, 0x00, 0xe0, 0x01, 0x80, 0x07, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x0f, 0x00, 0x00, 0xfc, 0x03,
-    0x00, 0x00, 0xf0, 0x00, 0x00, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x78, 0x00, 0x00, 0x1e, 0x00, 0x00, 0xfc, 0x03, 0x00,
-    0x00, 0x78, 0x00, 0x00, 0x1e, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
-    0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x78, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x1e,
-    0x00, 0x00, 0x78, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0x00, 0x00, 0xf0, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0x00,
-    0x00, 0xf0, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0xe0, 0x01, 0x00, 0xfc, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00,
-    0xe0, 0x01, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0,
-    0x03, 0x00, 0xfc, 0x03, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x80, 0x07, 0x00, 0xfc, 0x03, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x80, 0x07,
-    0x00, 0xfc, 0x03, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
-    0xfc, 0x03, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0xfc, 0x03, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0xfc,
-    0x03, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0xfc, 0x03, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0xfc, 0x03,
-    0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0xfc, 0x03, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0xfc, 0x03, 0x00,
-    0x0f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0xfc, 0x03, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0xfc, 0x03, 0x80, 0x07,
-    0x00, 0x00, 0x00, 0x00, 0xe0, 0x01, 0xfc, 0x03, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01, 0xfc, 0x03, 0xc0, 0x03, 0x00,
-    0x00, 0x00, 0x00, 0xc0, 0x03, 0xfc, 0x03, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0xfc, 0x03, 0xe0, 0x01, 0x00, 0x00,
-    0x00, 0x00, 0x80, 0x07, 0xfc, 0x03, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0xfc, 0x03, 0xf0, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x0f, 0xfc, 0x03, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3
-};
-
-#define chirpy_small_image_width 8
-#define chirpy_small_image_height 8
-static unsigned char small_chirpy[] = {0x7f, 0x41, 0x55, 0x55, 0x55, 0x55, 0x41, 0x7f};
+#endif
--- a/src/graphics/tftSetup.cpp
+++ b/src/graphics/tftSetup.cpp
@@ -41,78 +41,78 @@ void tftSetup(void)
    PacketAPI::create(PacketServer::init());
    deviceScreen->init(new PacketClient);
 #else
-    if (portduino_config.displayPanel != no_screen) {
+    if (settingsMap[displayPanel] != no_screen) {
        DisplayDriverConfig displayConfig;
        static char *panels[] = {"NOSCREEN", "X11",     "FB",      "ST7789",  "ST7735",  "ST7735S",
                                 "ST7796",   "ILI9341", "ILI9342", "ILI9486", "ILI9488", "HX8357D"};
        static char *touch[] = {"NOTOUCH", "XPT2046", "STMPE610", "GT911", "FT5x06"};
 #if defined(USE_X11)
-        if (portduino_config.displayPanel == x11) {
-            if (portduino_config.displayWidth && portduino_config.displayHeight)
-                displayConfig = DisplayDriverConfig(DisplayDriverConfig::device_t::X11, (uint16_t)portduino_config.displayWidth,
-                                                    (uint16_t)portduino_config.displayHeight);
+        if (settingsMap[displayPanel] == x11) {
+            if (settingsMap[displayWidth] && settingsMap[displayHeight])
+                displayConfig = DisplayDriverConfig(DisplayDriverConfig::device_t::X11, (uint16_t)settingsMap[displayWidth],
+                                                    (uint16_t)settingsMap[displayHeight]);
            else
                displayConfig.device(DisplayDriverConfig::device_t::X11);
        } else
 #elif defined(USE_FRAMEBUFFER)
-        if (portduino_config.displayPanel == fb) {
-            if (portduino_config.displayWidth && portduino_config.displayHeight)
-                displayConfig = DisplayDriverConfig(DisplayDriverConfig::device_t::FB, (uint16_t)portduino_config.displayWidth,
-                                                    (uint16_t)portduino_config.displayHeight);
+        if (settingsMap[displayPanel] == fb) {
+            if (settingsMap[displayWidth] && settingsMap[displayHeight])
+                displayConfig = DisplayDriverConfig(DisplayDriverConfig::device_t::FB, (uint16_t)settingsMap[displayWidth],
+                                                    (uint16_t)settingsMap[displayHeight]);
            else
                displayConfig.device(DisplayDriverConfig::device_t::FB);
        } else
 #endif
        {
            displayConfig.device(DisplayDriverConfig::device_t::CUSTOM_TFT)
-                .panel(DisplayDriverConfig::panel_config_t{.type = panels[portduino_config.displayPanel],
-                                                           .panel_width = (uint16_t)portduino_config.displayWidth,
-                                                           .panel_height = (uint16_t)portduino_config.displayHeight,
-                                                           .rotation = (bool)portduino_config.displayRotate,
-                                                           .pin_cs = (int16_t)portduino_config.displayCS.pin,
-                                                           .pin_rst = (int16_t)portduino_config.displayReset.pin,
-                                                           .offset_x = (uint16_t)portduino_config.displayOffsetX,
-                                                           .offset_y = (uint16_t)portduino_config.displayOffsetY,
-                                                           .offset_rotation = (uint8_t)portduino_config.displayOffsetRotate,
-                                                           .invert = portduino_config.displayInvert ? true : false,
-                                                           .rgb_order = (bool)portduino_config.displayRGBOrder,
-                                                           .dlen_16bit = portduino_config.displayPanel == ili9486 ||
-                                                                         portduino_config.displayPanel == ili9488})
-                .bus(DisplayDriverConfig::bus_config_t{.freq_write = (uint32_t)portduino_config.displayBusFrequency,
+                .panel(DisplayDriverConfig::panel_config_t{.type = panels[settingsMap[displayPanel]],
+                                                           .panel_width = (uint16_t)settingsMap[displayWidth],
+                                                           .panel_height = (uint16_t)settingsMap[displayHeight],
+                                                           .rotation = (bool)settingsMap[displayRotate],
+                                                           .pin_cs = (int16_t)settingsMap[displayCS],
+                                                           .pin_rst = (int16_t)settingsMap[displayReset],
+                                                           .offset_x = (uint16_t)settingsMap[displayOffsetX],
+                                                           .offset_y = (uint16_t)settingsMap[displayOffsetY],
+                                                           .offset_rotation = (uint8_t)settingsMap[displayOffsetRotate],
+                                                           .invert = settingsMap[displayInvert] ? true : false,
+                                                           .rgb_order = (bool)settingsMap[displayRGBOrder],
+                                                           .dlen_16bit = settingsMap[displayPanel] == ili9486 ||
+                                                                         settingsMap[displayPanel] == ili9488})
+                .bus(DisplayDriverConfig::bus_config_t{.freq_write = (uint32_t)settingsMap[displayBusFrequency],
                                                       .freq_read = 16000000,
-                                                       .spi{.pin_dc = (int8_t)portduino_config.displayDC.pin,
+                                                       .spi{.pin_dc = (int8_t)settingsMap[displayDC],
                                                            .use_lock = true,
-                                                            .spi_host = (uint16_t)portduino_config.display_spi_dev_int}})
-                .input(DisplayDriverConfig::input_config_t{.keyboardDevice = portduino_config.keyboardDevice,
-                                                           .pointerDevice = portduino_config.pointerDevice})
-                .light(DisplayDriverConfig::light_config_t{.pin_bl = (int16_t)portduino_config.displayBacklight.pin,
-                                                           .pwm_channel = (int8_t)portduino_config.displayBacklightPWMChannel.pin,
-                                                           .invert = (bool)portduino_config.displayBacklightInvert});
-            if (portduino_config.touchscreenI2CAddr == -1) {
+                                                            .spi_host = (uint16_t)settingsMap[displayspidev]}})
+                .input(DisplayDriverConfig::input_config_t{.keyboardDevice = settingsStrings[keyboardDevice],
+                                                           .pointerDevice = settingsStrings[pointerDevice]})
+                .light(DisplayDriverConfig::light_config_t{.pin_bl = (int16_t)settingsMap[displayBacklight],
+                                                           .pwm_channel = (int8_t)settingsMap[displayBacklightPWMChannel],
+                                                           .invert = (bool)settingsMap[displayBacklightInvert]});
+            if (settingsMap[touchscreenI2CAddr] == -1) {
                displayConfig.touch(
-                    DisplayDriverConfig::touch_config_t{.type = touch[portduino_config.touchscreenModule],
-                                                        .freq = (uint32_t)portduino_config.touchscreenBusFrequency,
-                                                        .pin_int = (int16_t)portduino_config.touchscreenIRQ.pin,
-                                                        .offset_rotation = (uint8_t)portduino_config.touchscreenRotate,
+                    DisplayDriverConfig::touch_config_t{.type = touch[settingsMap[touchscreenModule]],
+                                                        .freq = (uint32_t)settingsMap[touchscreenBusFrequency],
+                                                        .pin_int = (int16_t)settingsMap[touchscreenIRQ],
+                                                        .offset_rotation = (uint8_t)settingsMap[touchscreenRotate],
                                                        .spi{
-                                                            .spi_host = (int8_t)portduino_config.touchscreen_spi_dev_int,
+                                                            .spi_host = (int8_t)settingsMap[touchscreenspidev],
                                                        },
-                                                        .pin_cs = (int16_t)portduino_config.touchscreenCS.pin});
+                                                        .pin_cs = (int16_t)settingsMap[touchscreenCS]});
            } else {
                displayConfig.touch(DisplayDriverConfig::touch_config_t{
-                    .type = touch[portduino_config.touchscreenModule],
-                    .freq = (uint32_t)portduino_config.touchscreenBusFrequency,
+                    .type = touch[settingsMap[touchscreenModule]],
+                    .freq = (uint32_t)settingsMap[touchscreenBusFrequency],
                    .x_min = 0,
-                    .x_max = (int16_t)((portduino_config.touchscreenRotate & 1 ? portduino_config.displayWidth
-                                                                               : portduino_config.displayHeight) -
-                                       1),
+                    .x_max =
+                        (int16_t)((settingsMap[touchscreenRotate] & 1 ? settingsMap[displayWidth] : settingsMap[displayHeight]) -
+                                  1),
                    .y_min = 0,
-                    .y_max = (int16_t)((portduino_config.touchscreenRotate & 1 ? portduino_config.displayHeight
-                                                                               : portduino_config.displayWidth) -
-                                       1),
-                    .pin_int = (int16_t)portduino_config.touchscreenIRQ.pin,
-                    .offset_rotation = (uint8_t)portduino_config.touchscreenRotate,
-                    .i2c{.i2c_addr = (uint8_t)portduino_config.touchscreenI2CAddr}});
+                    .y_max =
+                        (int16_t)((settingsMap[touchscreenRotate] & 1 ? settingsMap[displayHeight] : settingsMap[displayWidth]) -
+                                  1),
+                    .pin_int = (int16_t)settingsMap[touchscreenIRQ],
+                    .offset_rotation = (uint8_t)settingsMap[touchscreenRotate],
+                    .i2c{.i2c_addr = (uint8_t)settingsMap[touchscreenI2CAddr]}});
            }
        }
        deviceScreen = &DeviceScreen::create(&displayConfig);
--- a/src/input/ExpressLRSFiveWay.cpp
+++ b/src/input/ExpressLRSFiveWay.cpp
@@ -188,7 +188,7 @@ void ExpressLRSFiveWay::determineAction(KeyType key, PressLength length)
 // Feed input to the canned messages module
 void ExpressLRSFiveWay::sendKey(input_broker_event key)
 {
-    InputEvent e = {};
+    InputEvent e;
    e.source = inputSourceName;
    e.inputEvent = key;
    notifyObservers(&e);
--- a/src/input/LinuxInput.cpp
+++ b/src/input/LinuxInput.cpp
@@ -33,9 +33,9 @@ int32_t LinuxInput::runOnce()
 {

    if (firstTime) {
-        if (portduino_config.keyboardDevice == "")
+        if (settingsStrings[keyboardDevice] == "")
            return disable();
-        fd = open(portduino_config.keyboardDevice.c_str(), O_RDWR);
+        fd = open(settingsStrings[keyboardDevice].c_str(), O_RDWR);
        if (fd < 0)
            return disable();
        ret = ioctl(fd, EVIOCGRAB, (void *)1);
@@ -73,7 +73,7 @@ int32_t LinuxInput::runOnce()
        int rd = read(events[i].data.fd, ev, sizeof(ev));
        assert(rd > ((signed int)sizeof(struct input_event)));
        for (int j = 0; j < rd / ((signed int)sizeof(struct input_event)); j++) {
-            InputEvent e = {};
+            InputEvent e;
            e.inputEvent = INPUT_BROKER_NONE;
            e.source = this->_originName;
            e.kbchar = 0;
--- a/src/input/RotaryEncoderInterruptBase.cpp
+++ b/src/input/RotaryEncoderInterruptBase.cpp
@@ -43,7 +43,7 @@ void RotaryEncoderInterruptBase::init(

 int32_t RotaryEncoderInterruptBase::runOnce()
 {
-    InputEvent e = {};
+    InputEvent e;
    e.inputEvent = INPUT_BROKER_NONE;
    e.source = this->_originName;

@@ -120,7 +120,7 @@ RotaryEncoderInterruptBaseStateType RotaryEncoderInterruptBase::intHandler(bool
        // Logic to prevent bouncing.
        newState = ROTARY_EVENT_CLEARED;
    }
-    setIntervalFromNow(ROTARY_DELAY); // TODO: this modifies a non-volatile variable!
+    setIntervalFromNow(50); // TODO: this modifies a non-volatile variable!

    return newState;
 }
--- a/src/input/SeesawRotary.cpp
+++ b/src/input/SeesawRotary.cpp
@@ -49,7 +49,7 @@ bool SeesawRotary::init()

 int32_t SeesawRotary::runOnce()
 {
-    InputEvent e = {};
+    InputEvent e;
    e.inputEvent = INPUT_BROKER_NONE;
    bool currentlyPressed = !ss.digitalRead(SS_SWITCH);

--- a/src/input/SerialKeyboard.cpp
+++ b/src/input/SerialKeyboard.cpp
@@ -29,7 +29,7 @@ SerialKeyboard::SerialKeyboard(const char *name) : concurrency::OSThread(name)

 void SerialKeyboard::erase()
 {
-    InputEvent e = {};
+    InputEvent e;
    e.inputEvent = INPUT_BROKER_BACK;
    e.kbchar = 0x08;
    e.source = this->_originName;
@@ -80,7 +80,7 @@ int32_t SerialKeyboard::runOnce()

        if (keys < prevKeys) { // a new key has been pressed (and not released), doesn't works for multiple presses at once but
                               // shouldn't be a limitation
-            InputEvent e = {};
+            InputEvent e;
            e.inputEvent = INPUT_BROKER_NONE;
            e.source = this->_originName;
            // SELECT OR SEND OR CANCEL EVENT
--- a/src/input/TouchScreenImpl1.cpp
+++ b/src/input/TouchScreenImpl1.cpp
@@ -18,7 +18,7 @@ TouchScreenImpl1::TouchScreenImpl1(uint16_t width, uint16_t height, bool (*getTo
 void TouchScreenImpl1::init()
 {
 #if ARCH_PORTDUINO
-    if (portduino_config.touchscreenModule) {
+    if (settingsMap[touchscreenModule]) {
        TouchScreenBase::init(true);
        inputBroker->registerSource(this);
    } else {
@@ -47,7 +47,7 @@ bool TouchScreenImpl1::getTouch(int16_t &x, int16_t &y)
 */
 void TouchScreenImpl1::onEvent(const TouchEvent &event)
 {
-    InputEvent e = {};
+    InputEvent e;
    e.source = event.source;
    e.kbchar = 0;
    e.touchX = event.x;
--- a/src/input/TrackballInterruptBase.cpp
+++ b/src/input/TrackballInterruptBase.cpp
@@ -48,7 +48,7 @@ void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLef

 int32_t TrackballInterruptBase::runOnce()
 {
-    InputEvent e = {};
+    InputEvent e;
    e.inputEvent = INPUT_BROKER_NONE;
 #if defined(T_DECK) // T-deck gets a super-simple debounce on trackball
    if (this->action == TB_ACTION_PRESSED) {
--- a/src/input/TrackballInterruptBase.h
+++ b/src/input/TrackballInterruptBase.h
@@ -6,7 +6,7 @@
 #ifndef TB_DIRECTION
 #if ARCH_PORTDUINO
 #include "PortduinoGlue.h"
-#define TB_DIRECTION (PinStatus) portduino_config.lora_usb_vid
+#define TB_DIRECTION (PinStatus) settingsMap[tbDirection]
 #else
 #define TB_DIRECTION RISING
 #endif
--- a/src/input/UpDownInterruptBase.cpp
+++ b/src/input/UpDownInterruptBase.cpp
@@ -40,7 +40,7 @@ void UpDownInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinPress,

 int32_t UpDownInterruptBase::runOnce()
 {
-    InputEvent e = {};
+    InputEvent e;
    e.inputEvent = INPUT_BROKER_NONE;
    unsigned long now = millis();
    if (this->action == UPDOWN_ACTION_PRESSED) {
--- a/src/input/kbI2cBase.cpp
+++ b/src/input/kbI2cBase.cpp
@@ -90,7 +90,7 @@ int32_t KbI2cBase::runOnce()
        while (keyCount--) {
            const BBQ10Keyboard::KeyEvent key = Q10keyboard.keyEvent();
            if ((key.key != 0x00) && (key.state == BBQ10Keyboard::StateRelease)) {
-                InputEvent e = {};
+                InputEvent e;
                e.inputEvent = INPUT_BROKER_NONE;
                e.source = this->_originName;
                switch (key.key) {
@@ -187,7 +187,7 @@ int32_t KbI2cBase::runOnce()
    }
    case 0x37: { // MPR121
        MPRkeyboard.trigger();
-        InputEvent e = {};
+        InputEvent e;

        while (MPRkeyboard.hasEvent()) {
            char nextEvent = MPRkeyboard.dequeueEvent();
@@ -250,7 +250,7 @@ int32_t KbI2cBase::runOnce()
    }
    case 0x84: { // Adafruit TCA8418
        TCAKeyboard.trigger();
-        InputEvent e = {};
+        InputEvent e;
        while (TCAKeyboard.hasEvent()) {
            char nextEvent = TCAKeyboard.dequeueEvent();
            e.inputEvent = INPUT_BROKER_ANYKEY;
@@ -350,7 +350,7 @@ int32_t KbI2cBase::runOnce()
        }
        if (PrintDataBuf != 0) {
            LOG_DEBUG("RAK14004 key 0x%x pressed", PrintDataBuf);
-            InputEvent e = {};
+            InputEvent e;
            e.inputEvent = INPUT_BROKER_MATRIXKEY;
            e.source = this->_originName;
            e.kbchar = PrintDataBuf;
@@ -365,7 +365,7 @@ int32_t KbI2cBase::runOnce()

        if (i2cBus->available()) {
            char c = i2cBus->read();
-            InputEvent e = {};
+            InputEvent e;
            e.inputEvent = INPUT_BROKER_NONE;
            e.source = this->_originName;
            switch (c) {
--- a/src/input/kbMatrixBase.cpp
+++ b/src/input/kbMatrixBase.cpp
@@ -72,7 +72,7 @@ int32_t KbMatrixBase::runOnce()
            if (key != 0) {
                LOG_DEBUG("Key 0x%x pressed", key);
                // reset shift now that we have a keypress
-                InputEvent e = {};
+                InputEvent e;
                e.inputEvent = INPUT_BROKER_NONE;
                e.source = this->_originName;
                switch (key) {
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -387,7 +387,7 @@ void setup()
 #endif
    concurrency::hasBeenSetup = true;
 #if ARCH_PORTDUINO
-    SPISettings spiSettings(portduino_config.spiSpeed, MSBFIRST, SPI_MODE0);
+    SPISettings spiSettings(settingsMap[spiSpeed], MSBFIRST, SPI_MODE0);
 #else
    SPISettings spiSettings(4000000, MSBFIRST, SPI_MODE0);
 #endif
@@ -532,9 +532,9 @@ void setup()
 #elif defined(I2C_SDA) && !defined(ARCH_RP2040)
    Wire.begin(I2C_SDA, I2C_SCL);
 #elif defined(ARCH_PORTDUINO)
-    if (portduino_config.i2cdev != "") {
-        LOG_INFO("Use %s as I2C device", portduino_config.i2cdev.c_str());
-        Wire.begin(portduino_config.i2cdev.c_str());
+    if (settingsStrings[i2cdev] != "") {
+        LOG_INFO("Use %s as I2C device", settingsStrings[i2cdev].c_str());
+        Wire.begin(settingsStrings[i2cdev].c_str());
    } else {
        LOG_INFO("No I2C device configured, Skip");
    }
@@ -586,7 +586,7 @@ void setup()
 #if defined(I2C_SDA)
    i2cScanner->scanPort(ScanI2C::I2CPort::WIRE);
 #elif defined(ARCH_PORTDUINO)
-    if (portduino_config.i2cdev != "") {
+    if (settingsStrings[i2cdev] != "") {
        LOG_INFO("Scan for i2c devices");
        i2cScanner->scanPort(ScanI2C::I2CPort::WIRE);
    }
@@ -859,7 +859,7 @@ void setup()
    SPI.begin(false);
 #endif // HW_SPI1_DEVICE
 #elif ARCH_PORTDUINO
-    if (portduino_config.lora_spi_dev != "ch341") {
+    if (settingsStrings[spidev] != "ch341") {
        SPI.begin();
    }
 #elif !defined(ARCH_ESP32) // ARCH_RP2040
@@ -886,7 +886,7 @@ void setup()
    defined(USE_SPISSD1306)
        screen = new graphics::Screen(screen_found, screen_model, screen_geometry);
 #elif defined(ARCH_PORTDUINO)
-        if ((screen_found.port != ScanI2C::I2CPort::NO_I2C || portduino_config.displayPanel) &&
+        if ((screen_found.port != ScanI2C::I2CPort::NO_I2C || settingsMap[displayPanel]) &&
            config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
            screen = new graphics::Screen(screen_found, screen_model, screen_geometry);
        }
@@ -987,13 +987,13 @@ void setup()
 #endif
 #if defined(ARCH_PORTDUINO)

-    if (portduino_config.userButtonPin.enabled) {
+    if (settingsMap.count(userButtonPin) != 0 && settingsMap[userButtonPin] != RADIOLIB_NC) {

-        LOG_DEBUG("Use GPIO%02d for button", portduino_config.userButtonPin.pin);
+        LOG_DEBUG("Use GPIO%02d for button", settingsMap[userButtonPin]);
        UserButtonThread = new ButtonThread("UserButton");
        if (screen) {
            ButtonConfig config;
-            config.pinNumber = (uint8_t)portduino_config.userButtonPin.pin;
+            config.pinNumber = (uint8_t)settingsMap[userButtonPin];
            config.activeLow = true;
            config.activePullup = true;
            config.pullupSense = INPUT_PULLUP;
@@ -1151,7 +1151,7 @@ void setup()
    if (screen)
        screen->setup();
 #elif defined(ARCH_PORTDUINO)
-    if ((screen_found.port != ScanI2C::I2CPort::NO_I2C || portduino_config.displayPanel) &&
+    if ((screen_found.port != ScanI2C::I2CPort::NO_I2C || settingsMap[displayPanel]) &&
        config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
        screen->setup();
    }
@@ -1167,10 +1167,15 @@ void setup()
 #endif

 #ifdef ARCH_PORTDUINO
+    const struct {
+        configNames cfgName;
+        std::string strName;
+    } loraModules[] = {{use_rf95, "RF95"},     {use_sx1262, "sx1262"}, {use_sx1268, "sx1268"}, {use_sx1280, "sx1280"},
+                       {use_lr1110, "lr1110"}, {use_lr1120, "lr1120"}, {use_lr1121, "lr1121"}, {use_llcc68, "LLCC68"}};
    // as one can't use a function pointer to the class constructor:
-    auto loraModuleInterface = [](LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
-                                  RADIOLIB_PIN_TYPE busy) {
-        switch (portduino_config.lora_module) {
+    auto loraModuleInterface = [](configNames cfgName, LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq,
+                                  RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy) {
+        switch (cfgName) {
        case use_rf95:
            return (RadioInterface *)new RF95Interface(hal, cs, irq, rst, busy);
        case use_sx1262:
@@ -1187,34 +1192,31 @@ void setup()
            return (RadioInterface *)new LR1121Interface(hal, cs, irq, rst, busy);
        case use_llcc68:
            return (RadioInterface *)new LLCC68Interface(hal, cs, irq, rst, busy);
-        case use_simradio:
-            return (RadioInterface *)new SimRadio;
        default:
            assert(0); // shouldn't happen
            return (RadioInterface *)nullptr;
        }
    };
-
-    LOG_DEBUG("Activate %s radio on SPI port %s", portduino_config.loraModules[portduino_config.lora_module].c_str(),
-              portduino_config.lora_spi_dev.c_str());
-    if (portduino_config.lora_spi_dev == "ch341") {
-        RadioLibHAL = ch341Hal;
-    } else {
-        RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
+    for (auto &loraModule : loraModules) {
+        if (settingsMap[loraModule.cfgName] && !rIf) {
+            LOG_DEBUG("Activate %s radio on SPI port %s", loraModule.strName.c_str(), settingsStrings[spidev].c_str());
+            if (settingsStrings[spidev] == "ch341") {
+                RadioLibHAL = ch341Hal;
+            } else {
+                RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
+            }
+            rIf = loraModuleInterface(loraModule.cfgName, (LockingArduinoHal *)RadioLibHAL, settingsMap[cs_pin],
+                                      settingsMap[irq_pin], settingsMap[reset_pin], settingsMap[busy_pin]);
+            if (!rIf->init()) {
+                LOG_WARN("No %s radio", loraModule.strName.c_str());
+                delete rIf;
+                rIf = NULL;
+                exit(EXIT_FAILURE);
+            } else {
+                LOG_INFO("%s init success", loraModule.strName.c_str());
+            }
+        }
    }
-    rIf =
-        loraModuleInterface((LockingArduinoHal *)RadioLibHAL, portduino_config.lora_cs_pin.pin, portduino_config.lora_irq_pin.pin,
-                            portduino_config.lora_reset_pin.pin, portduino_config.lora_busy_pin.pin);
-
-    if (!rIf->init()) {
-        LOG_WARN("No %s radio", portduino_config.loraModules[portduino_config.lora_module].c_str());
-        delete rIf;
-        rIf = NULL;
-        exit(EXIT_FAILURE);
-    } else {
-        LOG_INFO("%s init success", portduino_config.loraModules[portduino_config.lora_module].c_str());
-    }
-
 #elif defined(HW_SPI1_DEVICE)
    LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI1, spiSettings);
 #else // HW_SPI1_DEVICE
@@ -1236,6 +1238,20 @@ void setup()
    }
 #endif

+#if defined(ARCH_PORTDUINO)
+    if (!rIf) {
+        rIf = new SimRadio;
+        if (!rIf->init()) {
+            LOG_WARN("No simulated radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("Use SIMULATED radio!");
+            radioType = SIM_RADIO;
+        }
+    }
+#endif
+
 #if defined(RF95_IRQ) && RADIOLIB_EXCLUDE_SX127X != 1
    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
        rIf = new RF95Interface(RadioLibHAL, LORA_CS, RF95_IRQ, RF95_RESET, RF95_DIO1);
@@ -1446,7 +1462,7 @@ void setup()

 #ifdef ARCH_PORTDUINO
 #if __has_include(<ulfius.h>)
-    if (portduino_config.webserverport != -1) {
+    if (settingsMap[webserverport] != -1) {
        piwebServerThread = new PiWebServerThread();
        std::atexit([] { delete piwebServerThread; });
    }
--- a/src/mesh/Channels.cpp
+++ b/src/mesh/Channels.cpp
@@ -423,33 +423,6 @@ bool Channels::decryptForHash(ChannelIndex chIndex, ChannelHash channelHash)
    }
 }

-bool Channels::setDefaultPresetCryptoForHash(ChannelHash channelHash)
-{
-    // Iterate all known presets
-    for (int preset = _meshtastic_Config_LoRaConfig_ModemPreset_MIN; preset <= _meshtastic_Config_LoRaConfig_ModemPreset_MAX;
-         ++preset) {
-        const char *name =
-            DisplayFormatters::getModemPresetDisplayName((meshtastic_Config_LoRaConfig_ModemPreset)preset, false, false);
-        if (!name)
-            continue;
-        if (strcmp(name, "Invalid") == 0)
-            continue; // skip invalid placeholder
-        uint8_t h = xorHash((const uint8_t *)name, strlen(name));
-        // Expand default PSK alias 1 to actual bytes and xor into hash
-        uint8_t tmp = h ^ xorHash(defaultpsk, sizeof(defaultpsk));
-        if (tmp == channelHash) {
-            // Set crypto to defaultpsk and report success
-            CryptoKey k;
-            memcpy(k.bytes, defaultpsk, sizeof(defaultpsk));
-            k.length = sizeof(defaultpsk);
-            crypto->setKey(k);
-            LOG_INFO("Matched default preset '%s' for hash 0x%x; set default PSK", name, channelHash);
-            return true;
-        }
-    }
-    return false;
-}
-
 /** Given a channel index setup crypto for encoding that channel (or the primary channel if that channel is unsecured)
 *
 * This method is called before encoding outbound packets
--- a/src/mesh/Channels.h
+++ b/src/mesh/Channels.h
@@ -94,8 +94,6 @@ class Channels

    bool ensureLicensedOperation();

-    bool setDefaultPresetCryptoForHash(ChannelHash channelHash);
-
  private:
    /** Given a channel index, change to use the crypto key specified by that index
     *
--- a/src/mesh/FloodingRouter.cpp
+++ b/src/mesh/FloodingRouter.cpp
@@ -43,30 +43,12 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
    return Router::shouldFilterReceived(p);
 }

-bool FloodingRouter::roleAllowsCancelingDupe(const meshtastic_MeshPacket *p)
-{
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
-        config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER ||
-        config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
-        // ROUTER, REPEATER, ROUTER_LATE should never cancel relaying a packet (i.e. we should always rebroadcast),
-        // even if we've heard another station rebroadcast it already.
-        return false;
-    }
-
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) {
-        // CLIENT_BASE: if the packet is from or to a favorited node,
-        // we should act like a ROUTER and should never cancel a rebroadcast (i.e. we should always rebroadcast),
-        // even if we've heard another station rebroadcast it already.
-        return !nodeDB->isFromOrToFavoritedNode(*p);
-    }
-
-    // All other roles (such as CLIENT) should cancel a rebroadcast if they hear another station's rebroadcast.
-    return true;
-}
-
 void FloodingRouter::perhapsCancelDupe(const meshtastic_MeshPacket *p)
 {
-    if (p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA && roleAllowsCancelingDupe(p)) {
+    if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
+        config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
+        config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER_LATE &&
+        p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA) {
        // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
        // But only LoRa packets should be able to trigger this.
        if (Router::cancelSending(p->from, p->id))
--- a/src/mesh/FloodingRouter.h
+++ b/src/mesh/FloodingRouter.h
@@ -59,10 +59,6 @@ class FloodingRouter : public Router
     */
    virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;

-    // Return false for roles like ROUTER or REPEATER which should always rebroadcast even when we've heard another rebroadcast of
-    // the same packet
-    bool roleAllowsCancelingDupe(const meshtastic_MeshPacket *p);
-
    /* Call when receiving a duplicate packet to check whether we should cancel a packet in the Tx queue */
    void perhapsCancelDupe(const meshtastic_MeshPacket *p);

--- a/src/mesh/LR11x0Interface.cpp
+++ b/src/mesh/LR11x0Interface.cpp
@@ -21,7 +21,7 @@ static const Module::RfSwitchMode_t rfswitch_table[] = {
 // Particular boards might define a different max power based on what their hardware can do, default to max power output if not
 // specified (may be dangerous if using external PA and LR11x0 power config forgotten)
 #if ARCH_PORTDUINO
-#define LR1110_MAX_POWER portduino_config.lr1110_max_power
+#define LR1110_MAX_POWER settingsMap[lr1110_max_power]
 #endif
 #ifndef LR1110_MAX_POWER
 #define LR1110_MAX_POWER 22
@@ -30,7 +30,7 @@ static const Module::RfSwitchMode_t rfswitch_table[] = {
 // the 2.4G part maxes at 13dBm

 #if ARCH_PORTDUINO
-#define LR1120_MAX_POWER portduino_config.lr1120_max_power
+#define LR1120_MAX_POWER settingsMap[lr1120_max_power]
 #endif
 #ifndef LR1120_MAX_POWER
 #define LR1120_MAX_POWER 13
@@ -55,7 +55,7 @@ template <typename T> bool LR11x0Interface<T>::init()
 #endif

 #if ARCH_PORTDUINO
-    float tcxoVoltage = (float)portduino_config.dio3_tcxo_voltage / 1000;
+    float tcxoVoltage = (float)settingsMap[dio3_tcxo_voltage] / 1000;
 // FIXME: correct logic to default to not using TCXO if no voltage is specified for LR11x0_DIO3_TCXO_VOLTAGE
 #elif !defined(LR11X0_DIO3_TCXO_VOLTAGE)
    float tcxoVoltage =
--- a/src/mesh/NextHopRouter.cpp
+++ b/src/mesh/NextHopRouter.cpp
@@ -161,15 +161,6 @@ bool NextHopRouter::stopRetransmission(NodeNum from, PacketId id)
    return stopRetransmission(key);
 }

-bool NextHopRouter::roleAllowsCancelingFromTxQueue(const meshtastic_MeshPacket *p)
-{
-    // Return true if we're allowed to cancel a packet in the txQueue (so we may never transmit it even once)
-
-    // Return false for roles like ROUTER, REPEATER, ROUTER_LATE which should always transmit the packet at least once.
-
-    return roleAllowsCancelingDupe(p); // same logic as FloodingRouter::roleAllowsCancelingDupe
-}
-
 bool NextHopRouter::stopRetransmission(GlobalPacketId key)
 {
    auto old = findPendingPacket(key);
@@ -179,7 +170,9 @@ bool NextHopRouter::stopRetransmission(GlobalPacketId key)
          to avoid canceling a transmission if it was ACKed super fast via MQTT */
        if (old->numRetransmissions < NUM_RELIABLE_RETX - 1) {
            // We only cancel it if we are the original sender or if we're not a router(_late)/repeater
-            if (isFromUs(p) || roleAllowsCancelingFromTxQueue(p)) {
+            if (isFromUs(p) || (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
+                                config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
+                                config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER_LATE)) {
                // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
                cancelSending(getFrom(p), p->id);
            }
--- a/src/mesh/NextHopRouter.h
+++ b/src/mesh/NextHopRouter.h
@@ -121,9 +121,6 @@ class NextHopRouter : public FloodingRouter
     */
    PendingPacket *startRetransmission(meshtastic_MeshPacket *p, uint8_t numReTx = NUM_INTERMEDIATE_RETX);

-    // Return true if we're allowed to cancel a packet in the txQueue (so we may never transmit it even once)
-    bool roleAllowsCancelingFromTxQueue(const meshtastic_MeshPacket *p);
-
    /**
     * Stop any retransmissions we are doing of the specified node/packet ID pair
     *
--- a/src/mesh/NodeDB.cpp
+++ b/src/mesh/NodeDB.cpp
@@ -673,7 +673,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #endif
 #elif ARCH_PORTDUINO
    bool hasScreen = false;
-    if (portduino_config.displayPanel)
+    if (settingsMap[displayPanel])
        hasScreen = true;
    else
        hasScreen = screen_found.port != ScanI2C::I2CPort::NO_I2C;
@@ -1334,8 +1334,8 @@ void NodeDB::loadFromDisk()
    }
 #if ARCH_PORTDUINO
    // set any config overrides
-    if (portduino_config.has_configDisplayMode) {
-        config.display.displaymode = (_meshtastic_Config_DisplayConfig_DisplayMode)portduino_config.configDisplayMode;
+    if (settingsMap[has_configDisplayMode]) {
+        config.display.displaymode = (_meshtastic_Config_DisplayConfig_DisplayMode)settingsMap[configDisplayMode];
    }

 #endif
@@ -1750,65 +1750,6 @@ void NodeDB::set_favorite(bool is_favorite, uint32_t nodeId)
    }
 }

-bool NodeDB::isFavorite(uint32_t nodeId)
-{
-    // returns true if nodeId is_favorite; false if not or not found
-
-    // NODENUM_BROADCAST will never be in the DB
-    if (nodeId == NODENUM_BROADCAST)
-        return false;
-
-    meshtastic_NodeInfoLite *lite = getMeshNode(nodeId);
-
-    if (lite) {
-        return lite->is_favorite;
-    }
-    return false;
-}
-
-bool NodeDB::isFromOrToFavoritedNode(const meshtastic_MeshPacket &p)
-{
-    // This method is logically equivalent to:
-    //   return isFavorite(p.from) || isFavorite(p.to);
-    // but is more efficient by:
-    //   1. doing only one pass through the database, instead of two
-    //   2. exiting early when a favorite is found, or if both from and to have been seen
-
-    if (p.to == NODENUM_BROADCAST)
-        return isFavorite(p.from); // we never store NODENUM_BROADCAST in the DB, so we only need to check p.from
-
-    meshtastic_NodeInfoLite *lite = NULL;
-
-    bool seenFrom = false;
-    bool seenTo = false;
-
-    for (int i = 0; i < numMeshNodes; i++) {
-        lite = &meshNodes->at(i);
-
-        if (lite->num == p.from) {
-            if (lite->is_favorite)
-                return true;
-
-            seenFrom = true;
-        }
-
-        if (lite->num == p.to) {
-            if (lite->is_favorite)
-                return true;
-
-            seenTo = true;
-        }
-
-        if (seenFrom && seenTo)
-            return false; // we've seen both, and neither is a favorite, so we can stop searching early
-
-        // Note: if we knew that sortMeshDB was always called after any change to is_favorite, we could exit early after searching
-        // all favorited nodes first.
-    }
-
-    return false;
-}
-
 void NodeDB::pause_sort(bool paused)
 {
    sortingIsPaused = paused;
--- a/src/mesh/NodeDB.h
+++ b/src/mesh/NodeDB.h
@@ -185,16 +185,6 @@ class NodeDB
     */
    void set_favorite(bool is_favorite, uint32_t nodeId);

-    /*
-     * Returns true if the node is in the NodeDB and marked as favorite
-     */
-    bool isFavorite(uint32_t nodeId);
-
-    /*
-     * Returns true if p->from or p->to is a favorited node
-     */
-    bool isFromOrToFavoritedNode(const meshtastic_MeshPacket &p);
-
    /**
     * Other functions like the node picker can request a pause in the node sorting
     */
--- a/src/mesh/RF95Interface.cpp
+++ b/src/mesh/RF95Interface.cpp
@@ -10,7 +10,7 @@
 #endif

 #if ARCH_PORTDUINO
-#define RF95_MAX_POWER portduino_config.rf95_max_power
+#define RF95_MAX_POWER settingsMap[rf95_max_power]
 #endif
 #ifndef RF95_MAX_POWER
 #define RF95_MAX_POWER 20
@@ -94,16 +94,16 @@ void RF95Interface::setTransmitEnable(bool txon)
 #ifdef RF95_TXEN
    digitalWrite(RF95_TXEN, txon ? 1 : 0);
 #elif ARCH_PORTDUINO
-    if (portduino_config.lora_txen_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_txen_pin.pin, txon ? 1 : 0);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[txen_pin], txon ? 1 : 0);
    }
 #endif

 #ifdef RF95_RXEN
    digitalWrite(RF95_RXEN, txon ? 0 : 1);
 #elif ARCH_PORTDUINO
-    if (portduino_config.lora_rxen_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_rxen_pin.pin, txon ? 0 : 1);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[rxen_pin], txon ? 0 : 1);
    }
 #endif
 }
@@ -164,13 +164,13 @@ bool RF95Interface::init()
    digitalWrite(RF95_RXEN, 1);
 #endif
 #if ARCH_PORTDUINO
-    if (portduino_config.lora_txen_pin.pin != RADIOLIB_NC) {
-        pinMode(portduino_config.lora_txen_pin.pin, OUTPUT);
-        digitalWrite(portduino_config.lora_txen_pin.pin, 0);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        pinMode(settingsMap[txen_pin], OUTPUT);
+        digitalWrite(settingsMap[txen_pin], 0);
    }
-    if (portduino_config.lora_rxen_pin.pin != RADIOLIB_NC) {
-        pinMode(portduino_config.lora_rxen_pin.pin, OUTPUT);
-        digitalWrite(portduino_config.lora_rxen_pin.pin, 0);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        pinMode(settingsMap[rxen_pin], OUTPUT);
+        digitalWrite(settingsMap[rxen_pin], 0);
    }
 #endif
    setTransmitEnable(false);
--- a/src/mesh/RadioInterface.cpp
+++ b/src/mesh/RadioInterface.cpp
@@ -311,33 +311,16 @@ uint32_t RadioInterface::getTxDelayMsecWeightedWorst(float snr)
    return (2 * CWmax * slotTimeMsec) + pow_of_2(CWsize) * slotTimeMsec;
 }

-/** Returns true if we should rebroadcast early like a ROUTER */
-bool RadioInterface::shouldRebroadcastEarlyLikeRouter(meshtastic_MeshPacket *p)
-{
-    // If we are a ROUTER or REPEATER, we always rebroadcast early
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
-        config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
-        return true;
-    }
-
-    // If we are a CLIENT_BASE and the packet is from or to a favorited node, we should rebroadcast early
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) {
-        return nodeDB->isFromOrToFavoritedNode(*p);
-    }
-
-    return false;
-}
-
 /** The delay to use when we want to flood a message */
-uint32_t RadioInterface::getTxDelayMsecWeighted(meshtastic_MeshPacket *p)
+uint32_t RadioInterface::getTxDelayMsecWeighted(float snr)
 {
    //  high SNR = large CW size (Long Delay)
    //  low SNR = small CW size (Short Delay)
-    float snr = p->rx_snr;
    uint32_t delay = 0;
    uint8_t CWsize = getCWsize(snr);
    // LOG_DEBUG("rx_snr of %f so setting CWsize to:%d", snr, CWsize);
-    if (shouldRebroadcastEarlyLikeRouter(p)) {
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
+        config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
        delay = random(0, 2 * CWsize) * slotTimeMsec;
        LOG_DEBUG("rx_snr found in packet. Router: setting tx delay:%d", delay);
    } else {
--- a/src/mesh/RadioInterface.h
+++ b/src/mesh/RadioInterface.h
@@ -180,11 +180,8 @@ class RadioInterface
    /** The worst-case SNR_based packet delay */
    uint32_t getTxDelayMsecWeightedWorst(float snr);

-    /** Returns true if we should rebroadcast early like a ROUTER */
-    bool shouldRebroadcastEarlyLikeRouter(meshtastic_MeshPacket *p);
-
    /** The delay to use when we want to flood a message. Use a weighted scale based on SNR */
-    uint32_t getTxDelayMsecWeighted(meshtastic_MeshPacket *p);
+    uint32_t getTxDelayMsecWeighted(float snr);

    /** If the packet is not already in the late rebroadcast window, move it there */
    virtual void clampToLateRebroadcastWindow(NodeNum from, PacketId id) { return; }
--- a/src/mesh/RadioLibInterface.cpp
+++ b/src/mesh/RadioLibInterface.cpp
@@ -310,7 +310,7 @@ void RadioLibInterface::setTransmitDelay()
    // So we want to make sure the other side has had a chance to reconfigure its radio.

    if (p->tx_after) {
-        unsigned long add_delay = p->rx_rssi ? getTxDelayMsecWeighted(p) : getTxDelayMsec();
+        unsigned long add_delay = p->rx_rssi ? getTxDelayMsecWeighted(p->rx_snr) : getTxDelayMsec();
        unsigned long now = millis();
        p->tx_after = min(max(p->tx_after + add_delay, now + add_delay), now + 2 * getTxDelayMsecWeightedWorst(p->rx_snr));
        notifyLater(p->tx_after - now, TRANSMIT_DELAY_COMPLETED, false);
@@ -323,7 +323,7 @@ void RadioLibInterface::setTransmitDelay()
    } else {
        // If there is a SNR, start a timer scaled based on that SNR.
        LOG_DEBUG("rx_snr found. hop_limit:%d rx_snr:%f", p->hop_limit, p->rx_snr);
-        startTransmitTimerRebroadcast(p);
+        startTransmitTimerSNR(p->rx_snr);
    }
 }

@@ -336,11 +336,11 @@ void RadioLibInterface::startTransmitTimer(bool withDelay)
    }
 }

-void RadioLibInterface::startTransmitTimerRebroadcast(meshtastic_MeshPacket *p)
+void RadioLibInterface::startTransmitTimerSNR(float snr)
 {
    // If we have work to do and the timer wasn't already scheduled, schedule it now
    if (!txQueue.empty()) {
-        uint32_t delay = getTxDelayMsecWeighted(p);
+        uint32_t delay = getTxDelayMsecWeighted(snr);
        notifyLater(delay, TRANSMIT_DELAY_COMPLETED, false); // This will implicitly enable
    }
 }
@@ -417,7 +417,7 @@ void RadioLibInterface::handleReceiveInterrupt()

    int state = iface->readData((uint8_t *)&radioBuffer, length);
 #if ARCH_PORTDUINO
-    if (portduino_config.logoutputlevel == level_trace) {
+    if (settingsMap[logoutputlevel] == level_trace) {
        printBytes("Raw incoming packet: ", (uint8_t *)&radioBuffer, length);
    }
 #endif
--- a/src/mesh/RadioLibInterface.h
+++ b/src/mesh/RadioLibInterface.h
@@ -161,7 +161,7 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     * timer scaled to SNR of to be flooded packet
     * @return Timestamp after which the packet may be sent
     */
-    void startTransmitTimerRebroadcast(meshtastic_MeshPacket *p);
+    void startTransmitTimerSNR(float snr);

    void handleTransmitInterrupt();
    void handleReceiveInterrupt();
--- a/src/mesh/Router.cpp
+++ b/src/mesh/Router.cpp
@@ -430,36 +430,6 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
            }
        }
    }
-
-#if HAS_UDP_MULTICAST
-    // Fallback: for UDP multicast, try default preset names with default PSK if normal channel match failed
-    if (!decrypted && p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP) {
-        if (channels.setDefaultPresetCryptoForHash(p->channel)) {
-            memcpy(bytes, p->encrypted.bytes, rawSize);
-            crypto->decrypt(p->from, p->id, rawSize, bytes);
-
-            meshtastic_Data decodedtmp;
-            memset(&decodedtmp, 0, sizeof(decodedtmp));
-            if (pb_decode_from_bytes(bytes, rawSize, &meshtastic_Data_msg, &decodedtmp) &&
-                decodedtmp.portnum != meshtastic_PortNum_UNKNOWN_APP) {
-                p->decoded = decodedtmp;
-                p->which_payload_variant = meshtastic_MeshPacket_decoded_tag;
-                // Map to our local default channel index (name+PSK default), not necessarily primary
-                ChannelIndex defaultIndex = channels.getPrimaryIndex();
-                for (ChannelIndex i = 0; i < channels.getNumChannels(); ++i) {
-                    if (channels.isDefaultChannel(i)) {
-                        defaultIndex = i;
-                        break;
-                    }
-                }
-                chIndex = defaultIndex;
-                decrypted = true;
-            } else {
-                LOG_WARN("UDP fallback decode attempted but failed for hash 0x%x", p->channel);
-            }
-        }
-    }
-#endif
    if (decrypted) {
        // parsing was successful
        p->channel = chIndex; // change to store the index instead of the hash
@@ -490,7 +460,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
 #if ENABLE_JSON_LOGGING
        LOG_TRACE("%s", MeshPacketSerializer::JsonSerialize(p, false).c_str());
 #elif ARCH_PORTDUINO
-        if (portduino_config.traceFilename != "" || portduino_config.logoutputlevel == level_trace) {
+        if (settingsStrings[traceFilename] != "" || settingsMap[logoutputlevel] == level_trace) {
            LOG_TRACE("%s", MeshPacketSerializer::JsonSerialize(p, false).c_str());
        }
 #endif
@@ -730,7 +700,7 @@ void Router::perhapsHandleReceived(meshtastic_MeshPacket *p)
    LOG_TRACE("%s", MeshPacketSerializer::JsonSerializeEncrypted(p).c_str());
 #elif ARCH_PORTDUINO
    // Even ignored packets get logged in the trace
-    if (portduino_config.traceFilename != "" || portduino_config.logoutputlevel == level_trace) {
+    if (settingsStrings[traceFilename] != "" || settingsMap[logoutputlevel] == level_trace) {
        p->rx_time = getValidTime(RTCQualityFromNet); // store the arrival timestamp for the phone
        LOG_TRACE("%s", MeshPacketSerializer::JsonSerializeEncrypted(p).c_str());
    }
--- a/src/mesh/SX126xInterface.cpp
+++ b/src/mesh/SX126xInterface.cpp
@@ -12,7 +12,7 @@
 // Particular boards might define a different max power based on what their hardware can do, default to max power output if not
 // specified (may be dangerous if using external PA and SX126x power config forgotten)
 #if ARCH_PORTDUINO
-#define SX126X_MAX_POWER portduino_config.sx126x_max_power
+#define SX126X_MAX_POWER settingsMap[sx126x_max_power]
 #endif
 #ifndef SX126X_MAX_POWER
 #define SX126X_MAX_POWER 22
@@ -53,10 +53,10 @@ template <typename T> bool SX126xInterface<T>::init()
 #endif

 #if ARCH_PORTDUINO
-    tcxoVoltage = (float)portduino_config.dio3_tcxo_voltage / 1000;
-    if (portduino_config.lora_sx126x_ant_sw_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_sx126x_ant_sw_pin.pin, HIGH);
-        pinMode(portduino_config.lora_sx126x_ant_sw_pin.pin, OUTPUT);
+    tcxoVoltage = (float)settingsMap[dio3_tcxo_voltage] / 1000;
+    if (settingsMap[sx126x_ant_sw_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[sx126x_ant_sw_pin], HIGH);
+        pinMode(settingsMap[sx126x_ant_sw_pin], OUTPUT);
    }
 #endif
    if (tcxoVoltage == 0.0)
@@ -98,7 +98,7 @@ template <typename T> bool SX126xInterface<T>::init()
        bool dio2AsRfSwitch = true;
 #elif defined(ARCH_PORTDUINO)
        bool dio2AsRfSwitch = false;
-        if (portduino_config.dio2_as_rf_switch) {
+        if (settingsMap[dio2_as_rf_switch]) {
            dio2AsRfSwitch = true;
        }
 #else
@@ -112,9 +112,9 @@ template <typename T> bool SX126xInterface<T>::init()
    // no effect
 #if ARCH_PORTDUINO
    if (res == RADIOLIB_ERR_NONE) {
-        LOG_DEBUG("Use MCU pin %i as RXEN and pin %i as TXEN to control RF switching", portduino_config.lora_rxen_pin.pin,
-                  portduino_config.lora_txen_pin.pin);
-        lora.setRfSwitchPins(portduino_config.lora_rxen_pin.pin, portduino_config.lora_txen_pin.pin);
+        LOG_DEBUG("Use MCU pin %i as RXEN and pin %i as TXEN to control RF switching", settingsMap[rxen_pin],
+                  settingsMap[txen_pin]);
+        lora.setRfSwitchPins(settingsMap[rxen_pin], settingsMap[txen_pin]);
    }
 #else
 #ifndef SX126X_RXEN
--- a/src/mesh/SX128xInterface.cpp
+++ b/src/mesh/SX128xInterface.cpp
@@ -11,7 +11,7 @@

 // Particular boards might define a different max power based on what their hardware can do
 #if ARCH_PORTDUINO
-#define SX128X_MAX_POWER portduino_config.sx128x_max_power
+#define SX128X_MAX_POWER settingsMap[sx128x_max_power]
 #endif
 #ifndef SX128X_MAX_POWER
 #define SX128X_MAX_POWER 13
@@ -41,13 +41,13 @@ template <typename T> bool SX128xInterface<T>::init()
 #endif

 #if ARCH_PORTDUINO
-    if (portduino_config.lora_rxen_pin.pin != RADIOLIB_NC) {
-        pinMode(portduino_config.lora_rxen_pin.pin, OUTPUT);
-        digitalWrite(portduino_config.lora_rxen_pin.pin, LOW); // Set low before becoming an output
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        pinMode(settingsMap[rxen_pin], OUTPUT);
+        digitalWrite(settingsMap[rxen_pin], LOW); // Set low before becoming an output
    }
-    if (portduino_config.lora_txen_pin.pin != RADIOLIB_NC) {
-        pinMode(portduino_config.lora_txen_pin.pin, OUTPUT);
-        digitalWrite(portduino_config.lora_txen_pin.pin, LOW); // Set low before becoming an output
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        pinMode(settingsMap[txen_pin], OUTPUT);
+        digitalWrite(settingsMap[txen_pin], LOW); // Set low before becoming an output
    }
 #else
 #if defined(SX128X_RXEN) && (SX128X_RXEN != RADIOLIB_NC) // set not rx or tx mode
@@ -93,9 +93,8 @@ template <typename T> bool SX128xInterface<T>::init()
        lora.setRfSwitchPins(SX128X_RXEN, SX128X_TXEN);
    }
 #elif ARCH_PORTDUINO
-    if (res == RADIOLIB_ERR_NONE && portduino_config.lora_rxen_pin.pin != RADIOLIB_NC &&
-        portduino_config.lora_txen_pin.pin != RADIOLIB_NC) {
-        lora.setRfSwitchPins(portduino_config.lora_rxen_pin.pin, portduino_config.lora_txen_pin.pin);
+    if (res == RADIOLIB_ERR_NONE && settingsMap[rxen_pin] != RADIOLIB_NC && settingsMap[txen_pin] != RADIOLIB_NC) {
+        lora.setRfSwitchPins(settingsMap[rxen_pin], settingsMap[txen_pin]);
    }
 #endif

@@ -175,11 +174,11 @@ template <typename T> void SX128xInterface<T>::setStandby()
        LOG_ERROR("SX128x standby %s%d", radioLibErr, err);
    assert(err == RADIOLIB_ERR_NONE);
 #if ARCH_PORTDUINO
-    if (portduino_config.lora_rxen_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_rxen_pin.pin, LOW);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[rxen_pin], LOW);
    }
-    if (portduino_config.lora_txen_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_txen_pin.pin, LOW);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[txen_pin], LOW);
    }
 #else
 #if defined(SX128X_RXEN) && (SX128X_RXEN != RADIOLIB_NC) // we have RXEN/TXEN control - turn off RX and TX power
@@ -211,11 +210,11 @@ template <typename T> void SX128xInterface<T>::addReceiveMetadata(meshtastic_Mes
 template <typename T> void SX128xInterface<T>::configHardwareForSend()
 {
 #if ARCH_PORTDUINO
-    if (portduino_config.lora_txen_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_txen_pin.pin, HIGH);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[txen_pin], HIGH);
    }
-    if (portduino_config.lora_rxen_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_rxen_pin.pin, LOW);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[rxen_pin], LOW);
    }

 #else
@@ -242,11 +241,11 @@ template <typename T> void SX128xInterface<T>::startReceive()
    setStandby();

 #if ARCH_PORTDUINO
-    if (portduino_config.lora_rxen_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_rxen_pin.pin, HIGH);
+    if (settingsMap[rxen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[rxen_pin], HIGH);
    }
-    if (portduino_config.lora_txen_pin.pin != RADIOLIB_NC) {
-        digitalWrite(portduino_config.lora_txen_pin.pin, LOW);
+    if (settingsMap[txen_pin] != RADIOLIB_NC) {
+        digitalWrite(settingsMap[txen_pin], LOW);
    }

 #else
--- a/src/mesh/generated/meshtastic/config.pb.h
+++ b/src/mesh/generated/meshtastic/config.pb.h
@@ -173,10 +173,28 @@ typedef enum _meshtastic_Config_NetworkConfig_ProtocolFlags {
    meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST = 1
 } meshtastic_Config_NetworkConfig_ProtocolFlags;

-/* Deprecated in 2.7.4: Unused */
-typedef enum _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat {
-    meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_UNUSED = 0
-} meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat;
+/* How the GPS coordinates are displayed on the OLED screen. */
+typedef enum _meshtastic_Config_DisplayConfig_GpsCoordinateFormat {
+    /* GPS coordinates are displayed in the normal decimal degrees format:
+ DD.DDDDDD DDD.DDDDDD */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DEC = 0,
+    /* GPS coordinates are displayed in the degrees minutes seconds format:
+ DD°MM'SS"C DDD°MM'SS"C, where C is the compass point representing the locations quadrant */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DMS = 1,
+    /* Universal Transverse Mercator format:
+ ZZB EEEEEE NNNNNNN, where Z is zone, B is band, E is easting, N is northing */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_UTM = 2,
+    /* Military Grid Reference System format:
+ ZZB CD EEEEE NNNNN, where Z is zone, B is band, C is the east 100k square, D is the north 100k square,
+ E is easting, N is northing */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MGRS = 3,
+    /* Open Location Code (aka Plus Codes). */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OLC = 4,
+    /* Ordnance Survey Grid Reference (the National Grid System of the UK).
+ Format: AB EEEEE NNNNN, where A is the east 100k square, B is the north 100k square,
+ E is the easting, N is the northing */
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OSGR = 5
+} meshtastic_Config_DisplayConfig_GpsCoordinateFormat;

 /* Unit display preference */
 typedef enum _meshtastic_Config_DisplayConfig_DisplayUnits {
@@ -473,7 +491,7 @@ typedef struct _meshtastic_Config_DisplayConfig {
    uint32_t screen_on_secs;
    /* Deprecated in 2.7.4: Unused
 How the GPS coordinates are formatted on the OLED screen. */
-    meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat gps_format;
+    meshtastic_Config_DisplayConfig_GpsCoordinateFormat gps_format;
    /* Automatically toggles to the next page on the screen like a carousel, based the specified interval in seconds.
 Potentially useful for devices without user buttons. */
    uint32_t auto_screen_carousel_secs;
@@ -497,9 +515,6 @@ typedef struct _meshtastic_Config_DisplayConfig {
    /* If false (default), the device will display the time in 24-hour format on screen.
 If true, the device will display the time in 12-hour format on screen. */
    bool use_12h_clock;
-    /* If false (default), the device will use short names for various display screens.
- If true, node names will show in long format */
-    bool use_long_node_name;
 } meshtastic_Config_DisplayConfig;

 /* Lora Config */
@@ -663,9 +678,9 @@ extern "C" {
 #define _meshtastic_Config_NetworkConfig_ProtocolFlags_MAX meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST
 #define _meshtastic_Config_NetworkConfig_ProtocolFlags_ARRAYSIZE ((meshtastic_Config_NetworkConfig_ProtocolFlags)(meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST+1))

-#define _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_UNUSED
-#define _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MAX meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_UNUSED
-#define _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_ARRAYSIZE ((meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat)(meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_UNUSED+1))
+#define _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN meshtastic_Config_DisplayConfig_GpsCoordinateFormat_DEC
+#define _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MAX meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OSGR
+#define _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_ARRAYSIZE ((meshtastic_Config_DisplayConfig_GpsCoordinateFormat)(meshtastic_Config_DisplayConfig_GpsCoordinateFormat_OSGR+1))

 #define _meshtastic_Config_DisplayConfig_DisplayUnits_MIN meshtastic_Config_DisplayConfig_DisplayUnits_METRIC
 #define _meshtastic_Config_DisplayConfig_DisplayUnits_MAX meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL
@@ -706,7 +721,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_address_mode_ENUMTYPE meshtastic_Config_NetworkConfig_AddressMode


-#define meshtastic_Config_DisplayConfig_gps_format_ENUMTYPE meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat
+#define meshtastic_Config_DisplayConfig_gps_format_ENUMTYPE meshtastic_Config_DisplayConfig_GpsCoordinateFormat
 #define meshtastic_Config_DisplayConfig_units_ENUMTYPE meshtastic_Config_DisplayConfig_DisplayUnits
 #define meshtastic_Config_DisplayConfig_oled_ENUMTYPE meshtastic_Config_DisplayConfig_OledType
 #define meshtastic_Config_DisplayConfig_displaymode_ENUMTYPE meshtastic_Config_DisplayConfig_DisplayMode
@@ -727,7 +742,7 @@ extern "C" {
 #define meshtastic_Config_PowerConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, "", 0, 0}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
-#define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0, 0}
+#define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0}
 #define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_default {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
@@ -738,7 +753,7 @@ extern "C" {
 #define meshtastic_Config_PowerConfig_init_zero  {0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, "", 0, 0}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
-#define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0, 0}
+#define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0}
 #define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_zero {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
@@ -805,7 +820,6 @@ extern "C" {
 #define meshtastic_Config_DisplayConfig_wake_on_tap_or_motion_tag 10
 #define meshtastic_Config_DisplayConfig_compass_orientation_tag 11
 #define meshtastic_Config_DisplayConfig_use_12h_clock_tag 12
-#define meshtastic_Config_DisplayConfig_use_long_node_name_tag 13
 #define meshtastic_Config_LoRaConfig_use_preset_tag 1
 #define meshtastic_Config_LoRaConfig_modem_preset_tag 2
 #define meshtastic_Config_LoRaConfig_bandwidth_tag 3
@@ -951,8 +965,7 @@ X(a, STATIC,   SINGULAR, UENUM,    displaymode,       8) \
 X(a, STATIC,   SINGULAR, BOOL,     heading_bold,      9) \
 X(a, STATIC,   SINGULAR, BOOL,     wake_on_tap_or_motion,  10) \
 X(a, STATIC,   SINGULAR, UENUM,    compass_orientation,  11) \
-X(a, STATIC,   SINGULAR, BOOL,     use_12h_clock,    12) \
-X(a, STATIC,   SINGULAR, BOOL,     use_long_node_name,  13)
+X(a, STATIC,   SINGULAR, BOOL,     use_12h_clock,    12)
 #define meshtastic_Config_DisplayConfig_CALLBACK NULL
 #define meshtastic_Config_DisplayConfig_DEFAULT NULL

@@ -1030,7 +1043,7 @@ extern const pb_msgdesc_t meshtastic_Config_SessionkeyConfig_msg;
 #define MESHTASTIC_MESHTASTIC_CONFIG_PB_H_MAX_SIZE meshtastic_Config_size
 #define meshtastic_Config_BluetoothConfig_size   10
 #define meshtastic_Config_DeviceConfig_size      100
-#define meshtastic_Config_DisplayConfig_size     34
+#define meshtastic_Config_DisplayConfig_size     32
 #define meshtastic_Config_LoRaConfig_size        85
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     204
--- a/src/mesh/generated/meshtastic/device_ui.pb.cpp
+++ b/src/mesh/generated/meshtastic/device_ui.pb.cpp
@@ -28,5 +28,3 @@ PB_BIND(meshtastic_Map, meshtastic_Map, AUTO)



-
-
--- a/src/mesh/generated/meshtastic/device_ui.pb.h
+++ b/src/mesh/generated/meshtastic/device_ui.pb.h
@@ -74,32 +74,6 @@ typedef enum _meshtastic_Language {
    meshtastic_Language_TRADITIONAL_CHINESE = 31
 } meshtastic_Language;

-/* How the GPS coordinates are displayed on the OLED screen. */
-typedef enum _meshtastic_DeviceUIConfig_GpsCoordinateFormat {
-    /* GPS coordinates are displayed in the normal decimal degrees format:
- DD.DDDDDD DDD.DDDDDD */
-    meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC = 0,
-    /* GPS coordinates are displayed in the degrees minutes seconds format:
- DD°MM'SS"C DDD°MM'SS"C, where C is the compass point representing the locations quadrant */
-    meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS = 1,
-    /* Universal Transverse Mercator format:
- ZZB EEEEEE NNNNNNN, where Z is zone, B is band, E is easting, N is northing */
-    meshtastic_DeviceUIConfig_GpsCoordinateFormat_UTM = 2,
-    /* Military Grid Reference System format:
- ZZB CD EEEEE NNNNN, where Z is zone, B is band, C is the east 100k square, D is the north 100k square,
- E is easting, N is northing */
-    meshtastic_DeviceUIConfig_GpsCoordinateFormat_MGRS = 3,
-    /* Open Location Code (aka Plus Codes). */
-    meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC = 4,
-    /* Ordnance Survey Grid Reference (the National Grid System of the UK).
- Format: AB EEEEE NNNNN, where A is the east 100k square, B is the north 100k square,
- E is the easting, N is the northing */
-    meshtastic_DeviceUIConfig_GpsCoordinateFormat_OSGR = 5,
-    /* Maidenhead Locator System
- Described here: https://en.wikipedia.org/wiki/Maidenhead_Locator_System */
-    meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS = 6
-} meshtastic_DeviceUIConfig_GpsCoordinateFormat;
-
 /* Struct definitions */
 typedef struct _meshtastic_NodeFilter {
    /* Filter unknown nodes */
@@ -189,8 +163,6 @@ typedef struct _meshtastic_DeviceUIConfig {
    /* Clockface analog style
 true for analog clockface, false for digital clockface */
    bool is_clockface_analog;
-    /* How the GPS coordinates are formatted on the OLED screen. */
-    meshtastic_DeviceUIConfig_GpsCoordinateFormat gps_format;
 } meshtastic_DeviceUIConfig;


@@ -211,14 +183,9 @@ extern "C" {
 #define _meshtastic_Language_MAX meshtastic_Language_TRADITIONAL_CHINESE
 #define _meshtastic_Language_ARRAYSIZE ((meshtastic_Language)(meshtastic_Language_TRADITIONAL_CHINESE+1))

-#define _meshtastic_DeviceUIConfig_GpsCoordinateFormat_MIN meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC
-#define _meshtastic_DeviceUIConfig_GpsCoordinateFormat_MAX meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS
-#define _meshtastic_DeviceUIConfig_GpsCoordinateFormat_ARRAYSIZE ((meshtastic_DeviceUIConfig_GpsCoordinateFormat)(meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS+1))
-
 #define meshtastic_DeviceUIConfig_theme_ENUMTYPE meshtastic_Theme
 #define meshtastic_DeviceUIConfig_language_ENUMTYPE meshtastic_Language
 #define meshtastic_DeviceUIConfig_compass_mode_ENUMTYPE meshtastic_CompassMode
-#define meshtastic_DeviceUIConfig_gps_format_ENUMTYPE meshtastic_DeviceUIConfig_GpsCoordinateFormat



@@ -226,12 +193,12 @@ extern "C" {


 /* Initializer values for message structs */
-#define meshtastic_DeviceUIConfig_init_default   {0, 0, 0, 0, 0, 0, _meshtastic_Theme_MIN, 0, 0, 0, _meshtastic_Language_MIN, false, meshtastic_NodeFilter_init_default, false, meshtastic_NodeHighlight_init_default, {0, {0}}, false, meshtastic_Map_init_default, _meshtastic_CompassMode_MIN, 0, 0, _meshtastic_DeviceUIConfig_GpsCoordinateFormat_MIN}
+#define meshtastic_DeviceUIConfig_init_default   {0, 0, 0, 0, 0, 0, _meshtastic_Theme_MIN, 0, 0, 0, _meshtastic_Language_MIN, false, meshtastic_NodeFilter_init_default, false, meshtastic_NodeHighlight_init_default, {0, {0}}, false, meshtastic_Map_init_default, _meshtastic_CompassMode_MIN, 0, 0}
 #define meshtastic_NodeFilter_init_default       {0, 0, 0, 0, 0, "", 0}
 #define meshtastic_NodeHighlight_init_default    {0, 0, 0, 0, ""}
 #define meshtastic_GeoPoint_init_default         {0, 0, 0}
 #define meshtastic_Map_init_default              {false, meshtastic_GeoPoint_init_default, "", 0}
-#define meshtastic_DeviceUIConfig_init_zero      {0, 0, 0, 0, 0, 0, _meshtastic_Theme_MIN, 0, 0, 0, _meshtastic_Language_MIN, false, meshtastic_NodeFilter_init_zero, false, meshtastic_NodeHighlight_init_zero, {0, {0}}, false, meshtastic_Map_init_zero, _meshtastic_CompassMode_MIN, 0, 0, _meshtastic_DeviceUIConfig_GpsCoordinateFormat_MIN}
+#define meshtastic_DeviceUIConfig_init_zero      {0, 0, 0, 0, 0, 0, _meshtastic_Theme_MIN, 0, 0, 0, _meshtastic_Language_MIN, false, meshtastic_NodeFilter_init_zero, false, meshtastic_NodeHighlight_init_zero, {0, {0}}, false, meshtastic_Map_init_zero, _meshtastic_CompassMode_MIN, 0, 0}
 #define meshtastic_NodeFilter_init_zero          {0, 0, 0, 0, 0, "", 0}
 #define meshtastic_NodeHighlight_init_zero       {0, 0, 0, 0, ""}
 #define meshtastic_GeoPoint_init_zero            {0, 0, 0}
@@ -274,7 +241,6 @@ extern "C" {
 #define meshtastic_DeviceUIConfig_compass_mode_tag 16
 #define meshtastic_DeviceUIConfig_screen_rgb_color_tag 17
 #define meshtastic_DeviceUIConfig_is_clockface_analog_tag 18
-#define meshtastic_DeviceUIConfig_gps_format_tag 19

 /* Struct field encoding specification for nanopb */
 #define meshtastic_DeviceUIConfig_FIELDLIST(X, a) \
@@ -295,8 +261,7 @@ X(a, STATIC,   SINGULAR, BYTES,    calibration_data,  14) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  map_data,         15) \
 X(a, STATIC,   SINGULAR, UENUM,    compass_mode,     16) \
 X(a, STATIC,   SINGULAR, UINT32,   screen_rgb_color,  17) \
-X(a, STATIC,   SINGULAR, BOOL,     is_clockface_analog,  18) \
-X(a, STATIC,   SINGULAR, UENUM,    gps_format,       19)
+X(a, STATIC,   SINGULAR, BOOL,     is_clockface_analog,  18)
 #define meshtastic_DeviceUIConfig_CALLBACK NULL
 #define meshtastic_DeviceUIConfig_DEFAULT NULL
 #define meshtastic_DeviceUIConfig_node_filter_MSGTYPE meshtastic_NodeFilter
@@ -353,7 +318,7 @@ extern const pb_msgdesc_t meshtastic_Map_msg;

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_DEVICE_UI_PB_H_MAX_SIZE meshtastic_DeviceUIConfig_size
-#define meshtastic_DeviceUIConfig_size           204
+#define meshtastic_DeviceUIConfig_size           201
 #define meshtastic_GeoPoint_size                 33
 #define meshtastic_Map_size                      58
 #define meshtastic_NodeFilter_size               47
--- a/src/mesh/generated/meshtastic/deviceonly.pb.h
+++ b/src/mesh/generated/meshtastic/deviceonly.pb.h
@@ -360,7 +360,7 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 /* Maximum encoded size of messages (where known) */
 /* meshtastic_NodeDatabase_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
-#define meshtastic_BackupPreferences_size        2277
+#define meshtastic_BackupPreferences_size        2273
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_DeviceState_size              1737
 #define meshtastic_NodeInfoLite_size             196
--- a/src/mesh/generated/meshtastic/localonly.pb.h
+++ b/src/mesh/generated/meshtastic/localonly.pb.h
@@ -187,8 +187,8 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalConfig_size
-#define meshtastic_LocalConfig_size              749
-#define meshtastic_LocalModuleConfig_size        673
+#define meshtastic_LocalConfig_size              747
+#define meshtastic_LocalModuleConfig_size        671

 #ifdef __cplusplus
 } /* extern "C" */
--- a/src/mesh/generated/meshtastic/mesh.pb.h
+++ b/src/mesh/generated/meshtastic/mesh.pb.h
@@ -276,8 +276,6 @@ typedef enum _meshtastic_HardwareModel {
    meshtastic_HardwareModel_HELTEC_V4 = 110,
    /* M5Stack C6L */
    meshtastic_HardwareModel_M5STACK_C6L = 111,
-    /* M5Stack Cardputer Adv */
-    meshtastic_HardwareModel_M5STACK_CARDPUTER_ADV = 112,
    /* ------------------------------------------------------------------------------------------------------------------------------------------
 Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
 ------------------------------------------------------------------------------------------------------------------------------------------ */
--- a/src/mesh/generated/meshtastic/module_config.pb.h
+++ b/src/mesh/generated/meshtastic/module_config.pb.h
@@ -356,9 +356,6 @@ typedef struct _meshtastic_ModuleConfig_TelemetryConfig {
    uint32_t health_update_interval;
    /* Enable/Disable the health telemetry module on-device display */
    bool health_screen_enabled;
-    /* Enable/Disable the device telemetry module to send metrics to the mesh
- Note: We will still send telemtry to the connected phone / client every minute over the API */
-    bool device_telemetry_enabled;
 } meshtastic_ModuleConfig_TelemetryConfig;

 /* Canned Messages Module Config */
@@ -526,7 +523,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_StoreForwardConfig_init_default {0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_RangeTestConfig_init_default {0, 0, 0, 0}
-#define meshtastic_ModuleConfig_TelemetryConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_TelemetryConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_CannedMessageConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, 0, 0, "", 0}
 #define meshtastic_ModuleConfig_AmbientLightingConfig_init_default {0, 0, 0, 0, 0}
 #define meshtastic_RemoteHardwarePin_init_default {0, "", _meshtastic_RemoteHardwarePinType_MIN}
@@ -542,7 +539,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_StoreForwardConfig_init_zero {0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_RangeTestConfig_init_zero {0, 0, 0, 0}
-#define meshtastic_ModuleConfig_TelemetryConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_TelemetryConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_CannedMessageConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, _meshtastic_ModuleConfig_CannedMessageConfig_InputEventChar_MIN, 0, 0, "", 0}
 #define meshtastic_ModuleConfig_AmbientLightingConfig_init_zero {0, 0, 0, 0, 0}
 #define meshtastic_RemoteHardwarePin_init_zero   {0, "", _meshtastic_RemoteHardwarePinType_MIN}
@@ -630,7 +627,6 @@ extern "C" {
 #define meshtastic_ModuleConfig_TelemetryConfig_health_measurement_enabled_tag 11
 #define meshtastic_ModuleConfig_TelemetryConfig_health_update_interval_tag 12
 #define meshtastic_ModuleConfig_TelemetryConfig_health_screen_enabled_tag 13
-#define meshtastic_ModuleConfig_TelemetryConfig_device_telemetry_enabled_tag 14
 #define meshtastic_ModuleConfig_CannedMessageConfig_rotary1_enabled_tag 1
 #define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_pin_a_tag 2
 #define meshtastic_ModuleConfig_CannedMessageConfig_inputbroker_pin_b_tag 3
@@ -829,8 +825,7 @@ X(a, STATIC,   SINGULAR, UINT32,   power_update_interval,   9) \
 X(a, STATIC,   SINGULAR, BOOL,     power_screen_enabled,  10) \
 X(a, STATIC,   SINGULAR, BOOL,     health_measurement_enabled,  11) \
 X(a, STATIC,   SINGULAR, UINT32,   health_update_interval,  12) \
-X(a, STATIC,   SINGULAR, BOOL,     health_screen_enabled,  13) \
-X(a, STATIC,   SINGULAR, BOOL,     device_telemetry_enabled,  14)
+X(a, STATIC,   SINGULAR, BOOL,     health_screen_enabled,  13)
 #define meshtastic_ModuleConfig_TelemetryConfig_CALLBACK NULL
 #define meshtastic_ModuleConfig_TelemetryConfig_DEFAULT NULL

@@ -915,7 +910,7 @@ extern const pb_msgdesc_t meshtastic_RemoteHardwarePin_msg;
 #define meshtastic_ModuleConfig_RemoteHardwareConfig_size 96
 #define meshtastic_ModuleConfig_SerialConfig_size 28
 #define meshtastic_ModuleConfig_StoreForwardConfig_size 24
-#define meshtastic_ModuleConfig_TelemetryConfig_size 48
+#define meshtastic_ModuleConfig_TelemetryConfig_size 46
 #define meshtastic_ModuleConfig_size             227
 #define meshtastic_RemoteHardwarePin_size        21

--- a/src/mesh/raspihttp/PiWebServer.cpp
+++ b/src/mesh/raspihttp/PiWebServer.cpp
@@ -65,8 +65,8 @@ mail:   marchammermann@googlemail.com
 #define DEFAULT_REALM "default_realm"
 #define PREFIX ""

-#define KEY_PATH portduino_config.webserver_ssl_key_path.c_str()
-#define CERT_PATH portduino_config.webserver_ssl_cert_path.c_str()
+#define KEY_PATH settingsStrings[websslkeypath].c_str()
+#define CERT_PATH settingsStrings[websslcertpath].c_str()

 struct _file_config configWeb;

@@ -458,8 +458,8 @@ PiWebServerThread::PiWebServerThread()
        }
    }

-    if (portduino_config.webserverport != 0) {
-        webservport = portduino_config.webserverport;
+    if (settingsMap[webserverport] != 0) {
+        webservport = settingsMap[webserverport];
        LOG_INFO("Use webserver port from yaml config %i ", webservport);
    } else {
        LOG_INFO("Webserver port in yaml config set to 0, defaulting to port 9443");
@@ -490,7 +490,7 @@ PiWebServerThread::PiWebServerThread()
        u_map_put(&configWeb.mime_types, ".ico", "image/x-icon");
        u_map_put(&configWeb.mime_types, ".svg", "image/svg+xml");

-        webrootpath = portduino_config.webserver_root_path;
+        webrootpath = settingsStrings[webserverrootpath];

        configWeb.files_path = (char *)webrootpath.c_str();
        configWeb.url_prefix = "";
--- a/src/mesh/udp/UdpMulticastHandler.h
+++ b/src/mesh/udp/UdpMulticastHandler.h
@@ -50,10 +50,10 @@ class UdpMulticastHandler final
        LOG_DEBUG("UDP broadcast from: %s, len=%u", packet.remoteIP().toString().c_str(), packetLength);
 #endif
        meshtastic_MeshPacket mp;
+        mp.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP;
        LOG_DEBUG("Decoding MeshPacket from UDP len=%u", packetLength);
        bool isPacketDecoded = pb_decode_from_bytes(packet.data(), packetLength, &meshtastic_MeshPacket_msg, &mp);
        if (isPacketDecoded && router && mp.which_payload_variant == meshtastic_MeshPacket_encrypted_tag) {
-            mp.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP;
            mp.pki_encrypted = false;
            mp.public_key.size = 0;
            memset(mp.public_key.bytes, 0, sizeof(mp.public_key.bytes));
--- a/src/modules/AdminModule.cpp
+++ b/src/modules/AdminModule.cpp
@@ -104,10 +104,6 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
            (config.security.admin_key[2].size == 32 &&
             memcmp(mp.public_key.bytes, config.security.admin_key[2].bytes, 32) == 0)) {
            LOG_INFO("PKC admin payload with authorized sender key");
-            auto remoteNode = nodeDB->getMeshNode(mp.from);
-            if (remoteNode && !remoteNode->is_favorite) {
-                remoteNode->is_favorite = true;
-            }
        } else {
            myReply = allocErrorResponse(meshtastic_Routing_Error_ADMIN_PUBLIC_KEY_UNAUTHORIZED, &mp);
            LOG_INFO("Received PKC admin payload, but the sender public key does not match the admin authorized key!");
--- a/src/modules/CannedMessageModule.cpp
+++ b/src/modules/CannedMessageModule.cpp
@@ -394,14 +394,14 @@ bool CannedMessageModule::isUpEvent(const InputEvent *event)
    return event->inputEvent == INPUT_BROKER_UP ||
           ((runState == CANNED_MESSAGE_RUN_STATE_ACTIVE || runState == CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER ||
             runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) &&
-            (event->inputEvent == INPUT_BROKER_LEFT || event->inputEvent == INPUT_BROKER_ALT_PRESS));
+            event->inputEvent == INPUT_BROKER_ALT_PRESS);
 }
 bool CannedMessageModule::isDownEvent(const InputEvent *event)
 {
    return event->inputEvent == INPUT_BROKER_DOWN ||
           ((runState == CANNED_MESSAGE_RUN_STATE_ACTIVE || runState == CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER ||
             runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) &&
-            (event->inputEvent == INPUT_BROKER_RIGHT || event->inputEvent == INPUT_BROKER_USER_PRESS));
+            event->inputEvent == INPUT_BROKER_USER_PRESS);
 }
 bool CannedMessageModule::isSelectEvent(const InputEvent *event)
 {
--- a/src/modules/Modules.cpp
+++ b/src/modules/Modules.cpp
@@ -174,7 +174,7 @@ void setupModules()
 #endif
        // Example: Put your module here
        // new ReplyModule();
-#if (HAS_BUTTON || ARCH_PORTDUINO) && !MESHTASTIC_EXCLUDE_INPUTBROKER
+#if (HAS_BUTTON || ARCH_PORTDUINO) && !MESHTASTIC_EXCLUDE_INPUTBROKER && !MESHTASTIC_EXCLUDE_I2C
        if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
            rotaryEncoderInterruptImpl1 = new RotaryEncoderInterruptImpl1();
            if (!rotaryEncoderInterruptImpl1->init()) {
--- a/src/modules/Telemetry/EnvironmentTelemetry.cpp
+++ b/src/modules/Telemetry/EnvironmentTelemetry.cpp
@@ -30,8 +30,7 @@

 namespace graphics
 {
-extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr, bool force_no_invert,
-                             bool show_date);
+extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr, bool battery_only);
 }
 #if __has_include(<Adafruit_AHTX0.h>)
 #include "Sensor/AHT10.h"
--- a/src/modules/Telemetry/HostMetrics.cpp
+++ b/src/modules/Telemetry/HostMetrics.cpp
@@ -9,11 +9,11 @@
 int32_t HostMetricsModule::runOnce()
 {
 #if ARCH_PORTDUINO
-    if (portduino_config.hostMetrics_interval == 0) {
+    if (settingsMap[hostMetrics_interval] == 0) {
        return disable();
    } else {
        sendMetrics();
-        return 60 * 1000 * portduino_config.hostMetrics_interval;
+        return 60 * 1000 * settingsMap[hostMetrics_interval];
    }
 #else
    return disable();
@@ -110,8 +110,8 @@ meshtastic_Telemetry HostMetricsModule::getHostMetrics()
            proc_loadavg.close();
        }
    }
-    if (portduino_config.hostMetrics_user_command != "") {
-        std::string userCommandResult = exec(portduino_config.hostMetrics_user_command.c_str());
+    if (settingsStrings[hostMetrics_user_command] != "") {
+        std::string userCommandResult = exec(settingsStrings[hostMetrics_user_command].c_str());
        if (userCommandResult.length() > 1) {
            strncpy(t.variant.host_metrics.user_string, userCommandResult.c_str(), sizeof(t.variant.host_metrics.user_string));
            t.variant.host_metrics.user_string[sizeof(t.variant.host_metrics.user_string) - 1] = '\0';
@@ -135,7 +135,7 @@ bool HostMetricsModule::sendMetrics()
    p->to = NODENUM_BROADCAST;
    p->decoded.want_response = false;
    p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
-    p->channel = portduino_config.hostMetrics_channel;
+    p->channel = settingsMap[hostMetrics_channel];
    LOG_INFO("Send packet to mesh");
    service->sendToMesh(p, RX_SRC_LOCAL, true);
    return true;
--- a/src/modules/Telemetry/PowerTelemetry.cpp
+++ b/src/modules/Telemetry/PowerTelemetry.cpp
@@ -24,8 +24,7 @@

 namespace graphics
 {
-extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr, bool force_no_invert,
-                             bool show_date);
+extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr, bool battery_only);
 }

 int32_t PowerTelemetryModule::runOnce()
--- a/src/modules/esp32/PaxcounterModule.cpp
+++ b/src/modules/esp32/PaxcounterModule.cpp
@@ -90,8 +90,6 @@ int32_t PaxcounterModule::runOnce()
            configuration.blecounter = 1;
            configuration.blescantime = 0; // infinite
            configuration.wificounter = 1;
-            configuration.wifi_channel_map = WIFI_CHANNEL_ALL;
-            configuration.wifi_channel_switch_interval = 50;
            configuration.wifi_rssi_threshold = Default::getConfiguredOrDefault(moduleConfig.paxcounter.wifi_threshold, -80);
            configuration.ble_rssi_threshold = Default::getConfiguredOrDefault(moduleConfig.paxcounter.ble_threshold, -80);
            libpax_update_config(&configuration);
--- a/src/nimble/NimbleBluetooth.cpp
+++ b/src/nimble/NimbleBluetooth.cpp
@@ -231,10 +231,6 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
    {
        LOG_INFO("BLE disconnect");
 #endif
-#ifdef NIMBLE_TWO
-        if (ble->isDeInit)
-            return;
-#endif

        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
        bluetoothStatus->updateStatus(&newStatus);
@@ -274,7 +270,6 @@ void NimbleBluetooth::deinit()
 {
 #ifdef ARCH_ESP32
    LOG_INFO("Disable bluetooth until reboot");
-    isDeInit = true;

 #ifdef BLE_LED
 #ifdef BLE_LED_INVERTED
@@ -283,10 +278,8 @@ void NimbleBluetooth::deinit()
    digitalWrite(BLE_LED, LOW);
 #endif
 #endif
-#ifndef NIMBLE_TWO
    NimBLEDevice::deinit();
 #endif
-#endif
 }

 // Has initial setup been completed
--- a/src/nimble/NimbleBluetooth.h
+++ b/src/nimble/NimbleBluetooth.h
@@ -15,7 +15,6 @@ class NimbleBluetooth : BluetoothApi
 #if defined(NIMBLE_TWO)
    void startAdvertising();
 #endif
-    bool isDeInit = false;

  private:
    void setupService();
--- a/src/platform/esp32/main-esp32.cpp
+++ b/src/platform/esp32/main-esp32.cpp
@@ -169,9 +169,10 @@ void esp32Setup()
 // #define APP_WATCHDOG_SECS 45
 #define APP_WATCHDOG_SECS 90

-#ifdef CONFIG_IDF_TARGET_ESP32C6
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
    esp_task_wdt_config_t *wdt_config = (esp_task_wdt_config_t *)malloc(sizeof(esp_task_wdt_config_t));
    wdt_config->timeout_ms = APP_WATCHDOG_SECS * 1000;
+    wdt_config->idle_core_mask = 1 << 1;
    wdt_config->trigger_panic = true;
    res = esp_task_wdt_init(wdt_config);
    assert(res == ESP_OK);
--- a/src/platform/portduino/PortduinoGlue.cpp
+++ b/src/platform/portduino/PortduinoGlue.cpp
@@ -9,6 +9,7 @@
 #include "api/ServerAPI.h"
 #include "linux/gpio/LinuxGPIOPin.h"
 #include "meshUtils.h"
+#include "yaml-cpp/yaml.h"
 #include <ErriezCRC32.h>
 #include <Utility.h>
 #include <assert.h>
@@ -27,13 +28,14 @@

 #include "platform/portduino/USBHal.h"

+std::map<configNames, int> settingsMap;
+std::map<configNames, std::string> settingsStrings;
 portduino_config_struct portduino_config;
 std::ofstream traceFile;
 Ch341Hal *ch341Hal = nullptr;
 char *configPath = nullptr;
 char *optionMac = nullptr;
 bool verboseEnabled = false;
-bool yamlOnly = false;

 const char *argp_program_version = optstr(APP_VERSION);

@@ -73,9 +75,6 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state)
    case 'v':
        verboseEnabled = true;
        break;
-    case 'y':
-        yamlOnly = true;
-        break;
    case ARGP_KEY_ARG:
        return 0;
    default:
@@ -91,7 +90,6 @@ void portduinoCustomInit()
                                           {"hwid", 'h', "HWID", 0, "The mac address to assign to this virtual machine"},
                                           {"sim", 's', 0, 0, "Run in Simulated radio mode"},
                                           {"verbose", 'v', 0, 0, "Set log level to full debug"},
-                                           {"output-yaml", 'y', 0, 0, "Output config yaml and exit"},
                                           {0}};
    static void *childArguments;
    static char doc[] = "Meshtastic native build.";
@@ -117,8 +115,8 @@ void getMacAddr(uint8_t *dmac)
            dmac[4] = hwId >> 8;
            dmac[5] = hwId & 0xff;
        }
-    } else if (portduino_config.mac_address.length() > 11) {
-        MAC_from_string(portduino_config.mac_address, dmac);
+    } else if (settingsStrings[mac_address].length() > 11) {
+        MAC_from_string(settingsStrings[mac_address], dmac);
        exit;
    } else {

@@ -150,46 +148,89 @@ void getMacAddr(uint8_t *dmac)
 */
 void portduinoSetup()
 {
+    printf("Set up Meshtastic on Portduino...\n");
    int max_GPIO = 0;
+    const configNames GPIO_lines[] = {cs_pin,
+                                      irq_pin,
+                                      busy_pin,
+                                      reset_pin,
+                                      sx126x_ant_sw_pin,
+                                      txen_pin,
+                                      rxen_pin,
+                                      displayDC,
+                                      displayCS,
+                                      displayBacklight,
+                                      displayBacklightPWMChannel,
+                                      displayReset,
+                                      touchscreenCS,
+                                      touchscreenIRQ,
+                                      userButtonPin,
+                                      tbUpPin,
+                                      tbDownPin,
+                                      tbLeftPin,
+                                      tbRightPin,
+                                      tbPressPin};
+
    std::string gpioChipName = "gpiochip";
-    portduino_config.displayPanel = no_screen;
+    settingsStrings[i2cdev] = "";
+    settingsStrings[keyboardDevice] = "";
+    settingsStrings[pointerDevice] = "";
+    settingsStrings[webserverrootpath] = "";
+    settingsStrings[spidev] = "";
+    settingsStrings[displayspidev] = "";
+    settingsMap[spiSpeed] = 2000000;
+    settingsMap[ascii_logs] = !isatty(1);
+    settingsMap[displayPanel] = no_screen;
+    settingsMap[touchscreenModule] = no_touchscreen;
+    settingsMap[tbUpPin] = RADIOLIB_NC;
+    settingsMap[tbDownPin] = RADIOLIB_NC;
+    settingsMap[tbLeftPin] = RADIOLIB_NC;
+    settingsMap[tbRightPin] = RADIOLIB_NC;
+    settingsMap[tbPressPin] = RADIOLIB_NC;
+
+    YAML::Node yamlConfig;

    if (portduino_config.force_simradio == true) {
-        portduino_config.lora_module = use_simradio;
+        settingsMap[use_simradio] = true;
    } else if (configPath != nullptr) {
        if (loadConfig(configPath)) {
-            if (!yamlOnly)
-                std::cout << "Using " << configPath << " as config file" << std::endl;
+            std::cout << "Using " << configPath << " as config file" << std::endl;
        } else {
            std::cout << "Unable to use " << configPath << " as config file" << std::endl;
            exit(EXIT_FAILURE);
        }
    } else if (access("config.yaml", R_OK) == 0) {
        if (loadConfig("config.yaml")) {
-            if (!yamlOnly)
-                std::cout << "Using local config.yaml as config file" << std::endl;
+            std::cout << "Using local config.yaml as config file" << std::endl;
        } else {
            std::cout << "Unable to use local config.yaml as config file" << std::endl;
            exit(EXIT_FAILURE);
        }
    } else if (access("/etc/meshtasticd/config.yaml", R_OK) == 0) {
        if (loadConfig("/etc/meshtasticd/config.yaml")) {
-            if (!yamlOnly)
-                std::cout << "Using /etc/meshtasticd/config.yaml as config file" << std::endl;
+            std::cout << "Using /etc/meshtasticd/config.yaml as config file" << std::endl;
        } else {
            std::cout << "Unable to use /etc/meshtasticd/config.yaml as config file" << std::endl;
            exit(EXIT_FAILURE);
        }
    } else {
-        if (!yamlOnly)
-            std::cout << "No 'config.yaml' found..." << std::endl;
-        portduino_config.lora_module = use_simradio;
+        std::cout << "No 'config.yaml' found..." << std::endl;
+        settingsMap[use_simradio] = true;
    }

-    if (portduino_config.config_directory != "") {
+    if (settingsMap[use_simradio] == true) {
+        std::cout << "Running in simulated mode." << std::endl;
+        settingsMap[maxnodes] = 200;               // Default to 200 nodes
+        settingsMap[logoutputlevel] = level_debug; // Default to debug
+        // Set the random seed equal to TCPPort to have a different seed per instance
+        randomSeed(TCPPort);
+        return;
+    }
+
+    if (settingsStrings[config_directory] != "") {
        std::string filetype = ".yaml";
        for (const std::filesystem::directory_entry &entry :
-             std::filesystem::directory_iterator{portduino_config.config_directory}) {
+             std::filesystem::directory_iterator{settingsStrings[config_directory]}) {
            if (ends_with(entry.path().string(), ".yaml")) {
                std::cout << "Also using " << entry << " as additional config file" << std::endl;
                loadConfig(entry.path().c_str());
@@ -197,28 +238,15 @@ void portduinoSetup()
        }
    }

-    if (yamlOnly) {
-        std::cout << portduino_config.emit_yaml() << std::endl;
-        exit(EXIT_SUCCESS);
-    }
-
-    if (portduino_config.lora_module == use_simradio) {
-        std::cout << "Running in simulated mode." << std::endl;
-        portduino_config.MaxNodes = 200; // Default to 200 nodes
-        // Set the random seed equal to TCPPort to have a different seed per instance
-        randomSeed(TCPPort);
-        return;
-    }
-
    // If LoRa `Module: auto` (default in config.yaml),
    // attempt to auto config based on Product Strings
-    if (portduino_config.lora_module == use_autoconf) {
+    if (settingsMap[use_autoconf] == true) {
        char autoconf_product[96] = {0};
        // Try CH341
        try {
            std::cout << "autoconf: Looking for CH341 device..." << std::endl;
-            ch341Hal = new Ch341Hal(0, portduino_config.lora_usb_serial_num, portduino_config.lora_usb_vid,
-                                    portduino_config.lora_usb_pid);
+            ch341Hal =
+                new Ch341Hal(0, settingsStrings[lora_usb_serial_num], settingsMap[lora_usb_vid], settingsMap[lora_usb_pid]);
            ch341Hal->getProductString(autoconf_product, 95);
            delete ch341Hal;
            std::cout << "autoconf: Found CH341 device " << autoconf_product << std::endl;
@@ -295,7 +323,7 @@ void portduinoSetup()
                        if (mac_start != nullptr) {
                            std::cout << "autoconf: Found mac data " << mac_start << std::endl;
                            if (strlen(mac_start) == 12)
-                                portduino_config.mac_address = std::string(mac_start);
+                                settingsStrings[mac_address] = std::string(mac_start);
                        }
                        if (devID_start != nullptr) {
                            std::cout << "autoconf: Found deviceid data " << devID_start << std::endl;
@@ -326,7 +354,7 @@ void portduinoSetup()
                std::cerr << "autoconf: Unable to find config for " << autoconf_product << std::endl;
                exit(EXIT_FAILURE);
            }
-            if (loadConfig((portduino_config.available_directory + product_config).c_str())) {
+            if (loadConfig((settingsStrings[available_directory] + product_config).c_str())) {
                std::cout << "autoconf: Using " << product_config << " as config file for " << autoconf_product << std::endl;
            } else {
                std::cerr << "autoconf: Unable to use " << product_config << " as config file for " << autoconf_product
@@ -335,16 +363,15 @@ void portduinoSetup()
            }
        } else {
            std::cerr << "autoconf: Could not locate any devices" << std::endl;
-            exit(EXIT_FAILURE);
        }
    }

    // if we're using a usermode driver, we need to initialize it here, to get a serial number back for mac address
    uint8_t dmac[6] = {0};
-    if (portduino_config.lora_spi_dev == "ch341") {
+    if (settingsStrings[spidev] == "ch341") {
        try {
-            ch341Hal = new Ch341Hal(0, portduino_config.lora_usb_serial_num, portduino_config.lora_usb_vid,
-                                    portduino_config.lora_usb_pid);
+            ch341Hal =
+                new Ch341Hal(0, settingsStrings[lora_usb_serial_num], settingsMap[lora_usb_vid], settingsMap[lora_usb_pid]);
        } catch (std::exception &e) {
            std::cerr << e.what() << std::endl;
            std::cerr << "Could not initialize CH341 device!" << std::endl;
@@ -356,7 +383,7 @@ void portduinoSetup()
        char product_string[96] = {0};
        ch341Hal->getProductString(product_string, 95);
        std::cout << "CH341 Product " << product_string << std::endl;
-        if (strlen(serial) == 8 && portduino_config.mac_address.length() < 12) {
+        if (strlen(serial) == 8 && settingsStrings[mac_address].length() < 12) {
            uint8_t hash[32] = {0};
            memcpy(hash, serial, 8);
            crypto->hash(hash, 8);
@@ -368,7 +395,7 @@ void portduinoSetup()
            dmac[5] = hash[5];
            char macBuf[13] = {0};
            sprintf(macBuf, "%02X%02X%02X%02X%02X%02X", dmac[0], dmac[1], dmac[2], dmac[3], dmac[4], dmac[5]);
-            portduino_config.mac_address = macBuf;
+            settingsStrings[mac_address] = macBuf;
        }
    }

@@ -382,38 +409,100 @@ void portduinoSetup()
    // Rather important to set this, if not running simulated.
    randomSeed(time(NULL));

-    std::string defaultGpioChipName = gpioChipName + std::to_string(portduino_config.lora_default_gpiochip);
-    for (auto i : portduino_config.all_pins) {
-        if (i->enabled && i->pin > max_GPIO)
-            max_GPIO = i->pin;
+    std::string defaultGpioChipName = gpioChipName + std::to_string(settingsMap[default_gpiochip]);
+
+    for (configNames i : GPIO_lines) {
+        if (settingsMap.count(i) && settingsMap[i] > max_GPIO)
+            max_GPIO = settingsMap[i];
    }

    gpioInit(max_GPIO + 1); // Done here so we can inform Portduino how many GPIOs we need.

    // Need to bind all the configured GPIO pins so they're not simulated
    // TODO: If one of these fails, we should log and terminate
-    for (auto i : portduino_config.all_pins) {
-        if (i->enabled)
-            if (initGPIOPin(i->pin, gpioChipName + std::to_string(i->gpiochip), i->line) != ERRNO_OK) {
-                printf("Error setting pin number %d. It may not exist, or may already be in use.\n", i->line);
-                exit(EXIT_FAILURE);
-            }
+    if (settingsMap.count(userButtonPin) > 0 && settingsMap[userButtonPin] != RADIOLIB_NC) {
+        if (initGPIOPin(settingsMap[userButtonPin], defaultGpioChipName, settingsMap[userButtonPin]) != ERRNO_OK) {
+            settingsMap[userButtonPin] = RADIOLIB_NC;
+        }
+    }
+    if (settingsMap.count(tbUpPin) > 0 && settingsMap[tbUpPin] != RADIOLIB_NC) {
+        if (initGPIOPin(settingsMap[tbUpPin], defaultGpioChipName, settingsMap[tbUpPin]) != ERRNO_OK) {
+            settingsMap[tbUpPin] = RADIOLIB_NC;
+        }
+    }
+    if (settingsMap.count(tbDownPin) > 0 && settingsMap[tbDownPin] != RADIOLIB_NC) {
+        if (initGPIOPin(settingsMap[tbDownPin], defaultGpioChipName, settingsMap[tbDownPin]) != ERRNO_OK) {
+            settingsMap[tbDownPin] = RADIOLIB_NC;
+        }
+    }
+    if (settingsMap.count(tbLeftPin) > 0 && settingsMap[tbLeftPin] != RADIOLIB_NC) {
+        if (initGPIOPin(settingsMap[tbLeftPin], defaultGpioChipName, settingsMap[tbLeftPin]) != ERRNO_OK) {
+            settingsMap[tbLeftPin] = RADIOLIB_NC;
+        }
+    }
+    if (settingsMap.count(tbRightPin) > 0 && settingsMap[tbRightPin] != RADIOLIB_NC) {
+        if (initGPIOPin(settingsMap[tbRightPin], defaultGpioChipName, settingsMap[tbRightPin]) != ERRNO_OK) {
+            settingsMap[tbRightPin] = RADIOLIB_NC;
+        }
+    }
+    if (settingsMap.count(tbPressPin) > 0 && settingsMap[tbPressPin] != RADIOLIB_NC) {
+        if (initGPIOPin(settingsMap[tbPressPin], defaultGpioChipName, settingsMap[tbPressPin]) != ERRNO_OK) {
+            settingsMap[tbPressPin] = RADIOLIB_NC;
+        }
+    }
+    if (settingsMap[displayPanel] != no_screen) {
+        if (settingsMap[displayCS] > 0)
+            initGPIOPin(settingsMap[displayCS], defaultGpioChipName, settingsMap[displayCS]);
+        if (settingsMap[displayDC] > 0)
+            initGPIOPin(settingsMap[displayDC], defaultGpioChipName, settingsMap[displayDC]);
+        if (settingsMap[displayBacklight] > 0)
+            initGPIOPin(settingsMap[displayBacklight], defaultGpioChipName, settingsMap[displayBacklight]);
+        if (settingsMap[displayReset] > 0)
+            initGPIOPin(settingsMap[displayReset], defaultGpioChipName, settingsMap[displayReset]);
+    }
+    if (settingsMap[touchscreenModule] != no_touchscreen) {
+        if (settingsMap[touchscreenCS] > 0)
+            initGPIOPin(settingsMap[touchscreenCS], defaultGpioChipName, settingsMap[touchscreenCS]);
+        if (settingsMap[touchscreenIRQ] > 0)
+            initGPIOPin(settingsMap[touchscreenIRQ], defaultGpioChipName, settingsMap[touchscreenIRQ]);
    }

    // Only initialize the radio pins when dealing with real, kernel controlled SPI hardware
-    if (portduino_config.lora_spi_dev != "" && portduino_config.lora_spi_dev != "ch341") {
-        SPI.begin(portduino_config.lora_spi_dev.c_str());
+    if (settingsStrings[spidev] != "" && settingsStrings[spidev] != "ch341") {
+        const struct {
+            configNames pin;
+            configNames gpiochip;
+            configNames line;
+        } pinMappings[] = {{cs_pin, cs_gpiochip, cs_line},
+                           {irq_pin, irq_gpiochip, irq_line},
+                           {busy_pin, busy_gpiochip, busy_line},
+                           {reset_pin, reset_gpiochip, reset_line},
+                           {rxen_pin, rxen_gpiochip, rxen_line},
+                           {txen_pin, txen_gpiochip, txen_line},
+                           {sx126x_ant_sw_pin, sx126x_ant_sw_gpiochip, sx126x_ant_sw_line}};
+        for (auto &pinMap : pinMappings) {
+            auto setMapIter = settingsMap.find(pinMap.pin);
+            if (setMapIter != settingsMap.end() && setMapIter->second != RADIOLIB_NC) {
+                if (initGPIOPin(setMapIter->second, gpioChipName + std::to_string(settingsMap[pinMap.gpiochip]),
+                                settingsMap[pinMap.line]) != ERRNO_OK) {
+                    printf("Error setting pin number %d. It may not exist, or may already be in use.\n",
+                           settingsMap[pinMap.line]);
+                    exit(EXIT_FAILURE);
+                }
+            }
+        }
+        SPI.begin(settingsStrings[spidev].c_str());
    }
-    if (portduino_config.traceFilename != "") {
+    if (settingsStrings[traceFilename] != "") {
        try {
-            traceFile.open(portduino_config.traceFilename, std::ios::out | std::ios::app);
+            traceFile.open(settingsStrings[traceFilename], std::ios::out | std::ios::app);
        } catch (std::ofstream::failure &e) {
            std::cout << "*** traceFile Exception " << e.what() << std::endl;
            exit(EXIT_FAILURE);
        }
    }
-    if (verboseEnabled && portduino_config.logoutputlevel != level_trace) {
-        portduino_config.logoutputlevel = level_debug;
+    if (verboseEnabled && settingsMap[logoutputlevel] != level_trace) {
+        settingsMap[logoutputlevel] = level_debug;
    }

    return;
@@ -448,78 +537,99 @@ bool loadConfig(const char *configPath)
        yamlConfig = YAML::LoadFile(configPath);
        if (yamlConfig["Logging"]) {
            if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "trace") {
-                portduino_config.logoutputlevel = level_trace;
+                settingsMap[logoutputlevel] = level_trace;
            } else if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "debug") {
-                portduino_config.logoutputlevel = level_debug;
+                settingsMap[logoutputlevel] = level_debug;
            } else if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "info") {
-                portduino_config.logoutputlevel = level_info;
+                settingsMap[logoutputlevel] = level_info;
            } else if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "warn") {
-                portduino_config.logoutputlevel = level_warn;
+                settingsMap[logoutputlevel] = level_warn;
            } else if (yamlConfig["Logging"]["LogLevel"].as<std::string>("info") == "error") {
-                portduino_config.logoutputlevel = level_error;
+                settingsMap[logoutputlevel] = level_error;
            }
-            portduino_config.traceFilename = yamlConfig["Logging"]["TraceFile"].as<std::string>("");
+            settingsStrings[traceFilename] = yamlConfig["Logging"]["TraceFile"].as<std::string>("");
            if (yamlConfig["Logging"]["AsciiLogs"]) {
                // Default is !isatty(1) but can be set explicitly in config.yaml
-                portduino_config.ascii_logs = yamlConfig["Logging"]["AsciiLogs"].as<bool>();
-                portduino_config.ascii_logs_explicit = true;
+                settingsMap[ascii_logs] = yamlConfig["Logging"]["AsciiLogs"].as<bool>();
            }
        }
        if (yamlConfig["Lora"]) {
-
+            const struct {
+                configNames cfgName;
+                std::string strName;
+            } loraModules[] = {{use_simradio, "sim"},  {use_autoconf, "auto"}, {use_rf95, "RF95"},     {use_sx1262, "sx1262"},
+                               {use_sx1268, "sx1268"}, {use_sx1280, "sx1280"}, {use_lr1110, "lr1110"}, {use_lr1120, "lr1120"},
+                               {use_lr1121, "lr1121"}, {use_llcc68, "LLCC68"}};
+            for (auto &loraModule : loraModules) {
+                settingsMap[loraModule.cfgName] = false;
+            }
            if (yamlConfig["Lora"]["Module"]) {
-                for (auto &loraModule : portduino_config.loraModules) {
-                    if (yamlConfig["Lora"]["Module"].as<std::string>("") == loraModule.second) {
-                        portduino_config.lora_module = loraModule.first;
+                for (auto &loraModule : loraModules) {
+                    if (yamlConfig["Lora"]["Module"].as<std::string>("") == loraModule.strName) {
+                        settingsMap[loraModule.cfgName] = true;
                        break;
                    }
                }
            }
-            if (yamlConfig["Lora"]["SX126X_MAX_POWER"])
-                portduino_config.sx126x_max_power = yamlConfig["Lora"]["SX126X_MAX_POWER"].as<int>(22);
-            if (yamlConfig["Lora"]["SX128X_MAX_POWER"])
-                portduino_config.sx128x_max_power = yamlConfig["Lora"]["SX128X_MAX_POWER"].as<int>(13);
-            if (yamlConfig["Lora"]["LR1110_MAX_POWER"])
-                portduino_config.lr1110_max_power = yamlConfig["Lora"]["LR1110_MAX_POWER"].as<int>(22);
-            if (yamlConfig["Lora"]["LR1120_MAX_POWER"])
-                portduino_config.lr1120_max_power = yamlConfig["Lora"]["LR1120_MAX_POWER"].as<int>(13);
-            if (yamlConfig["Lora"]["RF95_MAX_POWER"])
-                portduino_config.rf95_max_power = yamlConfig["Lora"]["RF95_MAX_POWER"].as<int>(20);

-            if (portduino_config.lora_module != use_autoconf && portduino_config.lora_module != use_simradio &&
-                !portduino_config.force_simradio) {
-                portduino_config.dio2_as_rf_switch = yamlConfig["Lora"]["DIO2_AS_RF_SWITCH"].as<bool>(false);
-                portduino_config.dio3_tcxo_voltage = yamlConfig["Lora"]["DIO3_TCXO_VOLTAGE"].as<float>(0) * 1000;
-                if (portduino_config.dio3_tcxo_voltage == 0 && yamlConfig["Lora"]["DIO3_TCXO_VOLTAGE"].as<bool>(false)) {
-                    portduino_config.dio3_tcxo_voltage = 1800; // default millivolts for "true"
-                }
+            settingsMap[sx126x_max_power] = yamlConfig["Lora"]["SX126X_MAX_POWER"].as<int>(22);
+            settingsMap[sx128x_max_power] = yamlConfig["Lora"]["SX128X_MAX_POWER"].as<int>(13);
+            settingsMap[lr1110_max_power] = yamlConfig["Lora"]["LR1110_MAX_POWER"].as<int>(22);
+            settingsMap[lr1120_max_power] = yamlConfig["Lora"]["LR1120_MAX_POWER"].as<int>(13);
+            settingsMap[rf95_max_power] = yamlConfig["Lora"]["RF95_MAX_POWER"].as<int>(20);

-                // backwards API compatibility and to globally set gpiochip once
-                portduino_config.lora_default_gpiochip = yamlConfig["Lora"]["gpiochip"].as<int>(0);
-                for (auto this_pin : portduino_config.all_pins) {
-                    if (this_pin->config_section == "Lora") {
-                        readGPIOFromYaml(yamlConfig["Lora"][this_pin->config_name], *this_pin);
-                    }
+            settingsMap[dio2_as_rf_switch] = yamlConfig["Lora"]["DIO2_AS_RF_SWITCH"].as<bool>(false);
+            settingsMap[dio3_tcxo_voltage] = yamlConfig["Lora"]["DIO3_TCXO_VOLTAGE"].as<float>(0) * 1000;
+            if (settingsMap[dio3_tcxo_voltage] == 0 && yamlConfig["Lora"]["DIO3_TCXO_VOLTAGE"].as<bool>(false)) {
+                settingsMap[dio3_tcxo_voltage] = 1800; // default millivolts for "true"
+            }
+
+            // backwards API compatibility and to globally set gpiochip once
+            int defaultGpioChip = settingsMap[default_gpiochip] = yamlConfig["Lora"]["gpiochip"].as<int>(0);
+
+            const struct {
+                configNames pin;
+                configNames gpiochip;
+                configNames line;
+                std::string strName;
+            } pinMappings[] = {
+                {cs_pin, cs_gpiochip, cs_line, "CS"},
+                {irq_pin, irq_gpiochip, irq_line, "IRQ"},
+                {busy_pin, busy_gpiochip, busy_line, "Busy"},
+                {reset_pin, reset_gpiochip, reset_line, "Reset"},
+                {txen_pin, txen_gpiochip, txen_line, "TXen"},
+                {rxen_pin, rxen_gpiochip, rxen_line, "RXen"},
+                {sx126x_ant_sw_pin, sx126x_ant_sw_gpiochip, sx126x_ant_sw_line, "SX126X_ANT_SW"},
+            };
+            for (auto &pinMap : pinMappings) {
+                if (yamlConfig["Lora"][pinMap.strName].IsMap()) {
+                    settingsMap[pinMap.pin] = yamlConfig["Lora"][pinMap.strName]["pin"].as<int>(RADIOLIB_NC);
+                    settingsMap[pinMap.line] = yamlConfig["Lora"][pinMap.strName]["line"].as<int>(settingsMap[pinMap.pin]);
+                    settingsMap[pinMap.gpiochip] = yamlConfig["Lora"][pinMap.strName]["gpiochip"].as<int>(defaultGpioChip);
+                } else { // backwards API compatibility
+                    settingsMap[pinMap.pin] = yamlConfig["Lora"][pinMap.strName].as<int>(RADIOLIB_NC);
+                    settingsMap[pinMap.line] = settingsMap[pinMap.pin];
+                    settingsMap[pinMap.gpiochip] = defaultGpioChip;
                }
            }

-            portduino_config.spiSpeed = yamlConfig["Lora"]["spiSpeed"].as<int>(2000000);
-            portduino_config.lora_usb_serial_num = yamlConfig["Lora"]["USB_Serialnum"].as<std::string>("");
-            portduino_config.lora_usb_pid = yamlConfig["Lora"]["USB_PID"].as<int>(0x5512);
-            portduino_config.lora_usb_vid = yamlConfig["Lora"]["USB_VID"].as<int>(0x1A86);
+            settingsMap[spiSpeed] = yamlConfig["Lora"]["spiSpeed"].as<int>(2000000);
+            settingsStrings[lora_usb_serial_num] = yamlConfig["Lora"]["USB_Serialnum"].as<std::string>("");
+            settingsMap[lora_usb_pid] = yamlConfig["Lora"]["USB_PID"].as<int>(0x5512);
+            settingsMap[lora_usb_vid] = yamlConfig["Lora"]["USB_VID"].as<int>(0x1A86);

-            portduino_config.lora_spi_dev = yamlConfig["Lora"]["spidev"].as<std::string>("spidev0.0");
-            if (portduino_config.lora_spi_dev != "ch341") {
-                portduino_config.lora_spi_dev = "/dev/" + portduino_config.lora_spi_dev;
-                if (portduino_config.lora_spi_dev.length() == 14) {
-                    int x = portduino_config.lora_spi_dev.at(11) - '0';
-                    int y = portduino_config.lora_spi_dev.at(13) - '0';
+            settingsStrings[spidev] = yamlConfig["Lora"]["spidev"].as<std::string>("spidev0.0");
+            if (settingsStrings[spidev] != "ch341") {
+                settingsStrings[spidev] = "/dev/" + settingsStrings[spidev];
+                if (settingsStrings[spidev].length() == 14) {
+                    int x = settingsStrings[spidev].at(11) - '0';
+                    int y = settingsStrings[spidev].at(13) - '0';
                    // Pretty sure this is always true
                    if (x >= 0 && x < 10 && y >= 0 && y < 10) {
                        // I believe this bit of weirdness is specifically for the new GUI
-                        portduino_config.lora_spi_dev_int = x + y << 4;
-                        portduino_config.display_spi_dev_int = portduino_config.lora_spi_dev_int;
-                        portduino_config.touchscreen_spi_dev_int = portduino_config.lora_spi_dev_int;
+                        settingsMap[spidev] = x + y << 4;
+                        settingsMap[displayspidev] = settingsMap[spidev];
+                        settingsMap[touchscreenspidev] = settingsMap[spidev];
                    }
                }
            }
@@ -566,152 +676,163 @@ bool loadConfig(const char *configPath)
                }
            }
        }
-        readGPIOFromYaml(yamlConfig["GPIO"]["User"], portduino_config.userButtonPin);
+        if (yamlConfig["GPIO"]) {
+            settingsMap[userButtonPin] = yamlConfig["GPIO"]["User"].as<int>(RADIOLIB_NC);
+        }
        if (yamlConfig["GPS"]) {
            std::string serialPath = yamlConfig["GPS"]["SerialPath"].as<std::string>("");
            if (serialPath != "") {
                Serial1.setPath(serialPath);
-                portduino_config.has_gps = 1;
+                settingsMap[has_gps] = 1;
            }
        }
        if (yamlConfig["I2C"]) {
-            portduino_config.i2cdev = yamlConfig["I2C"]["I2CDevice"].as<std::string>("");
+            settingsStrings[i2cdev] = yamlConfig["I2C"]["I2CDevice"].as<std::string>("");
        }
        if (yamlConfig["Display"]) {
-
-            for (auto &screen_name : portduino_config.screen_names) {
-                if (yamlConfig["Display"]["Panel"].as<std::string>("") == screen_name.second)
-                    portduino_config.displayPanel = screen_name.first;
-            }
-            portduino_config.displayHeight = yamlConfig["Display"]["Height"].as<int>(0);
-            portduino_config.displayWidth = yamlConfig["Display"]["Width"].as<int>(0);
-
-            readGPIOFromYaml(yamlConfig["Display"]["DC"], portduino_config.displayDC, -1);
-            readGPIOFromYaml(yamlConfig["Display"]["CS"], portduino_config.displayCS, -1);
-            readGPIOFromYaml(yamlConfig["Display"]["Backlight"], portduino_config.displayBacklight, -1);
-            readGPIOFromYaml(yamlConfig["Display"]["BacklightPWMChannel"], portduino_config.displayBacklightPWMChannel, -1);
-            readGPIOFromYaml(yamlConfig["Display"]["Reset"], portduino_config.displayReset, -1);
-
-            portduino_config.displayBacklightInvert = yamlConfig["Display"]["BacklightInvert"].as<bool>(false);
-            portduino_config.displayRGBOrder = yamlConfig["Display"]["RGBOrder"].as<bool>(false);
-            portduino_config.displayOffsetX = yamlConfig["Display"]["OffsetX"].as<int>(0);
-            portduino_config.displayOffsetY = yamlConfig["Display"]["OffsetY"].as<int>(0);
-            portduino_config.displayRotate = yamlConfig["Display"]["Rotate"].as<bool>(false);
-            portduino_config.displayOffsetRotate = yamlConfig["Display"]["OffsetRotate"].as<int>(1);
-            portduino_config.displayInvert = yamlConfig["Display"]["Invert"].as<bool>(false);
-            portduino_config.displayBusFrequency = yamlConfig["Display"]["BusFrequency"].as<int>(40000000);
+            if (yamlConfig["Display"]["Panel"].as<std::string>("") == "ST7789")
+                settingsMap[displayPanel] = st7789;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "ST7735")
+                settingsMap[displayPanel] = st7735;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "ST7735S")
+                settingsMap[displayPanel] = st7735s;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "ST7796")
+                settingsMap[displayPanel] = st7796;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "ILI9341")
+                settingsMap[displayPanel] = ili9341;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "ILI9342")
+                settingsMap[displayPanel] = ili9342;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "ILI9486")
+                settingsMap[displayPanel] = ili9486;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "ILI9488")
+                settingsMap[displayPanel] = ili9488;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "HX8357D")
+                settingsMap[displayPanel] = hx8357d;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "X11")
+                settingsMap[displayPanel] = x11;
+            else if (yamlConfig["Display"]["Panel"].as<std::string>("") == "FB")
+                settingsMap[displayPanel] = fb;
+            settingsMap[displayHeight] = yamlConfig["Display"]["Height"].as<int>(0);
+            settingsMap[displayWidth] = yamlConfig["Display"]["Width"].as<int>(0);
+            settingsMap[displayDC] = yamlConfig["Display"]["DC"].as<int>(-1);
+            settingsMap[displayCS] = yamlConfig["Display"]["CS"].as<int>(-1);
+            settingsMap[displayRGBOrder] = yamlConfig["Display"]["RGBOrder"].as<bool>(false);
+            settingsMap[displayBacklight] = yamlConfig["Display"]["Backlight"].as<int>(-1);
+            settingsMap[displayBacklightInvert] = yamlConfig["Display"]["BacklightInvert"].as<bool>(false);
+            settingsMap[displayBacklightPWMChannel] = yamlConfig["Display"]["BacklightPWMChannel"].as<int>(-1);
+            settingsMap[displayReset] = yamlConfig["Display"]["Reset"].as<int>(-1);
+            settingsMap[displayOffsetX] = yamlConfig["Display"]["OffsetX"].as<int>(0);
+            settingsMap[displayOffsetY] = yamlConfig["Display"]["OffsetY"].as<int>(0);
+            settingsMap[displayRotate] = yamlConfig["Display"]["Rotate"].as<bool>(false);
+            settingsMap[displayOffsetRotate] = yamlConfig["Display"]["OffsetRotate"].as<int>(1);
+            settingsMap[displayInvert] = yamlConfig["Display"]["Invert"].as<bool>(false);
+            settingsMap[displayBusFrequency] = yamlConfig["Display"]["BusFrequency"].as<int>(40000000);
            if (yamlConfig["Display"]["spidev"]) {
-                portduino_config.display_spi_dev = "/dev/" + yamlConfig["Display"]["spidev"].as<std::string>("spidev0.1");
-                if (portduino_config.display_spi_dev.length() == 14) {
-                    int x = portduino_config.display_spi_dev.at(11) - '0';
-                    int y = portduino_config.display_spi_dev.at(13) - '0';
+                settingsStrings[displayspidev] = "/dev/" + yamlConfig["Display"]["spidev"].as<std::string>("spidev0.1");
+                if (settingsStrings[displayspidev].length() == 14) {
+                    int x = settingsStrings[displayspidev].at(11) - '0';
+                    int y = settingsStrings[displayspidev].at(13) - '0';
                    if (x >= 0 && x < 10 && y >= 0 && y < 10) {
-                        portduino_config.display_spi_dev_int = x + y << 4;
-                        portduino_config.touchscreen_spi_dev_int = portduino_config.display_spi_dev_int;
+                        settingsMap[displayspidev] = x + y << 4;
+                        settingsMap[touchscreenspidev] = settingsMap[displayspidev];
                    }
                }
            }
        }
        if (yamlConfig["Touchscreen"]) {
            if (yamlConfig["Touchscreen"]["Module"].as<std::string>("") == "XPT2046")
-                portduino_config.touchscreenModule = xpt2046;
+                settingsMap[touchscreenModule] = xpt2046;
            else if (yamlConfig["Touchscreen"]["Module"].as<std::string>("") == "STMPE610")
-                portduino_config.touchscreenModule = stmpe610;
+                settingsMap[touchscreenModule] = stmpe610;
            else if (yamlConfig["Touchscreen"]["Module"].as<std::string>("") == "GT911")
-                portduino_config.touchscreenModule = gt911;
+                settingsMap[touchscreenModule] = gt911;
            else if (yamlConfig["Touchscreen"]["Module"].as<std::string>("") == "FT5x06")
-                portduino_config.touchscreenModule = ft5x06;
-
-            readGPIOFromYaml(yamlConfig["Touchscreen"]["CS"], portduino_config.touchscreenCS, -1);
-            readGPIOFromYaml(yamlConfig["Touchscreen"]["IRQ"], portduino_config.touchscreenIRQ, -1);
-
-            portduino_config.touchscreenBusFrequency = yamlConfig["Touchscreen"]["BusFrequency"].as<int>(1000000);
-            portduino_config.touchscreenRotate = yamlConfig["Touchscreen"]["Rotate"].as<int>(-1);
-            portduino_config.touchscreenI2CAddr = yamlConfig["Touchscreen"]["I2CAddr"].as<int>(-1);
+                settingsMap[touchscreenModule] = ft5x06;
+            settingsMap[touchscreenCS] = yamlConfig["Touchscreen"]["CS"].as<int>(-1);
+            settingsMap[touchscreenIRQ] = yamlConfig["Touchscreen"]["IRQ"].as<int>(-1);
+            settingsMap[touchscreenBusFrequency] = yamlConfig["Touchscreen"]["BusFrequency"].as<int>(1000000);
+            settingsMap[touchscreenRotate] = yamlConfig["Touchscreen"]["Rotate"].as<int>(-1);
+            settingsMap[touchscreenI2CAddr] = yamlConfig["Touchscreen"]["I2CAddr"].as<int>(-1);
            if (yamlConfig["Touchscreen"]["spidev"]) {
-                portduino_config.touchscreen_spi_dev = "/dev/" + yamlConfig["Touchscreen"]["spidev"].as<std::string>("");
-                if (portduino_config.touchscreen_spi_dev.length() == 14) {
-                    int x = portduino_config.touchscreen_spi_dev.at(11) - '0';
-                    int y = portduino_config.touchscreen_spi_dev.at(13) - '0';
+                settingsStrings[touchscreenspidev] = "/dev/" + yamlConfig["Touchscreen"]["spidev"].as<std::string>("");
+                if (settingsStrings[touchscreenspidev].length() == 14) {
+                    int x = settingsStrings[touchscreenspidev].at(11) - '0';
+                    int y = settingsStrings[touchscreenspidev].at(13) - '0';
                    if (x >= 0 && x < 10 && y >= 0 && y < 10) {
-                        portduino_config.touchscreen_spi_dev_int = x + y << 4;
+                        settingsMap[touchscreenspidev] = x + y << 4;
                    }
                }
            }
        }
        if (yamlConfig["Input"]) {
-            portduino_config.keyboardDevice = (yamlConfig["Input"]["KeyboardDevice"]).as<std::string>("");
-            portduino_config.pointerDevice = (yamlConfig["Input"]["PointerDevice"]).as<std::string>("");
-
-            readGPIOFromYaml(yamlConfig["Input"]["User"], portduino_config.userButtonPin);
-            readGPIOFromYaml(yamlConfig["Input"]["TrackballUp"], portduino_config.tbUpPin);
-            readGPIOFromYaml(yamlConfig["Input"]["TrackballDown"], portduino_config.tbDownPin);
-            readGPIOFromYaml(yamlConfig["Input"]["TrackballLeft"], portduino_config.tbLeftPin);
-            readGPIOFromYaml(yamlConfig["Input"]["TrackballRight"], portduino_config.tbRightPin);
-            readGPIOFromYaml(yamlConfig["Input"]["TrackballPress"], portduino_config.tbPressPin);
-
+            settingsStrings[keyboardDevice] = (yamlConfig["Input"]["KeyboardDevice"]).as<std::string>("");
+            settingsStrings[pointerDevice] = (yamlConfig["Input"]["PointerDevice"]).as<std::string>("");
+            settingsMap[userButtonPin] = yamlConfig["Input"]["User"].as<int>(RADIOLIB_NC);
+            settingsMap[tbUpPin] = yamlConfig["Input"]["TrackballUp"].as<int>(RADIOLIB_NC);
+            settingsMap[tbDownPin] = yamlConfig["Input"]["TrackballDown"].as<int>(RADIOLIB_NC);
+            settingsMap[tbLeftPin] = yamlConfig["Input"]["TrackballLeft"].as<int>(RADIOLIB_NC);
+            settingsMap[tbRightPin] = yamlConfig["Input"]["TrackballRight"].as<int>(RADIOLIB_NC);
+            settingsMap[tbPressPin] = yamlConfig["Input"]["TrackballPress"].as<int>(RADIOLIB_NC);
            if (yamlConfig["Input"]["TrackballDirection"].as<std::string>("RISING") == "RISING") {
-                portduino_config.tbDirection = 4;
+                settingsMap[tbDirection] = 4;
            } else if (yamlConfig["Input"]["TrackballDirection"].as<std::string>("RISING") == "FALLING") {
-                portduino_config.tbDirection = 3;
+                settingsMap[tbDirection] = 3;
            }
        }

        if (yamlConfig["Webserver"]) {
-            portduino_config.webserverport = (yamlConfig["Webserver"]["Port"]).as<int>(-1);
-            portduino_config.webserver_root_path =
+            settingsMap[webserverport] = (yamlConfig["Webserver"]["Port"]).as<int>(-1);
+            settingsStrings[webserverrootpath] =
                (yamlConfig["Webserver"]["RootPath"]).as<std::string>("/usr/share/meshtasticd/web");
-            portduino_config.webserver_ssl_key_path =
+            settingsStrings[websslkeypath] =
                (yamlConfig["Webserver"]["SSLKey"]).as<std::string>("/etc/meshtasticd/ssl/private_key.pem");
-            portduino_config.webserver_ssl_cert_path =
+            settingsStrings[websslcertpath] =
                (yamlConfig["Webserver"]["SSLCert"]).as<std::string>("/etc/meshtasticd/ssl/certificate.pem");
        }

        if (yamlConfig["HostMetrics"]) {
-            portduino_config.hostMetrics_channel = (yamlConfig["HostMetrics"]["Channel"]).as<int>(0);
-            portduino_config.hostMetrics_interval = (yamlConfig["HostMetrics"]["ReportInterval"]).as<int>(0);
-            portduino_config.hostMetrics_user_command = (yamlConfig["HostMetrics"]["UserStringCommand"]).as<std::string>("");
+            settingsMap[hostMetrics_channel] = (yamlConfig["HostMetrics"]["Channel"]).as<int>(0);
+            settingsMap[hostMetrics_interval] = (yamlConfig["HostMetrics"]["ReportInterval"]).as<int>(0);
+            settingsStrings[hostMetrics_user_command] = (yamlConfig["HostMetrics"]["UserStringCommand"]).as<std::string>("");
        }

        if (yamlConfig["Config"]) {
            if (yamlConfig["Config"]["DisplayMode"]) {
-                portduino_config.has_configDisplayMode = true;
+                settingsMap[has_configDisplayMode] = true;
                if ((yamlConfig["Config"]["DisplayMode"]).as<std::string>("") == "TWOCOLOR") {
-                    portduino_config.configDisplayMode = meshtastic_Config_DisplayConfig_DisplayMode_TWOCOLOR;
+                    settingsMap[configDisplayMode] = meshtastic_Config_DisplayConfig_DisplayMode_TWOCOLOR;
                } else if ((yamlConfig["Config"]["DisplayMode"]).as<std::string>("") == "INVERTED") {
-                    portduino_config.configDisplayMode = meshtastic_Config_DisplayConfig_DisplayMode_INVERTED;
+                    settingsMap[configDisplayMode] = meshtastic_Config_DisplayConfig_DisplayMode_INVERTED;
                } else if ((yamlConfig["Config"]["DisplayMode"]).as<std::string>("") == "COLOR") {
-                    portduino_config.configDisplayMode = meshtastic_Config_DisplayConfig_DisplayMode_COLOR;
+                    settingsMap[configDisplayMode] = meshtastic_Config_DisplayConfig_DisplayMode_COLOR;
                } else {
-                    portduino_config.configDisplayMode = meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT;
+                    settingsMap[configDisplayMode] = meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT;
                }
            }
        }

        if (yamlConfig["General"]) {
-            portduino_config.MaxNodes = (yamlConfig["General"]["MaxNodes"]).as<int>(200);
-            portduino_config.maxtophone = (yamlConfig["General"]["MaxMessageQueue"]).as<int>(100);
-            portduino_config.config_directory = (yamlConfig["General"]["ConfigDirectory"]).as<std::string>("");
-            portduino_config.available_directory =
+            settingsMap[maxnodes] = (yamlConfig["General"]["MaxNodes"]).as<int>(200);
+            settingsMap[maxtophone] = (yamlConfig["General"]["MaxMessageQueue"]).as<int>(100);
+            settingsStrings[config_directory] = (yamlConfig["General"]["ConfigDirectory"]).as<std::string>("");
+            settingsStrings[available_directory] =
                (yamlConfig["General"]["AvailableDirectory"]).as<std::string>("/etc/meshtasticd/available.d/");
            if ((yamlConfig["General"]["MACAddress"]).as<std::string>("") != "" &&
                (yamlConfig["General"]["MACAddressSource"]).as<std::string>("") != "") {
                std::cout << "Cannot set both MACAddress and MACAddressSource!" << std::endl;
                exit(EXIT_FAILURE);
            }
-            portduino_config.mac_address = (yamlConfig["General"]["MACAddress"]).as<std::string>("");
-            if (portduino_config.mac_address != "") {
-                portduino_config.mac_address_explicit = true;
-            } else if ((yamlConfig["General"]["MACAddressSource"]).as<std::string>("") != "") {
-                portduino_config.mac_address_source = (yamlConfig["General"]["MACAddressSource"]).as<std::string>("");
-                std::ifstream infile("/sys/class/net/" + portduino_config.mac_address_source + "/address");
-                std::getline(infile, portduino_config.mac_address);
+            settingsStrings[mac_address] = (yamlConfig["General"]["MACAddress"]).as<std::string>("");
+            if ((yamlConfig["General"]["MACAddressSource"]).as<std::string>("") != "") {
+                std::ifstream infile("/sys/class/net/" + (yamlConfig["General"]["MACAddressSource"]).as<std::string>("") +
+                                     "/address");
+                std::getline(infile, settingsStrings[mac_address]);
            }

            // https://stackoverflow.com/a/20326454
-            portduino_config.mac_address.erase(
-                std::remove(portduino_config.mac_address.begin(), portduino_config.mac_address.end(), ':'),
-                portduino_config.mac_address.end());
+            settingsStrings[mac_address].erase(
+                std::remove(settingsStrings[mac_address].begin(), settingsStrings[mac_address].end(), ':'),
+                settingsStrings[mac_address].end());
        }
    } catch (YAML::Exception &e) {
        std::cout << "*** Exception " << e.what() << std::endl;
@@ -730,12 +851,12 @@ bool MAC_from_string(std::string mac_str, uint8_t *dmac)
 {
    mac_str.erase(std::remove(mac_str.begin(), mac_str.end(), ':'), mac_str.end());
    if (mac_str.length() == 12) {
-        dmac[0] = std::stoi(portduino_config.mac_address.substr(0, 2), nullptr, 16);
-        dmac[1] = std::stoi(portduino_config.mac_address.substr(2, 2), nullptr, 16);
-        dmac[2] = std::stoi(portduino_config.mac_address.substr(4, 2), nullptr, 16);
-        dmac[3] = std::stoi(portduino_config.mac_address.substr(6, 2), nullptr, 16);
-        dmac[4] = std::stoi(portduino_config.mac_address.substr(8, 2), nullptr, 16);
-        dmac[5] = std::stoi(portduino_config.mac_address.substr(10, 2), nullptr, 16);
+        dmac[0] = std::stoi(settingsStrings[mac_address].substr(0, 2), nullptr, 16);
+        dmac[1] = std::stoi(settingsStrings[mac_address].substr(2, 2), nullptr, 16);
+        dmac[2] = std::stoi(settingsStrings[mac_address].substr(4, 2), nullptr, 16);
+        dmac[3] = std::stoi(settingsStrings[mac_address].substr(6, 2), nullptr, 16);
+        dmac[4] = std::stoi(settingsStrings[mac_address].substr(8, 2), nullptr, 16);
+        dmac[5] = std::stoi(settingsStrings[mac_address].substr(10, 2), nullptr, 16);
        return true;
    } else {
        return false;
@@ -754,19 +875,4 @@ std::string exec(const char *cmd)
        result += buffer.data();
    }
    return result;
-}
-
-void readGPIOFromYaml(YAML::Node sourceNode, pinMapping &destPin, int pinDefault)
-{
-    if (sourceNode.IsMap()) {
-        destPin.enabled = true;
-        destPin.pin = sourceNode["pin"].as<int>(pinDefault);
-        destPin.line = sourceNode["line"].as<int>(destPin.pin);
-        destPin.gpiochip = sourceNode["gpiochip"].as<int>(portduino_config.lora_default_gpiochip);
-    } else if (sourceNode) { // backwards API compatibility
-        destPin.enabled = true;
-        destPin.pin = sourceNode.as<int>(pinDefault);
-        destPin.line = destPin.pin;
-        destPin.gpiochip = portduino_config.lora_default_gpiochip;
-    }
 }
--- a/src/platform/portduino/PortduinoGlue.h
+++ b/src/platform/portduino/PortduinoGlue.h
@@ -6,7 +6,6 @@
 #include "LR11x0Interface.h"
 #include "Module.h"
 #include "platform/portduino/USBHal.h"
-#include "yaml-cpp/yaml.h"

 // Product strings for auto-configuration
 // {"PRODUCT_STRING", "CONFIG.YAML"}
@@ -20,10 +19,36 @@ inline const std::unordered_map<std::string, std::string> configProducts = {
    {"RAK6421-13300-S1", "lora-RAK6421-13300-slot1.yaml"},
    {"RAK6421-13300-S2", "lora-RAK6421-13300-slot2.yaml"}};

-enum screen_modules { no_screen, x11, fb, st7789, st7735, st7735s, st7796, ili9341, ili9342, ili9486, ili9488, hx8357d };
-enum touchscreen_modules { no_touchscreen, xpt2046, stmpe610, gt911, ft5x06 };
-enum portduino_log_level { level_error, level_warn, level_info, level_debug, level_trace };
-enum lora_module_enum {
+enum configNames {
+    default_gpiochip,
+    cs_pin,
+    cs_line,
+    cs_gpiochip,
+    irq_pin,
+    irq_line,
+    irq_gpiochip,
+    busy_pin,
+    busy_line,
+    busy_gpiochip,
+    reset_pin,
+    reset_line,
+    reset_gpiochip,
+    txen_pin,
+    txen_line,
+    txen_gpiochip,
+    rxen_pin,
+    rxen_line,
+    rxen_gpiochip,
+    sx126x_ant_sw_pin,
+    sx126x_ant_sw_line,
+    sx126x_ant_sw_gpiochip,
+    sx126x_max_power,
+    sx128x_max_power,
+    lr1110_max_power,
+    lr1120_max_power,
+    rf95_max_power,
+    dio2_as_rf_switch,
+    dio3_tcxo_voltage,
    use_simradio,
    use_autoconf,
    use_rf95,
@@ -33,18 +58,72 @@ enum lora_module_enum {
    use_lr1110,
    use_lr1120,
    use_lr1121,
-    use_llcc68
-};
-
-struct pinMapping {
-    std::string config_section;
-    std::string config_name;
-    int pin = RADIOLIB_NC;
-    int gpiochip;
-    int line;
-    bool enabled = false;
+    use_llcc68,
+    lora_usb_serial_num,
+    lora_usb_pid,
+    lora_usb_vid,
+    userButtonPin,
+    tbUpPin,
+    tbDownPin,
+    tbLeftPin,
+    tbRightPin,
+    tbPressPin,
+    tbDirection,
+    spidev,
+    spiSpeed,
+    i2cdev,
+    has_gps,
+    touchscreenModule,
+    touchscreenCS,
+    touchscreenIRQ,
+    touchscreenI2CAddr,
+    touchscreenBusFrequency,
+    touchscreenRotate,
+    touchscreenspidev,
+    displayspidev,
+    displayBusFrequency,
+    displayPanel,
+    displayWidth,
+    displayHeight,
+    displayCS,
+    displayDC,
+    displayRGBOrder,
+    displayBacklight,
+    displayBacklightPWMChannel,
+    displayBacklightInvert,
+    displayReset,
+    displayRotate,
+    displayOffsetRotate,
+    displayOffsetX,
+    displayOffsetY,
+    displayInvert,
+    keyboardDevice,
+    pointerDevice,
+    logoutputlevel,
+    traceFilename,
+    webserver,
+    webserverport,
+    webserverrootpath,
+    websslkeypath,
+    websslcertpath,
+    maxtophone,
+    maxnodes,
+    ascii_logs,
+    config_directory,
+    available_directory,
+    mac_address,
+    hostMetrics_interval,
+    hostMetrics_channel,
+    hostMetrics_user_command,
+    configDisplayMode,
+    has_configDisplayMode
 };
+enum { no_screen, x11, fb, st7789, st7735, st7735s, st7796, ili9341, ili9342, ili9486, ili9488, hx8357d };
+enum { no_touchscreen, xpt2046, stmpe610, gt911, ft5x06 };
+enum { level_error, level_warn, level_info, level_debug, level_trace };

+extern std::map<configNames, int> settingsMap;
+extern std::map<configNames, std::string> settingsStrings;
 extern std::ofstream traceFile;
 extern Ch341Hal *ch341Hal;
 int initGPIOPin(int pinNum, std::string gpioChipname, int line);
@@ -52,422 +131,13 @@ bool loadConfig(const char *configPath);
 static bool ends_with(std::string_view str, std::string_view suffix);
 void getMacAddr(uint8_t *dmac);
 bool MAC_from_string(std::string mac_str, uint8_t *dmac);
-void readGPIOFromYaml(YAML::Node sourceNode, pinMapping &destPin, int pinDefault = RADIOLIB_NC);
 std::string exec(const char *cmd);

 extern struct portduino_config_struct {
-    // Lora
-    std::map<lora_module_enum, std::string> loraModules = {
-        {use_simradio, "sim"},  {use_autoconf, "auto"}, {use_rf95, "RF95"},     {use_sx1262, "sx1262"}, {use_sx1268, "sx1268"},
-        {use_sx1280, "sx1280"}, {use_lr1110, "lr1110"}, {use_lr1120, "lr1120"}, {use_lr1121, "lr1121"}, {use_llcc68, "LLCC68"}};
-
-    std::map<screen_modules, std::string> screen_names = {{x11, "X11"},         {fb, "FB"},           {st7789, "ST7789"},
-                                                          {st7735, "ST7735"},   {st7735s, "ST7735S"}, {st7796, "ST7796"},
-                                                          {ili9341, "ILI9341"}, {ili9342, "ILI9342"}, {ili9486, "ILI9486"},
-                                                          {ili9488, "ILI9488"}, {hx8357d, "HX8357D"}};
-
-    lora_module_enum lora_module;
    bool has_rfswitch_table = false;
    uint32_t rfswitch_dio_pins[5] = {RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC};
    Module::RfSwitchMode_t rfswitch_table[8];
    bool force_simradio = false;
    bool has_device_id = false;
    uint8_t device_id[16] = {0};
-    std::string lora_spi_dev = "";
-    std::string lora_usb_serial_num = "";
-    int lora_spi_dev_int = 0;
-    int lora_default_gpiochip = 0;
-    int sx126x_max_power = 22;
-    int sx128x_max_power = 13;
-    int lr1110_max_power = 22;
-    int lr1120_max_power = 13;
-    int rf95_max_power = 20;
-    bool dio2_as_rf_switch = false;
-    int dio3_tcxo_voltage = 0;
-    int lora_usb_pid = 0x5512;
-    int lora_usb_vid = 0x1A86;
-    int spiSpeed = 2000000;
-    pinMapping lora_cs_pin = {"Lora", "CS"};
-    pinMapping lora_irq_pin = {"Lora", "IRQ"};
-    pinMapping lora_busy_pin = {"Lora", "Busy"};
-    pinMapping lora_reset_pin = {"Lora", "Reset"};
-    pinMapping lora_txen_pin = {"Lora", "TXen"};
-    pinMapping lora_rxen_pin = {"Lora", "RXen"};
-    pinMapping lora_sx126x_ant_sw_pin = {"Lora", "SX126X_ANT_SW"};
-
-    // GPS
-    bool has_gps = false;
-
-    // I2C
-    std::string i2cdev = "";
-
-    // Display
-    std::string display_spi_dev = "";
-    int display_spi_dev_int = 0;
-    int displayBusFrequency = 40000000;
-    screen_modules displayPanel = no_screen;
-    int displayWidth = 0;
-    int displayHeight = 0;
-    bool displayRGBOrder = false;
-    bool displayBacklightInvert = false;
-    bool displayRotate = false;
-    int displayOffsetRotate = 1;
-    bool displayInvert = false;
-    int displayOffsetX = 0;
-    int displayOffsetY = 0;
-    pinMapping displayDC = {"Display", "DC"};
-    pinMapping displayCS = {"Display", "CS"};
-    pinMapping displayBacklight = {"Display", "Backlight"};
-    pinMapping displayBacklightPWMChannel = {"Display", "BacklightPWMChannel"};
-    pinMapping displayReset = {"Display", "Reset"};
-
-    // Touchscreen
-    std::string touchscreen_spi_dev = "";
-    int touchscreen_spi_dev_int = 0;
-    touchscreen_modules touchscreenModule = no_touchscreen;
-    int touchscreenI2CAddr = -1;
-    int touchscreenBusFrequency = 1000000;
-    int touchscreenRotate = -1;
-    pinMapping touchscreenCS = {"Touchscreen", "CS"};
-    pinMapping touchscreenIRQ = {"Touchscreen", "IRQ"};
-
-    // Input
-    std::string keyboardDevice = "";
-    std::string pointerDevice = "";
-    int tbDirection;
-    pinMapping userButtonPin = {"Input", "User"};
-    pinMapping tbUpPin = {"Input", "TrackballUp"};
-    pinMapping tbDownPin = {"Input", "TrackballDown"};
-    pinMapping tbLeftPin = {"Input", "TrackballLwft"};
-    pinMapping tbRightPin = {"Input", "TrackballRight"};
-    pinMapping tbPressPin = {"Input", "TrackballPress"};
-
-    // Logging
-    portduino_log_level logoutputlevel = level_debug;
-    std::string traceFilename;
-    bool ascii_logs = !isatty(1);
-    bool ascii_logs_explicit = false;
-
-    // Webserver
-    std::string webserver_root_path = "";
-    std::string webserver_ssl_key_path = "/etc/meshtasticd/ssl/private_key.pem";
-    std::string webserver_ssl_cert_path = "/etc/meshtasticd/ssl/certificate.pem";
-    int webserverport = -1;
-
-    // HostMetrics
-    std::string hostMetrics_user_command = "";
-    int hostMetrics_interval = 0;
-    int hostMetrics_channel = 0;
-
-    // config
-    int configDisplayMode = 0;
-    bool has_configDisplayMode = false;
-
-    // General
-    std::string mac_address = "";
-    bool mac_address_explicit = false;
-    std::string mac_address_source = "";
-    std::string config_directory = "";
-    std::string available_directory = "/etc/meshtasticd/available.d/";
-    int maxtophone = 100;
-    int MaxNodes = 200;
-
-    pinMapping *all_pins[20] = {&lora_cs_pin,
-                                &lora_irq_pin,
-                                &lora_busy_pin,
-                                &lora_reset_pin,
-                                &lora_txen_pin,
-                                &lora_rxen_pin,
-                                &lora_sx126x_ant_sw_pin,
-                                &displayDC,
-                                &displayCS,
-                                &displayBacklight,
-                                &displayBacklightPWMChannel,
-                                &displayReset,
-                                &touchscreenCS,
-                                &touchscreenIRQ,
-                                &userButtonPin,
-                                &tbUpPin,
-                                &tbDownPin,
-                                &tbLeftPin,
-                                &tbRightPin,
-                                &tbPressPin};
-
-    std::string emit_yaml()
-    {
-        YAML::Emitter out;
-        out << YAML::BeginMap;
-
-        // Lora
-        out << YAML::Key << "Lora" << YAML::Value << YAML::BeginMap;
-        out << YAML::Key << "Module" << YAML::Value << loraModules[lora_module];
-
-        for (auto lora_pin : all_pins) {
-            if (lora_pin->config_section == "Lora" && lora_pin->enabled) {
-                out << YAML::Key << lora_pin->config_name << YAML::Value << YAML::BeginMap;
-                out << YAML::Key << "pin" << YAML::Value << lora_pin->pin;
-                out << YAML::Key << "line" << YAML::Value << lora_pin->line;
-                out << YAML::Key << "gpiochip" << YAML::Value << lora_pin->gpiochip;
-                out << YAML::EndMap; // User
-            }
-        }
-
-        if (sx126x_max_power != 22)
-            out << YAML::Key << "SX126X_MAX_POWER" << YAML::Value << sx126x_max_power;
-        if (sx128x_max_power != 13)
-            out << YAML::Key << "SX128X_MAX_POWER" << YAML::Value << sx128x_max_power;
-        if (lr1110_max_power != 22)
-            out << YAML::Key << "LR1110_MAX_POWER" << YAML::Value << lr1110_max_power;
-        if (lr1120_max_power != 13)
-            out << YAML::Key << "LR1120_MAX_POWER" << YAML::Value << lr1120_max_power;
-        if (rf95_max_power != 20)
-            out << YAML::Key << "RF95_MAX_POWER" << YAML::Value << rf95_max_power;
-        out << YAML::Key << "DIO2_AS_RF_SWITCH" << YAML::Value << dio2_as_rf_switch;
-        if (dio3_tcxo_voltage != 0)
-            out << YAML::Key << "DIO3_TCXO_VOLTAGE" << YAML::Value << dio3_tcxo_voltage;
-        if (lora_usb_pid != 0x5512)
-            out << YAML::Key << "USB_PID" << YAML::Value << YAML::Hex << lora_usb_pid;
-        if (lora_usb_vid != 0x1A86)
-            out << YAML::Key << "USB_VID" << YAML::Value << YAML::Hex << lora_usb_vid;
-        if (lora_spi_dev != "")
-            out << YAML::Key << "spidev" << YAML::Value << lora_spi_dev;
-        if (lora_usb_serial_num != "")
-            out << YAML::Key << "USB_Serialnum" << YAML::Value << lora_usb_serial_num;
-        out << YAML::Key << "spiSpeed" << YAML::Value << spiSpeed;
-        if (rfswitch_dio_pins[0] != RADIOLIB_NC) {
-            out << YAML::Key << "rfswitch_table" << YAML::Value << YAML::BeginMap;
-
-            out << YAML::Key << "pins";
-            out << YAML::Value << YAML::Flow << YAML::BeginSeq;
-
-            for (int i = 0; i < 5; i++) {
-                // set up the pin array first
-                if (rfswitch_dio_pins[i] == RADIOLIB_LR11X0_DIO5)
-                    out << "DIO5";
-                if (rfswitch_dio_pins[i] == RADIOLIB_LR11X0_DIO6)
-                    out << "DIO6";
-                if (rfswitch_dio_pins[i] == RADIOLIB_LR11X0_DIO7)
-                    out << "DIO7";
-                if (rfswitch_dio_pins[i] == RADIOLIB_LR11X0_DIO8)
-                    out << "DIO8";
-                if (rfswitch_dio_pins[i] == RADIOLIB_LR11X0_DIO10)
-                    out << "DIO10";
-            }
-            out << YAML::EndSeq;
-
-            for (int i = 0; i < 7; i++) {
-                switch (i) {
-                case 0:
-                    out << YAML::Key << "MODE_STBY";
-                    break;
-                case 1:
-                    out << YAML::Key << "MODE_RX";
-                    break;
-                case 2:
-                    out << YAML::Key << "MODE_TX";
-                    break;
-                case 3:
-                    out << YAML::Key << "MODE_TX_HP";
-                    break;
-                case 4:
-                    out << YAML::Key << "MODE_TX_HF";
-                    break;
-                case 5:
-                    out << YAML::Key << "MODE_GNSS";
-                    break;
-                case 6:
-                    out << YAML::Key << "MODE_WIFI";
-                    break;
-                }
-
-                out << YAML::Value << YAML::Flow << YAML::BeginSeq;
-                for (int j = 0; j < 5; j++) {
-                    if (rfswitch_table[i].values[j] == HIGH) {
-                        out << "HIGH";
-                    } else {
-                        out << "LOW";
-                    }
-                }
-                out << YAML::EndSeq;
-            }
-            out << YAML::EndMap; // rfswitch_table
-        }
-        out << YAML::EndMap; // Lora
-
-        if (i2cdev != "") {
-            out << YAML::Key << "I2C" << YAML::Value << YAML::BeginMap;
-            out << YAML::Key << "I2CDevice" << YAML::Value << i2cdev;
-            out << YAML::EndMap; // I2C
-        }
-
-        // Display
-        if (displayPanel != no_screen) {
-            out << YAML::Key << "Display" << YAML::Value << YAML::BeginMap;
-            for (auto &screen_name : screen_names) {
-                if (displayPanel == screen_name.first)
-                    out << YAML::Key << "Module" << YAML::Value << screen_name.second;
-            }
-            for (auto display_pin : all_pins) {
-                if (display_pin->config_section == "Display" && display_pin->enabled) {
-                    out << YAML::Key << display_pin->config_name << YAML::Value << YAML::BeginMap;
-                    out << YAML::Key << "pin" << YAML::Value << display_pin->pin;
-                    out << YAML::Key << "line" << YAML::Value << display_pin->line;
-                    out << YAML::Key << "gpiochip" << YAML::Value << display_pin->gpiochip;
-                    out << YAML::EndMap;
-                }
-            }
-            out << YAML::Key << "spidev" << YAML::Value << display_spi_dev;
-            out << YAML::Key << "BusFrequency" << YAML::Value << displayBusFrequency;
-            if (displayWidth)
-                out << YAML::Key << "Width" << YAML::Value << displayWidth;
-            if (displayHeight)
-                out << YAML::Key << "Height" << YAML::Value << displayHeight;
-            if (displayRGBOrder)
-                out << YAML::Key << "RGBOrder" << YAML::Value << true;
-            if (displayBacklightInvert)
-                out << YAML::Key << "BacklightInvert" << YAML::Value << true;
-            if (displayRotate)
-                out << YAML::Key << "Rotate" << YAML::Value << true;
-            if (displayInvert)
-                out << YAML::Key << "Invert" << YAML::Value << true;
-            if (displayOffsetX)
-                out << YAML::Key << "OffsetX" << YAML::Value << displayOffsetX;
-            if (displayOffsetY)
-                out << YAML::Key << "OffsetY" << YAML::Value << displayOffsetY;
-
-            out << YAML::Key << "OffsetRotate" << YAML::Value << displayOffsetRotate;
-
-            out << YAML::EndMap; // Display
-        }
-
-        // Touchscreen
-        if (touchscreen_spi_dev != "") {
-            out << YAML::Key << "Touchscreen" << YAML::Value << YAML::BeginMap;
-            out << YAML::Key << "spidev" << YAML::Value << touchscreen_spi_dev;
-            out << YAML::Key << "BusFrequency" << YAML::Value << touchscreenBusFrequency;
-            switch (touchscreenModule) {
-            case xpt2046:
-                out << YAML::Key << "Module" << YAML::Value << "XPT2046";
-            case stmpe610:
-                out << YAML::Key << "Module" << YAML::Value << "STMPE610";
-            case gt911:
-                out << YAML::Key << "Module" << YAML::Value << "GT911";
-            case ft5x06:
-                out << YAML::Key << "Module" << YAML::Value << "FT5x06";
-            }
-            for (auto touchscreen_pin : all_pins) {
-                if (touchscreen_pin->config_section == "Touchscreen" && touchscreen_pin->enabled) {
-                    out << YAML::Key << touchscreen_pin->config_name << YAML::Value << YAML::BeginMap;
-                    out << YAML::Key << "pin" << YAML::Value << touchscreen_pin->pin;
-                    out << YAML::Key << "line" << YAML::Value << touchscreen_pin->line;
-                    out << YAML::Key << "gpiochip" << YAML::Value << touchscreen_pin->gpiochip;
-                    out << YAML::EndMap;
-                }
-            }
-            if (touchscreenRotate != -1)
-                out << YAML::Key << "Rotate" << YAML::Value << touchscreenRotate;
-            if (touchscreenI2CAddr != -1)
-                out << YAML::Key << "I2CAddr" << YAML::Value << touchscreenI2CAddr;
-            out << YAML::EndMap; // Touchscreen
-        }
-
-        // Input
-        out << YAML::Key << "Input" << YAML::Value << YAML::BeginMap;
-        if (keyboardDevice != "")
-            out << YAML::Key << "KeyboardDevice" << YAML::Value << keyboardDevice;
-        if (pointerDevice != "")
-            out << YAML::Key << "PointerDevice" << YAML::Value << pointerDevice;
-
-        for (auto input_pin : all_pins) {
-            if (input_pin->config_section == "Input" && input_pin->enabled) {
-                out << YAML::Key << input_pin->config_name << YAML::Value << YAML::BeginMap;
-                out << YAML::Key << "pin" << YAML::Value << input_pin->pin;
-                out << YAML::Key << "line" << YAML::Value << input_pin->line;
-                out << YAML::Key << "gpiochip" << YAML::Value << input_pin->gpiochip;
-                out << YAML::EndMap;
-            }
-        }
-        if (tbDirection == 3)
-            out << YAML::Key << "TrackballDirection" << YAML::Value << "FALLING";
-
-        out << YAML::EndMap; // Input
-
-        out << YAML::Key << "Logging" << YAML::Value << YAML::BeginMap;
-        out << YAML::Key << "LogLevel" << YAML::Value;
-        switch (logoutputlevel) {
-        case level_error:
-            out << "error";
-            break;
-        case level_warn:
-            out << "warn";
-            break;
-        case level_info:
-            out << "info";
-            break;
-        case level_debug:
-            out << "debug";
-            break;
-        case level_trace:
-            out << "trace";
-            break;
-        }
-        if (traceFilename != "")
-            out << YAML::Key << "TraceFile" << YAML::Value << traceFilename;
-        if (ascii_logs_explicit) {
-            out << YAML::Key << "AsciiLogs" << YAML::Value << ascii_logs;
-        }
-        out << YAML::EndMap; // Logging
-
-        // Webserver
-        if (webserver_root_path != "") {
-            out << YAML::Key << "Webserver" << YAML::Value << YAML::BeginMap;
-            out << YAML::Key << "RootPath" << YAML::Value << webserver_root_path;
-            out << YAML::Key << "SSLKey" << YAML::Value << webserver_ssl_key_path;
-            out << YAML::Key << "SSLCert" << YAML::Value << webserver_ssl_cert_path;
-            out << YAML::Key << "Port" << YAML::Value << webserverport;
-            out << YAML::EndMap; // Webserver
-        }
-
-        // HostMetrics
-        if (hostMetrics_user_command != "") {
-            out << YAML::Key << "HostMetrics" << YAML::Value << YAML::BeginMap;
-            out << YAML::Key << "UserStringCommand" << YAML::Value << hostMetrics_user_command;
-            out << YAML::Key << "ReportInterval" << YAML::Value << hostMetrics_interval;
-            out << YAML::Key << "Channel" << YAML::Value << hostMetrics_channel;
-
-            out << YAML::EndMap; // HostMetrics
-        }
-
-        // config
-        if (has_configDisplayMode) {
-            out << YAML::Key << "Config" << YAML::Value << YAML::BeginMap;
-            switch (configDisplayMode) {
-            case meshtastic_Config_DisplayConfig_DisplayMode_TWOCOLOR:
-                out << YAML::Key << "DisplayMode" << YAML::Value << "TWOCOLOR";
-            case meshtastic_Config_DisplayConfig_DisplayMode_INVERTED:
-                out << YAML::Key << "DisplayMode" << YAML::Value << "INVERTED";
-            case meshtastic_Config_DisplayConfig_DisplayMode_COLOR:
-                out << YAML::Key << "DisplayMode" << YAML::Value << "COLOR";
-            case meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT:
-                out << YAML::Key << "DisplayMode" << YAML::Value << "DEFAULT";
-            }
-
-            out << YAML::EndMap; // Config
-        }
-
-        // General
-        out << YAML::Key << "General" << YAML::Value << YAML::BeginMap;
-        if (config_directory != "")
-            out << YAML::Key << "ConfigDirectory" << YAML::Value << config_directory;
-        if (mac_address_explicit)
-            out << YAML::Key << "MACAddress" << YAML::Value << mac_address;
-        if (mac_address_source != "")
-            out << YAML::Key << "MACAddressSource" << YAML::Value << mac_address_source;
-        if (available_directory != "")
-            out << YAML::Key << "AvailableDirectory" << YAML::Value << available_directory;
-        out << YAML::Key << "MaxMessageQueue" << YAML::Value << maxtophone;
-        out << YAML::Key << "MaxNodes" << YAML::Value << MaxNodes;
-        out << YAML::EndMap; // General
-        return out.c_str();
-    }
 } portduino_config;
--- a/src/platform/portduino/SimRadio.cpp
+++ b/src/platform/portduino/SimRadio.cpp
@@ -43,7 +43,7 @@ void SimRadio::setTransmitDelay()
    } else {
        // If there is a SNR, start a timer scaled based on that SNR.
        LOG_DEBUG("rx_snr found. hop_limit:%d rx_snr:%f", p->hop_limit, p->rx_snr);
-        startTransmitTimerRebroadcast(p);
+        startTransmitTimerSNR(p->rx_snr);
    }
 }

@@ -57,11 +57,11 @@ void SimRadio::startTransmitTimer(bool withDelay)
    }
 }

-void SimRadio::startTransmitTimerRebroadcast(meshtastic_MeshPacket *p)
+void SimRadio::startTransmitTimerSNR(float snr)
 {
    // If we have work to do and the timer wasn't already scheduled, schedule it now
    if (!txQueue.empty()) {
-        uint32_t delayMsec = getTxDelayMsecWeighted(p);
+        uint32_t delayMsec = getTxDelayMsecWeighted(snr);
        // LOG_DEBUG("xmit timer %d", delay);
        notifyLater(delayMsec, TRANSMIT_DELAY_COMPLETED, false);
    }
--- a/src/platform/portduino/SimRadio.h
+++ b/src/platform/portduino/SimRadio.h
@@ -64,7 +64,7 @@ class SimRadio : public RadioInterface, protected concurrency::NotifiedWorkerThr
    void startTransmitTimer(bool withDelay = true);

    /** timer scaled to SNR of to be flooded packet */
-    void startTransmitTimerRebroadcast(meshtastic_MeshPacket *p);
+    void startTransmitTimerSNR(float snr);

    void handleTransmitInterrupt();
    void handleReceiveInterrupt();
--- a/src/platform/portduino/architecture.h
+++ b/src/platform/portduino/architecture.h
@@ -28,9 +28,9 @@
 #endif
 #ifndef HAS_TRACKBALL
 #define HAS_TRACKBALL 1
-#define TB_DOWN (uint8_t) portduino_config.tbDownPin.pin
-#define TB_UP (uint8_t) portduino_config.tbUpPin.pin
-#define TB_LEFT (uint8_t) portduino_config.tbLeftPin.pin
-#define TB_RIGHT (uint8_t) portduino_config.tbRightPin.pin
-#define TB_PRESS (uint8_t) portduino_config.tbPressPin.pin
+#define TB_DOWN (uint8_t) settingsMap[tbDownPin]
+#define TB_UP (uint8_t) settingsMap[tbUpPin]
+#define TB_LEFT (uint8_t) settingsMap[tbLeftPin]
+#define TB_RIGHT (uint8_t) settingsMap[tbRightPin]
+#define TB_PRESS (uint8_t) settingsMap[tbPressPin]
 #endif
--- a/variants/esp32s3/seeed-sensecap-indicator/platformio.ini
+++ b/variants/esp32s3/seeed-sensecap-indicator/platformio.ini
@@ -1,18 +1,31 @@
 ; Seeed Studio SenseCAP Indicator
+; note: does not work with vscode platformio plugin; needs pioarduino IDE plugin instead
 [env:seeed-sensecap-indicator]
 extends = esp32s3_base
+platform =
+    https://github.com/pioarduino/platform-espressif32.git#55.03.30-1
+
 platform_packages =
-    platformio/framework-arduinoespressif32 @ https://github.com/mverch67/arduino-esp32/archive/aef7fef6de3329ed6f75512d46d63bba12b09bb5.zip ; add_tca9535 (based on 2.0.16)
+    platformio/framework-arduinoespressif32 @ https://github.com/mverch67/arduino-esp32#ab7f873773424561fa0d8434034960a36d335fcb

 board = seeed-sensecap-indicator
 board_check = true
 board_build.partitions = partition-table-8MB.csv
 upload_protocol = esptool

-build_flags = ${esp32_base.build_flags}
+build_unflags =
+  -DCONFIG_BT_NIMBLE_ENABLED
+  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
+  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
+  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
+
+build_flags = ${esp32_base.build_flags} -D lcd_periph_signals=lcd_periph_rgb_signals -mtext-section-literals -ffat-lto-objects
  -Ivariants/esp32s3/seeed-sensecap-indicator
  -DSENSECAP_INDICATOR
-  -DCONFIG_ARDUHAL_LOG_COLORS
+  -DARDUINO_HAL_LOG_LEVEL=5
+  -DARDUHAL_LOG_MAXIMUM_LEVEL=5
+  -DARDUHAL_LOG_COLORS=1
+  -DUSE_ARDUINO_HAL_GPIO
  -DRADIOLIB_DEBUG_SPI=0
  -DRADIOLIB_DEBUG_PROTOCOL=0
  -DRADIOLIB_DEBUG_BASIC=0
@@ -20,13 +33,72 @@ build_flags = ${esp32_base.build_flags}
  -DRADIOLIB_SPI_PARANOID=0
  -DIO_EXPANDER=0x40
  -DIO_EXPANDER_IRQ=42
-  ;-DIO_EXPANDER_DEBUG
-  -DUSE_ARDUINO_HAL_GPIO
+;  -DIO_EXPANDER_DEBUG

 lib_deps = ${esp32s3_base.lib_deps}
-  https://github.com/mverch67/LovyanGFX/archive/4c76238c1344162a234ae917b27651af146d6fb2.zip
-  earlephilhower/ESP8266Audio@^1.9.9
-  earlephilhower/ESP8266SAM@^1.0.1
+  https://github.com/mverch67/LovyanGFX/archive/a1c1278fc9116d1c6cb15a7bb14565aef59a9a97.zip
+
+custom_component_remove =
+    espressif/esp_hosted
+    espressif/esp_wifi_remote
+    espressif/esp_modem
+    espressif/esp-dsp
+    espressif/esp32-camera
+    espressif/libsodium
+    espressif/esp-modbus
+    espressif/qrcode
+    espressif/esp_insights
+    espressif/esp_diag_data_store
+    espressif/esp_diagnostics
+    espressif/esp_rainmaker
+    espressif/rmaker_common
+    espressif/network_provisioning
+    chmorgan/esp-libhelix-mp3
+
+custom_sdkconfig =
+    CONFIG_AUTOSTART_ARDUINO=y
+    CONFIG_LOG_DEFAULT_LEVEL=4
+    CONFIG_LOG_MAXIMUM_LEVEL=4
+    CONFIG_LOG_COLORS=y
+    CONFIG_ARDUHAL_LOG_COLORS=y
+    CONFIG_SPIRAM_MODE_OCT=y
+    CONFIG_SPIRAM_SPEED_120M=y
+    CONFIG_SPIRAM_SPEED=120
+    CONFIG_SPIRAM_XIP_FROM_PSRAM=y
+    CONFIG_LCD_RGB_ISR_IRAM_SAFE=y
+    CONFIG_GDMA_CTRL_FUNC_IN_IRAM=y
+    CONFIG_I2S_ISR_IRAM_SAFE=y
+    CONFIG_GDMA_ISR_IRAM_SAFE=y
+    CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240=y
+    CONFIG_ESP32S3_DATA_CACHE_64KB=y
+    CONFIG_ESP32S3_DATA_CACHE_LINE_64B=y
+    CONFIG_I2C_SKIP_LEGACY_CONFLICT_CHECK=y
+    CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH=y
+    CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH=y
+    CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH=y
+    CONFIG_ESP_SYSTEM_ESP32_SRAM1_REGION_AS_IRAM=y
+    CONFIG_ESP_WIFI_IRAM_OPT=n
+    CONFIG_ESP32_WIFI_RX_IRAM_OPT=n
+    CONFIG_SPIRAM_CACHE_LIBCHAR_IN_IRAM=n
+    CONFIG_SPIRAM_CACHE_LIBSTR_IN_IRAM=n
+    CONFIG_SPIRAM_CACHE_LIBMISC_IN_IRAM=n
+    CONFIG_SPIRAM_CACHE_LIBTIME_IN_IRAM=n
+    CONFIG_HAL_DEFAULT_ASSERTION_LEVEL=0
+    CONFIG_BT_ENABLED=y
+    CONFIG_BT_NIMBLE_ENABLED=y
+    CONFIG_BT_BLUEDROID_ENABLED=y
+    CONFIG_BT_CONTROLLER_ENABLED=y
+    CONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
+    CONFIG_BT_NIMBLE_MAX_CCCDS=20
+    CONFIG_BT_NIMBLE_CPP_LOG_LEVEL=1
+    CONFIG_ESPTOOLPY_FLASHSIZE_8MB=y
+    CONFIG_ESPTOOLPY_FLASHSIZE="8MB"
+    CONFIG_ESPTOOLPY_FLASHFREQ_120M=y
+    CONFIG_ESPTOOLPY_FLASHFREQ="120m"
+    CONFIG_ESP_TASK_WDT_INIT=n
+    CONFIG_IDF_EXPERIMENTAL_FEATURES=y
+    CONFIG_COMPILER_OPTIMIZATION_PERF=y
+    CONFIG_BOOTLOADER_LOG_LEVEL_INFO=y


 [env:seeed-sensecap-indicator-tft]
@@ -37,14 +109,19 @@ upload_speed = 460800
 build_flags =
  ${env:seeed-sensecap-indicator.build_flags}
  -D INPUTDRIVER_BUTTON_TYPE=38
+  -D MESHTASTIC_EXCLUDE_WEBSERVER=1
+  -D MESHTASTIC_EXCLUDE_SERIAL=1
+  -D MESHTASTIC_EXCLUDE_SOCKETAPI=1
+  -D MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR=1
+  -D HAS_TELEMETRY=0
  -D CONFIG_DISABLE_HAL_LOCKS=1
  -D HAS_SCREEN=1
  -D HAS_TFT=1
  -D DISPLAY_SET_RESOLUTION
-  -D RAM_SIZE=4096
-	-D LV_LVGL_H_INCLUDE_SIMPLE
-	-D LV_CONF_INCLUDE_SIMPLE
-	-D LV_COMP_CONF_INCLUDE_SIMPLE
+  -D RAM_SIZE=3072
+  -D LV_LVGL_H_INCLUDE_SIMPLE
+  -D LV_CONF_INCLUDE_SIMPLE
+  -D LV_COMP_CONF_INCLUDE_SIMPLE
  -D LV_USE_SYSMON=0
  -D LV_USE_PROFILER=0
  -D LV_USE_PERF_MONITOR=0
--- a/variants/esp32s3/seeed-sensecap-indicator/variant.h
+++ b/variants/esp32s3/seeed-sensecap-indicator/variant.h
@@ -4,7 +4,7 @@
 // This board has a serial coprocessor for sensor readings
 #define SENSOR_RP2040_TXD 19
 #define SENSOR_RP2040_RXD 20
-#define SENSOR_PORT_NUM 2
+#define SENSOR_PORT_NUM UART_NUM_2
 #define SENSOR_BAUD_RATE 115200

 #define BUTTON_PIN 38
--- a/variants/esp32s3/t-deck-pro/variant.h
+++ b/variants/esp32s3/t-deck-pro/variant.h
@@ -93,10 +93,11 @@
 // Internally the TTGO module hooks the SX1262-DIO2 in to control the TX/RX switch (which is the default for the sx1262interface
 // code)

-#define MODEM_POWER_EN 41
-#define MODEM_PWRKEY 40
-#define MODEM_RST 9
-#define MODEM_RI 7
-#define MODEM_DTR 8
-#define MODEM_RX 10
-#define MODEM_TX 11
+#define MODEM_POWER_EN  41
+#define MODEM_PWRKEY    40
+#define MODEM_RST  9
+#define MODEM_RI  7
+#define MODEM_DTR  8
+#define MODEM_RX  10
+#define MODEM_TX  11
+
--- a/variants/esp32s3/tlora-pager/rfswitch.h
+++ b/variants/esp32s3/tlora-pager/rfswitch.h
@@ -4,8 +4,12 @@ static const uint32_t rfswitch_dio_pins[] = {RADIOLIB_LR11X0_DIO5, RADIOLIB_LR11

 static const Module::RfSwitchMode_t rfswitch_table[] = {
    // mode                  DIO5  DIO6
-    {LR11x0::MODE_STBY, {LOW, LOW}},  {LR11x0::MODE_RX, {LOW, HIGH}},
-    {LR11x0::MODE_TX, {HIGH, LOW}},   {LR11x0::MODE_TX_HP, {HIGH, LOW}},
-    {LR11x0::MODE_TX_HF, {LOW, LOW}}, {LR11x0::MODE_GNSS, {LOW, LOW}},
-    {LR11x0::MODE_WIFI, {LOW, LOW}},  END_OF_MODE_TABLE,
+    {LR11x0::MODE_STBY, {LOW, LOW}},
+    {LR11x0::MODE_RX, {LOW, HIGH}},
+    {LR11x0::MODE_TX, {HIGH, LOW}},
+    {LR11x0::MODE_TX_HP, {HIGH, LOW}},
+    {LR11x0::MODE_TX_HF, {LOW, LOW}},
+    {LR11x0::MODE_GNSS, {LOW, LOW}},
+    {LR11x0::MODE_WIFI, {LOW, LOW}},
+    END_OF_MODE_TABLE,
 };
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
mverch67	6b05f090dc	reduce PSRAM allocated to lvgl	2025-09-18 10:17:58 +02:00
Manuel	e9b87f7a81	Merge branch 'master' into arduino-esp32-v3.2	2025-09-18 09:48:51 +02:00
Manuel	d47d249550	Merge branch 'master' into arduino-esp32-v3.2	2025-09-12 21:15:43 +02:00
Manuel	ff28355e16	Merge branch 'master' into arduino-esp32-v3.2	2025-09-08 19:20:15 +02:00
Manuel	351cbd723b	Merge branch 'master' into arduino-esp32-v3.2	2025-09-08 10:41:14 +02:00
Manuel	be1a724ab4	Merge branch 'master' into arduino-esp32-v3.2	2025-08-10 00:11:27 +02:00
mverch67	04f98cf20e	update config; include wifi	2025-08-09 23:49:16 +02:00
mverch67	75a1a41d8c	fix duplicate Syslog classes	2025-08-09 23:43:45 +02:00
mverch67	344efa6675	update device-ui (fix native compilation)	2025-08-08 17:29:02 +02:00
mverch67	e919b3da9c	cleanup	2025-08-06 10:36:04 +02:00
Manuel	155783c782	Merge branch 'master' into arduino-esp32-v3.2	2025-08-06 09:15:44 +02:00
Manuel	76bcd05259	Merge branch 'master' into arduino-esp32-v3.2	2025-08-06 00:09:37 +02:00
mverch67	2d29cbc34c	device-ui: use fast mem for critical draw functions	2025-08-06 00:08:54 +02:00
mverch67	2b77864192	fix attachInterrupt issue	2025-08-05 23:59:37 +02:00
mverch67	10aa4cbfee	don't exclude I2C	2025-08-02 19:07:34 +02:00
mverch67	c24a174490	don't exclude I2C	2025-08-02 19:05:07 +02:00
Manuel	3e5e19efec	Merge branch 'master' into arduino-esp32-v3.2	2025-08-01 21:50:40 +02:00
mverch67	ea2c247024	pr: update device-ui for indicator	2025-08-01 21:45:40 +02:00
mverch67	0b463b6443	update references to fixed io expander	2025-08-01 20:54:57 +02:00
mverch67	7d3c804279	update wdt task	2025-08-01 20:54:15 +02:00
mverch67	1fa7d9f40e	try-fix watchdog trigger	2025-08-01 09:23:01 +02:00
mverch67	aa7abb1d3e	use ng-io-expander 3.3.0	2025-07-30 23:37:09 +02:00
mverch67	effb454af0	comment out assert on watchdog creation	2025-07-30 23:24:31 +02:00
mverch67	27bb42ed3b	git ignore new toolchain tmp files	2025-07-29 22:08:07 +02:00
mverch67	05dc8caed8	platformio updates	2025-07-29 22:07:18 +02:00
mverch67	f3734d407d	remove OTA partition for now until fw size got smaller again	2025-07-29 22:06:21 +02:00
mverch67	bc8e509a8c	fix copy&paste	2025-07-29 22:05:29 +02:00
mverch67	74d0472834	fix merge again	2025-07-29 21:55:34 +02:00
mverch67	5afc43ebc1	try-out WDT timer issue --> needs revert	2025-07-29 21:07:28 +02:00
mverch67	6cdb92b7a8	fix merge error	2025-07-29 21:06:19 +02:00
Thomas Göttgens	0e1872398a	Merge remote-tracking branch 'remotes/origin/master' into arduino-esp32-v3.2 # Conflicts: # arch/esp32/esp32.ini # src/graphics/draw/MenuHandler.cpp # src/modules/Modules.cpp # variants/esp32s3/seeed-sensecap-indicator/platformio.ini	2025-07-29 13:06:13 +02:00
mverch67	f25544c7e0	updated platform references	2025-07-18 03:16:54 +02:00
mverch67	f40b2ba153	temp workaround for nimble compile	2025-07-18 03:14:45 +02:00
mverch67	5033fd1f9f	fix MESHTASTIC_EXCLUDE_I2C compile errors	2025-07-17 12:40:02 +02:00
mverch67	cd170fb011	boot_freq 120MHz	2025-07-16 20:50:25 +02:00
mverch67	fa169a5e43	compare IDF versions	2025-07-14 17:14:21 +02:00
mverch67	c6e2a53a02	exclude not needed modules	2025-07-03 17:08:29 +02:00
Ben Meadors	a286c06271	Merge branch 'master' into arduino-esp32-v3.2	2025-07-02 06:00:44 -05:00
Manuel	dda4b90e34	Merge branch 'master' into arduino-esp32-v3.2	2025-07-01 00:56:56 +02:00
mverch67	cc5dc5046c	indicator: adaptations for arduino-esp32 v3.2	2025-07-01 00:48:11 +02:00
				`@@ -28,5 +28,3 @@ PB_BIND(meshtastic_Map, meshtastic_Map, AUTO)`