Imrpoved sound quality in analog_audio_app, and added Nyquist protection option to BBW filter for praline. (#3054)

* Added PRO button to analog_audio.cpp for debugging metallic ringing sounds in Audio app. Ensured consitency to 4MHz in analog_audio.cpp

* Restored blutooth after loss.

* Added several sampling rates to analog_audio for testing.

* Ran format-code.sh

* Fixed 0x03 mode for DC/Q-INV/Q-SHFT being set at every tuning and sample rate change. This was the root cause for loss of bluetooth before. Sample rate, and frequency can now be changed without need for manually resetting DC/Q-INV/Q-SHIFT settings. Updated method for setting frequncies in praline so that we have more testing options.

* Ran format-code.sh and cleaned up stale comments.

* Addressed comments, and removed commented line, opting for higher register values, 5E and 5D. Added WFM Debug View to support testing demodulation ringing.

* Addressed comments in PR conversation to clean comments and ensure consistency at initializtion accross updated methods and displays.

* Ran format-code.sh

* Set initial legacy state. Improved readability of clocking initialization settings. Updated set_sampling_frequency, and udpate_bandwidth to set decimation values in the fpga_registers to avoid aliasing in low band frequencies.

* Updated clock_manager to use correct clock and clock parameters for audio pll. Ran format-code.sh.

.clang-format

@@ -1,14 +1,13 @@
 ---
 BasedOnStyle: Chromium
-IndentWidth: '4'
-SortIncludes: 'false'
-AllowAllArgumentsOnNextLine: 'true'
+IndentWidth: 4
+SortIncludes: false
+AllowAllArgumentsOnNextLine: true
 ColumnLimit: 0
-Cpp11BracedListStyle: 'true'
-AllowShortLoopsOnASingleLine: 'true'
-AllowShortIfStatementsOnASingleLine: 'true'
+Cpp11BracedListStyle: true
+AllowShortLoopsOnASingleLine: true
+AllowShortIfStatementsOnASingleLine: true
 SpacesInLineCommentPrefix:
   Minimum: 1
   Maximum: 1
-
 ...

.github/workflows/check_formatting.yml

@@ -3,7 +3,7 @@ name: Check formatting
 on: [pull_request]
 
 jobs:
-  check_date:
+  check_format:
     runs-on: ubuntu-latest
     name: Check formatting
     strategy:
@@ -13,12 +13,20 @@ jobs:
           - "firmware/application"
           - "firmware/baseband"
     steps:
-      - uses: actions/checkout@v2
-      - name: print latest_commit
-        run: echo ${{ github.sha }}
-      - name: clang-format Check
-        uses: jidicula/clang-format-action@v4.11.0
-        with:
-          clang-format-version: '18'
-          check-path: ${{ matrix.path }}
-          fallback-style: Chromium
+      - uses: actions/checkout@v4
+
+      - name: clang-format check (repo pinned)
+        run: |
+          set -euo pipefail
+
+          CF="./tools/clang-format.sh"
+          chmod +x "$CF" || true
+
+          "$CF" --version
+
+          ROOT="${{ matrix.path }}"
+          find "$ROOT" -type f \( \
+              -name '*.c' -o -name '*.cpp' -o \
+              -name '*.h' -o -name '*.hpp' \
+            \) -print0 \
+            | xargs -0 -r "$CF" --dry-run --Werror --style=file

.github/workflows/create_nightly_release.yml

@@ -3,7 +3,7 @@ name: Nightly Release
 on:
   schedule:
     - cron: "0 0 * * *"
-    
+
   workflow_dispatch:
 
 jobs:
@@ -21,27 +21,36 @@ jobs:
         id: should_run
         continue-on-error: true
         run: test -z $(git rev-list  --after="24 hours" ${{ github.sha }}) && echo "should_run=false" >> $GITHUB_OUTPUT
+
   build:
     needs: check_date
     if: ${{ needs.check_date.outputs.should_run != 'false' }}
     runs-on: ubuntu-latest
+    name: build (${{ matrix.device_name }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - device: default
+            device_name: HackRF
+            cmake_args: ""
+            artifact_suffix: "_hackrf"
+          - device: portarf
+            device_name: PortaRF
+            cmake_args: "-DFLASH_MB_SIZE=2 -DFLASH_MB_LIMIT_SIZE=2"
+            artifact_suffix: "_portarf"
+          - device: hpro
+            device_name: HackRF Pro
+            cmake_args: "-DBOARD=PRALINE"
+            artifact_suffix: "_hpro"
     steps:
-      - name: Get current date
-        id: date
-        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
       - name: Get version date
         id: version_date
         run: echo "date=n_$(date +'%y%m%d')" >> $GITHUB_OUTPUT
-      - name: Checkout 
+      - name: Checkout
         uses: actions/checkout@master
         with:
           fetch-depth: 0
-          #ref: next
-          # The branch, tag or SHA to checkout. When checking out the repository that
-          # triggered a workflow, this defaults to the reference or SHA for that event.
-          # Otherwise, uses the default branch.
-          # https://github.com/actions/checkout
-          # So scheduled runs will use the default branch (next) but its now possible to trigger a workflow from another branch
           submodules: true
       - name: Git Sumbodule Update
         run: |
@@ -51,10 +60,10 @@ jobs:
       - name: Make build folder
         run: mkdir ${{ github.workspace }}/build
       - name: Run the Docker image
-        run: docker run -e VERSION_STRING=${{ steps.version_date.outputs.date }} -i -v ${{ github.workspace }}:/havoc portapack-dev
+        run: docker run -e VERSION_STRING=${{ steps.version_date.outputs.date }} -i -v ${{ github.workspace }}:/havoc portapack-dev ${{ matrix.cmake_args }}
       - name: Create Small SD Card ZIP - No World Map
         run: |
-          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-mayhem-firmware.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version_date.outputs.date }}.bin && cp build/firmware/portapack-mayhem_OCI.ppfw.tar sdcard/FIRMWARE/mayhem_nightly_${{ steps.version_date.outputs.date }}_OCI.ppfw.tar && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && cp build/firmware/standalone/*/*.ppmp sdcard/APPS && cd sdcard && zip -r ../sdcard-no-map.zip . && cd ..
+          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-mayhem-firmware.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version_date.outputs.date }}.bin && cp build/firmware/portapack-mayhem_OCI.ppfw.tar sdcard/FIRMWARE/mayhem_nightly_${{ steps.version_date.outputs.date }}${{ matrix.artifact_suffix }}_OCI.ppfw.tar && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && cp build/firmware/standalone/*/*.ppmp sdcard/APPS && cd sdcard && zip -r ../sdcard-no-map.zip . && cd ..
       - name: Download world map
         run: |
           wget https://github.com/portapack-mayhem/mayhem-firmware/releases/download/world_map/world_map.zip
@@ -69,7 +78,47 @@ jobs:
           zip -j firmware.zip build/firmware/portapack-mayhem-firmware.bin && cd flashing && zip -r ../firmware.zip *
       - name: Create SD Card ZIP
         run: |
-          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-mayhem-firmware.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version_date.outputs.date }}.bin && cp build/firmware/portapack-mayhem_OCI.ppfw.tar sdcard/FIRMWARE/mayhem_nightly_${{ steps.version_date.outputs.date }}_OCI.ppfw.tar && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && cp build/firmware/standalone/*/*.ppmp sdcard/APPS && cd sdcard && zip -r ../sdcard.zip . && cd ..
+          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-mayhem-firmware.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version_date.outputs.date }}.bin && cp build/firmware/portapack-mayhem_OCI.ppfw.tar sdcard/FIRMWARE/mayhem_nightly_${{ steps.version_date.outputs.date }}${{ matrix.artifact_suffix }}_OCI.ppfw.tar && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && cp build/firmware/standalone/*/*.ppmp sdcard/APPS && cd sdcard && zip -r ../sdcard.zip . && cd ..
+      - name: Upload firmware zip artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: firmware-${{ matrix.device }}
+          path: ./firmware.zip
+      - name: Upload SD card artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdcard-${{ matrix.device }}
+          path: ./sdcard.zip
+      - name: Upload SD card no-map artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdcard-no-map-${{ matrix.device }}
+          path: ./sdcard-no-map.zip
+      - name: Upload OCI tar artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: oci-tar-${{ matrix.device }}
+          path: build/firmware/portapack-mayhem_OCI.ppfw.tar
+
+  release:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get current date
+        id: date
+        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+      - name: Get version date
+        id: version_date
+        run: echo "date=n_$(date +'%y%m%d')" >> $GITHUB_OUTPUT
+      - name: Checkout
+        uses: actions/checkout@master
+        with:
+          fetch-depth: 0
+          submodules: true
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
       - name: Create changelog
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -96,43 +145,114 @@ jobs:
             ${{ steps.changelog.outputs.content }}
           draft: false
           prerelease: true
-      - name: Upload Firmware TAR Asset
-        id: upload-firmware-tar-asset 
+      # Default device assets
+      - name: Upload Default Firmware TAR Asset
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: build/firmware/portapack-mayhem_OCI.ppfw.tar
-          asset_name: mayhem_nightly_${{ steps.version_date.outputs.date }}_OCI.ppfw.tar
+          asset_path: artifacts/oci-tar-default/portapack-mayhem_OCI.ppfw.tar
+          asset_name: OCI_hackrf_mayhem_nightly_${{ steps.version_date.outputs.date }}.ppfw.tar
           asset_content_type: application/x-tar
-      - name: Upload Firmware Asset
-        id: upload-firmware-asset 
+      - name: Upload Default Firmware Asset
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./firmware.zip
-          asset_name: mayhem_nightly_${{ steps.version_date.outputs.date }}_FIRMWARE.zip
+          asset_path: artifacts/firmware-default/firmware.zip
+          asset_name: FIRMWARE_hackrf_mayhem_nightly_${{ steps.version_date.outputs.date }}.zip
           asset_content_type: application/zip
-      - name: Upload SD Card Assets
-        id: upload-sd-card-asset 
+      - name: Upload Default SD Card Asset
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./sdcard.zip
-          asset_name: mayhem_nightly_${{ steps.version_date.outputs.date }}_COPY_TO_SDCARD.zip
+          asset_path: artifacts/sdcard-default/sdcard.zip
+          asset_name: COPY_TO_SDCARD_hackrf_mayhem_nightly_${{ steps.version_date.outputs.date }}.zip
           asset_content_type: application/zip
-      - name: Upload SD Card Assets - No Map
-        id: upload-sd-card-asset-no-map 
+      - name: Upload Default SD Card Asset - No Map
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./sdcard-no-map.zip
-          asset_name: mayhem_nightly_${{ steps.version_date.outputs.date }}_COPY_TO_SDCARD-no-world-map.zip
+          asset_path: artifacts/sdcard-no-map-default/sdcard-no-map.zip
+          asset_name: COPY_TO_SDCARD_hackrf_mayhem_nightly_${{ steps.version_date.outputs.date }}-no-world-map.zip
+          asset_content_type: application/zip
+      # PortaRF device assets
+      - name: Upload PortaRF Firmware TAR Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/oci-tar-portarf/portapack-mayhem_OCI.ppfw.tar
+          asset_name: OCI_portarf_mayhem_nightly_${{ steps.version_date.outputs.date }}.ppfw.tar
+          asset_content_type: application/x-tar
+      - name: Upload PortaRF Firmware Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/firmware-portarf/firmware.zip
+          asset_name: FIRMWARE_portarf_mayhem_nightly_${{ steps.version_date.outputs.date }}.zip
+          asset_content_type: application/zip
+      - name: Upload PortaRF SD Card Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/sdcard-portarf/sdcard.zip
+          asset_name: COPY_TO_SDCARD_portarf_mayhem_nightly_${{ steps.version_date.outputs.date }}.zip
+          asset_content_type: application/zip
+      - name: Upload PortaRF SD Card Asset - No Map
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/sdcard-no-map-portarf/sdcard-no-map.zip
+          asset_name: COPY_TO_SDCARD_portarf_mayhem_nightly_${{ steps.version_date.outputs.date }}-no-world-map.zip
+          asset_content_type: application/zip
+      # HPro device assets
+      - name: Upload HPro Firmware TAR Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/oci-tar-hpro/portapack-mayhem_OCI.ppfw.tar
+          asset_name: OCI_hpro_mayhem_nightly_${{ steps.version_date.outputs.date }}.ppfw.tar
+          asset_content_type: application/x-tar
+      - name: Upload HPro Firmware Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/firmware-hpro/firmware.zip
+          asset_name: FIRMWARE_hpro_mayhem_nightly_${{ steps.version_date.outputs.date }}.zip
+          asset_content_type: application/zip
+      - name: Upload HPro SD Card Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/sdcard-hpro/sdcard.zip
+          asset_name: COPY_TO_SDCARD_hpro_mayhem_nightly_${{ steps.version_date.outputs.date }}.zip
+          asset_content_type: application/zip
+      - name: Upload HPro SD Card Asset - No Map
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/sdcard-no-map-hpro/sdcard-no-map.zip
+          asset_name: COPY_TO_SDCARD_hpro_mayhem_nightly_${{ steps.version_date.outputs.date }}-no-world-map.zip
           asset_content_type: application/zip

.github/workflows/create_stable_release.yml

@@ -1,25 +1,36 @@
 name: Stable Release
 
-on:    
+on:
   workflow_dispatch:
 
 jobs:
   build:
     runs-on: ubuntu-latest
+    name: build (${{ matrix.device_name }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - device: default
+            device_name: HackRF
+            cmake_args: ""
+            artifact_suffix: "_hackrf"
+          - device: portarf
+            device_name: PortaRF
+            cmake_args: "-DFLASH_MB_SIZE=2 -DFLASH_MB_LIMIT_SIZE=2"
+            artifact_suffix: "_portarf"
+          - device: hpro
+            device_name: HackRF Pro
+            cmake_args: "-DBOARD=PRALINE"
+            artifact_suffix: "_hpro"
     steps:
       - name: Get current date
         id: date
         run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
-      - name: Checkout 
+      - name: Checkout
         uses: actions/checkout@master
         with:
           fetch-depth: 0
-          #ref: next
-          # The branch, tag or SHA to checkout. When checking out the repository that
-          # triggered a workflow, this defaults to the reference or SHA for that event.
-          # Otherwise, uses the default branch.
-          # https://github.com/actions/checkout
-          # So scheduled runs will use the default branch (next) but its now possible to trigger a workflow from another branch
           submodules: true
       - name: Git Sumbodule Update
         run: |
@@ -27,18 +38,15 @@ jobs:
       - name: Get version
         id: version
         run: echo "version=$(cat .github/workflows/version.txt)" >> $GITHUB_OUTPUT
-      - name: Get past version
-        id: past_version
-        run: echo "past_version=$(cat .github/workflows/past_version.txt)" >> $GITHUB_OUTPUT
       - name: Build the Docker image
         run: docker build -t portapack-dev -f dockerfile-nogit . --tag my-image-name:$(date +%s)
       - name: Make build folder
         run: mkdir ${{ github.workspace }}/build
       - name: Run the Docker image
-        run: docker run -e VERSION_STRING=${{ steps.version.outputs.version }} -i -v ${{ github.workspace }}:/havoc portapack-dev
+        run: docker run -e VERSION_STRING=${{ steps.version.outputs.version }} -i -v ${{ github.workspace }}:/havoc portapack-dev ${{ matrix.cmake_args }}
       - name: Create Small SD Card ZIP - No World Map
         run: |
-          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-mayhem-firmware.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version.outputs.version }}.bin && cp build/firmware/portapack-mayhem_OCI.ppfw.tar sdcard/FIRMWARE/mayhem_${{ steps.version.outputs.version }}_OCI.ppfw.tar && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && cp build/firmware/standalone/*/*.ppmp sdcard/APPS && cd sdcard && zip -r ../sdcard-no-map.zip . && cd ..
+          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-mayhem-firmware.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version.outputs.version }}.bin && cp build/firmware/portapack-mayhem_OCI.ppfw.tar sdcard/FIRMWARE/mayhem_${{ steps.version.outputs.version }}${{ matrix.artifact_suffix }}_OCI.ppfw.tar && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && cp build/firmware/standalone/*/*.ppmp sdcard/APPS && cd sdcard && zip -r ../sdcard-no-map.zip . && cd ..
       - name: Download world map
         run: |
           wget https://github.com/portapack-mayhem/mayhem-firmware/releases/download/world_map/world_map.zip
@@ -53,7 +61,50 @@ jobs:
           zip -j firmware.zip build/firmware/portapack-mayhem-firmware.bin && cd flashing && zip -r ../firmware.zip *
       - name: Create SD Card ZIP
         run: |
-          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-mayhem-firmware.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version.outputs.version }}.bin && cp build/firmware/portapack-mayhem_OCI.ppfw.tar sdcard/FIRMWARE/mayhem_${{ steps.version.outputs.version }}_OCI.ppfw.tar && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && cp build/firmware/standalone/*/*.ppmp sdcard/APPS && cd sdcard && zip -r ../sdcard.zip . && cd ..
+          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-mayhem-firmware.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version.outputs.version }}.bin && cp build/firmware/portapack-mayhem_OCI.ppfw.tar sdcard/FIRMWARE/mayhem_${{ steps.version.outputs.version }}${{ matrix.artifact_suffix }}_OCI.ppfw.tar && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && cp build/firmware/standalone/*/*.ppmp sdcard/APPS && cd sdcard && zip -r ../sdcard.zip . && cd ..
+      - name: Upload firmware zip artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: firmware-${{ matrix.device }}
+          path: ./firmware.zip
+      - name: Upload SD card artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdcard-${{ matrix.device }}
+          path: ./sdcard.zip
+      - name: Upload SD card no-map artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdcard-no-map-${{ matrix.device }}
+          path: ./sdcard-no-map.zip
+      - name: Upload OCI tar artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: oci-tar-${{ matrix.device }}
+          path: build/firmware/portapack-mayhem_OCI.ppfw.tar
+
+  release:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get current date
+        id: date
+        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+      - name: Checkout
+        uses: actions/checkout@master
+        with:
+          fetch-depth: 0
+          submodules: true
+      - name: Get version
+        id: version
+        run: echo "version=$(cat .github/workflows/version.txt)" >> $GITHUB_OUTPUT
+      - name: Get past version
+        id: past_version
+        run: echo "past_version=$(cat .github/workflows/past_version.txt)" >> $GITHUB_OUTPUT
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
       - name: Create changelog
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -78,7 +129,7 @@ jobs:
             ## Release notes
             ###  Revision (${{ steps.version.outputs.version }}):
             ${{ steps.changelog.outputs.content }}
-            
+
             **Full Changelog**: https://github.com/portapack-mayhem/mayhem-firmware/compare/${{ steps.past_version.outputs.past_version }}...${{ steps.version.outputs.version }}
 
             ## Installation
@@ -90,44 +141,114 @@ jobs:
             For certain functionality, like external apps, the world map, GPS simulator, and others you need to uncompress (using [7-zip](https://www.7-zip.org/download.html)) the files from `mayhem_vX.Y.Z_COPY_TO_SDCARD.zip` to a FAT32 formatted MicroSD card.
           draft: true
           prerelease: false
-      - name: Upload Firmware TAR Asset
-        id: upload-firmware-tar-asset 
+      # Default device assets
+      - name: Upload Default Firmware TAR Asset
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: build/firmware/portapack-mayhem_OCI.ppfw.tar
-          asset_name: mayhem_${{ steps.version.outputs.version }}_OCI.ppfw.tar
+          asset_path: artifacts/oci-tar-default/portapack-mayhem_OCI.ppfw.tar
+          asset_name: OCI_hackrf_mayhem_${{ steps.version.outputs.version }}.ppfw.tar
           asset_content_type: application/x-tar
-      - name: Upload Firmware Asset
-        id: upload-firmware-asset 
+      - name: Upload Default Firmware Asset
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./firmware.zip
-          asset_name: mayhem_${{ steps.version.outputs.version }}_FIRMWARE.zip
+          asset_path: artifacts/firmware-default/firmware.zip
+          asset_name: FIRMWARE_hackrf_mayhem_${{ steps.version.outputs.version }}.zip
           asset_content_type: application/zip
-      - name: Upload SD Card Assets
-        id: upload-sd-card-asset 
+      - name: Upload Default SD Card Asset
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./sdcard.zip
-          asset_name: mayhem_${{ steps.version.outputs.version }}_COPY_TO_SDCARD.zip
+          asset_path: artifacts/sdcard-default/sdcard.zip
+          asset_name: COPY_TO_SDCARD_hackrf_mayhem_${{ steps.version.outputs.version }}.zip
           asset_content_type: application/zip
-      - name: Upload SD Card Assets - No Map
-        id: upload-sd-card-asset-no-map 
+      - name: Upload Default SD Card Asset - No Map
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./sdcard-no-map.zip
-          asset_name: mayhem_${{ steps.version.outputs.version }}_COPY_TO_SDCARD-no-world-map.zip
+          asset_path: artifacts/sdcard-no-map-default/sdcard-no-map.zip
+          asset_name: COPY_TO_SDCARD_hackrf_mayhem_${{ steps.version.outputs.version }}-no-world-map.zip
+          asset_content_type: application/zip
+      # PortaRF device assets
+      - name: Upload PortaRF Firmware TAR Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/oci-tar-portarf/portapack-mayhem_OCI.ppfw.tar
+          asset_name: OCI_portarf_mayhem_${{ steps.version.outputs.version }}.ppfw.tar
+          asset_content_type: application/x-tar
+      - name: Upload PortaRF Firmware Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/firmware-portarf/firmware.zip
+          asset_name: FIRMWARE_portarf_mayhem_${{ steps.version.outputs.version }}.zip
+          asset_content_type: application/zip
+      - name: Upload PortaRF SD Card Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/sdcard-portarf/sdcard.zip
+          asset_name: COPY_TO_SDCARD_portarf_mayhem_${{ steps.version.outputs.version }}.zip
+          asset_content_type: application/zip
+      - name: Upload PortaRF SD Card Asset - No Map
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/sdcard-no-map-portarf/sdcard-no-map.zip
+          asset_name: COPY_TO_SDCARD_portarf_mayhem_${{ steps.version.outputs.version }}-no-world-map.zip
+          asset_content_type: application/zip
+      # HPro device assets
+      - name: Upload HPro Firmware TAR Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/oci-tar-hpro/portapack-mayhem_OCI.ppfw.tar
+          asset_name: OCI_hpro_mayhem_${{ steps.version.outputs.version }}.ppfw.tar
+          asset_content_type: application/x-tar
+      - name: Upload HPro Firmware Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/firmware-hpro/firmware.zip
+          asset_name: FIRMWARE_hpro_mayhem_${{ steps.version.outputs.version }}.zip
+          asset_content_type: application/zip
+      - name: Upload HPro SD Card Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/sdcard-hpro/sdcard.zip
+          asset_name: COPY_TO_SDCARD_hpro_mayhem_${{ steps.version.outputs.version }}.zip
+          asset_content_type: application/zip
+      - name: Upload HPro SD Card Asset - No Map
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/sdcard-no-map-hpro/sdcard-no-map.zip
+          asset_name: COPY_TO_SDCARD_hpro_mayhem_${{ steps.version.outputs.version }}-no-world-map.zip
           asset_content_type: application/zip
-     

CMakeLists.txt

@@ -27,6 +27,37 @@ set(CMAKE_COLOR_MAKEFILE ON)
 
 add_compile_options(-fdiagnostics-color=always)
 
+#Flash size related options
+#This is the size of the flash memory we SUPPORT. Don't worry, the internl flash app has harder limits based on device type.
+if(NOT DEFINED FLASH_MB_SIZE)
+    if(BOARD STREQUAL "PRALINE")
+        set(FLASH_MB_SIZE 4) # PRALINE has 4MB flash
+    else()
+        set(FLASH_MB_SIZE 2) # Default to 2MB if not provided. For PortaRf this should be 2MB passed to cmake with -DFLASH_MB_SIZE=2
+    endif()
+endif()
+message("Configuring for FLASH_MB_SIZE=${FLASH_MB_SIZE}MB")
+#This is the flash memory size we build. This can be less, so the FW size will be less, so can be flashed with older utils.
+if(NOT DEFINED FLASH_MB_LIMIT_SIZE)
+	if(BOARD STREQUAL "PRALINE")
+		set(FLASH_MB_LIMIT_SIZE 3.5) #PRALINE 4 MB = 3.5 firmware + 0.5 MB fpga bitstream.
+	else()
+	    set(FLASH_MB_LIMIT_SIZE 1) #TODO: should be ${FLASH_MB_SIZE} remove once we got a stable build for all devices we support with bigger than 1 mb flash
+		endif()
+endif()
+message("Configuring for FLASH_MB_LIMIT_SIZE=${FLASH_MB_LIMIT_SIZE}MB")
+
+if(FLASH_MB_SIZE LESS FLASH_MB_LIMIT_SIZE)
+    message(FATAL_ERROR "Error: The supported flash size is lower than the generated flash file. Build halted.")
+endif()
+
+math(EXPR FLASH_BYTES_SIZE "${FLASH_MB_SIZE} * 1024 * 1024")
+if(BOARD STREQUAL "PRALINE")
+	math(EXPR FLASH_BYTES_LIMIT_SIZE "3584 * 1024") #4 MB = 3.5 firmware + 0.5 MB fpga bitstream.
+else()
+    math(EXPR FLASH_BYTES_LIMIT_SIZE "${FLASH_MB_LIMIT_SIZE} * 1024 * 1024")
+endif()
+
 option(USE_CCACHE "Enable ccache, please keep an eye on this because sometimes it's not quite stable and generated unusable binary" OFF)
 
 project(portapack-h1)

dockerize.sh

@@ -15,8 +15,11 @@
 # - Get a shell inside the build image to
 #   inspect problems: ./dockerize.sh shell
 # - Give additional parameters to the container:
-#   ./dockerize.sh -j10
-#   ./dockerize.sh ninja -j10
+#   Additional parameters to make:        ./dockerize.sh -j10
+#   Use ninja instead of make:            ./dockerize.sh ninja -j10
+#   Addotopnal CMake parameters:          ./dockerize.sh -DBOARD=PRALINE
+#   Change the default build directory:   ./dockerize.sh -B build-alt
+#                                         (Alternatively --workdir works as well)
 # - Use a different dockerfile:
 #   ./dockerize.sh build dockerfile-other
 # - Use a different cpu architecture:

docs/CNAME

@@ -1 +0,0 @@
-portapack.ried.cl

firmware/CMakeLists.txt

@@ -48,19 +48,44 @@ if(NOT ${CMAKE_CXX_COMPILER_VERSION} VERSION_EQUAL ${EXPECTED_GCC_VERSION})
 	set(GCC_VERSION_MISMATCH 1)
 endif()
 
+#generate h files
+configure_file(flashsize.h.in flashsize.h)
+add_compile_options(-include ${CMAKE_CURRENT_BINARY_DIR}/flashsize.h)
+
 add_subdirectory(application)
 add_subdirectory(baseband)
 add_subdirectory(standalone)
 add_subdirectory(test)
 
-# NOTE: Dependencies break if the .bin files aren't included in DEPENDS. WTF, CMake?
-add_custom_command(
-	OUTPUT ${FIRMWARE_FILENAME}
-	COMMAND ${MAKE_SPI_IMAGE} ${application_BINARY_DIR}/application.bin ${baseband_BINARY_DIR}/baseband.img ${FIRMWARE_FILENAME}
-	DEPENDS baseband application ${MAKE_SPI_IMAGE}
-		 ${baseband_BINARY_DIR}/baseband.img ${application_BINARY_DIR}/application.bin
-	VERBATIM
-)
+if(BOARD STREQUAL "PRALINE")
+	math(EXPR PRALINE_FINAL_SIZE "4 * 1024 * 1024")
+	set(PRALINE_FPGA_BIN ${CMAKE_CURRENT_SOURCE_DIR}/../hackrf/firmware/fpga/build/praline_fpga.bin)
+	set(APPEND_FPGA_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/tools/append_fpga_bitstream.py)
+
+	# NOTE: Dependencies break if the .bin files aren't included in DEPENDS. WTF, CMake?
+	add_custom_command(
+		OUTPUT ${FIRMWARE_FILENAME}
+		COMMAND ${MAKE_SPI_IMAGE} ${application_BINARY_DIR}/application.bin ${baseband_BINARY_DIR}/baseband.img ${FIRMWARE_FILENAME} ${FLASH_BYTES_LIMIT_SIZE}
+		# PRALINE: Append FPGA bitstream to firmware at offset 0x380000
+		# The base firmware is 3.5MB, FPGA bitstream gets appended at the end of it, final size is 4MB
+		COMMAND ${CMAKE_COMMAND} -E echo "Appending PRALINE FPGA bitstream to firmware..."
+		COMMAND python3 ${APPEND_FPGA_SCRIPT} ${FIRMWARE_FILENAME} ${PRALINE_FPGA_BIN} ${FIRMWARE_FILENAME}.tmp ${PRALINE_FINAL_SIZE}
+		COMMAND ${CMAKE_COMMAND} -E rename ${FIRMWARE_FILENAME}.tmp ${FIRMWARE_FILENAME}
+		DEPENDS baseband application ${MAKE_SPI_IMAGE}
+			${baseband_BINARY_DIR}/baseband.img ${application_BINARY_DIR}/application.bin
+			${PRALINE_FPGA_BIN} ${APPEND_FPGA_SCRIPT}
+		VERBATIM
+	)
+else() # Sadly this part had to be duplicated (or at least I couldn't find a better way to do it)
+	# NOTE: Dependencies break if the .bin files aren't included in DEPENDS. WTF, CMake?
+	add_custom_command(
+		OUTPUT ${FIRMWARE_FILENAME}
+		COMMAND ${MAKE_SPI_IMAGE} ${application_BINARY_DIR}/application.bin ${baseband_BINARY_DIR}/baseband.img ${FIRMWARE_FILENAME} ${FLASH_BYTES_LIMIT_SIZE}
+		DEPENDS baseband application ${MAKE_SPI_IMAGE}
+			${baseband_BINARY_DIR}/baseband.img ${application_BINARY_DIR}/application.bin
+		VERBATIM
+	)
+endif()
 
 add_custom_target(
 	firmware

firmware/application/CMakeLists.txt

@@ -86,6 +86,9 @@ set(CPLD_20150901_DATA_CPP ${CMAKE_CURRENT_BINARY_DIR}/portapack_cpld_20150901_d
 set(CPLD_20170522_SVF_PATH ${HARDWARE_PATH}/portapack_h1/cpld/20170522/output_files/portapack_h1_cpld.svf)
 set(CPLD_20170522_DATA_CPP ${CMAKE_CURRENT_BINARY_DIR}/portapack_cpld_20170522_data.cpp)
 
+set(CPLD_H4M_SVF_PATH ${HARDWARE_PATH}/portapack_h4m/CPLD/AG256SL100/output_files/portapack_h4m_cpld.svf)
+set(CPLD_H4M_DATA_CPP ${CMAKE_CURRENT_BINARY_DIR}/portapack_cpld_h4m_data.cpp)
+
 set(HACKRF_CPLD_DATA_HPP ${CMAKE_CURRENT_BINARY_DIR}/hackrf_cpld_data.hpp)
 set(HACKRF_CPLD_DATA_CPP ${CMAKE_CURRENT_BINARY_DIR}/hackrf_cpld_data.cpp)
 
@@ -118,11 +121,16 @@ set(CSRC
 	usb_serial_endpoints.c
 	usb_serial_device_to_host.c
 	i2c_device_to_host.c
+	hackrf_core_mini.c
+	${HACKRF_PATH}/firmware/common/adc.c
 	${HACKRF_PATH}/firmware/common/usb.c
 	${HACKRF_PATH}/firmware/common/usb_queue.c
 	${HACKRF_PATH}/firmware/hackrf_usb/usb_device.c
 	${HACKRF_PATH}/firmware/common/usb_request.c
 	${HACKRF_PATH}/firmware/common/usb_standard_request.c
+	${HACKRF_PATH}/firmware/libopencm3/lib/lpc43xx/scu.c
+	${HACKRF_PATH}/firmware/common/gpio_lpc.c
+	${HACKRF_PATH}/firmware/common/platform_detect.c
 	${CHIBIOS}/os/various/chprintf.c
 )
 
@@ -205,6 +213,9 @@ set(CPPSRC
 	irq_controls.cpp
 	irq_lcd_frame.cpp
 	irq_rtc.cpp
+    keeloq_common.cpp
+	keeloq_file.cpp
+	keeloq_keystore.cpp
 	log_file.cpp
 	metadata_file.cpp
 	flipper_subfile.cpp
@@ -237,6 +248,7 @@ set(CPPSRC
 	hw/encoder.cpp
 	hw/max2837.cpp
 	hw/max2839.cpp
+	hw/max2831.cpp
 	hw/max5864.cpp
 	hw/rffc507x.cpp
 	hw/rffc507x_spi.cpp
@@ -246,6 +258,7 @@ set(CPPSRC
 	ook_file.cpp
 	ui_baseband_stats_view.cpp
 	ui_navigation.cpp
+	ui_notifications.cpp
 	ui_record_view.cpp
 	ui_sd_card_status_view.cpp
 	ui/ui_alphanum.cpp
@@ -292,14 +305,11 @@ set(CPPSRC
 	apps/ui_mictx.cpp
 	apps/ui_modemsetup.cpp
 	apps/ui_playlist.cpp
-	apps/ui_pocsag_tx.cpp
 	apps/ui_rds.cpp
 	apps/ui_recon_settings.cpp
 	apps/ui_recon.cpp
-	apps/ui_sd_over_usb.cpp
 	apps/ui_search.cpp
 	apps/ui_settings.cpp
-	apps/ui_siggen.cpp
 	apps/ui_sonde.cpp
 	apps/ui_ss_viewer.cpp
 	apps/ui_standalone_view.cpp
@@ -319,6 +329,7 @@ set(CPPSRC
 	config_mode.cpp
 	${CPLD_20150901_DATA_CPP}
 	${CPLD_20170522_DATA_CPP}
+	${CPLD_H4M_DATA_CPP}
 	${HACKRF_CPLD_DATA_CPP}
 	ui_external_items_menu_loader.cpp
 	view_factory_base.cpp
@@ -404,7 +415,11 @@ set(CPPWARN "-Wall -Wextra -Wno-psabi")
 # List all default C defines here, like -D_DEBUG=1
 # TODO: Switch -DCRT0_INIT_DATA depending on load from RAM or SPIFI?
 # NOTE: _RANDOM_TCC to kill a GCC 4.9.3 error with std::max argument types
-set(DDEFS "-DLPC43XX -DLPC43XX_M0 -D__NEWLIB__ -DHACKRF_ONE -DTOOLCHAIN_GCC -DTOOLCHAIN_GCC_ARM -D_RANDOM_TCC=0 -D'VERSION_STRING=\"${VERSION}\"' -DVERSION_MD5=${VERSION_MD5} -D'GCC_VERSION_MISMATCH=${GCC_VERSION_MISMATCH}'")
+# Use BOARD variable if set, otherwise default to HACKRF_ONE
+if(NOT DEFINED BOARD)
+    set(BOARD "HACKRF_ONE")
+endif()
+set(DDEFS "-DLPC43XX -DLPC43XX_M0 -D__NEWLIB__ -D${BOARD} -DTOOLCHAIN_GCC -DTOOLCHAIN_GCC_ARM -D_RANDOM_TCC=0 -D'VERSION_STRING=\"${VERSION}\"' -DVERSION_MD5=${VERSION_MD5} -D'GCC_VERSION_MISMATCH=${GCC_VERSION_MISMATCH}'")
 
 # List all default ASM defines here, like -D_DEBUG=1
 set(DADEFS)
@@ -462,6 +477,12 @@ add_custom_command(
 	DEPENDS ${EXTRACT_CPLD_DATA} ${CPLD_20170522_SVF_PATH}
 )
 
+add_custom_command(
+	OUTPUT ${CPLD_H4M_DATA_CPP}
+	COMMAND ${EXTRACT_CPLD_DATA} ${CPLD_H4M_SVF_PATH} rev_h4m >${CPLD_H4M_DATA_CPP}
+	DEPENDS ${EXTRACT_CPLD_DATA} ${CPLD_H4M_SVF_PATH}
+)
+
 add_custom_command(
 	OUTPUT ${HACKRF_CPLD_DATA_CPP}
 	COMMAND ${HACKRF_CPLD_TOOL} --xsvf ${HACKRF_CPLD_XSVF_PATH} --portapack-data ${HACKRF_CPLD_DATA_CPP}
@@ -469,6 +490,9 @@ add_custom_command(
 )
 
 add_executable(${PROJECT_NAME}.elf ${CSRC} ${CPPSRC} ${ASMSRC})
+target_link_options(${PROJECT_NAME}.elf PRIVATE
+    "LINKER:--defsym,LD_FLASH_SIZE=${FLASH_BYTES_LIMIT_SIZE}"
+)
 set_target_properties(${PROJECT_NAME}.elf PROPERTIES LINK_DEPENDS ${LDSCRIPT})
 add_definitions(${DEFS})
 include_directories(. ${INCDIR})

firmware/application/app_settings.cpp

@@ -68,6 +68,9 @@ void BoundSetting::parse(std::string_view value) {
             as<bool>() = (parsed != 0);
             break;
         }
+        case SettingType::Float:
+            as<float>() = atof(value.data());
+            break;
     };
 }
 
@@ -101,6 +104,11 @@ void BoundSetting::write(File& file) const {
         case SettingType::Bool:
             file.write(as<bool>() ? "1" : "0", 1);
             break;
+
+        case SettingType::Float: {
+            auto float_str = to_string_decimal(as<float>(), 6);
+            file.write(float_str.c_str(), float_str.length());
+        }
     }
 
     file.write("\r\n", 2);

firmware/application/app_settings.hpp

@@ -52,6 +52,7 @@ class BoundSetting {
         U8,
         String,
         Bool,
+        Float
     };
 
    public:
@@ -73,6 +74,9 @@ class BoundSetting {
     BoundSetting(std::string_view name, bool* target)
         : name_{name}, target_{target}, type_{SettingType::Bool} {}
 
+    BoundSetting(std::string_view name, float* target)
+        : name_{name}, target_{target}, type_{SettingType::Float} {}
+
     std::string_view name() const { return name_; }
     void parse(std::string_view value);
     void write(File& file) const;

firmware/application/apps/analog_audio_app.cpp

@@ -199,6 +199,58 @@ SPECOptionsView::SPECOptionsView(
     view->set_spec_iq_phase_calibration_value(view->get_spec_iq_phase_calibration_value());  // initialize iq_phase_calibration in radio
 }
 
+/* PralineOptionsView *******************************************************/
+
+#ifdef PRALINE
+PralineOptionsView::PralineOptionsView(Rect parent_rect, const Style* style) {
+    set_parent_rect(parent_rect);
+    add_children({&label_sr, &options_sr, &label_dc, &options_dc,
+                  &label_qi, &options_qi, &label_qs, &options_qs,
+                  &label_dec, &options_dec});
+
+    // 1. READ the current state from hardware
+    fpga_reg_1 = radio::debug::fpga::register_read(1);
+    uint32_t fpga_reg_2 = radio::debug::fpga::register_read(2);
+
+    // 2. INITIALIZE UI WIDGETS based on read bits
+    options_dc.set_by_value((fpga_reg_1 & 0x01) ? 1 : 0);  // Bit 0
+    options_qi.set_by_value((fpga_reg_1 & 0x02) ? 1 : 0);  // Bit 1
+    options_qs.set_by_value((fpga_reg_1 & 0x04) ? 1 : 0);  // Bit 2
+    options_dec.set_by_value(fpga_reg_2);
+    options_sr.set_value(receiver_model.sampling_rate() / 1000);
+
+    options_sr.on_change = [this](int32_t v) { receiver_model.set_sampling_rate(static_cast<uint32_t>(v) * 1000); };
+    options_dc.on_change = [this](size_t, OptionsField::value_t v) {
+        if (v)
+            fpga_reg_1 |= 0x01;
+        else
+            fpga_reg_1 &= ~0x01;
+        update_fpga_ctrl();
+    };
+
+    options_qi.on_change = [this](size_t, OptionsField::value_t v) {
+        if (v)
+            fpga_reg_1 |= 0x02;
+        else
+            fpga_reg_1 &= ~0x02;
+        update_fpga_ctrl();
+    };
+
+    options_qs.on_change = [this](size_t, OptionsField::value_t v) {
+        if (v)
+            fpga_reg_1 |= 0x04;
+        else
+            fpga_reg_1 &= ~0x04;
+        update_fpga_ctrl();
+    };
+    options_dec.on_change = [this](size_t, OptionsField::value_t v) { radio::debug::fpga::register_write(2, v); };
+}
+
+void PralineOptionsView::update_fpga_ctrl() {
+    radio::debug::fpga::register_write(1, fpga_reg_1);
+}
+#endif
+
 /* AnalogAudioView *******************************************************/
 
 AnalogAudioView::AnalogAudioView(
@@ -217,7 +269,14 @@ AnalogAudioView::AnalogAudioView(
                   &field_volume,
                   &text_ctcss,
                   &record_view,
-                  &waterfall});
+#ifdef PRALINE
+                  &waterfall,
+                  &button_pro
+#else
+                  &waterfall
+
+#endif
+    });
 
     // Filename Datetime and Frequency
     record_view.set_filename_date_frequency(true);
@@ -256,6 +315,10 @@ AnalogAudioView::AnalogAudioView(
         field_frequency.set_value(receiver_model.target_frequency() + offset);
     };
 
+#ifdef PRALINE
+    button_pro.on_select = [this](Button&) { this->on_show_options_praline(); };
+#endif
+
     audio::output::start();
 
     // This call starts the correct baseband image to run
@@ -511,7 +574,11 @@ void AnalogAudioView::update_modulation(ReceiverModel::Mode modulation) {
     const auto is_wideband_spectrum_mode = (modulation == ReceiverModel::Mode::SpectrumAnalysis);
     receiver_model.set_modulation(modulation);
 
+#ifdef PRALINE
+    receiver_model.set_sampling_rate(is_wideband_spectrum_mode ? spec_bw : 3023000);
+#else
     receiver_model.set_sampling_rate(is_wideband_spectrum_mode ? spec_bw : 3072000);
+#endif
     receiver_model.set_baseband_bandwidth(is_wideband_spectrum_mode ? spec_bw / 2 : 1750000);
 
     receiver_model.set_hidden_offset(modulation == ReceiverModel::Mode::AMAudioFMApt ? -2200 : 0);  // wefax needs to be shifted, see wefax rx app.
@@ -553,4 +620,11 @@ void AnalogAudioView::handle_coded_squelch(uint32_t value) {
 void AnalogAudioView::on_freqchg(int64_t freq) {
     field_frequency.set_value(freq);
 }
+
+#ifdef PRALINE
+void AnalogAudioView::on_show_options_praline() {
+    set_options_widget(std::make_unique<PralineOptionsView>(options_view_rect, Theme::getInstance()->option_active));
+}
+#endif
+
 } /* namespace ui */

firmware/application/apps/analog_audio_app.hpp

@@ -37,6 +37,41 @@ namespace ui {
 
 class AnalogAudioView;
 
+#ifdef PRALINE
+class PralineOptionsView : public View {
+   public:
+    PralineOptionsView(Rect parent_rect, const Style* style);
+
+   private:
+    // Layout: SR (Sample Rate), DC (DC Block), QI (Q-Invert), QS (Quarter Shift), D (Decim)
+    Text label_sr{{UI_POS_X(0), UI_POS_Y(0), UI_POS_WIDTH(2), UI_POS_HEIGHT(1)}, "SR"};
+
+    // Parameters: Position, Length (in chars), Range, Step, and default value
+    NumberField options_sr{
+        {UI_POS_X(3), UI_POS_Y(0)},
+        5,           // Number of digits to show
+        {0, 40000},  // Range: 0 to 40,000 kHz
+        1,           // Step: 1 kHz
+        ' '          // Fix: Single quotes for char
+    };
+
+    Text label_dc{{UI_POS_X(8), UI_POS_Y(0), UI_POS_WIDTH(2), UI_POS_HEIGHT(1)}, "DC"};
+    OptionsField options_dc{{UI_POS_X(11), UI_POS_Y(0)}, 2, {{"Of", 0}, {"On", 1}}};
+
+    Text label_qi{{UI_POS_X(14), UI_POS_Y(0), UI_POS_WIDTH(2), UI_POS_HEIGHT(1)}, "QI"};
+    OptionsField options_qi{{UI_POS_X(17), UI_POS_Y(0)}, 2, {{"Of", 0}, {"On", 1}}};
+
+    Text label_qs{{UI_POS_X(20), UI_POS_Y(0), UI_POS_WIDTH(2), UI_POS_HEIGHT(1)}, "QS"};
+    OptionsField options_qs{{UI_POS_X(23), UI_POS_Y(0)}, 2, {{"Of", 0}, {"On", 1}}};
+
+    Text label_dec{{UI_POS_X(26), UI_POS_Y(0), UI_POS_WIDTH(1), UI_POS_HEIGHT(1)}, "D"};
+    OptionsField options_dec{{UI_POS_X(28), UI_POS_Y(0)}, 2, {{" 1", 0}, {" 2", 1}, {" 4", 2}, {" 8", 3}, {"16", 4}}};
+
+    uint8_t fpga_reg_1{0x00};  // Tracks DC, QI, QS bits
+    void update_fpga_ctrl();
+};
+#endif
+
 class AMOptionsView : public View {
    public:
     AMOptionsView(AnalogAudioView* view, Rect parent_rect, const Style* style);
@@ -222,6 +257,11 @@ class AnalogAudioView : public View {
     uint8_t get_previous_zoom_option();
     void set_previous_zoom_option(uint8_t zoom);
 
+#ifdef PRALINE
+    Button button_pro{{UI_POS_X(12), UI_POS_Y(2), UI_POS_WIDTH(3), UI_POS_HEIGHT(1)}, "PRO"};
+    void on_show_options_praline();
+#endif
+
    private:
     static constexpr ui::Dim header_height = 3 * 16;
 

firmware/application/apps/ble_tx_app.cpp

@@ -199,6 +199,7 @@ void BLETxView::send_packet() {
     generateRandomMacAddress(randomMac);
 
     char advertisementData[63] = {0};
+    packets[current_packet].advertisementData[62] = '\0';
     strcpy(advertisementData, packets[current_packet].advertisementData);
 
     // TODO: Make this a checkbox.
@@ -225,7 +226,7 @@ void BLETxView::send_packet() {
                         uint8_t min = 0x00;
                         uint8_t max = 0x0F;
 
-                        hexDigit = min + std::rand() % (max - min + 1);
+                        hexDigit = min + rand() % (max - min + 1);
                     } break;
                     default:
                         hexDigit = 0;

firmware/application/apps/ui_adsb_rx.cpp

@@ -271,10 +271,17 @@ ADSBRxDetailsView::ADSBRxDetailsView(
          &text_frame_pos_even,
          &text_frame_pos_odd,
          &button_aircraft_details,
-         &button_see_map});
+         &button_see_map,
+         &opt_map_list});
 
     text_icao_address.set(entry_.icao_str);
 
+    opt_map_list.on_change = [this](size_t, uint32_t mf) {
+        map_filter = mf;
+        clear_map_markers();  // reset them
+        pos_history.clear();  // erase the trail
+    };
+
     button_aircraft_details.on_select = [this, &nav](Button&) {
         aircraft_details_view_ = nav.push<ADSBRxAircraftDetailsView>(entry_);
         nav.set_on_pop([this]() {
@@ -288,7 +295,7 @@ ADSBRxDetailsView::ADSBRxDetailsView(
             get_map_tag(entry_),
             entry_.pos.altitude,
             GeoPos::alt_unit::FEET,
-            GeoPos::spd_unit::HIDDEN,
+            GeoPos::spd_unit::KNOTS,
             entry_.pos.latitude,
             entry_.pos.longitude,
             entry_.velo.heading);
@@ -312,17 +319,107 @@ void ADSBRxDetailsView::update(const AircraftRecentEntry& entry) {
         // AC Details view is showing, nothing to update.
     } else if (geomap_view_) {
         // Map is showing, update the current item.
+        if (map_filter == 1) {
+            // add to map trail history
+            add_map_trail(entry);
+        }
         geomap_view_->update_tag(get_map_tag(entry_));
-        geomap_view_->update_position(entry.pos.latitude, entry.pos.longitude, entry.velo.heading, entry.pos.altitude, entry.velo.speed);
+        geomap_view_->update_position(entry.pos.latitude, entry.pos.longitude, entry.velo.heading, entry.pos.altitude, entry.get_ground_speed());
     } else {
         // Details is showing, update details.
         refresh_ui();
     }
 }
 
+void ADSBRxDetailsView::get_altitude_color(int32_t alt_ft, uint8_t* r, uint8_t* g, uint8_t* b) {
+    static const struct {
+        int32_t alt;
+        uint8_t r, g, b;
+    } stops[] = {
+        {0, 220, 220, 220},    // 0 ft:     White/Grey (Ground)
+        {2000, 255, 255, 0},   // 2k ft:    Yellow
+        {10000, 0, 255, 0},    // 10k ft:   Green
+        {20000, 0, 255, 255},  // 20k ft:   Cyan
+        {30000, 60, 60, 255},  // 30k ft:   Blue (Lightened for visibility on Black)
+        {40000, 255, 0, 255}   // 40k+ ft:  Magenta
+    };
+    if (alt_ft <= stops[0].alt) {
+        *r = stops[0].r;
+        *g = stops[0].g;
+        *b = stops[0].b;
+        return;
+    }
+    const int count = sizeof(stops) / sizeof(stops[0]);
+    if (alt_ft >= stops[count - 1].alt) {
+        *r = stops[count - 1].r;
+        *g = stops[count - 1].g;
+        *b = stops[count - 1].b;
+        return;
+    }
+    for (int i = 0; i < count - 1; i++) {
+        if (alt_ft < stops[i + 1].alt) {
+            float t = (float)(alt_ft - stops[i].alt) / (stops[i + 1].alt - stops[i].alt);
+
+            *r = (uint8_t)(stops[i].r + (stops[i + 1].r - stops[i].r) * t);
+            *g = (uint8_t)(stops[i].g + (stops[i + 1].g - stops[i].g) * t);
+            *b = (uint8_t)(stops[i].b + (stops[i + 1].b - stops[i].b) * t);
+            return;
+        }
+    }
+    // Fallback: in case no interval matched, default to ground color.
+    *r = stops[0].r;
+    *g = stops[0].g;
+    *b = stops[0].b;
+}
+
 void ADSBRxDetailsView::clear_map_markers() {
     if (geomap_view_)
         geomap_view_->clear_markers();
+    if (map_filter == 1)
+        refresh_trail_markers();  // re add trail
+}
+
+void ADSBRxDetailsView::refresh_trail_markers() {
+    if (!geomap_view_)
+        return;
+
+    geomap_view_->clear_markers();
+    for (const auto& pos : pos_history) {
+        GeoMarker marker{};
+        marker.lon = pos.lon;
+        marker.lat = pos.lat;
+        marker.angle = pos.heading;
+        marker.tag = "";  // No tag for trail points
+        uint8_t r, g, b;
+        get_altitude_color(pos.altitude, &r, &g, &b);
+        marker.color = Color(r, g, b);
+        geomap_view_->store_marker(marker);
+    }
+}
+
+void ADSBRxDetailsView::add_map_trail(const AircraftRecentEntry& entry) {
+    if (!geomap_view_)
+        return;
+    if (entry.pos.pos_valid == false)
+        return;
+
+    if (!pos_history.empty()) {
+        const auto& last_pos = pos_history.back();
+        const float THRESH_DEG = 0.009f;
+        const float THRESH_SQ = THRESH_DEG * THRESH_DEG;  // 0.00002025f
+
+        float d_lat = entry.pos.latitude - last_pos.lat;
+        float d_lon = entry.pos.longitude - last_pos.lon;
+        if ((d_lat * d_lat) + (d_lon * d_lon) < THRESH_SQ) {
+            return;  // Moved less than ~1000m, skip (rough estimate, varies with latitude but good enough for our purposes). This prevents adding too many points when the plane is circling or taxiing.
+        }
+    }
+
+    // Only keep the last 30 positions in the trail.
+    if (pos_history.size() >= 30)
+        pos_history.erase(pos_history.begin());
+    pos_history.push_back({entry.pos.latitude, entry.pos.longitude, entry.velo.heading, entry.pos.altitude});
+    refresh_trail_markers();
 }
 
 bool ADSBRxDetailsView::add_map_marker(const AircraftRecentEntry& entry) {
@@ -330,11 +427,16 @@ bool ADSBRxDetailsView::add_map_marker(const AircraftRecentEntry& entry) {
     if (!geomap_view_)
         return false;
 
+    if (map_filter == 1) return false;  // this is the 'only me' option, so skip all others
+
     GeoMarker marker{};
     marker.lon = entry.pos.longitude;
     marker.lat = entry.pos.latitude;
     marker.angle = entry.velo.heading;
     marker.tag = get_map_tag(entry);
+    uint8_t r, g, b;
+    get_altitude_color(entry.pos.altitude, &r, &g, &b);
+    marker.color = Color(r, g, b);
 
     auto markerStored = geomap_view_->store_marker(marker);
     return markerStored == MARKER_STORED;
@@ -651,14 +753,15 @@ void ADSBRxView::refresh_ui() {
         // Process the entries list.
         for (const auto& entry : recent) {
             // Found the entry being shown in details view. Update it.
-            if (entry.key() == detail_key) {
+            if (entry.key() == detail_key) {  // we don't add it to the markers, since this is the currently selected and shown in the middle one. This eliminates the "shadow" marker, and saves ram
                 details_view->update(entry);
                 current_updated = true;
-            }
-
-            // NB: current entry also gets a marker so it shows up if map is panned.
-            if (map_needs_update && entry.pos.pos_valid && entry.state <= ADSBAgeState::Recent) {
-                map_needs_update = details_view->add_map_marker(entry);
+            } else {
+                // Add others only
+                // NB: current entry also gets a marker so it shows up if map is panned.
+                if (map_needs_update && entry.pos.pos_valid && entry.state <= ADSBAgeState::Recent) {
+                    map_needs_update = details_view->add_map_marker(entry);
+                }
             }
 
             // Any work left to do?

firmware/application/apps/ui_adsb_rx.hpp

@@ -64,9 +64,9 @@ namespace ui {
 #define VEL_AIR_SUBSONIC 3
 #define VEL_AIR_SUPERSONIC 4
 
-#define O_E_FRAME_TIMEOUT 20          // timeout between odd and even frames
-#define MARKER_UPDATE_SECONDS_OSM 10  // "other" map marker redraw interval for osm
-#define MARKER_UPDATE_SECONDS_BIN 5   // "other" map marker redraw interval for bin map
+#define O_E_FRAME_TIMEOUT 20         // timeout between odd and even frames
+#define MARKER_UPDATE_SECONDS_OSM 8  // "other" map marker redraw interval for osm
+#define MARKER_UPDATE_SECONDS_BIN 5  // "other" map marker redraw interval for bin map
 
 /* Thresholds (in seconds) that define the transition between ages. */
 struct ADSBAgeLimit {
@@ -150,6 +150,19 @@ struct AircraftRecentEntry {
         age = 0;
     }
 
+    int32_t get_ground_speed() const {
+        if (velo.valid == false) return 0;
+        if (velo.type == SPD_GND)
+            return velo.speed;
+        else if (velo.type == SPD_IAS) {
+            if (!pos.alt_valid) return velo.speed;  // can't correct without altitude, so just return IAS
+            return (int32_t)(velo.speed * (1.0f + (0.02f * (pos.altitude / 1000.0f))));
+        } else if (velo.type == SPD_TAS)
+            return velo.speed;  // We don't know the wind speed
+        else
+            return 0;
+    }
+
     void inc_age(int delta) {
         age += delta;
 
@@ -208,50 +221,50 @@ class ADSBRxAircraftDetailsView : public View {
 
    private:
     Labels labels{
-        {{UI_POS_X(0), 1 * 16}, "ICAO:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 2 * 16}, "Registration:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 3 * 16}, "Manufacturer:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 5 * 16}, "Model:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 7 * 16}, "Type:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 8 * 16}, "Number of engines:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 9 * 16}, "Engine type:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 11 * 16}, "Owner:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 13 * 16}, "Operator:", Theme::getInstance()->fg_light->foreground}};
+        {{UI_POS_X(0), UI_POS_Y(1)}, "ICAO:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(2)}, "Registration:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(3)}, "Manufacturer:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(5)}, "Model:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(7)}, "Type:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(8)}, "Number of engines:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(9)}, "Engine type:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(11)}, "Owner:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(13)}, "Operator:", Theme::getInstance()->fg_light->foreground}};
 
     Text text_icao_address{
-        {5 * 8, 1 * 16, 6 * 8, UI_POS_HEIGHT(1)},
+        {UI_POS_X(5), UI_POS_Y(1), 6 * 8, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_registration{
-        {13 * 8, 2 * 16, 8 * 8, UI_POS_HEIGHT(1)},
+        {UI_POS_X(13), UI_POS_Y(2), 8 * 8, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_manufacturer{
-        {UI_POS_X(0), 4 * 16, 19 * 8, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(4), 19 * 8, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_model{
-        {UI_POS_X(0), 6 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(6), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_type{
-        {5 * 8, 7 * 16, 22 * 8, UI_POS_HEIGHT(1)},
+        {UI_POS_X(5), UI_POS_Y(7), 22 * 8, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_number_of_engines{
-        {18 * 8, 8 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(18), UI_POS_Y(8), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_engine_type{
-        {UI_POS_X(0), 10 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(10), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_owner{
-        {UI_POS_X(0), 12 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(12), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_operator{
-        {UI_POS_X(0), 14 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(14), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Button button_close{
@@ -270,11 +283,14 @@ class ADSBRxDetailsView : public View {
     void focus() override;
     void update(const AircraftRecentEntry& entry);
 
+    void get_altitude_color(int32_t alt_ft, uint8_t* r, uint8_t* g, uint8_t* b);
     /* Calls forwarded to map view if shown. */
     bool map_active() const { return geomap_view_; }
     void clear_map_markers();
     /* Adds a marker for the entry to the map. Returns true on success. */
     bool add_map_marker(const AircraftRecentEntry& entry);
+    void add_map_trail(const AircraftRecentEntry& entry);
+    void refresh_trail_markers();
 
     std::string title() const override { return "Details"; }
 
@@ -297,57 +313,72 @@ class ADSBRxDetailsView : public View {
     // if removed from the recent entries list.
     AircraftRecentEntry entry_{AircraftRecentEntry::invalid_key};
     bool airline_checked{false};
+    uint8_t map_filter{0};  // 0: all, 1: only this, set by opt_map_list.
+    struct PosHistory {
+        float lat;
+        float lon;
+        uint16_t heading;
+        int32_t altitude;
+    };
+    std::vector<PosHistory> pos_history{};
 
     Labels labels{
-        {{UI_POS_X(0), 1 * 16}, "ICAO:", Theme::getInstance()->fg_light->foreground},
-        {{13 * 8, 1 * 16}, "Callsign:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 2 * 16}, "Last seen:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 3 * 16}, "Airline:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 5 * 16}, "Country:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 13 * 16}, "Even position frame:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 15 * 16}, "Odd position frame:", Theme::getInstance()->fg_light->foreground}};
+        {{UI_POS_X(0), UI_POS_Y(0)}, "ICAO:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(13), UI_POS_Y(0)}, "Callsign:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(1)}, "Last seen:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(2)}, "Airline:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(4)}, "Country:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(7)}, "Map filter:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(13)}, "Even position frame:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(15)}, "Odd position frame:", Theme::getInstance()->fg_light->foreground}};
 
     Text text_icao_address{
-        {5 * 8, 1 * 16, 6 * 8, UI_POS_HEIGHT(1)},
+        {UI_POS_X(5), UI_POS_Y(0), 6 * 8, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_callsign{
-        {22 * 8, 1 * 16, 8 * 8, UI_POS_HEIGHT(1)},
+        {UI_POS_X(22), UI_POS_Y(0), 8 * 8, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_last_seen{
-        {11 * 8, 2 * 16, 19 * 8, UI_POS_HEIGHT(1)},
+        {UI_POS_X(11), UI_POS_Y(1), 19 * 8, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_airline{
-        {UI_POS_X(0), 4 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(3), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_country{
-        {8 * 8, 5 * 16, 22 * 8, UI_POS_HEIGHT(1)},
+        {UI_POS_X(8), UI_POS_Y(4), 22 * 8, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_infos{
-        {UI_POS_X(0), 6 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(5), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_info2{
-        {UI_POS_X(0), 7 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(6), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_frame_pos_even{
-        {UI_POS_X(0), 14 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(14), screen_width, UI_POS_HEIGHT(1)},
         "-"};
     Text text_frame_pos_odd{
-        {UI_POS_X(0), 16 * 16, screen_width, UI_POS_HEIGHT(1)},
+        {UI_POS_X(0), UI_POS_Y(16), screen_width, UI_POS_HEIGHT(1)},
         "-"};
 
     Button button_aircraft_details{
-        {UI_POS_X_CENTER(12) - UI_POS_X(8), UI_POS_Y(9), UI_POS_WIDTH(12), UI_POS_HEIGHT(3)},
+        {UI_POS_X_CENTER(12) - UI_POS_X(8), UI_POS_Y(8), UI_POS_WIDTH(12), UI_POS_HEIGHT(3)},
         "A/C details"};
 
+    OptionsField opt_map_list{
+        {UI_POS_X_CENTER(12) + UI_POS_X(8), UI_POS_Y(7)},
+        12,
+        {{"All", 0},
+         {"Only this", 1}}};
+
     Button button_see_map{
-        {UI_POS_X_CENTER(12) + UI_POS_X(8), UI_POS_Y(9), UI_POS_WIDTH(12), UI_POS_HEIGHT(3)},
+        {UI_POS_X_CENTER(12) + UI_POS_X(8), UI_POS_Y(8), UI_POS_WIDTH(12), UI_POS_HEIGHT(3)},
         "See on map"};
 
     MessageHandlerRegistration message_handler_gps{

firmware/application/apps/ui_aprs_tx.cpp

@@ -29,6 +29,7 @@
 #include "baseband_api.hpp"
 #include "portapack_shared_memory.hpp"
 #include "portapack_persistent_memory.hpp"
+#include "ui_geomap.hpp"
 
 #include <cstring>
 #include <stdio.h>
@@ -49,10 +50,24 @@ APRSTXView::~APRSTXView() {
 
 void APRSTXView::start_tx() {
     // TODO: Clean up this API to take string_views to avoid allocations.
+    std::string new_payload = payload;
+
+    std::string gps = text_gps_coord.get();
+    std::string token = "?GPS?";
+    size_t pos = 0;
+    while ((pos = new_payload.find(token, pos)) != std::string::npos) {
+        new_payload.replace(pos, token.size(), gps);
+        pos += gps.size();
+    }
+
+    text_payload.set(new_payload);
+
+    std::string path = text_path.get();
+
     make_aprs_frame(
         sym_source.to_string().c_str(), num_ssid_source.value(),
         sym_dest.to_string().c_str(), num_ssid_dest.value(),
-        payload);
+        new_payload, path);
 
     // uint8_t * bb_data_ptr = shared_memory.bb_data.data;
     // text_payload.set(to_string_hex_array(bb_data_ptr + 56, 15));
@@ -77,6 +92,61 @@ void APRSTXView::on_tx_progress(const uint32_t progress, const bool done) {
     }
 }
 
+void APRSTXView::process_coordinates(float lat_, float lon_) {
+    std::string s;
+
+    char ns = lat_ >= 0 ? 'N' : 'S';
+    float lat = (lat_ >= 0) ? lat_ : -lat_;
+    uint32_t lat_d = (uint32_t)lat;
+    uint32_t lat_m = (uint32_t)((lat - lat_d) * 6000.0f + 0.5f);
+
+    if (lat_m >= 6000) {
+        lat_m = 0;
+        lat_d++;
+    }
+
+    s += to_string_dec_uint(lat_d, 2, '0');
+    s += to_string_dec_uint(lat_m / 100, 2, '0');
+    s += ".";
+    s += to_string_dec_uint(lat_m % 100, 2, '0');
+    s += ns;
+
+    s += "/";
+
+    char ew = lon_ >= 0 ? 'E' : 'W';
+    float lon = (lon_ >= 0) ? lon_ : -lon_;
+    uint32_t lon_d = (uint32_t)lon;
+    uint32_t lon_m = (uint32_t)((lon - lon_d) * 6000.0f + 0.5f);
+
+    if (lon_m >= 6000) {
+        lon_m = 0;
+        lon_d++;
+    }
+
+    s += to_string_dec_uint(lon_d, 3, '0');
+    s += to_string_dec_uint(lon_m / 100, 2, '0');
+    s += ".";
+    s += to_string_dec_uint(lon_m % 100, 2, '0');
+    s += ew;
+    text_gps_coord.set(s);
+}
+
+void APRSTXView::on_gps(const GPSPosDataMessage* message) {
+    if (manual_gps_mode) {
+        return;  // no more update once set manually
+    }
+    if (message->lat < -90.0 || message->lat > 90.0 ||
+        message->lon < -180.0 || message->lon > 180.0) {
+        return;
+    }
+    if (message->lat == 0.0f && message->lon == 0.0f) {
+        return;
+    }
+    last_lat = message->lat;
+    last_lon = message->lon;
+    process_coordinates(message->lat, message->lon);
+}
+
 APRSTXView::APRSTXView(NavigationView& nav) {
     baseband::run_image(portapack::spi_flash::image_tag_afsk);
 
@@ -87,8 +157,33 @@ APRSTXView::APRSTXView(NavigationView& nav) {
                   &num_ssid_dest,
                   &text_payload,
                   &button_set,
+                  &text_gps_coord,
+                  &button_mangps,
+                  &gps_is_manual,
+                  &text_path,
+                  &button_setpath,
                   &tx_view});
 
+    sym_source.set_value(symsrc);
+    num_ssid_source.set_value(ssidsrc);
+    sym_dest.set_value(symdst);
+    num_ssid_dest.set_value(ssiddst);
+    text_payload.set(payload);
+    text_path.set(path_cache);
+
+    sym_source.on_change = [this](SymField&) {
+        symsrc = sym_source.to_string();
+    };
+    num_ssid_source.on_change = [this](int32_t v) {
+        ssidsrc = v;
+    };
+    sym_dest.on_change = [this](SymField&) {
+        symdst = sym_dest.to_string();
+    };
+    num_ssid_dest.on_change = [this](int32_t v) {
+        ssiddst = v;
+    };
+
     button_set.on_select = [this, &nav](Button&) {
         text_prompt(
             nav,
@@ -99,6 +194,17 @@ APRSTXView::APRSTXView(NavigationView& nav) {
                 text_payload.set(s);
             });
     };
+    button_setpath.on_select = [this, &nav](Button&) {
+        text_prompt(
+            nav,
+            path_cache,
+            60,
+            ENTER_KEYBOARD_MODE_ALPHA,
+            [this](std::string& s) {
+                text_path.set(s);
+                path_cache = s;
+            });
+    };
 
     tx_view.on_edit_frequency = [this, &nav]() {
         auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.target_frequency());
@@ -116,6 +222,23 @@ APRSTXView::APRSTXView(NavigationView& nav) {
         tx_view.set_transmitting(false);
         transmitter_model.disable();
     };
+
+    button_mangps.on_select = [this, &nav](Button&) {
+        nav.push<GeoMapView>(
+            0,
+            GeoPos::alt_unit::METERS,
+            GeoPos::spd_unit::HIDDEN,
+            last_lat,
+            last_lon,
+            [this](int32_t, float lat, float lon, int32_t) {
+                last_lat = lat;
+                last_lon = lon;
+                manual_gps_mode = true;
+                gps_is_manual.set("MANUAL");
+                process_coordinates(lat, lon);
+            });
+    };
+    // process_coordinates(last_lat, last_lon); //don't load last, so won't confuse users
 }
 
 } /* namespace ui */

firmware/application/apps/ui_aprs_tx.hpp

@@ -50,59 +50,109 @@ class APRSTXView : public View {
         1750000 /* bandwidth */,
         AFSK_TX_SAMPLERATE /* sampling rate */
     };
-    app_settings::SettingsManager settings_{
-        "tx_aprs", app_settings::Mode::TX};
 
+    std::string symsrc = "";
+    std::string symdst = "";
     std::string payload{""};
+    std::string path_cache = "";
+    int32_t ssidsrc = 0;
+    int32_t ssiddst = 0;
+
+    bool manual_gps_mode = false;
+    float last_lat = 0.0f;
+    float last_lon = 0.0f;
+
+    app_settings::SettingsManager settings_{
+        "tx_aprs",
+        app_settings::Mode::TX,
+        {{"symsrc"sv, &symsrc},
+         {"symdst"sv, &symdst},
+         {"ssidsrc"sv, &ssidsrc},
+         {"ssiddst"sv, &ssiddst},
+         {"payload"sv, &payload},
+         {"last_lat"sv, &last_lat},
+         {"last_lon"sv, &last_lon},
+         {"path"sv, &path_cache}}};
 
     void start_tx();
     void generate_frame();
     void generate_frame_pos();
     void on_tx_progress(const uint32_t progress, const bool done);
+    void on_gps(const GPSPosDataMessage* message);
+    void process_coordinates(float lat, float lon);
 
     Labels labels{
-        {{UI_POS_X(0), 1 * 16}, "Source:       SSID:", Theme::getInstance()->fg_light->foreground},  // 6 alphanum + SSID
-        {{UI_POS_X(0), 2 * 16}, " Dest.:       SSID:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 4 * 16}, "Info field:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(0)}, "Source:       SSID:", Theme::getInstance()->fg_light->foreground},  // 6 alphanum + SSID
+        {{UI_POS_X(0), UI_POS_Y(1)}, " Dest.:       SSID:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(2)}, "Path: (ex.: WIDE1-1,WIDE2-1)", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(6)}, "Info field:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(10)}, "GPS:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_CENTER(22), UI_POS_Y(14)}, "Use ?GPS? in the info", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_CENTER(17), UI_POS_Y(15)}, "as a placeholder.", Theme::getInstance()->fg_light->foreground},
+    };
+
+    Text text_path{
+        {UI_POS_X(0), UI_POS_Y(3), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)},
+        "WIDE1-1",
+    };
+    Text gps_is_manual{
+        {UI_POS_X(6), UI_POS_Y(10), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
+        "",
     };
 
     SymField sym_source{
-        {7 * 8, 1 * 16},
+        {UI_POS_X(7), UI_POS_Y(0)},
         6,
         SymField::Type::Alpha};
 
     NumberField num_ssid_source{
-        {19 * 8, 1 * 16},
+        {UI_POS_X(19), UI_POS_Y(0)},
         2,
         {0, 15},
         1,
         ' '};
 
     SymField sym_dest{
-        {7 * 8, 2 * 16},
+        {UI_POS_X(7), UI_POS_Y(1)},
         6,
         SymField::Type::Alpha};
 
     NumberField num_ssid_dest{
-        {19 * 8, 2 * 16},
+        {UI_POS_X(19), UI_POS_Y(1)},
         2,
         {0, 15},
         1,
         ' '};
 
     Text text_payload{
-        {UI_POS_X(0), 5 * 16, screen_width, 16},
-        "-"};
+        {UI_POS_X(0), UI_POS_Y(7), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)},
+        ""};
     Button button_set{
-        {UI_POS_X(0), 6 * 16, 80, 32},
+        {UI_POS_X(0), UI_POS_Y(8), UI_POS_WIDTH(10), UI_POS_HEIGHT(2)},
         "Set"};
 
+    Text text_gps_coord{
+        {UI_POS_X(0), UI_POS_Y(11), UI_POS_WIDTH(20), UI_POS_HEIGHT(1)},
+        "-"};
+
+    Button button_mangps{
+        {UI_POS_X(0), UI_POS_Y(12), UI_POS_WIDTH(14), UI_POS_HEIGHT(2)},
+        "Manual GPS"};
+    Button button_setpath{
+        {UI_POS_X(0), UI_POS_Y(4), UI_POS_WIDTH(14), UI_POS_HEIGHT(2)},
+        "Set Path"};
     TransmitterView tx_view{
         (int16_t)UI_POS_Y_BOTTOM(4),
         5000,
         0  // disable setting bandwith, since APRS used fixed 10k bandwidth
     };
 
+    MessageHandlerRegistration message_handler_gps{
+        Message::ID::GPSPosData,
+        [this](Message* const p) {
+            const auto message = static_cast<const GPSPosDataMessage*>(p);
+            this->on_gps(message);
+        }};
     MessageHandlerRegistration message_handler_tx_progress{
         Message::ID::TXProgress,
         [this](const Message* const p) {

firmware/application/apps/ui_battinfo.hpp

@@ -98,7 +98,7 @@ class BattinfoView : public View {
         "Volt"};
 
     Button button_exit{
-        {UI_POS_X_CENTER(12), 17 * 16, UI_POS_WIDTH(12), UI_POS_HEIGHT(3)},
+        {UI_POS_X_CENTER(12), UI_POS_Y_BOTTOM(4), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
         "Back"};
     static msg_t static_fn(void* arg);
     Thread* thread{nullptr};

firmware/application/apps/ui_debug.hpp

@@ -93,6 +93,10 @@ typedef enum {
     CT_SI5351,
     CT_AUDIO,
     CT_MAX17055,
+#ifdef PRALINE
+    CT_FPGA,
+#endif
+    CT_SGPIO,
 } chip_type_t;
 
 struct RegistersWidgetConfig {
@@ -373,6 +377,829 @@ private:
         };
 };*/
 
+/* Radio Signal Path Diagnostics View
+ * Shows status of each component in the RX/TX signal chain:
+ * Antenna -> RF Path -> RFFC5072 -> MAX283x -> MAX5864 -> FPGA -> SGPIO -> MCU
+ */
+class RadioDiagnosticsView : public View {
+   public:
+    RadioDiagnosticsView(NavigationView& nav);
+
+    void focus() override;
+    std::string title() const override { return "Radio Diag"; };
+
+   private:
+    NavigationView& nav_;
+
+    void update_status();
+
+    Text text_title{{0, 0, 240, 16}, "=== Signal Path Status ==="};
+
+    Text text_lbl_rffc{{0, 20, 140, 16}, "RFFC5072 (1st IF):"};
+    Text text_rffc_status{{144, 20, 96, 16}, "---"};
+
+    Text text_lbl_max{{0, 36, 140, 16}, "MAX283x (2nd IF):"};
+    Text text_max_status{{144, 36, 96, 16}, "---"};
+
+    Text text_lbl_adc{{0, 52, 140, 16}, "MAX5864 (ADC):"};
+    Text text_adc_status{{144, 52, 96, 16}, "---"};
+
+    Text text_lbl_fpga{{0, 68, 140, 16}, "FPGA/CPLD:"};
+    Text text_fpga_status{{144, 68, 96, 16}, "---"};
+
+    Text text_lbl_sgpio{{0, 84, 140, 16}, "SGPIO:"};
+    Text text_sgpio_status{{144, 84, 96, 16}, "---"};
+
+    Text text_lbl_clock{{0, 100, 140, 16}, "Si5351 Clocks:"};
+    Text text_clock_status{{144, 100, 96, 16}, "---"};
+
+    Text text_regs_title{{0, 124, 240, 16}, "=== Key Registers ==="};
+
+    Text text_lbl_rffc_reg{{0, 144, 80, 16}, "RFFC R0:"};
+    Text text_rffc_reg{{80, 144, 160, 16}, "---"};
+
+    Text text_lbl_max_reg{{0, 160, 80, 16}, "MAX R0:"};
+    Text text_max_reg{{80, 160, 160, 16}, "---"};
+
+    Text text_lbl_fpga_reg{{0, 176, 80, 16}, "FPGA:"};
+    Text text_fpga_reg{{80, 176, 160, 16}, "---"};
+
+    Text text_lbl_sgpio_reg{{0, 192, 80, 16}, "SGPIO:"};
+    Text text_sgpio_reg{{80, 192, 160, 16}, "---"};
+
+    Text text_test_result{{0, 220, 240, 32}, ""};
+
+    Button button_refresh{
+        {8, 280, 72, 24},
+        "Refresh"};
+
+    Button button_done{
+        {168, 280, 64, 24},
+        "Done"};
+};
+
+#ifdef PRALINE
+/* Praline-Specific Radio Debug View
+ * Monitors Mixer Lock, SPI Bit Depth, and toggles Si5351 CLK5
+ */
+class PralineRadioDebugView : public View {
+   public:
+    PralineRadioDebugView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "Pro Radio Debug"; };
+
+   private:
+    void refresh();
+    void toggle_clk5();
+
+    Text text_title{{0, 0, 240, 16}, "=== Pro Radio Debug ==="};
+
+    // Mixer Lock (PD_11 / GPIO6[25])
+    Text text_lbl_lock{{0, 24, 124, 16}, "Mix Lock (LD):"};
+    Text text_lock_status{{126, 24, 114, 16}, "---"};
+
+    // Si5351 CLK5 (Mixer Reference)
+    Text text_lbl_clk5{{0, 40, 124, 16}, "Si5351 CLK5(Mix):"};
+    Text text_clk5_status{{126, 40, 114, 16}, "---"};
+
+    // SPI Bus configuration check
+    Text text_lbl_spi{{0, 56, 124, 16}, "SPI Bit Mode:"};
+    Text text_spi_status{{126, 56, 118, 16}, "---"};
+
+    // FPGA DC Block (Reg 1)
+    Text text_lbl_fpga_ctrl{{0, 72, 124, 16}, "FPGA Reg 1:"};
+    Text text_fpga_ctrl{{126, 72, 118, 16}, "---"};
+
+    // VAA Power Rail (P8_1 / GPIO4[1])
+    Text text_lbl_vaa{{0, 88, 124, 16}, "VAA RF Power:"};
+    Text text_vaa_status{{126, 88, 118, 16}, "---"};
+
+    Text text_status_msg{{0, 110, 240, 48}, ""};
+
+    Button button_refresh{{8, 240, 72, 24}, "Refresh"};
+    Button button_toggle_clk5{{88, 240, 72, 24}, "CLK5_T"};
+    Button button_done{{168, 240, 64, 24}, "Done"};
+};
+#endif
+
+/* WFMAudioDebugView ***************************************************/
+
+#ifdef PRALINE
+class WFMAudioDebugView : public View {
+   public:
+    WFMAudioDebugView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "WFM Audio Debug"; }
+
+   private:
+    void refresh();
+
+    NavigationView& nav_;
+
+    Text text_title{{0, 0, 240, 16}, "=== WFM Audio Debug ==="};
+
+    // Sample rates section
+    Text text_lbl_clk0{{0, 20, 140, 16}, "Si5351 CLK0 Rate:"};
+    Text text_clk0{{150, 20, 90, 16}, "---"};
+
+    Text text_lbl_fpga_dec{{0, 36, 140, 16}, "FPGA Decimation:"};
+    Text text_fpga_dec{{150, 36, 90, 16}, "---"};
+
+    Text text_lbl_post_fpga{{0, 52, 140, 16}, "Post-FPGA Rate:"};
+    Text text_post_fpga{{150, 52, 90, 16}, "---"};
+
+    // MAX2831 section
+    Text text_section1{{0, 72, 240, 16}, "--- MAX2831 LPF ---"};
+
+    Text text_lbl_reg8{{0, 88, 140, 16}, "Reg8 (LPF RX):"};
+    Text text_reg8{{150, 88, 90, 16}, "---"};
+
+    Text text_lbl_lpf_bw{{0, 104, 140, 16}, "LPF Bandwidth:"};
+    Text text_lpf_bw{{150, 104, 90, 16}, "---"};
+
+    // FPGA section
+    Text text_section2{{0, 124, 240, 16}, "--- FPGA Control ---"};
+
+    Text text_lbl_fpga_r1{{0, 140, 140, 16}, "Reg1 (Ctrl):"};
+    Text text_fpga_r1{{150, 140, 90, 16}, "---"};
+
+    Text text_lbl_dc_q{{0, 156, 70, 16}, "DC/Q/QS:"};
+    Text text_dc_q{{72, 156, 168, 16}, "---"};
+
+    // Audio section
+    Text text_section3{{0, 176, 240, 16}, "--- Audio Path ---"};
+
+    Text text_lbl_expected{{0, 192, 96, 16}, "Expctd Aud:"};
+    Text text_expected{{98, 192, 142, 16}, "---"};
+
+    Text text_lbl_deemph{{0, 208, 96, 16}, "D-emph Cfg:"};
+    Text text_deemph{{98, 208, 132, 16}, "---"};
+
+    // Status
+    Text text_status{{0, 228, 240, 16}, "---"};
+    Text text_status2{{0, 244, 240, 16}, "---"};
+
+    Button button_refresh{{10, 268, 70, 24}, "Refresh"};
+    Button button_toggle_q{{90, 268, 70, 24}, "Toggle Q"};
+    Button button_done{{170, 268, 60, 24}, "Done"};
+};
+#endif
+
+/* BasebandStatusView ***************************************************/
+
+class BasebandStatusView : public View {
+   public:
+    BasebandStatusView(NavigationView& nav);
+
+    void focus() override;
+    std::string title() const override { return "Baseband Status"; };
+
+   private:
+    NavigationView& nav_;
+
+    void update();
+
+    Text text_title{{0, 0, 240, 16}, "=== Baseband Counters ==="};
+
+    Text text_lbl_marker{{0, 20, 140, 16}, "Streaming Marker:"};
+    Text text_marker{{144, 20, 96, 16}, "---"};
+
+    Text text_lbl_loops{{0, 36, 140, 16}, "Baseband Loops:"};
+    Text text_loops{{144, 36, 96, 16}, "---"};
+
+    Text text_lbl_wait{{0, 52, 140, 16}, "DMA Wait Count:"};
+    Text text_wait{{144, 52, 96, 16}, "---"};
+
+    Text text_lbl_xfr{{0, 68, 140, 16}, "DMA Xfr Count:"};
+    Text text_xfr{{144, 68, 96, 16}, "---"};
+
+    Text text_lbl_missed{{0, 84, 140, 16}, "Buffer Missed:"};
+    Text text_missed{{144, 84, 96, 16}, "---"};
+
+    Text text_status_line1{{0, 110, 240, 16}, ""};
+    Text text_status_line2{{0, 126, 240, 16}, ""};
+    Text text_status_line3{{0, 142, 240, 16}, ""};
+
+    Button button_refresh{
+        {8, 280, 72, 24},
+        "Refresh"};
+
+    Button button_done{
+        {168, 280, 64, 24},
+        "Done"};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) { this->update(); }};
+};
+
+/* SGPIOLiveMonitorView ***************************************************/
+
+class SGPIOLiveMonitorView : public View {
+   public:
+    SGPIOLiveMonitorView(NavigationView& nav);
+
+    void focus() override;
+    std::string title() const override { return "SGPIO Live"; };
+
+   private:
+    NavigationView& nav_;
+
+    void update();
+
+    Text text_title{{0, 0, 240, 16}, "=== SGPIO Registers ==="};
+
+    Text text_lbl_ctrl{{0, 20, 140, 16}, "CTRL_ENABLE:"};
+    Text text_ctrl{{144, 20, 96, 16}, "---"};
+
+    Text text_lbl_in{{0, 36, 140, 16}, "GPIO_INREG:"};
+    Text text_in{{144, 36, 96, 16}, "---"};
+
+    Text text_lbl_ss{{0, 52, 140, 16}, "REG_SS[0]:"};
+    Text text_ss{{144, 52, 96, 16}, "---"};
+
+    Text text_lbl_status{{0, 68, 140, 16}, "STATUS_1:"};
+    Text text_status{{144, 68, 96, 16}, "---"};
+
+    Text text_lbl_out{{0, 84, 140, 16}, "GPIO_OUTREG:"};
+    Text text_out{{144, 84, 96, 16}, "---"};
+
+    Text text_lbl_oen{{0, 100, 140, 16}, "GPIO_OENREG:"};
+    Text text_oen{{144, 100, 96, 16}, "---"};
+
+    Text text_diag_line1{{0, 126, 240, 16}, ""};
+    Text text_diag_line2{{0, 142, 240, 16}, ""};
+    Text text_diag_line3{{0, 158, 240, 16}, ""};
+    Text text_diag_line4{{0, 174, 240, 16}, ""};
+
+    Button button_refresh{
+        {8, 280, 72, 24},
+        "Refresh"};
+
+    Button button_done{
+        {168, 280, 64, 24},
+        "Done"};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) { this->update(); }};
+};
+
+/* Radio RX Step-by-Step Test View
+ * Tests radio hardware directly without M0 baseband involvement.
+ * Logs each step to help isolate where the signal chain breaks.
+ */
+class RadioRxTestView : public View {
+   public:
+    RadioRxTestView(NavigationView& nav);
+
+    void focus() override;
+    std::string title() const override { return "RX Test"; };
+
+   private:
+    NavigationView& nav_;
+    bool radio_initialized_{false};
+    uint32_t test_frequency_{433000000};  // 433 MHz default
+
+    void log(const std::string& msg);
+    void log_registers(const std::string& label);
+    void run_init_test();
+    void run_rx_mode_test();
+    void run_freq_test();
+    void run_sgpio_test();
+    void run_full_test();
+    void run_step_test();
+    bool check_gpio_changing();
+
+    Labels labels{
+        {{0, 0}, "=== Radio RX Test ===", Theme::getInstance()->fg_yellow->foreground}};
+
+    Console console{
+        {0, 20, 240, 200}};
+
+    Button button_init{
+        {0, 224, 56, 24},
+        "Init"};
+
+    Button button_rx{
+        {60, 224, 56, 24},
+        "RX"};
+
+    Button button_freq{
+        {120, 224, 56, 24},
+        "Freq"};
+
+    Button button_sgpio{
+        {180, 224, 56, 24},
+        "SGPIO"};
+
+    Button button_full{
+        {0, 252, 56, 24},
+        "Full"};
+
+    Button button_step{
+        {60, 252, 56, 24},
+        "Step"};
+
+    Button button_done{
+        {120, 252, 112, 24},
+        "Done"};
+};
+
+/* SGPIO8 Clock Detector View
+ * Samples SGPIO8 pin to verify external clock is present.
+ * Shows toggle count and estimated frequency.
+ */
+class SGPIO8ClockDetectorView : public View {
+   public:
+    SGPIO8ClockDetectorView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "SGPIO8 Clock"; };
+
+   private:
+    NavigationView& nav_;
+
+    Text text_title{{8, 16, 224, 16}, "SGPIO8 Clock Detector"};
+    Text text_lbl_samples{{8, 48, 160, 16}, "Samples (first 20):"};
+    Text text_samples{{8, 64, 224, 16}, "                    "};
+    Text text_lbl_toggles{{8, 96, 160, 16}, "Toggle count:"};
+    Text text_toggles{{8, 112, 224, 16}, "                         "};
+    Text text_status{{8, 144, 224, 32}, "                              "};
+
+    Button button_sample{{8, 200, 96, 24}, "Sample"};
+    Button button_done{{128, 200, 96, 24}, "Done"};
+
+    void sample_sgpio8();
+};
+
+/* Slice Status View
+ * Shows SGPIO slice status: which slices are enabled vs active,
+ * counter values, and data capture status.
+ */
+
+/* Si5351 Debug View
+ * Dedicated diagnostic tool for Si5351 clock generator.
+ * Shows PLL lock status, clock configurations, and allows testing.
+ */
+class Si5351DebugView : public View {
+   public:
+    Si5351DebugView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "Si5351 Clocks"; };
+
+   private:
+    NavigationView& nav_;
+
+    Text text_title{{0, 0, 200, 16}, "Si5351 Clock Generator"};
+
+    Text text_status_label{{0, 16, 80, 16}, "Status Reg:"};
+    Text text_status_value{{96, 16, 144, 16}, ""};
+
+    Text text_pll_a_label{{0, 32, 80, 16}, "PLL A:"};
+    Text text_pll_a_status{{96, 32, 144, 16}, ""};
+
+    Text text_pll_b_label{{0, 48, 80, 16}, "PLL B:"};
+    Text text_pll_b_status{{96, 48, 144, 16}, ""};
+
+    Text text_sys_init_label{{0, 64, 80, 16}, "SYS_INIT:"};
+    Text text_sys_init_status{{96, 64, 144, 16}, ""};
+
+    Text text_xtal_cap_label{{0, 80, 80, 16}, "XTAL Cap:"};
+    Text text_xtal_cap_value{{96, 80, 144, 16}, ""};
+
+    Text text_clk0_label{{0, 96, 48, 16}, "CLK0:"};
+    Text text_clk0_status{{50, 96, 28, 16}, ""};
+    Text text_clk0_freq_value{{80, 96, 160, 16}, ""};
+    Text text_clk0_div_value{{50, 112, 190, 16}, ""};
+
+    Text text_clk1_label{{0, 128, 96, 16}, "CLK1 (SCT):"};
+    Text text_clk1_status{{112, 128, 128, 16}, ""};
+
+    Text text_clk4_label{{0, 144, 96, 16}, "CLK4 (MAX):"};
+    Text text_clk4_status{{112, 144, 128, 16}, ""};
+
+    Text text_clk5_label{{0, 160, 96, 16}, "CLK5 (RFFC):"};
+    Text text_clk5_status{{112, 160, 128, 16}, ""};
+
+    Button button_refresh{{8, 240, 72, 24}, "Refresh"};
+    Button button_reset_pll{{88, 240, 72, 24}, "Reset PLL"};
+    Button button_done{{168, 240, 64, 24}, "Done"};
+
+    void refresh_status();
+    void reset_pll();
+};
+
+#ifdef PRALINE
+/* SignalPathStatusView *************************************************/
+class SignalPathStatusView : public View {
+   public:
+    SignalPathStatusView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "Signal Path"; };
+
+   private:
+    NavigationView& nav_;
+    void refresh_status();
+
+    Text text_title{{0, 0, 240, 16}, "=== Signal Path Status ==="};
+
+    Text text_lbl_max_enable{{0, 20, 114, 16}, "MAX2831:"};
+    Text text_max_enable{{116, 20, 124, 16}, "---"};
+
+    Text text_lbl_max_mode{{0, 36, 114, 16}, "RX Mode:"};
+    Text text_max_mode{{116, 36, 124, 16}, "---"};
+
+    Text text_lbl_rf_path{{0, 52, 114, 16}, "RF Path:"};
+    Text text_rf_path{{116, 52, 124, 16}, "---"};
+
+    Text text_lbl_filter{{0, 68, 114, 16}, "Filter Band:"};
+    Text text_filter{{116, 68, 124, 16}, "---"};
+
+    Text text_lbl_mixer{{0, 84, 114, 16}, "Mixer Enable:"};
+    Text text_mixer{{116, 84, 124, 16}, "---"};
+
+    Text text_lbl_rf_amp{{0, 100, 114, 16}, "RF Amp:"};
+    Text text_rf_amp{{116, 100, 124, 16}, "---"};
+
+    Text text_lbl_lna{{0, 116, 114, 16}, "LNA Gain:"};
+    Text text_lna{{116, 116, 124, 16}, "---"};
+
+    Text text_lbl_vga{{0, 132, 114, 16}, "VGA Gain:"};
+    Text text_vga{{116, 132, 124, 16}, "---"};
+
+    Text text_lbl_fpga_decim{{0, 148, 114, 16}, "FPGA Decim:"};
+    Text text_fpga_decim{{116, 148, 124, 16}, "---"};
+
+    Text text_lbl_fpga_ctrl_dc_q{{0, 164, 114, 16}, "FPGA Ctrl:"};
+    Text text_fpga_ctrl_dc_q{{116, 164, 124, 16}, "---"};
+
+    Text text_lbl_fpga_ctrl_qs{{0, 180, 114, 16}, ""};
+    Text text_fpga_ctrl_qs{{116, 180, 124, 16}, "---"};
+
+    Text text_status{{0, 200, 240, 32}, ""};
+
+    Button button_refresh{{0, 280, 72, 24}, "Refresh"};
+    Button button_toggle_q{{88, 280, 72, 24}, "Q Inv"};
+    Button button_done{{176, 280, 64, 24}, "Done"};
+};
+#endif
+
+#ifdef PRALINE
+class GPIODebugView : public View {
+   public:
+    GPIODebugView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "GPIO Debug"; };
+
+   private:
+    void refresh();
+
+    // GPIO4 (LPF and RF Amp)
+    Text text_lbl_gpio4{{0, 0, 240, 16}, "Pin Diag: GPIO4 (LPF|Amp|Mix)"};
+
+    Text text_lbl_mixr1{{0, 18, 56, 16}, "MixR1:"};
+    Text text_mixr1{{58, 18, 180, 16}, "---"};
+
+    Text text_lbl_pin4{{0, 36, 114, 16}, "PIN[4] (read):"};
+    Text text_pin4{{116, 36, 124, 16}, "---"};
+
+    Text text_lbl_set4{{0, 54, 114, 16}, "SET[4] (write):"};
+    Text text_set4{{116, 54, 124, 16}, "---"};
+
+    // Bit 8 (LPF)
+    Text text_lbl_lpf_bit{{0, 78, 240, 16}, "Bit 8 (LPF - GPIO4[8]):"};
+    Text text_lpf_dir{{0, 96, 80, 16}, "DIR: ?"};
+    Text text_lpf_pin{{82, 96, 78, 16}, "PIN: ?"};
+    Text text_lpf_set{{162, 96, 78, 16}, "SET: ?"};
+
+    Button button_lpf_toggle{{8, 114, 110, 24}, "Toggle LPF"};
+    Button button_lpf_on{{122, 114, 50, 24}, "ON"};
+    Button button_lpf_off{{176, 114, 50, 24}, "OFF"};
+
+    // Bit 9 (RF Amp)
+    Text text_lbl_amp_bit{{0, 146, 240, 16}, "Bit 9 (Amp - GPIO4[9]):"};
+    Text text_amp_dir{{0, 164, 80, 16}, "DIR: ?"};
+    Text text_amp_pin{{82, 164, 78, 16}, "PIN: ?"};
+    Text text_amp_set{{162, 164, 78, 16}, "SET: ?"};
+
+    Button button_amp_toggle{{8, 182, 110, 24}, "Toggle Amp"};
+    Button button_amp_on{{122, 182, 50, 24}, "ON"};
+    Button button_amp_off{{176, 182, 50, 24}, "OFF"};
+
+    // GPIO3 (Mixer)
+    Text text_lbl_gpio3{{0, 214, 240, 16}, "--- GPIO3 (Mixer) ---"};
+    Text text_lbl_mix_bit{{0, 232, 240, 16}, "Bit 2 (MIX - GPIO3[2]):"};
+    Text text_mix_dir{{0, 250, 80, 16}, "DIR: ?"};
+    Text text_mix_pin{{82, 250, 78, 16}, "PIN: ?"};
+    Text text_mix_set{{162, 250, 78, 16}, "SET: ?"};
+
+    // Controls
+    Button button_refresh{{8, 280, 72, 24}, "Refresh"};
+    Button button_done{{168, 280, 64, 24}, "Done"};
+};
+#endif
+
+#ifdef PRALINE
+/* RFFC5072StatusView *************************************************/
+class RFFC5072StatusView : public View {
+   public:
+    RFFC5072StatusView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "RFFC5072 Status"; };
+
+   private:
+    NavigationView& nav_;
+    void refresh_status();
+
+    Text text_status{{0, 0, 240, 16}, "---"};
+
+    Text text_gpio4{{0, 16, 240, 16}, "---"};
+
+    Text text_ctrl{{0, 32, 240, 16}, "---"};
+
+    Text text_lbl_enabled{{0, 48, 114, 16}, "Status:"};
+    Text text_enabled{{116, 48, 124, 16}, "---"};
+
+    Text text_lbl_freq{{0, 64, 114, 16}, "LO Freq:"};
+    Text text_freq{{116, 64, 124, 16}, "---"};
+
+    Text text_lbl_path{{0, 80, 114, 16}, "Path:"};
+    Text text_path{{116, 80, 124, 16}, "---"};
+
+    Text text_lbl_mixer{{0, 96, 114, 16}, "Mixer:"};
+    Text text_mixer{{116, 96, 124, 16}, "---"};
+
+    Text text_lbl_r0{{0, 112, 114, 16}, "Reg 0:"};
+    Text text_r0{{116, 112, 124, 16}, "---"};
+
+    Text text_lbl_r1{{0, 128, 114, 16}, "Reg 1 (N):"};
+    Text text_r1{{116, 128, 124, 16}, "---"};
+
+    Text text_lbl_r2{{0, 144, 114, 16}, "Reg 2:"};
+    Text text_r2{{116, 144, 124, 16}, "---"};
+
+    Text text_lbl_n{{0, 160, 114, 16}, "N divider:"};
+    Text text_n{{116, 160, 124, 16}, "---"};
+
+    Text text_lbl_lodiv{{0, 176, 114, 16}, "LO divider:"};
+    Text text_lodiv{{116, 176, 124, 16}, "---"};
+
+    Text text_lbl_calc{{0, 192, 114, 16}, "Calc freq:"};
+    Text text_calc{{116, 192, 124, 16}, "---"};
+
+    Text text_regs_status{{0, 208, 240, 16}, "---"};
+
+    Text text_status2{{0, 224, 240, 16}, ""};
+    Text text_status3{{0, 240, 240, 16}, ""};
+
+    Button button_refresh{{2, 280, 72, 24}, "Refresh"};
+    Button button_force{{98, 280, 60, 24}, "SPI"};
+    Button button_done{{182, 280, 56, 24}, "Done"};
+};
+
+#ifdef PRALINE
+/* RFFCTuningDebugView *************************************************/
+class RFFCTuningDebugView : public View {
+   public:
+    RFFCTuningDebugView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "RFFC Tuning Debug"; };
+
+   private:
+    void refresh();
+
+    Text text_title{{0, 0, 240, 16}, "RFFC5072 Tuning Debug"};
+
+    Text text_lbl_called{{0, 18, 120, 16}, "Freq Set:"};
+    Text text_called{{122, 18, 118, 16}, "NO"};
+
+    Text text_lbl_req{{0, 38, 120, 16}, "Requested:"};
+    Text text_req{{122, 38, 118, 16}, "---"};
+
+    Text text_lbl_exp_n{{0, 56, 120, 16}, "Expected N:"};
+    Text text_exp_n{{122, 56, 118, 16}, "---"};
+
+    Text text_lbl_act_n{{0, 74, 120, 16}, "Actual N:"};
+    Text text_act_n{{122, 74, 118, 16}, "---"};
+
+    Text text_lbl_exp_div{{0, 92, 120, 16}, "Exp LO/Pres:"};
+    Text text_exp_div{{122, 92, 118, 16}, "---"};
+
+    Text text_lbl_act_div{{0, 110, 120, 16}, "Act LO/Pres:"};
+    Text text_act_div{{122, 110, 118, 16}, "---"};
+
+    Text text_lbl_calc{{0, 128, 120, 16}, "Calc LO freq:"};
+    Text text_calc{{122, 128, 118, 16}, "---"};
+
+    Text text_lbl_calc_lo{{0, 146, 120, 16}, "Calc input:"};
+    Text text_calc_lo{{122, 146, 118, 16}, "---"};
+
+    Text text_lbl_calc_vco{{0, 164, 120, 16}, "In Calc VCO:"};
+    Text text_calc_vco{{122, 164, 118, 16}, "---"};
+
+    Text text_lbl_vco{{0, 182, 120, 16}, "Calc VCO:"};
+    Text text_vco{{122, 182, 118, 16}, "---"};
+
+    Text text_lbl_n_q24{{0, 200, 120, 16}, "N (Q24):"};
+    Text text_n_q24{{122, 200, 118, 16}, "---"};
+
+    Text text_status{{0, 224, 240, 48}, ""};
+
+    Button button_refresh{{8, 280, 72, 24}, "Refresh"};
+    Button button_done{{168, 280, 64, 24}, "Done"};
+};
+
+#endif
+
+#ifdef PRALINE
+/* MAX2831DebugView *************************************************/
+
+class MAX2831DebugView : public View {
+   public:
+    MAX2831DebugView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "MAX2831 Debug"; };
+
+   private:
+    void refresh();
+
+    Text text_title{{0, 0, 240, 16}, "MAX2831 (2nd IF) Debug"};
+
+    Text text_lbl_called{{0, 24, 120, 16}, "Freq Set:"};
+    Text text_called{{122, 24, 118, 16}, "NO"};
+
+    Text text_lbl_valid{{0, 42, 120, 16}, "In Range:"};
+    Text text_valid{{122, 42, 118, 16}, "---"};
+
+    Text text_lbl_req{{0, 60, 120, 16}, "Requested:"};
+    Text text_req{{122, 60, 118, 16}, "---"};
+
+    Text text_lbl_calc_n{{0, 78, 120, 16}, "Calc N:"};
+    Text text_calc_n{{122, 78, 118, 16}, "---"};
+
+    Text text_lbl_calc_frac{{0, 96, 120, 16}, "Calc Frac:"};
+    Text text_calc_frac{{122, 96, 118, 16}, "---"};
+
+    Text text_spacer{{0, 114, 240, 16}, "--- Hardware Regs ---"};
+
+    Text text_lbl_r3{{0, 132, 120, 16}, "Reg 3:"};
+    Text text_r3{{122, 132, 118, 16}, "---"};
+
+    Text text_lbl_r4{{0, 150, 120, 16}, "Reg 4:"};
+    Text text_r4{{122, 150, 118, 16}, "---"};
+
+    Text text_lbl_act_n{{0, 168, 120, 16}, "Actual N:"};
+    Text text_act_n{{122, 168, 118, 16}, "---"};
+
+    Text text_lbl_act_frac{{0, 186, 120, 16}, "Actual Frac:"};
+    Text text_act_frac{{122, 186, 118, 16}, "---"};
+
+    Text text_lbl_calc_freq{{0, 204, 120, 16}, "Calc Freq:"};
+    Text text_calc_freq{{122, 204, 118, 16}, "---"};
+
+    Text text_status{{0, 228, 240, 44}, ""};
+
+    Button button_refresh{{8, 280, 72, 24}, "Refresh"};
+    Button button_done{{168, 280, 64, 24}, "Done"};
+};
+#endif
+
+#ifdef PRALINE
+class SystemDiagnosticsView : public View {
+   public:
+    SystemDiagnosticsView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "System Diagnostics"; };
+
+   private:
+    void refresh();
+    void read_gpio_states();
+    void set_sample_rate(uint32_t rate);
+
+    Text text_title{{0, 0, 240, 16}, "System Diagnostics"};
+
+    // Sample Rate Section
+    Text text_lbl_sample{{0, 24, 42, 16}, "Rate:"};
+    Text text_sample_rate{{44, 24, 50, 16}, "---"};
+    Text text_lbl_fpga_decode{{96, 24, 144, 16}, "DC:? Q:? QS:?"};
+
+    Button button_sample_2m{{2, 44, 56, 24}, "2 MSPS"};
+    Button button_sample_4m{{62, 44, 56, 24}, "4 MSPS"};
+    Button button_sample_8m{{122, 44, 56, 24}, "8 MSPS"};
+    Button button_sample_20m{{182, 44, 56, 24}, "20 MSPS"};
+
+    // Baseband Filter Section
+    Text text_lbl_bb_filter{{0, 76, 114, 16}, "BB Filter BW:"};
+    Text text_bb_filter{{116, 76, 124, 16}, "---"};
+
+    Text text_lbl_reg8{{0, 94, 114, 16}, "MAX2831 R8:"};
+    Text text_reg8{{116, 94, 124, 16}, "---"};
+
+    // GPIO States Section
+    Text text_lbl_gpio{{0, 118, 240, 16}, "--- GPIO Pin States ---"};
+
+    Text text_lbl_lpf{{0, 136, 56, 16}, "LPF:"};
+    Text text_gpio_lpf{{58, 136, 181, 16}, "---"};
+
+    Text text_lbl_mix{{0, 154, 56, 16}, "Mixer:"};
+    Text text_gpio_mix{{58, 154, 181, 16}, "---"};
+
+    Text text_lbl_amp{{0, 172, 56, 16}, "RF Amp:"};
+    Text text_gpio_amp{{58, 172, 181, 16}, "---"};
+
+    // FPGA Control Section
+    Text text_lbl_fpga{{0, 196, 240, 16}, "--- FPGA Control ---"};
+
+    Text text_lbl_fpga_ctrl{{0, 214, 114, 16}, "FPGA Reg 1:"};
+    Text text_fpga_ctrl{{116, 214, 124, 16}, "---"};
+
+    Text text_lbl_band{{0, 232, 48, 16}, "Band:"};
+    Text text_band{{50, 232, 190, 16}, "---"};
+
+    Button button_toggle_q{{2, 252, 110, 24}, "Toggle Q Inv"};
+    Button button_toggle_dc{{122, 252, 110, 24}, "Toggle DC Blk"};
+
+    // Control Buttons
+    Button button_refresh{{2, 280, 72, 24}, "Refresh"};
+    Button button_done{{168, 280, 64, 24}, "Done"};
+};
+#endif
+
+#ifdef PRALINE
+class PralineClockDebugView : public View {
+   public:
+    PralineClockDebugView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "Pro Clock Status"; };
+
+   private:
+    void refresh();
+
+    Text text_title{{0, 0, 240, 16}, "=== Pro Clock Dashboard ==="};
+
+    // System Status
+    Text text_lbl_pll{{0, 20, 80, 16}, "PLL Lock:"};
+    Text text_pll_status{{88, 20, 152, 16}, "---"};
+
+    Text text_lbl_afe{{0, 36, 80, 16}, "AFE Rate:"};
+    Text text_afe_rate{{88, 36, 152, 16}, "---"};
+
+    Text text_lbl_n{{0, 52, 80, 16}, "Decim (n):"};
+    Text text_n_val{{88, 52, 152, 16}, "-"};
+
+    // Table Header
+    Text text_header{{0, 72, 240, 16}, "ID  mA   Mode   Phase  Stat"};
+
+    // Helper structure to group row widgets for CLK0-CLK5
+    struct ClockRow {
+        Text* id;
+        Text* ma;
+        Text* mode;
+        Text* phase;
+        Text* stat;
+    };
+    std::vector<ClockRow> rows;
+
+    // We define the actual widgets for 6 clocks
+    // Note: Layout uses 16px vertical spacing per row
+    Text t0_id{{0, 88, 24, 16}, "C0:"};
+    Text t0_ma{{32, 88, 24, 16}, "-"};
+    Text t0_mode{{64, 88, 48, 16}, "-"};
+    Text t0_ph{{128, 88, 56, 16}, "-"};
+    Text t0_st{{192, 88, 48, 16}, "-"};
+    Text t1_id{{0, 104, 24, 16}, "C1:"};
+    Text t1_ma{{32, 104, 24, 16}, "-"};
+    Text t1_mode{{64, 104, 48, 16}, "-"};
+    Text t1_ph{{128, 104, 56, 16}, "-"};
+    Text t1_st{{192, 104, 48, 16}, "-"};
+    Text t2_id{{0, 120, 24, 16}, "C2:"};
+    Text t2_ma{{32, 120, 24, 16}, "-"};
+    Text t2_mode{{64, 120, 48, 16}, "-"};
+    Text t2_ph{{128, 120, 56, 16}, "-"};
+    Text t2_st{{192, 120, 48, 16}, "-"};
+    Text t3_id{{0, 136, 24, 16}, "C3:"};
+    Text t3_ma{{32, 136, 24, 16}, "-"};
+    Text t3_mode{{64, 136, 48, 16}, "-"};
+    Text t3_ph{{128, 136, 56, 16}, "-"};
+    Text t3_st{{192, 136, 48, 16}, "-"};
+    Text t4_id{{0, 152, 24, 16}, "C4:"};
+    Text t4_ma{{32, 152, 24, 16}, "-"};
+    Text t4_mode{{64, 152, 48, 16}, "-"};
+    Text t4_ph{{128, 152, 56, 16}, "-"};
+    Text t4_st{{192, 152, 48, 16}, "-"};
+    Text t5_id{{0, 168, 24, 16}, "C5:"};
+    Text t5_ma{{32, 168, 24, 16}, "-"};
+    Text t5_mode{{64, 168, 48, 16}, "-"};
+    Text t5_ph{{128, 168, 56, 16}, "-"};
+    Text t5_st{{192, 168, 48, 16}, "-"};
+
+    Button button_refresh{{8, 260, 100, 24}, "Refresh"};
+    Button button_done{{132, 260, 100, 24}, "Done"};
+};
+#endif
+
+#endif
+
 class DebugPeripheralsMenuView : public BtnGridView {
    public:
     DebugPeripheralsMenuView(NavigationView& nav);

firmware/application/apps/ui_flash_utility.cpp

@@ -45,10 +45,14 @@ bool valid_firmware_file(std::filesystem::path::string_type path) {
     // test read of the whole file just to validate checksum (baseband flash code will re-read when flashing)
     auto result = firmware_file.open(path.c_str());
     if (!result.is_valid()) {
+        uint64_t file_size = firmware_file.size();
+        if (file_size > FLASH_ROM_SIZE) {
+            // Firmware file is larger than the flash size for this device
+            return false;
+        }
         checksum = 0;
-        for (uint32_t offset = 0; offset < FLASH_ROM_SIZE; offset += sizeof(read_buffer)) {
+        for (uint64_t offset = 0; offset < FLASH_ROM_SIZE && offset < file_size; offset += sizeof(read_buffer)) {
             auto readResult = firmware_file.read(&read_buffer, sizeof(read_buffer));
-
             if ((!readResult) || (readResult.value() != sizeof(read_buffer))) {
                 // File was smaller than 1MB:
                 // If version is such that the file SHOULD have been 1MB, call it a checksum error (otherwise say it's OK).

firmware/application/apps/ui_flash_utility.hpp

@@ -32,7 +32,7 @@
 #include "untar.hpp"
 #include <cstdint>
 
-#define FLASH_ROM_SIZE 1048576
+#define FLASH_ROM_SIZE (FLASH_SIZE_MB * 1024 * 1024)
 #define FLASH_STARTING_ADDRESS 0x00000000
 #define FLASH_EXPECTED_CHECKSUM 0x00000000
 #define FLASH_CHECKSUM_ERROR 0xFFFFFFFF

firmware/application/apps/ui_looking_glass_app.cpp

@@ -69,7 +69,7 @@ void GlassView::manage_beep_audio() {
     }
 }
 
-void GlassView::get_max_power(const ChannelSpectrum& spectrum, uint8_t bin, uint8_t& max_power) {
+void GlassView::get_max_power(const ChannelSpectrum& spectrum, uint16_t bin, uint8_t& max_power) {
     if (mode == LOOKING_GLASS_SINGLEPASS) {
         // <20MHz spectrum mode
         if (bin < 120) {
@@ -91,7 +91,7 @@ void GlassView::get_max_power(const ChannelSpectrum& spectrum, uint8_t bin, uint
     }
 }
 
-rf::Frequency GlassView::get_freq_from_bin_pos(uint8_t pos) {
+rf::Frequency GlassView::get_freq_from_bin_pos(uint16_t pos) {
     rf::Frequency freq_at_pos = 0;
     if (mode == LOOKING_GLASS_SINGLEPASS) {
         // starting from the middle, minus 8 ignored bin on each side. Since pos is [-120,120] after the (pos - 120), it's divided by screen_width(240)/2 => 120
@@ -101,7 +101,14 @@ rf::Frequency GlassView::get_freq_from_bin_pos(uint8_t pos) {
     return freq_at_pos;
 }
 
-void GlassView::on_marker_change() {
+void GlassView::on_marker_change(int8_t delta) {
+    if ((marker_pixel_index + delta) < 0)
+        marker_pixel_index = marker_pixel_index + delta + screen_width;
+    else if ((marker_pixel_index + delta) > screen_width)
+        marker_pixel_index = marker_pixel_index + delta - screen_width;
+    else
+        marker_pixel_index = marker_pixel_index + delta;
+
     marker = get_freq_from_bin_pos(marker_pixel_index);
     field_marker.set_text(to_string_short_freq(marker));
     plot_marker(marker_pixel_index);  // Refresh marker on screen
@@ -200,7 +207,7 @@ void GlassView::on_channel_spectrum(const ChannelSpectrum& spectrum) {
     baseband::spectrum_streaming_stop();
     // Convert bins of this spectrum slice into a representative max_power and when enough, into pixels
     // we actually need screen_width (240) of those bins
-    for (uint8_t bin = 0; bin < bin_length; bin++) {
+    for (uint16_t bin = 0; bin < bin_length; bin++) {
         get_max_power(spectrum, bin, max_power);
         if (max_power > range_max_power)
             range_max_power = max_power;
@@ -208,7 +215,7 @@ void GlassView::on_channel_spectrum(const ChannelSpectrum& spectrum) {
         if (bin == 119) {
             uint8_t next_max_power = 0;
             get_max_power(spectrum, bin + 1, next_max_power);
-            for (uint8_t it = 0; it < ignore_dc; it++) {
+            for (uint16_t it = 0; it < ignore_dc; it++) {
                 uint8_t med_max_power = (max_power + next_max_power) / 2;  // due to the way process_bins works we have to keep resetting the color
                 if (process_bins(&med_max_power) == true)
                     return;  // new line signaled, return
@@ -285,7 +292,7 @@ void GlassView::on_range_changed() {
     max_power = 0;
     bins_hz_size = 0;
 
-    on_marker_change();
+    on_marker_change(0);
     update_range_field();
 
     // set the sample rate and bandwidth
@@ -298,8 +305,8 @@ void GlassView::on_range_changed() {
     receiver_model.set_target_frequency(f_center);  // tune rx for this slice
 }
 
-void GlassView::plot_marker(uint8_t pos) {
-    uint8_t shift_y = 0;
+void GlassView::plot_marker(uint16_t pos) {
+    uint16_t shift_y = 0;
     if (live_frequency_view > 0)  // plot one line down when in live view
     {
         shift_y = 16;
@@ -381,9 +388,10 @@ GlassView::GlassView(
                   &button_beep_squelch,
                   &field_marker,
                   &field_trigger,
+                  &button_marker_minus,
+                  &button_marker_plus,
                   &button_jump,
                   &button_rst,
-                  &field_rx_iq_phase_cal,
                   &freq_stats});
 
     load_presets();  // Load available presets from TXT files (or default).
@@ -491,13 +499,7 @@ GlassView::GlassView(
     range_presets.set_selected_index(preset_index);
 
     field_marker.on_encoder_change = [this](TextField&, EncoderEvent delta) {
-        if ((marker_pixel_index + delta) < 0)
-            marker_pixel_index = marker_pixel_index + delta + screen_width;
-        else if ((marker_pixel_index + delta) > screen_width)
-            marker_pixel_index = marker_pixel_index + delta - screen_width;
-        else
-            marker_pixel_index = marker_pixel_index + delta;
-        on_marker_change();
+        on_marker_change(delta);
     };
 
     field_marker.on_select = [this](TextField&) {
@@ -516,6 +518,14 @@ GlassView::GlassView(
         update_range_field();
     };
 
+    button_marker_minus.on_select = [this](Button&) {
+        on_marker_change(-1);
+    };
+
+    button_marker_plus.on_select = [this](Button&) {
+        on_marker_change(1);
+    };
+
     button_jump.on_select = [this](Button&) {
         // Launch Audio with peak frequency.
         launch_audio(max_freq_hold);
@@ -525,13 +535,6 @@ GlassView::GlassView(
         reset_live_view();
     };
 
-    field_rx_iq_phase_cal.set_range(0, hackrf_r9 ? 63 : 31);                 // max2839 has 6 bits [0..63],  max2837 has 5 bits [0..31]
-    field_rx_iq_phase_cal.set_value(get_spec_iq_phase_calibration_value());  // using  accessor function of AnalogAudioView to read iq_phase_calibration_value from rx_audio.ini
-    field_rx_iq_phase_cal.on_change = [this](int32_t v) {
-        set_spec_iq_phase_calibration_value(v);  // using  accessor function of AnalogAudioView to write inside SPEC submenu, register value to max283x and save it to rx_audio.ini
-    };
-    set_spec_iq_phase_calibration_value(get_spec_iq_phase_calibration_value());  // initialize iq_phase_calibration in radio
-
     display.scroll_set_area(109, screen_height - 1);  // Restart scroll on the correct coordinates
 
     // trigger:
@@ -581,15 +584,6 @@ void GlassView::on_freqchg(int64_t freq) {
     on_range_changed();
 }
 
-uint8_t GlassView::get_spec_iq_phase_calibration_value() {  // define accessor functions inside AnalogAudioView to read & write real iq_phase_calibration_value
-    return iq_phase_calibration_value;
-}
-
-void GlassView::set_spec_iq_phase_calibration_value(uint8_t cal_value) {  // define accessor functions
-    iq_phase_calibration_value = cal_value;
-    radio::set_rx_max283x_iq_phase_calibration(iq_phase_calibration_value);
-}
-
 void GlassView::load_presets() {
     File presets_file;
     auto error = presets_file.open(looking_glass_dir / u"PRESETS.TXT");

firmware/application/apps/ui_looking_glass_app.hpp

@@ -66,9 +66,6 @@ class GlassView : public View {
     void on_hide() override;
     void focus() override;
 
-    uint8_t get_spec_iq_phase_calibration_value();
-    void set_spec_iq_phase_calibration_value(uint8_t cal_value);
-
    private:
     NavigationView& nav_;
     Gradient gradient{};
@@ -80,11 +77,10 @@ class GlassView : public View {
     uint8_t filter_index = 0;  // OFF
     uint8_t trigger = 32;
     uint8_t mode = LOOKING_GLASS_FASTSCAN;
-    uint8_t live_frequency_view = 0;         // Spectrum
-    uint8_t live_frequency_integrate = 3;    // Default (3 * old value + new_value) / 4
-    uint8_t iq_phase_calibration_value{15};  // initial default RX IQ phase calibration value , used for both max2837 & max2839
-    int32_t beep_squelch = 20;               // range from -100 to +20, >=20 disabled
-    bool beep_enabled = false;               // activate on bip button click
+    uint8_t live_frequency_view = 0;       // Spectrum
+    uint8_t live_frequency_integrate = 3;  // Default (3 * old value + new_value) / 4
+    int32_t beep_squelch = 20;             // range from -100 to +20, >=20 disabled
+    bool beep_enabled = false;             // activate on bip button click
     app_settings::SettingsManager settings_{
         "rx_glass"sv,
         app_settings::Mode::RX,
@@ -97,7 +93,6 @@ class GlassView : public View {
             {"scan_mode"sv, &mode},
             {"freq_view"sv, &live_frequency_view},
             {"freq_integrate"sv, &live_frequency_integrate},
-            {"iq_phase_calibration"sv, &iq_phase_calibration_value},  // we are saving and restoring that CAL from Settings.
             {"beep_squelch"sv, &beep_squelch},
             {"beep_enabled"sv, &beep_enabled},
         }};
@@ -116,9 +111,9 @@ class GlassView : public View {
     void update_min(int32_t v);
     void update_max(int32_t v);
     void update_range_field();
-    void get_max_power(const ChannelSpectrum& spectrum, uint8_t bin, uint8_t& max_power);
-    rf::Frequency get_freq_from_bin_pos(uint8_t pos);
-    void on_marker_change();
+    void get_max_power(const ChannelSpectrum& spectrum, uint16_t bin, uint8_t& max_power);
+    rf::Frequency get_freq_from_bin_pos(uint16_t pos);
+    void on_marker_change(int8_t delta);
     void retune();
     bool process_bins(uint8_t* powerlevel);
     void on_channel_spectrum(const ChannelSpectrum& spectrum);
@@ -128,7 +123,7 @@ class GlassView : public View {
     void on_range_changed();
     void reset_live_view();
     void add_spectrum_pixel(uint8_t power);
-    void plot_marker(uint8_t pos);
+    void plot_marker(uint16_t pos);
     void load_presets();
     void populate_presets();
     void launch_audio(rf::Frequency center_freq);
@@ -138,7 +133,7 @@ class GlassView : public View {
     rf::Frequency f_center_ini{0};
 
     rf::Frequency marker{0};
-    uint8_t marker_pixel_index{0};
+    uint16_t marker_pixel_index{0};
     rf::Frequency marker_pixel_step{0};
 
     // Size of one spectrum bin in Hz.
@@ -173,8 +168,7 @@ class GlassView : public View {
         {{0, UI_POS_Y(0)}, "MIN:     MAX:     LNA   VGA  ", Theme::getInstance()->fg_light->foreground},
         {{0, 1 * 16}, "RANGE:       FILTER:     AMP:", Theme::getInstance()->fg_light->foreground},
         {{0, 2 * 16}, "P:", Theme::getInstance()->fg_light->foreground},
-        {{0, 3 * 16}, "MARKER:          MHz RXIQCAL", Theme::getInstance()->fg_light->foreground},
-        //{{0, 4 * 16}, "RES:    STEPS:", Theme::getInstance()->fg_light->foreground}};
+        {{0, 3 * 16}, "MARKER( / ):          MHz", Theme::getInstance()->fg_light->foreground},
         {{0, 4 * 16}, "RES:     VOL:", Theme::getInstance()->fg_light->foreground}};
 
     NumberField field_frequency_min{
@@ -223,16 +217,16 @@ class GlassView : public View {
         ""};
 
     TextField field_marker{
-        {7 * 8, 3 * 16, 9 * 8, 16},
+        {12 * 8, 3 * 16, 9 * 8, 16},
         ""};
 
-    NumberField field_rx_iq_phase_cal{
-        {28 * 8, 3 * 16},
-        2,
-        {0, 63},  // 5 or 6 bits IQ CAL phase adjustment (range updated later)
-        1,
-        ' ',
-    };
+    Button button_marker_minus{
+        {7 * 8, 3 * 16 + 4, 1 * 8, 1 * 8},
+        "-"};
+
+    Button button_marker_plus{
+        {9 * 8, 3 * 16 + 4, 1 * 8, 1 * 8},
+        "+"};
 
     NumberField field_trigger{
         {4 * 8, 4 * 16},

firmware/application/apps/ui_mictx.cpp

@@ -350,6 +350,12 @@ MicTXView::MicTXView(
                   &tx_button,
                   &tx_icon});
 
+    // disable key repeat on select
+    initial_switch_config_ = get_switches_repeat_config();
+    SwitchesState config = initial_switch_config_;
+    config[toUType(Switch::Sel)] = false;
+    set_switches_repeat_config(config);
+
     set_rxbw_options();
     set_rxbw_defaults(settings_.loaded());
 
@@ -640,6 +646,9 @@ MicTXView::MicTXView(
 }
 
 MicTXView::~MicTXView() {
+    // restore select key repeat mode
+    set_switches_repeat_config(initial_switch_config_);
+
     audio::input::stop();
     if (rx_enabled) {  // Also turn off both (audio rx if enabled, and disable  mic_loop to HP)
         rxaudio(false);

firmware/application/apps/ui_mictx.hpp

@@ -90,6 +90,9 @@ class MicTXView : public View {
         sampling_rate /* sampling rate */
     };
 
+    // structure used to control key repeat
+    SwitchesState initial_switch_config_{};
+
     enum Mic_Modulation : uint32_t {
         MIC_MOD_NFM = 0,
         MIC_MOD_WFM = 1,
@@ -301,7 +304,8 @@ class MicTXView : public View {
         {
             {" 8k5  ", 0},  // Initial dynamic values when we start Mic App.
             {" 11k  ", 1},
-            {" 16k  ", 2},
+            {" 12k5  ", 2},
+            {" 16k  ", 3},
         }};
 
     NumberField field_squelch{

firmware/application/apps/ui_recon.cpp

@@ -1261,6 +1261,7 @@ size_t ReconView::change_mode(freqman_index_t new_mod) {
             else
                 v = SPEC_MODULATION;
             field_mode.set_selected_index(v);
+            return;  // Important ! Guru will occur if you don't return when modifying field from within on_change !
         }
         last_mode = v;
         change_mode(v);

firmware/application/apps/ui_settings.cpp

@@ -33,6 +33,8 @@
 #include "ui_touch_calibration.hpp"
 #include "ui_text_editor.hpp"
 #include "ui_external_items_menu_loader.hpp"
+#include "ui_ss_viewer.hpp"
+#include "ui_fileman.hpp"
 
 #include "portapack_persistent_memory.hpp"
 #include "lpc43xx_cpp.hpp"
@@ -309,13 +311,45 @@ SetFrequencyCorrectionModel SetRadioView::form_collect() {
     };
 }
 
+/* SetTXLimitView ************************************/
+
+SetTXLimitView::SetTXLimitView(NavigationView& nav) {
+    add_children({
+        &labels,
+        &tx_gain_max_db,
+        &tx_disable_switch,
+        &tx_amp_disable_switch,
+        &button_save,
+        &button_cancel,
+    });
+
+    tx_disable_switch.set_value(pmem::config_tx_disabled());
+    tx_amp_disable_switch.set_value(pmem::config_tx_amp_disabled());
+    tx_gain_max_db.set_value(pmem::config_tx_gain_max_db());
+
+    button_save.on_select = [&nav, this](Button&) {
+        pmem::set_config_tx_disabled(tx_disable_switch.value());
+        pmem::set_config_tx_amp_disabled(tx_amp_disable_switch.value());
+        pmem::set_config_tx_gain_max_db(tx_gain_max_db.value());
+        send_system_refresh();
+        nav.pop();
+    };
+
+    button_cancel.on_select = [&nav, this](Button&) {
+        nav.pop();
+    };
+}
+
+void SetTXLimitView::focus() {
+    button_save.focus();
+}
+
 /* SetUIView *********************************************/
 
 SetUIView::SetUIView(NavigationView& nav) {
     add_children({&checkbox_disable_touchscreen,
                   &checkbox_bloff,
                   &options_bloff,
-                  &checkbox_showsplash,
                   &checkbox_showclock,
                   &options_clockformat,
                   &checkbox_guireturnflag,
@@ -342,7 +376,6 @@ SetUIView::SetUIView(NavigationView& nav) {
     }
 
     checkbox_disable_touchscreen.set_value(pmem::disable_touchscreen());
-    checkbox_showsplash.set_value(pmem::config_splash());
     checkbox_showclock.set_value(!pmem::hide_clock());
     checkbox_guireturnflag.set_value(pmem::show_gui_return_icon());
 
@@ -381,7 +414,6 @@ SetUIView::SetUIView(NavigationView& nav) {
                 pmem::set_clock_with_date(false);
         }
 
-        pmem::set_config_splash(checkbox_showsplash.value());
         pmem::set_clock_hidden(!checkbox_showclock.value());
         pmem::set_gui_return_icon(checkbox_guireturnflag.value());
         pmem::set_disable_touchscreen(checkbox_disable_touchscreen.value());
@@ -1080,6 +1112,46 @@ void SetBatteryView::focus() {
     button_cancel.focus();
 }
 
+/* SetSlpash *********************************************/
+
+SetSplash::SetSplash(NavigationView& nav) {
+    add_children({&checkbox_showsplash,
+                  &checkbox_randomsplash,
+                  &message,
+                  &button_picture_select,
+                  &button_save,
+                  &button_cancel});
+
+    checkbox_showsplash.set_value(pmem::config_splash());
+    splash_bmp_exists = file_exists(splash_dot_bmp);
+    checkbox_randomsplash.set_value(!splash_bmp_exists);
+    message.hidden(splash_bmp_exists);
+
+    checkbox_randomsplash.on_select = [this](Checkbox&, bool v) {
+        random_enabled = v;
+    };
+
+    button_picture_select.on_select = [this, &nav](Button&) {
+        auto ret = nav.push<FileManagerView>();
+        ret->push_dir(splash_dir);
+    };
+
+    button_save.on_select = [&nav, this](Button&) {
+        if (random_enabled == true) delete_file(splash_dot_bmp);
+        pmem::set_config_splash(checkbox_showsplash.value());
+        send_system_refresh();
+        nav.pop();
+    };
+
+    button_cancel.on_select = [&nav, this](Button&) {
+        nav.pop();
+    };
+}
+
+void SetSplash::focus() {
+    button_save.focus();
+}
+
 /* SettingsMenuView **************************************/
 
 SettingsMenuView::SettingsMenuView(NavigationView& nav)
@@ -1107,11 +1179,13 @@ void SettingsMenuView::on_populate() {
         {"Freq. Correct", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [this]() { nav_.push<SetFrequencyCorrectionView>(); }},
         {"P.Memory Mgmt", ui::Color::dark_cyan(), &bitmap_icon_memory, [this]() { nav_.push<SetPersistentMemoryView>(); }},
         {"Radio", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [this]() { nav_.push<SetRadioView>(); }},
+        {"TX Limit", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [this]() { nav_.push<SetTXLimitView>(); }},
         {"SD Card", ui::Color::dark_cyan(), &bitmap_icon_sdcard, [this]() { nav_.push<SetSDCardView>(); }},
         {"User Interface", ui::Color::dark_cyan(), &bitmap_icon_options_ui, [this]() { nav_.push<SetUIView>(); }},
         {"Display", ui::Color::dark_cyan(), &bitmap_icon_brightness, [this]() { nav_.push<SetDisplayView>(); }},
         {"Menu Color", ui::Color::dark_cyan(), &bitmap_icon_brightness, [this]() { nav_.push<SetMenuColorView>(); }},
         {"Theme", ui::Color::dark_cyan(), &bitmap_icon_setup, [this]() { nav_.push<SetThemeView>(); }},
+        {"Splash settings", ui::Color::dark_cyan(), &bitmap_icon_file_image, [this]() { nav_.push<SetSplash>(); }},
     });
 
     if (battery::BatteryManagement::isDetected()) add_item({"Battery", ui::Color::dark_cyan(), &bitmap_icon_batt_icon, [this]() { nav_.push<SetBatteryView>(); }});

firmware/application/apps/ui_settings.hpp

@@ -264,6 +264,51 @@ class SetRadioView : public View {
     SetFrequencyCorrectionModel form_collect();
 };
 
+class SetTXLimitView : public View {
+   public:
+    SetTXLimitView(NavigationView& nav);
+
+    void focus() override;
+
+    std::string title() const override { return "TX Limit"; };
+
+   private:
+    Labels labels{
+        {{1 * 8, 1 * 16}, "Limits RF TX Gain", Theme::getInstance()->fg_light->foreground},
+        {{1 * 8, 2 * 16}, "(This may affect", Theme::getInstance()->fg_light->foreground},
+        {{1 * 8, 3 * 16}, "all applications.)", Theme::getInstance()->fg_light->foreground},
+        {{2 * 8, 12 * 16}, "TX Max Gain:", Theme::getInstance()->fg_light->foreground},
+
+    };
+
+    Checkbox tx_disable_switch{
+        {1 * 8, 6 * 16},
+        23,
+        "Disable TX"};
+
+    Checkbox tx_amp_disable_switch{
+        {1 * 8, 8 * 16},
+        23,
+        "Disable TX Amp"};
+
+    NumberField tx_gain_max_db{
+        {20 * 8, 12 * 16},
+        6,
+        {0, 47},
+        1,
+        ' ',
+    };
+
+    Button button_save{
+        {UI_POS_X_CENTER(12) - UI_POS_WIDTH(8), UI_POS_Y_BOTTOM(4), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
+        "Save"};
+
+    Button button_cancel{
+        {UI_POS_X_CENTER(16) + UI_POS_WIDTH(8), UI_POS_Y_BOTTOM(4), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
+        "Cancel",
+    };
+};
+
 using portapack::persistent_memory::backlight_timeout_t;
 
 class SetUIView : public View {
@@ -298,77 +343,72 @@ class SetUIView : public View {
             {"1 hour", backlight_timeout_t::Timeout3600Sec},
         }};
 
-    Checkbox checkbox_showsplash{
-        {3 * 8, 6 * 16},
-        20,
-        "Show splash"};
-
     Checkbox checkbox_showclock{
-        {3 * 8, 8 * 16},
+        {3 * 8, 6 * 16},
         20,
         "Show clock with:"};
 
     OptionsField options_clockformat{
-        {60, 9 * 16 + 8},
+        {60, 7 * 16 + 8},
         20,
         {{"time only", 0},
          {"time and date", 1}}};
 
     Checkbox checkbox_guireturnflag{
-        {3 * 8, 11 * 16},
+        {3 * 8, 9 * 16},
         20,
         "Back button in menu"};
 
     Labels labels{
-        {{3 * 8, 13 * 16}, "Show/Hide Status Icons", Theme::getInstance()->fg_light->foreground},
+        {{3 * 8, 11 * 16}, "Show/Hide Status Icons", Theme::getInstance()->fg_light->foreground},
     };
 
     ImageToggle toggle_camera{
-        {2 * 8, 14 * 16 + 2, 16, 16},
+        {2 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_camera};
 
     ImageToggle toggle_sleep{
-        {4 * 8, 14 * 16 + 2, 16, 16},
+        {4 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_sleep};
 
     ImageToggle toggle_stealth{
-        {6 * 8, 14 * 16 + 2, 16, 16},
+        {6 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_stealth};
 
     ImageToggle toggle_converter{
-        {8 * 8, 14 * 16 + 2, 16, 16},
+        {8 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_upconvert};
 
     ImageToggle toggle_bias_tee{
-        {10 * 8, 14 * 16 + 2, 16, 16},
+        {10 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_biast_off};
 
     ImageToggle toggle_clock{
-        {12 * 8, 14 * 16 + 2, 8, 16},
+        {12 * 8, 12 * 16 + 2, 8, 16},
         &bitmap_icon_clk_ext};
 
     ImageToggle toggle_mute{
-        {13 * 8, 14 * 16 + 2, 16, 16},
+        {13 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_speaker_and_headphones_mute};
 
     ImageToggle toggle_speaker{
-        {15 * 8, 14 * 16 + 2, 16, 16},
+        {15 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_speaker_mute};
 
     ImageToggle toggle_battery_icon{
-        {17 * 8, 14 * 16 + 2, 16, 16},
+        {17 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_batt_icon};
 
     ImageToggle toggle_battery_text{
-        {19 * 8, 14 * 16 + 2, 16, 16},
+        {19 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_batt_text};
 
     ImageToggle toggle_fake_brightness{
-        {21 * 8, 14 * 16 + 2, 16, 16},
+        {21 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_icon_brightness};
 
     ImageToggle toggle_sd_card{
-        {23 * 8, 14 * 16 + 2, 16, 16},
+        {23 * 8, 12 * 16 + 2, 16, 16},
         &bitmap_sd_card_ok};
 
     Button button_save{
@@ -1024,6 +1064,43 @@ class SettingsMenuView : public BtnGridView {
     void on_populate() override;
 };
 
+class SetSplash : public View {
+   public:
+    SetSplash(NavigationView& nav);
+
+    void focus() override;
+
+    std::string title() const override { return "Splash"; };
+
+   private:
+    bool splash_bmp_exists = false;
+    bool random_enabled = false;
+
+    Checkbox checkbox_showsplash{
+        {3 * 8, 1 * 16},
+        20,
+        "Show splash"};
+
+    Checkbox checkbox_randomsplash{
+        {3 * 8, 3 * 16},
+        20,
+        "Random splash on boot"};
+
+    Text message{{UI_POS_X(1), UI_POS_Y(6), UI_POS_WIDTH(26), UI_POS_HEIGHT(1)}, "Pick image to stop random."};
+
+    Button button_picture_select{
+        {UI_POS_X_CENTER(8) - UI_POS_WIDTH(4), UI_POS_Y_BOTTOM(7), UI_POS_WIDTH(13), UI_POS_HEIGHT(2)},
+        "Select pict."};
+
+    Button button_save{
+        {UI_POS_X_CENTER(12) - UI_POS_WIDTH(8), UI_POS_Y_BOTTOM(4), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
+        "Save"};
+
+    Button button_cancel{
+        {UI_POS_X_CENTER(16) + UI_POS_WIDTH(8), UI_POS_Y_BOTTOM(4), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
+        "Cancel"};
+};
+
 } /* namespace ui */
 
 #endif /*__UI_SETTINGS_H__*/

firmware/application/apps/ui_ss_viewer.cpp

@@ -27,8 +27,6 @@ namespace fs = std::filesystem;
 
 namespace ui {
 
-const std::filesystem::path splash_dot_bmp{u"/splash.bmp"};
-
 ScreenshotViewer::ScreenshotViewer(
     NavigationView& nav,
     const std::filesystem::path& path)
@@ -44,7 +42,6 @@ bool ScreenshotViewer::on_key(KeyEvent) {
 
 void ScreenshotViewer::paint(Painter& painter) {
     File file{};
-
     painter.fill_rectangle({0, 0, screen_width, screen_height}, Color::black());
 
     auto show_invalid = [&]() {

firmware/application/apps/ui_ss_viewer.hpp

@@ -28,11 +28,10 @@
 #include "ui_painter.hpp"
 #include "ui_widget.hpp"
 #include "file.hpp"
+#include "file_path.hpp"
 
 namespace ui {
 
-extern const std::filesystem::path splash_dot_bmp;
-
 class ScreenshotViewer : public View {
    public:
     ScreenshotViewer(NavigationView& nav, const std::filesystem::path& path);
@@ -49,7 +48,6 @@ class SplashViewer : public View {
     SplashViewer(NavigationView& nav, const std::filesystem::path& path);
     bool on_key(KeyEvent key) override;
     void paint(Painter& painter) override;
-    void update_ss(void);
 
    private:
     NavigationView& nav_;

firmware/application/apps/ui_standalone_view.cpp

@@ -34,7 +34,7 @@
 namespace ui {
 
 void create_thread(int32_t (*fn)(void*), void* arg, size_t stack_size, int priority) {
-    // TODO: collect memory on terminate, once this is used
+    // TODO: collect memory on terminate, once this is used. This is a HUGE TODO! need to call chThdWait on all of them!
     chThdCreateFromHeap(NULL, stack_size, priority, fn, arg);
 }
 

firmware/application/apps/ui_subghzd.cpp

@@ -25,6 +25,10 @@
 #include "baseband_api.hpp"
 #include "string_format.hpp"
 #include "file_path.hpp"
+#include "ui_textentry.hpp"
+#include "../keeloq_keystore.hpp"
+#include "../keeloq_file.hpp"
+#include "../keeloq_common.hpp"
 #include "portapack_persistent_memory.hpp"
 
 using namespace portapack;
@@ -56,6 +60,51 @@ void SubGhzDRecentEntryDetailView::update_data() {
     if (cnt != SD_NO_CNT) console.writeln("Cnt: " + to_string_dec_uint(cnt));
 
     if (entry_.data != 0) console.writeln("Data: " + to_string_hex(entry_.data));
+
+    if (entry_.sensorType == FPS_RESTAURANT_PAGER) {
+        uint8_t pager_addr = (entry_.data >> 5) & 0x0F;
+        uint8_t func_code = (entry_.data >> 1) & 0x0F;
+        console.writeln("Station: 0x" + to_string_hex(serial) + " (" + to_string_dec_uint(serial) + ")");
+        console.writeln("Pager: " + to_string_dec_uint(pager_addr));
+        if (func_code == 0x0D)
+            console.writeln("Action: Buzz");
+        else if (func_code == 0x0F)
+            console.writeln("Action: Sync");
+        else
+            console.writeln("Action: 0x" + to_string_hex(func_code));
+    }
+
+    if (entry_.sensorType == FPS_KEELOQ) {
+        console.writeln("Fix: " + to_string_hex(fix));
+        console.writeln("Encrypted: " + to_string_hex(encrypted));
+        console.writeln("Manufacturer: " + mf_name);
+
+        if (hop != SD_NO_HOP) {
+            console.writeln("Hop: " + to_string_hex(hop));
+
+            add_children({&button_save});
+
+            button_save.on_select = [this](const Button&) {
+                keeloq_file_buffer.clear();
+
+                text_prompt(
+                    nav_,
+                    keeloq_file_buffer,
+                    64,
+                    ENTER_KEYBOARD_MODE_ALPHA,
+                    [this](std::string& buffer) {
+                        KeeloqData params{
+                            mf_name,
+                            serial,
+                            (uint16_t)cnt,
+                            btn};
+
+                        ensure_directory(keeloq_remotes_dir);
+                        write_keeloq_file(keeloq_remotes_dir / buffer + ".KEELOQ", params);
+                    });
+            };
+        }
+    }
 }
 
 SubGhzDRecentEntryDetailView::SubGhzDRecentEntryDetailView(NavigationView& nav, const SubGhzDRecentEntry& entry)
@@ -242,6 +291,10 @@ const char* SubGhzDView::getSensorTypeName(FPROTO_SUBGHZD_SENSOR type) {
             return "GangQi";
         case FPS_MARANTEC24:
             return "Marantec24";
+        case FPS_HOLTEKHT6P20B:
+            return "Holtek HT6P20B";
+        case FPS_RESTAURANT_PAGER:
+            return "Rest. Pager";
         case FPS_Invalid:
         default:
             return "Unknown";
@@ -268,7 +321,14 @@ void RecentEntriesTable<ui::SubGhzDRecentEntries>::draw(
     line.reserve(30);
 
     line = SubGhzDView::getSensorTypeName((FPROTO_SUBGHZD_SENSOR)entry.sensorType);
-    line = line + " " + to_string_hex(entry.data << 32);
+    if (entry.sensorType == FPS_RESTAURANT_PAGER) {
+        uint8_t pgr = (entry.data >> 5) & 0x0F;
+        uint8_t func = (entry.data >> 1) & 0x0F;
+        line += " P:" + to_string_dec_uint(pgr) + (func == 0x0D ? " Buzz" : func == 0x0F ? " Sync"
+                                                                                         : "");
+    } else {
+        line = line + " " + to_string_hex(entry.data << 32);
+    }
     line.resize(columns.at(0).second, ' ');
     std::string ageStr = to_string_dec_uint(entry.age);
     std::string bitsStr = to_string_dec_uint(entry.bits);
@@ -301,6 +361,29 @@ void atomo_decrypt(uint8_t* buff) {
     }
 }
 
+bool SubGhzDRecentEntryDetailView::keeloq_check_decrypt(uint32_t decrypt) {
+    uint16_t end_serial = serial & 0xFF;
+
+    if ((decrypt >> 28 == btn) && (((((uint16_t)(decrypt >> 16)) & 0xFF) == end_serial) ||
+                                   ((((uint16_t)(decrypt >> 16)) & 0xFF) == 0))) {
+        cnt = decrypt & 0xFFFF;
+
+        return true;
+    }
+
+    return false;
+}
+
+bool SubGhzDRecentEntryDetailView::keeloq_check_decrypt_centurion(uint32_t decrypt) {
+    if ((decrypt >> 28 == btn) && ((((uint16_t)(decrypt >> 16)) & 0x3FF) == 0x1CE)) {
+        cnt = decrypt & 0xFFFF;
+
+        return true;
+    }
+
+    return false;
+}
+
 const uint32_t came_twee_magic_numbers_xor[15] = {
     0x0E0E0E00,
     0x1D1D1D11,
@@ -589,7 +672,57 @@ void SubGhzDRecentEntryDetailView::parseProtocol() {
     }
 
     if (entry_.sensorType == FPS_KEELOQ) {
-        // too many sub protocol versions, skipping. maybe in future when we'll have much more fw space
+        uint64_t data_rev = FProtoGeneral::subghz_protocol_blocks_reverse_key(entry_.data, 64);
+
+        btn = data_rev >> 60;
+        serial = (data_rev >> 32) & 0xFFFFFFF;
+        fix = data_rev >> 32;
+        encrypted = data_rev & 0xFFFFFFFF;
+
+        KeeloqKeystore keystore{};
+
+        const auto& keys = keystore.get_keys();
+
+        if (keys.empty()) {
+            return;
+        }
+
+        for (const auto& key : keys) {
+            switch (key.type) {
+                case KEELOQ_SIMPLE_LEARNING: {
+                    uint32_t decrypted = keeloq_decrypt(encrypted, key.key);
+
+                    if (keeloq_check_decrypt(decrypted)) {
+                        mf_name = key.mf_name;
+                        hop = decrypted;
+
+                        return;
+                    }
+
+                    break;
+                }
+
+                case KEELOQ_NORMAL_LEARNING: {
+                    uint64_t man = keeloq_normal_learning(fix, key.key);
+                    uint32_t decrypted = keeloq_decrypt(encrypted, man);
+
+                    if (key.mf_name == "Centurion" && keeloq_check_decrypt_centurion(decrypted)) {
+                        mf_name = "Centurion";
+                        hop = decrypted;
+
+                        return;
+                    } else if (keeloq_check_decrypt(decrypted)) {
+                        mf_name = key.mf_name;
+                        hop = decrypted;
+
+                        return;
+                    }
+
+                    break;
+                }
+            }
+        }
+
         return;
     }
 
@@ -756,5 +889,18 @@ void SubGhzDRecentEntryDetailView::parseProtocol() {
         btn = entry_.data & 0xf;
         return;
     }
+
+    if (entry_.sensorType == FPS_HOLTEKHT6P20B) {
+        serial = entry_.data >> 8;
+        btn = (entry_.data >> 4) & 0xF;
+        return;
+    }
+
+    if (entry_.sensorType == FPS_RESTAURANT_PAGER) {
+        // 25-bit EV1527-variant: [sysid:16][pager:4][func:4][stop:1]
+        serial = (entry_.data >> 9) & 0xFFFF;  // System ID
+        // btn/cnt left as SD_NO values; friendly output in update_data()
+        return;
+    }
 }
-}  // namespace ui
+}  // namespace ui

firmware/application/apps/ui_subghzd.hpp

@@ -25,7 +25,11 @@
 
 #define SD_NO_SERIAL 0xFFFFFFFF
 #define SD_NO_BTN 0xFF
-#define SD_NO_CNT 0xFF
+#define SD_NO_CNT 0xFFFFFFFF
+
+#define SD_NO_HOP 0xFFFFFFFF
+#define SD_NO_FIX 0xFFFFFFFF
+#define SD_NO_ENCRYPTED 0xFFFFFFFF
 
 #include "ui.hpp"
 #include "ui_navigation.hpp"
@@ -191,6 +195,19 @@ class SubGhzDRecentEntryDetailView : public View {
     uint32_t cnt = SD_NO_CNT;
     uint32_t seed = 0;
 
+    // keeloq specific
+    std::string keeloq_file_buffer{};
+
+    uint32_t hop = SD_NO_HOP;
+    uint32_t fix = SD_NO_FIX;
+    uint32_t encrypted = SD_NO_ENCRYPTED;
+
+    std::string mf_name = "Unknown";
+
+    bool keeloq_check_decrypt(uint32_t decrypt);
+    bool keeloq_check_decrypt_centurion(uint32_t decrypt);
+    // end keeloq specific
+
     Text text_type{{UI_POS_X(0), 1 * 16, 15 * 8, 16}, "?"};
     Text text_id{{6 * 8, 2 * 16, 10 * 8, 16}, "?"};
 
@@ -207,6 +224,10 @@ class SubGhzDRecentEntryDetailView : public View {
         {screen_width - 96 - 4, screen_height - 32 - 12, 96, 32},
         "Done"};
 
+    Button button_save{
+        {4, screen_height - 32 - 12, 96, 32},
+        "Save"};
+
     void parseProtocol();
 };
 

firmware/application/baseband_api.cpp

@@ -52,12 +52,21 @@ static void send_message(const Message* const message) {
     creg::m0apptxevent::assert_event();
 
     if constexpr (check_for_message_hang) {
+#ifdef PRALINE
+        /* Timeout: ~3 seconds at typical clock speeds */
+        auto count = 200'000'000u;
+#else
         auto count = UINT32_MAX;
+#endif
         while (shared_memory.baseband_message && --count)
             /* spin */;
 
         if (count == 0)
+#ifdef PRALINE
+            chDbgPanic("BB Msg Timeout");
+#else
             chDbgPanic("Baseband Send Fail");
+#endif
     } else {
         while (shared_memory.baseband_message)
             /* spin */;
@@ -368,6 +377,41 @@ void set_subghzd_config(uint8_t modulation = 0, uint32_t sampling_rate = 0) {
     send_message(&message);
 }
 
+void set_moreserx_config(uint8_t mode) {
+    const MorseRXConfigureMessage message{mode};
+    send_message(&message);
+}
+
+void set_morsetx_config(uint8_t mode, uint32_t tone, float fm_delta) {
+    const MorseTXConfigureMessage message{mode, tone, fm_delta};
+    send_message(&message);
+}
+
+void set_morsetx_key(bool key_down) {
+    const MorseTXkeyMessage message{key_down};
+    send_message(&message);
+}
+
+void set_bitstream_config(uint32_t deviation, uint8_t mode) {
+    const StreamTXConfigurationMessage message{deviation, mode};
+    send_message(&message);
+}
+
+void set_rtty_config(uint16_t baud, uint16_t shift, uint8_t* payload, uint16_t payload_length) {
+    RTTYDataMessage message{baud, shift};
+    if (payload && payload_length > 0) {
+        message.data_len = payload_length > message.max_len ? message.max_len : payload_length;
+        for (size_t i = 0; i < message.data_len; ++i) {
+            message.data[i] = payload[i];
+        }
+    }
+    send_message(&message);
+}
+
+void set_rtty_config(RTTYDataMessage& message) {
+    send_message(&message);
+}
+
 static bool baseband_image_running = false;
 
 void run_image(const spi_flash::image_tag_t image_tag) {
@@ -429,7 +473,12 @@ void shutdown() {
     send_message(&message);
 
     shared_memory.application_queue.reset();
-
+    // Allow time for the shutdown message to be processed and for the baseband
+    // core to stop before starting another image. Otherwise, the M4 may still be
+    // running and cause a crash when the next image is started.
+#ifdef PRALINE
+    chThdSleepMilliseconds(20);
+#endif
     baseband_image_running = false;
 }
 

firmware/application/baseband_api.hpp

@@ -102,9 +102,15 @@ void set_siggen_tone(const uint32_t tone);
 void set_siggen_config(const uint32_t bw, const uint32_t shape, const uint32_t duration);
 void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bool update, int32_t bw);
 void set_subghzd_config(uint8_t modulation, uint32_t sampling_rate);
+void set_moreserx_config(uint8_t mode);
+void set_morsetx_config(uint8_t mode, uint32_t tone, float fm_delta);
+void set_morsetx_key(bool key_down);
 void set_wefax_config(uint8_t lpm, uint8_t ioc);
 void set_noaaapt_config();
 void set_flex_config();
+void set_bitstream_config(uint32_t deviation, uint8_t mode);                                                   // mode 0 for am, 1 for 2fsk
+void set_rtty_config(uint16_t baud, uint16_t shift, uint8_t* payload = nullptr, uint16_t payload_length = 0);  // baud*100
+void set_rtty_config(RTTYDataMessage& message);
 
 void request_roger_beep();
 void request_rssi_beep();

firmware/application/bitmap.hpp

@@ -4297,7 +4297,7 @@ static constexpr Bitmap bitmap_icon_tpms{
     {16, 16},
     bitmap_icon_tpms_data};
 
-static constexpr uint8_t bitmap_icon_tranceivers_data[] = {
+static constexpr uint8_t bitmap_icon_transceivers_data[] = {
     0x80,
     0x01,
     0xC0,
@@ -4331,9 +4331,9 @@ static constexpr uint8_t bitmap_icon_tranceivers_data[] = {
     0xFF,
     0xFF,
 };
-static constexpr Bitmap bitmap_icon_tranceivers{
+static constexpr Bitmap bitmap_icon_transceivers{
     {16, 16},
-    bitmap_icon_tranceivers_data};
+    bitmap_icon_transceivers_data};
 
 static constexpr uint8_t bitmap_icon_transmit_data[] = {
     0x80,

firmware/application/clock_manager.cpp

@@ -23,6 +23,7 @@
 
 #include "portapack_persistent_memory.hpp"
 #include "portapack_io.hpp"
+#include "portapack.hpp"
 
 #include "hackrf_hal.hpp"
 using namespace hackrf::one;
@@ -30,6 +31,14 @@ using namespace hackrf::one;
 #include "lpc43xx_cpp.hpp"
 using namespace lpc43xx;
 
+#ifdef PRALINE
+extern "C" {
+#include "fpga_bridge.h"
+}
+// Need access to ssp1_arbiter from radio namespace
+#include "radio.hpp"
+#endif
+
 constexpr uint32_t si5351_vco_f = 800000000;
 
 constexpr si5351::Inputs si5351_inputs{
@@ -54,6 +63,12 @@ constexpr si5351::PLL si5351_pll_xtal_25m{
     .c = 1,
 };
 constexpr auto si5351_pll_a_xtal_reg = si5351_pll_xtal_25m.reg(0);
+#ifdef PRALINE
+static_assert(si5351_pll_xtal_25m.f_vco() == si5351_vco_f, "PLL XTAL frequency wrong");
+static_assert(si5351_pll_xtal_25m.p1() == 3584, "PLL XTAL P1 wrong");
+static_assert(si5351_pll_xtal_25m.p2() == 0, "PLL XTAL P2 wrong");
+static_assert(si5351_pll_xtal_25m.p3() == 1, "PLL XTAL P3 wrong");
+#endif
 
 constexpr si5351::PLL si5351_pll_clkin_10m{
     .f_in = si5351_inputs.f_clkin_out(),
@@ -64,10 +79,12 @@ constexpr si5351::PLL si5351_pll_clkin_10m{
 constexpr auto si5351c_pll_b_clkin_reg = si5351_pll_clkin_10m.reg(1);
 constexpr auto si5351a_pll_a_clkin_reg = si5351_pll_clkin_10m.reg(0);
 
+#ifndef PRALINE
 static_assert(si5351_pll_xtal_25m.f_vco() == si5351_vco_f, "PLL XTAL frequency wrong");
 static_assert(si5351_pll_xtal_25m.p1() == 3584, "PLL XTAL P1 wrong");
 static_assert(si5351_pll_xtal_25m.p2() == 0, "PLL XTAL P2 wrong");
 static_assert(si5351_pll_xtal_25m.p3() == 1, "PLL XTAL P3 wrong");
+#endif
 
 static_assert(si5351_pll_clkin_10m.f_vco() == si5351_vco_f, "PLL CLKIN frequency wrong");
 static_assert(si5351_pll_clkin_10m.p1() == 9728, "PLL CLKIN P1 wrong");
@@ -92,6 +109,15 @@ constexpr si5351::MultisynthFractional si5351_ms_0_20m {
 };
 constexpr auto si5351_ms_0_20m_reg = si5351_ms_0_20m.reg(0);
 */
+
+constexpr si5351::MultisynthFractional si5351_ms_0_4m{
+    .f_src = si5351_vco_f,  // 800,000,000 Hz
+    .a = 100,               // Integer divider 100
+    .b = 0,
+    .c = 1,
+    .r_div = 1  // Final R-divider: 2^1 = 2
+};
+
 constexpr si5351::MultisynthFractional si5351_ms_0_8m{
     .f_src = si5351_vco_f,
     .a = 50,
@@ -101,6 +127,22 @@ constexpr si5351::MultisynthFractional si5351_ms_0_8m{
 };
 constexpr auto si5351c_ms_0_8m_reg = si5351_ms_0_8m.reg(clock_generator_output_og_codec);
 
+#ifdef PRALINE
+// Verify compile-time values for 8 MHz config
+static_assert(si5351_ms_0_8m.p1() == 5888, "MS0 8MHz P1 should be 5888 (0x1700)");
+static_assert(si5351_ms_0_8m.p2() == 0, "MS0 8MHz P2 should be 0");
+static_assert(si5351_ms_0_8m.p3() == 1, "MS0 8MHz P3 should be 1");
+static_assert(si5351_ms_0_8m.f_out() == 8000000, "MS0 should output 8 MHz");
+
+// Verify register array encoding
+static_assert(si5351c_ms_0_8m_reg[0] == 42, "MS0 base register should be 42");
+static_assert(si5351c_ms_0_8m_reg[1] == 0x00, "MS0 reg43 P3[15:8] should be 0x00");
+static_assert(si5351c_ms_0_8m_reg[2] == 0x01, "MS0 reg44 P3[7:0] should be 0x01");
+static_assert(si5351c_ms_0_8m_reg[3] == 0x10, "MS0 reg45 R_DIV should be 0x10");
+static_assert(si5351c_ms_0_8m_reg[4] == 0x17, "MS0 reg46 P1[15:8] should be 0x17");
+static_assert(si5351c_ms_0_8m_reg[5] == 0x00, "MS0 reg47 P1[7:0] should be 0x00");
+#endif
+
 constexpr si5351::MultisynthFractional si5351_ms_group{
     .f_src = si5351_vco_f,
     .a = 80, /* Don't care */
@@ -204,15 +246,38 @@ constexpr ClockControls si5351c_clock_control_common{{
 }};
 
 constexpr ClockControls si5351a_clock_control_common{{
+#ifdef PRALINE
+    // CLK0: MAX5864 (ADC) - 4mA, Inverted (Standard for Praline sync)
+    {ClockControl::ClockCurrentDrive::_4mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Fractional, ClockControl::ClockPowerDown::Power_On},
+    // CLK1: SCT_CLK (iCE40 FPGA) - 6mA, Inverted (Fixes 30-60Hz Drumming)
+    {ClockControl::ClockCurrentDrive::_6mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Invert, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_On},
+    // CLK2: LPC43xx MCU - 4mA, Normal (Must be Integer for MCU stability)
+    {ClockControl::ClockCurrentDrive::_4mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_On},
+    // CLK3: CLKOUT SMA Port P1 - 8mA, Normal
+    {ClockControl::ClockCurrentDrive::_8mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_On},
+    // CLK4: MAX2831 reference (40 MHz) - Inverted (Required for mixer lock)
+    {ClockControl::ClockCurrentDrive::_4mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Invert, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_On},
+    // CLK5: RFFC5072 reference (40 MHz) - Inverted (Required for mixer lock)
+    {ClockControl::ClockCurrentDrive::_6mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Invert, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_On},
+    // CLK6: SMA Port P2 - 8mA, Normal
+    {ClockControl::ClockCurrentDrive::_8mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_On},
+#else
     {ClockControl::ClockCurrentDrive::_6mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_Off},
     {ClockControl::ClockCurrentDrive::_4mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Fractional, ClockControl::ClockPowerDown::Power_Off},
     {ClockControl::ClockCurrentDrive::_8mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_Off},
     {ClockControl::ClockCurrentDrive::_2mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_Off},
+    // CLK4: HackRF r9 - not inverted
     {ClockControl::ClockCurrentDrive::_2mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_Off},
+    // CLK5: HackRF r9 - not used
     {ClockControl::ClockCurrentDrive::_2mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_Off},
+    // CLK6: Not used
     {ClockControl::ClockCurrentDrive::_2mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_Off},
+#endif
+    // CLK7: Not used
     {ClockControl::ClockCurrentDrive::_2mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_Off},
+
 }};
+
 ClockManager::Reference ClockManager::get_reference() const {
     return reference;
 }
@@ -255,9 +320,48 @@ static void portapack_tcxo_disable() {
 using namespace hackrf::one;
 
 void ClockManager::init_clock_generator() {
+#ifdef PRALINE
+    // PRALINE: Configure clock input mux GPIO
+    // GPIO0_15 (clkin_ctrl) selects GP_CLKIN source:
+    //   0 = P1 connector (external)
+    //   1 = P22 (internal Si5351 CLK2)
+    constexpr GPIO gpio_clkin_ctrl = gpio[GPIO0_15];
+    gpio_clkin_ctrl.output();
+    gpio_clkin_ctrl.write(1);  // CLKIN_SIGNAL_P22 = 1 = internal Si5351 CLK2
+
+    // Also enable MCU clock gate (GPIO0_8)
+    gpio_r9_mcu_clk_en.output();
+    gpio_r9_mcu_clk_en.write(1);
+#else
+    // HackRF One r9: GPIO0_8 (mcu_clk_en) gates Si5351 CLK2/CLK7 to GP_CLKIN
+    if (hackrf_r9) {
+        gpio_r9_mcu_clk_en.output();
+        gpio_r9_mcu_clk_en.write(1);
+    }
+#endif
+
     clock_generator.reset();
     clock_generator.set_crystal_internal_load_capacitance(CrystalInternalLoadCapacitance::XTAL_CL_8pF);
     clock_generator.enable_fanout();
+
+#ifdef PRALINE
+    /* PRALINE has Si5351A (NOT Si5351C like HackRF One OG).
+     * Must use Si5351A configuration: PLLA only, no CLKIN support.
+     *
+     * IMPORTANT: Follow HackRF reference sequence:
+     * 1. Set PLL input sources
+     * 2. Configure PLL and multisynths
+     * 3. Set clock control registers (AFTER multisynths!)
+     * 4. Reset PLLs
+     * 5. Enable outputs
+     */
+    clock_generator.set_pll_input_sources(si5351a_pll_input_sources);
+
+    /* Skip MCU CLKIN setup and reference detection for PRALINE - not applicable */
+    reference = Reference{ReferenceSource::Xtal, 0};
+
+    /* Clock control will be set AFTER multisynth configuration - see below */
+#else
     clock_generator.set_pll_input_sources(hackrf_r9
                                               ? si5351a_pll_input_sources
                                               : si5351c_pll_input_sources);
@@ -298,7 +402,75 @@ void ClockManager::init_clock_generator() {
         si5351_clock_control_common[7].ms_src(ref_pll),
     }};
     clock_generator.set_clock_control(si5351_clock_control);
+#endif
 
+#ifdef PRALINE
+
+    /* * Praline HackRF Pro Clock Assignments (800 MHz VCO Configuration)
+     * VCO Frequency: 800,000,000 Hz (Master Reference)
+     * * CLK0: AFE_CLK (MAX5864 Codec & FPGA ADC Interface)
+     *  - Initialized to: 4,000,000 Hz (si5351_ms_4m)
+     *  - Divider: 100 (Integer), R_DIV: 2 (r_div=1)
+     *  - Note: Defines hardware sample rate. Essential for WFM purity.
+     * * CLK1: SCT_CLK (iCE40 FPGA System/Timing Clock)
+     *  - Initialized to: 10,000,000 Hz (si5351_ms_10m)
+     *  - Divider: 80 (Integer), R_DIV: 1 (r_div=0)
+     *  - Note: Timing for SGPIO data bus; scales to 2x SR in wideband modes.
+     * * CLK2: MCU_CLKIN (LPC43xx MCU External Clock Input)
+     *  - Initialized to: 10,000,000 Hz (si5351_ms_10m)
+     *  - Divider: 80 (Integer), R_DIV: 1 (r_div=0)
+     *  - Note: Synchronizes MCU processing to the RF clock tree.
+     * * CLK3: SG_CLK (Switching Regulator/Internal Logic Sync)
+     *  - Initialized to: 10,000,000 Hz (si5351_ms_10m)
+     *  - Divider: 80 (Integer), R_DIV: 1 (r_div=0)
+     *  - Note: Used for internal FPGA logic/gateware synchronization.
+     * * CLK4: P_CLK (Peripheral/Expansion Clock)
+     *  - Configured via: si5351c_ms_4_reg
+     *  - Note: Routed to expansion headers for external hardware sync.
+     * * CLK5: AUX_CLK (Auxiliary reference for secondary logic)
+     *  - Configured via: si5351c_ms_5_reg
+     *  - Note: Provides additional timing flexibility for the iCE40 FPGA.
+     * * CLK6/7: Unused / Power-Down
+     *  - State: Disabled (si5351a_ms6_7_off_reg)
+     *  - Note: Kept OFF to reduce EMI/RFI near the RF front-end.
+     * * CLKOUT: Optional external clock output on the header.
+     */
+
+    /* Step 1: Write PLL A configuration (800 MHz VCO from 25 MHz XTAL) */
+    /* Use single-byte writes to debug I2C issues */
+    {
+        const auto& pll_regs = si5351_pll_a_xtal_reg;
+        const uint8_t base_reg = pll_regs[0];
+        for (size_t i = 1; i < pll_regs.size(); i++) {
+            clock_generator.write_register(base_reg + i - 1, pll_regs[i]);
+        }
+    }
+
+    /* Step 2: Write multisynth configurations using single-byte writes */
+    // These cover all active channels on the Praline board
+    clock_generator.write_ms_single_byte(0, si5351_ms_0_4m);  // CLK0: Codec (4 MHz)
+    clock_generator.write_ms_single_byte(1, si5351_ms_10m);   // CLK1: FPGA Timing (10 MHz)
+    clock_generator.write_ms_single_byte(2, si5351_ms_10m);   // CLK2: MCU Input (10 MHz)
+    clock_generator.write_ms_single_byte(3, si5351_ms_10m);   // CLK3: Logic Sync (10 MHz)
+    clock_generator.write_ms_single_byte(4, si5351_ms_40m);   // CLK4: First IF (40 MHz)
+    clock_generator.write_ms_single_byte(5, si5351_ms_40m);   // CLK5: Second IF (40 MHz)
+
+    /* Step 3: NOW set clock control registers (AFTER multisynths per HackRF reference) */
+    const auto ref_pll = ClockControl::MultiSynthSource::PLLA;
+    const ClockControls si5351_clock_control = ClockControls{{
+        si5351a_clock_control_common[0].ms_src(ref_pll),
+        si5351a_clock_control_common[1].ms_src(ref_pll),
+        si5351a_clock_control_common[2].ms_src(ref_pll),
+        si5351a_clock_control_common[3].ms_src(ref_pll),
+        si5351a_clock_control_common[4].ms_src(ref_pll),
+        si5351a_clock_control_common[5].ms_src(ref_pll),
+        si5351a_clock_control_common[6].ms_src(ref_pll),
+        si5351a_clock_control_common[7].ms_src(ref_pll),
+    }};
+    // clock_generator.set_clock_control(si5351_clock_control);
+    //  Use single-byte writes instead of multi-byte
+    clock_generator.set_clock_control_single_byte(si5351_clock_control);
+#else
     if (hackrf_r9) {
         const PLLReg pll_reg = (reference.source == ReferenceSource::Xtal)
                                    ? si5351_pll_a_xtal_reg
@@ -319,21 +491,39 @@ void ClockManager::init_clock_generator() {
         clock_generator.write(si5351c_ms_5_reg);
         clock_generator.write(si5351c_ms6_7_off_mcu_clkin_reg);
     }
+#endif
 
     clock_generator.reset_plls();
 
     // Wait for PLL(s) to lock.
+#ifdef PRALINE
+    // PRALINE: Wait for PLLA to lock (0x20 = LOL_A bit)
+    uint8_t device_status_mask = 0x20;
+    uint32_t pll_timeout = 100000;
+    while ((clock_generator.device_status() & device_status_mask) != 0 && pll_timeout > 0) {
+        pll_timeout--;
+    }
+    // Store PLL lock status for debugging
+    static volatile uint32_t pll_lock_timeout = pll_timeout;
+    (void)pll_lock_timeout;
+
+    // CRITICAL: Add delay to ensure Si5351 writes complete before I2C bus stops
+    chThdSleepMilliseconds(100);
+#else
+    // Wait for PLL(s) to lock - with timeout to prevent hang
     uint8_t device_status_mask = hackrf_r9
                                      ? 0x20
                                  : (ref_pll == ClockControl::MultiSynthSource::PLLB)
                                      ? 0x40
                                      : 0x20;
+
     while ((clock_generator.device_status() & device_status_mask) != 0);
 
     clock_generator.set_clock_control(
         clock_generator_output_mcu_clkin,
         si5351_clock_control_common[clock_generator_output_mcu_clkin].ms_src(ref_pll).clk_pdn(ClockControl::ClockPowerDown::Power_On));
     clock_generator.enable_output(clock_generator_output_mcu_clkin);
+#endif
 }
 
 uint32_t ClockManager::measure_gp_clkin_frequency() {
@@ -400,6 +590,15 @@ void ClockManager::shutdown() {
 }
 
 void ClockManager::enable_codec_clocks() {
+#ifdef PRALINE
+    /* PRALINE: CLK0 (AFE_CLK) for codec/FPGA, CLK1 (SCT_CLK) for FPGA timing.
+     * Reference hackrf_core.c shows PRALINE needs both CLK0 and CLK1. */
+    clock_generator.enable_clock(clock_generator_output_og_codec); /* CLK0 MAX5864*/
+    clock_generator.enable_clock(clock_generator_output_og_cpld);  /* CLK1 iCE40 FPGA*/
+    clock_generator.enable_clock(clock_generator_output_og_sgpio); /* CLK2 LPC43xx*/
+    clock_generator.enable_output_mask(
+        (1U << clock_generator_output_og_codec) | (1U << clock_generator_output_og_cpld) | (1U << clock_generator_output_og_sgpio));
+#else
     if (hackrf_r9) {
         clock_generator.enable_clock(clock_generator_output_r9_sgpio);
     } else {
@@ -417,6 +616,7 @@ void ClockManager::enable_codec_clocks() {
         clock_generator.enable_output_mask(
             (1U << clock_generator_output_og_codec) | (1U << clock_generator_output_og_cpld) | (1U << clock_generator_output_og_sgpio));
     }
+#endif
 }
 
 void ClockManager::disable_codec_clocks() {
@@ -424,6 +624,14 @@ void ClockManager::disable_codec_clocks() {
      * be enabled for the output to come to rest at the state specified by
      * CLKx_DISABLE_STATE.
      */
+#ifdef PRALINE
+    /* PRALINE: CLK0 (AFE_CLK), CLK1 (SCT_CLK), and CLK2 MCU used for codec/FPGA */
+    clock_generator.disable_output_mask(
+        (1U << clock_generator_output_og_codec) | (1U << clock_generator_output_og_cpld) | (1U << clock_generator_output_og_sgpio));
+    clock_generator.disable_clock(clock_generator_output_og_codec);
+    clock_generator.disable_clock(clock_generator_output_og_cpld);
+    clock_generator.disable_clock(clock_generator_output_og_sgpio);
+#else
     if (hackrf_r9) {
         clock_generator.disable_output_mask(1U << clock_generator_output_r9_sgpio);
         clock_generator.disable_clock(clock_generator_output_r9_sgpio);
@@ -434,9 +642,17 @@ void ClockManager::disable_codec_clocks() {
         clock_generator.disable_clock(clock_generator_output_og_cpld);
         clock_generator.disable_clock(clock_generator_output_og_sgpio);
     }
+#endif
 }
 
 void ClockManager::enable_if_clocks() {
+#ifdef PRALINE
+    /* PRALINE uses CLK5 (first IF) and CLK4 (second IF) */
+    clock_generator.enable_clock(clock_generator_output_og_first_if);
+    clock_generator.enable_output_mask(1U << clock_generator_output_og_first_if);
+    clock_generator.enable_clock(clock_generator_output_og_second_if);
+    clock_generator.enable_output_mask(1U << clock_generator_output_og_second_if);
+#else
     if (hackrf_r9) {
         clock_generator.enable_clock(clock_generator_output_r9_if);
         clock_generator.enable_output_mask(1U << clock_generator_output_r9_if);
@@ -446,9 +662,16 @@ void ClockManager::enable_if_clocks() {
         clock_generator.enable_clock(clock_generator_output_og_second_if);
         clock_generator.enable_output_mask(1U << clock_generator_output_og_second_if);
     }
+#endif
 }
 
 void ClockManager::disable_if_clocks() {
+#ifdef PRALINE
+    clock_generator.disable_output_mask(1U << clock_generator_output_og_first_if);
+    clock_generator.disable_clock(clock_generator_output_og_first_if);
+    clock_generator.disable_output_mask(1U << clock_generator_output_og_second_if);
+    clock_generator.disable_clock(clock_generator_output_og_second_if);
+#else
     if (hackrf_r9) {
         clock_generator.disable_output_mask(1U << clock_generator_output_r9_if);
         clock_generator.disable_clock(clock_generator_output_r9_if);
@@ -458,19 +681,59 @@ void ClockManager::disable_if_clocks() {
         clock_generator.disable_output_mask(1U << clock_generator_output_og_second_if);
         clock_generator.disable_clock(clock_generator_output_og_second_if);
     }
+#endif
 }
 
 void ClockManager::set_sampling_frequency(const uint32_t frequency) {
+#ifdef PRALINE
+    /*
+     * PRALINE sample rate strategy:
+     * 1. Maximize AFE rate to push Nyquist above MAX2831's 11.6 MHz LPF minimum
+     * 2. Use FPGA decimation to achieve desired output rate
+     * 3. Ensure AFE rate is achievable by Si5351 (clean division from 800 MHz VCO)
+     */
+
+    constexpr uint32_t MAX_AFE_RATE = 40000000;  // Use 40 MHz per GSG reference
+    constexpr uint8_t MAX_N = 5;
+
+    _base_band_frequency = frequency;
+
+    uint8_t n = 0;
+    uint32_t afe_rate = frequency;
+
+    // Find the largest n where AFE rate stays within limit
+    // Start at n=0 and work up
+    while (n < MAX_N) {
+        uint32_t next_rate = afe_rate << 1;
+        if (next_rate > MAX_AFE_RATE) break;
+        afe_rate = next_rate;
+        n++;
+    }
+
+    _resampling_n = n;
+
+    // Set FPGA RX decimation register
+    fpga_debug_register_write(2, n);
+    radio::invalidate_spi_config();
+
+    // Configure Si5351 clocks
+    // CLK0: AFE_CLK (with r_div=1 for ÷2)
+    // CLK1: SCT_CLK (with r_div=0 for ÷1, runs at 2× AFE for FPGA timing)
+    clock_generator.set_ms_frequency(0, afe_rate * 2, si5351_vco_f, 1);
+    clock_generator.set_ms_frequency(1, afe_rate * 2, si5351_vco_f, 0);
+#else
     /* Codec clock is at sampling frequency, CPLD and SGPIO clocks are at
      * twice the frequency, and derived from the MS0 synth. So it's only
      * necessary to change the MS0 synth frequency, and ensure the output
      * is divided by two.
      */
+
     if (hackrf_r9) {
         clock_generator.set_ms_frequency(clock_generator_output_r9_sgpio, frequency * 2, si5351_vco_f, 0);
     } else {
         clock_generator.set_ms_frequency(clock_generator_output_og_codec, frequency * 2, si5351_vco_f, 1);
     }
+#endif
 }
 
 void ClockManager::set_reference_ppb(const int32_t ppb) {
@@ -510,7 +773,15 @@ void ClockManager::start_frequency_monitor_measurement(const cgu::CLK_SEL clk_se
 
 void ClockManager::wait_For_frequency_monitor_measurement_done() {
     // FREQ_MON mechanism fails to finish if there's no clock present on selected input?!
+#ifndef PRALINE
     while (LPC_CGU->FREQ_MON.MEAS == 1);
+#else
+    // PRALINE FIX: Add timeout to prevent infinite hang
+    uint32_t timeout = 100000;
+    while (LPC_CGU->FREQ_MON.MEAS == 1 && timeout > 0) {
+        timeout--;
+    }
+#endif
 }
 
 uint32_t ClockManager::get_frequency_monitor_measurement_in_hertz() {
@@ -521,6 +792,45 @@ uint32_t ClockManager::get_frequency_monitor_measurement_in_hertz() {
 }
 
 void ClockManager::start_audio_pll() {
+#ifdef PRALINE
+    /* PRALINE: Use 12MHz XTAL for audio PLL
+     * For 12MHz XTAL input, 48kHz audio rate, 256Fs MCLK:
+     *   Fout=12.288MHz, Fcco=491.52MHz
+     *   12MHz * 1024 / 25 = 491.52MHz
+     *   MSEL=1024, NSEL=25, PSEL=20
+     */
+
+    cgu::pll0audio::mdiv({
+        .mdec = 22625UL,  // Encoded value for MSEL=1024
+    });
+    cgu::pll0audio::np_div({
+        .pdec = 31,  // Encoded value for PSEL=20
+        .ndec = 69,  // Encoded value for NSEL=25
+    });
+
+    cgu::pll0audio::frac({
+        .pllfract_ctrl = 0,
+    });
+
+    cgu::pll0audio::power_up();
+
+    // Praline Fix: Wait for lock with a safety timeout
+    {
+        uint32_t timeout = 100000;
+        while (!cgu::pll0audio::is_locked() && timeout > 0) {
+            timeout--;
+        }
+    }
+
+    cgu::pll0audio::clock_enable();
+
+    /* Route the 12.288MHz PLL to the Base Audio Clock */
+    // PD = 0 enables the clock; AUTOBLOCK = 1 prevents glitches during clock switching
+    LPC_CGU->BASE_AUDIO_CLK.PD = 0;
+    LPC_CGU->BASE_AUDIO_CLK.AUTOBLOCK = 1;
+    LPC_CGU->BASE_AUDIO_CLK.CLK_SEL = toUType(cgu::CLK_SEL::PLL0AUDIO);
+
+#else
     cgu::pll0audio::ctrl({
         .pd = 1,
         .bypass = 0,
@@ -549,13 +859,24 @@ void ClockManager::start_audio_pll() {
         .pdec = 31,
         .ndec = 45,
     });
+#endif
 
     cgu::pll0audio::frac({
         .pllfract_ctrl = 0,
     });
 
     cgu::pll0audio::power_up();
+#ifndef PRALINE
     while (!cgu::pll0audio::is_locked());
+#else
+    // PRALINE FIX: Add timeout to prevent infinite hang if GP_CLKIN not present
+    {
+        uint32_t timeout = 100000;
+        while (!cgu::pll0audio::is_locked() && timeout > 0) {
+            timeout--;
+        }
+    }
+#endif
     cgu::pll0audio::clock_enable();
 
     set_base_audio_clock_divider(1);

firmware/application/clock_manager.hpp

@@ -70,8 +70,21 @@ class ClockManager {
 
     void set_sampling_frequency(const uint32_t frequency);
 
+    uint32_t get_sampling_frequency() const {
+        return _base_band_frequency;
+    };
+
     void set_reference_ppb(const int32_t ppb);
 
+#ifdef PRALINE
+    uint8_t get_resampling_n() const { return _resampling_n; }
+
+    // Si5351 diagnostic methods
+    uint8_t si5351_read_status() { return clock_generator.device_status(); }
+    uint8_t si5351_read_register(uint8_t reg) { return clock_generator.read_register(reg); }
+    void si5351_write_register(uint8_t reg, uint8_t value) { clock_generator.write_register(reg, value); }
+#endif
+
     uint32_t get_frequency_monitor_measurement_in_hertz();
 
     Reference get_reference() const;
@@ -85,6 +98,8 @@ class ClockManager {
     si5351::Si5351& clock_generator;
     Reference reference;
 
+    uint32_t _base_band_frequency{20000000};
+
     void set_gp_clkin_to_clkin_direct();
 
     void start_frequency_monitor_measurement(const cgu::CLK_SEL clk_sel);
@@ -99,6 +114,10 @@ class ClockManager {
     ReferenceSource detect_reference_source();
     Reference choose_reference();
     bool loss_of_signal();
+
+#ifdef PRALINE
+    uint8_t _resampling_n{0};  // Current decimation factor (log2)
+#endif
 };
 
 #endif /*__CLOCK_MANAGER_H__*/

firmware/application/event_m0.cpp

@@ -256,7 +256,9 @@ ui::Widget* EventDispatcher::touch_widget(ui::Widget* const w, ui::TouchEvent ev
     if (!w->hidden()) {
         // To achieve reverse depth ordering (last object drawn is
         // considered "top"), descend first.
-        for (const auto child : w->children()) {
+        auto& children = w->children();
+        for (auto it = children.rbegin(); it != children.rend(); ++it) {  // reverse, bc the lastly added will be "top" if overlaps
+            const auto& child = *it;
             const auto touched_widget = touch_widget(child, event);
             if (touched_widget) {
                 return touched_widget;

firmware/application/external/acars_rx/acars_app.cpp

@@ -33,6 +33,76 @@ using namespace portapack;
 
 namespace ui::external_app::acars_rx {
 
+// ACARS frame field layout (0-based byte offsets):
+//   [0]          SOH framing byte   (skipped)
+//   [1..7]       Aircraft registration (7 chars)
+//   [8]          STX framing byte   (skipped)
+//   [9..10]      Label              (2 chars)
+//   [11]         Block ID           (1 char)
+//   [12..14]     Message number     (3 chars)
+//   [15..20]     Flight ID          (6 chars)
+//   [21..N-3]    Free-text payload  (variable)
+//   [N-2..N-1]   CRC-16/CCITT      (2 bytes, MSB first, NOT part of payload)
+//
+// Minimum valid frame: 21-byte fixed header + 2 CRC bytes = 23 bytes.
+// (A zero-length payload is legal per spec; we require at least 23 bytes.)
+static constexpr std::string::size_type kAcarsCrcLen = 2;
+static constexpr std::string::size_type kAcarsHeaderLen = 21;
+static constexpr std::string::size_type kAcarsMinLen = kAcarsHeaderLen + kAcarsCrcLen;
+
+// CRC-16/CCITT: poly 0x1021, init 0x0000, no reflection, no final XOR.
+// This is the variant used by ACARS (same as XMODEM CRC).
+static uint16_t acars_crc16(const std::string& data, std::string::size_type len) {
+    uint16_t crc = 0x0000;
+    for (std::string::size_type i = 0; i < len; ++i) {
+        crc ^= static_cast<uint16_t>(static_cast<uint8_t>(data[i])) << 8;
+        for (int bit = 0; bit < 8; ++bit) {
+            if (crc & 0x8000)
+                crc = static_cast<uint16_t>((crc << 1) ^ 0x1021);
+            else
+                crc = static_cast<uint16_t>(crc << 1);
+        }
+    }
+    return crc;
+}
+
+AcarsDecoded acars_decode(const std::string& raw) {
+    AcarsDecoded result;
+    if (raw.size() < kAcarsMinLen) {
+        result.txt = "ACARS message too short (" + std::to_string(raw.size()) +
+                     " bytes, need " + std::to_string(kAcarsMinLen) + ")";
+        return result;
+    }
+
+    // Verify CRC: computed over everything except the last 2 bytes,
+    // then compared against those 2 bytes (MSB first).
+    const std::string::size_type payload_len = raw.size() - kAcarsCrcLen;
+    const uint16_t computed = acars_crc16(raw, payload_len);
+    const uint16_t received = (static_cast<uint16_t>(static_cast<uint8_t>(raw[raw.size() - 2])) << 8) |
+                              static_cast<uint16_t>(static_cast<uint8_t>(raw[raw.size() - 1]));
+    result.crc_ok = (computed == received);
+
+    result.reg = raw.substr(1, 7);
+    result.label = raw.substr(9, 2);
+    result.block_id = raw[11];
+    result.msg_num = raw.substr(12, 3);
+    result.flight_id = raw.substr(15, 6);
+    // Payload sits between end of fixed header and the 2 trailing CRC bytes.
+    if (payload_len > kAcarsHeaderLen)
+        result.txt = raw.substr(kAcarsHeaderLen, payload_len - kAcarsHeaderLen);
+    return result;
+}
+
+std::string acars_format(const AcarsDecoded& msg) {
+    return std::string("ACARS Decoded Result\nCRC: ") + (msg.crc_ok ? "OK" : "FAIL") +
+           "\nRegistration: " + msg.reg +
+           "\nLabel: " + msg.label +
+           "\nBlockID: " + msg.block_id +
+           "\nMsgNum: " + msg.msg_num +
+           "\nFlightID: " + msg.flight_id +
+           "\nMessage: " + msg.txt;
+}
+
 void ACARSLogger::log_str(std::string msg) {
     log_file.write_entry(msg);
 }
@@ -77,17 +147,16 @@ void ACARSAppView::focus() {
 
 void ACARSAppView::on_packet(const ACARSPacketMessage* packet) {
     std::string console_info;
-
     if (packet->state == 255) {
         // got a packet, parse it, and display
         rtc::RTC datetime;
         rtc_time::now(datetime);
-        // todo parity error recovery
         console_info = to_string_datetime(datetime, HMS);
         console_info += ": ";
-        console_info += packet->message;
+        std::string message{packet->message, packet->message + packet->msg_len};
+        AcarsDecoded decoded = acars_decode(message);
+        console_info += acars_format(decoded);
         console.writeln(console_info);
-        // Log raw data whatever it contains
         if (logger && logging)
             logger->log_str(console_info);
     } else {

firmware/application/external/acars_rx/acars_app.hpp

@@ -33,6 +33,26 @@
 
 namespace ui::external_app::acars_rx {
 
+// Decoded ACARS message fields extracted from a raw frame.
+// CRC-16/CCITT (poly 0x1021, init 0x0000) is verified against the two
+// trailing bytes of the raw frame; crc_ok reflects that result.
+struct AcarsDecoded {
+    bool crc_ok{false};
+    std::string reg{};
+    std::string label{};
+    std::string flight_id{};
+    std::string msg_num{};
+    char block_id{'\0'};
+    std::string txt{};
+};
+
+// Decode a raw ACARS frame: verify CRC-16/CCITT and extract fixed-offset fields.
+// Returns a partially-filled AcarsDecoded (txt error only) if the frame is too short.
+AcarsDecoded acars_decode(const std::string& raw);
+
+// Format a decoded ACARS message for display or logging.
+std::string acars_format(const AcarsDecoded& msg);
+
 class ACARSLogger {
    public:
     Optional<File::Error> append(const std::filesystem::path& filename) {
@@ -106,4 +126,4 @@ class ACARSAppView : public View {
 
 }  // namespace ui::external_app::acars_rx
 
-#endif /*__ACARS_APP_H__*/
+#endif /*__ACARS_APP_H__*/

firmware/application/external/acars_rx/main.cpp

@@ -1,83 +1,83 @@
-/*
- * Copyright (C) 2023 Bernd Herzog
- *
- * This file is part of PortaPack.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-
-#include "ui.hpp"
-#include "acars_app.hpp"
-#include "ui_navigation.hpp"
-#include "external_app.hpp"
-
-namespace ui::external_app::acars_rx {
-void initialize_app(ui::NavigationView& nav) {
-    nav.push<ACARSAppView>();
-}
-}  // namespace ui::external_app::acars_rx
-
-extern "C" {
-
-__attribute__((section(".external_app.app_acars_rx.application_information"), used)) application_information_t _application_information_acars_rx = {
-    /*.memory_location = */ (uint8_t*)0x00000000,
-    /*.externalAppEntry = */ ui::external_app::acars_rx::initialize_app,
-    /*.header_version = */ CURRENT_HEADER_VERSION,
-    /*.app_version = */ VERSION_MD5,
-
-    /*.app_name = */ "ACARS",
-    /*.bitmap_data = */ {
-        0x80,
-        0x01,
-        0xC0,
-        0x03,
-        0xC0,
-        0x03,
-        0xC0,
-        0x03,
-        0xC0,
-        0x03,
-        0xE0,
-        0x07,
-        0xF8,
-        0x1F,
-        0xFE,
-        0x7F,
-        0xFF,
-        0xFF,
-        0xFF,
-        0xFF,
-        0xC0,
-        0x03,
-        0xC0,
-        0x03,
-        0xC0,
-        0x03,
-        0xE0,
-        0x07,
-        0xF0,
-        0x0F,
-        0xF8,
-        0x1F,
-    },
-    /*.icon_color = */ ui::Color::orange().v,
-    /*.menu_location = */ app_location_t::RX,
-    /*.desired_menu_position = */ -1,
-
-    /*.m4_app_tag = portapack::spi_flash::image_tag_acars */ {'P', 'A', 'C', 'A'},
-    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
-};
-}
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "acars_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::acars_rx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<ACARSAppView>();
+}
+}  // namespace ui::external_app::acars_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_acars_rx.application_information"), used)) application_information_t _application_information_acars_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::acars_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "ACARS",
+    /*.bitmap_data = */ {
+        0x80,
+        0x01,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xE0,
+        0x07,
+        0xF8,
+        0x1F,
+        0xFE,
+        0x7F,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xE0,
+        0x07,
+        0xF0,
+        0x0F,
+        0xF8,
+        0x1F,
+    },
+    /*.icon_color = */ ui::Color::orange().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_acars */ {'P', 'A', 'C', 'A'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/adult_toys_controller/ui_adult_toys_controller.cpp

@@ -339,7 +339,7 @@ void AdultToysView::randomizeMac() {
 }
 
 void AdultToysView::randomChn() {
-    channel_number = 37 + std::rand() % (39 - 37 + 1);
+    channel_number = 37 + rand() % (39 - 37 + 1);
     field_frequency.set_value(get_freq_by_channel_number(channel_number));
 }
 

firmware/application/external/app_manager/ui_app_manager.cpp

@@ -62,19 +62,24 @@ AppManagerView::AppManagerView(NavigationView& nav)
         auto app_name = get_app_info(menu_view.highlighted_index(), true);
         auto app_id = get_app_info(menu_view.highlighted_index(), false);
 
-        info += "Hidden:";
+        if (!app_name.empty()) {
+            info += "Hidden:";
 
-        if (is_blacklisted(app_name)) {
-            info += "Yes ";
-        } else {
-            info += "No ";
+            if (is_blacklisted(app_name)) {
+                info += "Yes ";
+            } else {
+                info += "No ";
+            }
         }
 
-        info += "Autostart:";
-        if (is_autostart_app(app_id)) {
-            info += "Yes";
-        } else {
-            info += "No";
+        if (!app_id.empty()) {
+            info += "Autostart:";
+
+            if (is_autostart_app(app_id)) {
+                info += "Yes";
+            } else {
+                info += "No";
+            }
         }
 
         if (info.empty()) {
@@ -82,6 +87,8 @@ AppManagerView::AppManagerView(NavigationView& nav)
         }
 
         text_app_info.set(info);
+        button_hide_unhide.set_focusable(!app_name.empty());
+        button_set_cancel_autostart.set_focusable(!app_id.empty());
     };
 
     button_hide_unhide.on_select = [this](Button&) {
@@ -120,27 +127,23 @@ void AppManagerView::refresh_list() {
     };
 
     for (auto& app : NavigationView::appList) {
-        if (app.id == nullptr) continue;
-
         app_list_index++;
 
-        menu_view.add_item({app.displayName + std::string(is_autostart_app(app.id) ? padding(app.displayName) : ""),
+        menu_view.add_item({app.displayName + std::string((app.id != nullptr && is_autostart_app(app.id)) ? padding(app.displayName) : ""),
                             app.iconColor,
                             app.icon,
-                            [this, app_id = std::string(app.id)](KeyEvent) {
+                            [this, app_id = std::string(app.id != nullptr ? app.id : "")](KeyEvent) {
                                 button_hide_unhide.focus();
                             }});
     }
 
     ExternalItemsMenuLoader::load_all_external_items_callback([this, &index, &padding](ui::AppInfoConsole& app) {
-        if (app.appCallName == nullptr) return;
-
         app_list_index++;
 
-        menu_view.add_item({app.appFriendlyName + std::string(is_autostart_app(app.appCallName) ? padding(app.appFriendlyName) : ""),
+        menu_view.add_item({app.appFriendlyName + std::string((app.appCallName != nullptr && is_autostart_app(app.appCallName)) ? padding(app.appFriendlyName) : ""),
                             ui::Color::light_grey(),
                             &bitmap_icon_sdcard,
-                            [this, app_id = std::string(app.appCallName)](KeyEvent) {
+                            [this, app_id = std::string(app.appCallName != nullptr ? app.appCallName : "")](KeyEvent) {
                                 button_hide_unhide.focus();
                             }});
     });
@@ -156,19 +159,29 @@ void AppManagerView::hide_app() {
     std::vector<std::string> blacklist;
     get_blacklist(blacklist);
 
-    blacklist.push_back(get_app_info(menu_view.highlighted_index(), true));
+    auto app_name = get_app_info(menu_view.highlighted_index(), true);
+    if (app_name.empty()) return;
+
+    blacklist.push_back(app_name);
     write_blacklist(blacklist);
 }
 
 void AppManagerView::unhide_app() {
     std::vector<std::string> blacklist;
     get_blacklist(blacklist);
-    blacklist.erase(std::remove(blacklist.begin(), blacklist.end(), get_app_info(menu_view.highlighted_index(), true)), blacklist.end());
+
+    auto app_name = get_app_info(menu_view.highlighted_index(), true);
+    if (app_name.empty()) return;
+
+    blacklist.erase(std::remove(blacklist.begin(), blacklist.end(), app_name), blacklist.end());
     write_blacklist(blacklist);
 }
 
 void AppManagerView::hide_unhide_app() {
-    if (is_blacklisted(get_app_info(menu_view.highlighted_index(), true)))
+    auto app_name = get_app_info(menu_view.highlighted_index(), true);
+    if (app_name.empty()) return;
+
+    if (is_blacklisted(app_name))
         unhide_app();
     else
         hide_app();
@@ -218,6 +231,7 @@ void AppManagerView::set_auto_start() {
     if (app_index >= app_list_index) return;
 
     auto id_aka_app_call_name = get_app_info(app_index, false);
+    if (id_aka_app_call_name.empty()) return;
 
     autostart_app = id_aka_app_call_name;
 
@@ -234,6 +248,7 @@ void AppManagerView::set_unset_autostart_app() {
     if (app_index >= app_list_index) return;
 
     auto id_aka_friendly_name = get_app_info(app_index, false);
+    if (id_aka_friendly_name.empty()) return;
 
     if (is_autostart_app(id_aka_friendly_name))
         unset_auto_start();
@@ -254,17 +269,15 @@ std::string AppManagerView::get_app_info(uint16_t index, bool is_display_name) {
     std::string result;
 
     for (auto& app : NavigationView::appList) {
-        if (app.id == nullptr) continue;
         if (current_index == index) {
-            return is_display_name ? std::string(app.displayName) : std::string(app.id);
+            return is_display_name ? std::string(app.displayName != nullptr ? app.displayName : "") : std::string(app.id != nullptr ? app.id : "");
         }
         current_index++;
     }
 
     ExternalItemsMenuLoader::load_all_external_items_callback([&current_index, &index, &result, &is_display_name](ui::AppInfoConsole& app) {
-        if (app.appCallName == nullptr) return;
         if (current_index == index) {
-            result = is_display_name ? app.appFriendlyName : app.appCallName;
+            result = is_display_name ? (app.appFriendlyName != nullptr ? app.appFriendlyName : "") : (app.appCallName != nullptr ? app.appCallName : "");
         }
         current_index++;
     });

firmware/application/external/blackjack/ui_blackjack.cpp

@@ -72,7 +72,7 @@ void BlackjackView::paint(Painter& painter) {
 
     if (!initialized) {
         initialized = true;
-        std::srand(LPC_RTC->CTIME0);
+        srand(LPC_RTC->CTIME0);
         init_deck();
     }
 }

firmware/application/external/blespam/ui_blespam.cpp

@@ -132,7 +132,7 @@ void BLESpamView::reset() {
 }
 
 void BLESpamView::randomChn() {
-    channel_number = 37 + std::rand() % (39 - 37 + 1);
+    channel_number = 37 + rand() % (39 - 37 + 1);
     field_frequency.set_value(get_freq_by_channel_number(channel_number));
 }
 

firmware/application/external/breakout/ui_breakout.cpp

@@ -655,7 +655,7 @@ void BreakoutView::paint(Painter& painter) {
 
     if (!initialized) {
         initialized = true;
-        std::srand(LPC_RTC->CTIME0);
+        srand(LPC_RTC->CTIME0);
         init_game();
     }
 }

firmware/application/external/dinogame/ui_dinogame.cpp

@@ -125,7 +125,7 @@ void DinoGameView::paint(Painter& painter) {
 
     if (!initialized) {
         initialized = true;
-        std::srand(LPC_RTC->CTIME0);
+        srand(LPC_RTC->CTIME0);
         init_game();
     }
 }
@@ -789,8 +789,8 @@ void DinoGameView::draw_current_score() {
 
 void DinoGameView::draw_high_score() {
     auto style = *ui::Theme::getInstance()->fg_light;
-    painter.fill_rectangle({UI_POS_X_RIGHT(90), 28, 90, 18}, Color::black());
-    painter.draw_string({UI_POS_X_RIGHT(90), 30}, style, "HI " + score_to_string(highScore));
+    painter.fill_rectangle({UI_POS_X_RIGHT(10), 28, 90, 18}, Color::black());
+    painter.draw_string({UI_POS_X_RIGHT(10), 30}, style, "HI " + score_to_string(highScore));
 }
 
 void DinoGameView::jump() {

firmware/application/external/doom/ui_doom.cpp

@@ -204,11 +204,11 @@ void spawn_entity(uint8_t type, uint8_t x, uint8_t y) {
 
 void spawn_random_entity(uint8_t type) {
     if (num_entities >= MAX_ENTITIES) return;
-    std::srand(LPC_RTC->CTIME0);
+    srand(LPC_RTC->CTIME0);
     uint8_t spawn_x, spawn_y;
     do {
-        spawn_x = std::rand() % LEVEL_WIDTH;
-        spawn_y = std::rand() % LEVEL_HEIGHT;
+        spawn_x = rand() % LEVEL_WIDTH;
+        spawn_y = rand() % LEVEL_HEIGHT;
     } while (get_block_at(spawn_x, spawn_y) == 0xF ||
              (spawn_x == (uint8_t)player.pos.x && spawn_y == (uint8_t)player.pos.y));
 
@@ -227,9 +227,9 @@ void remove_entity(uint8_t index) {
         bool spawned = false;
 
         while (!spawned && attempts < 50) {
-            std::srand(LPC_RTC->CTIME0 + attempts);
-            uint8_t spawn_x = std::rand() % LEVEL_WIDTH;
-            uint8_t spawn_y = std::rand() % LEVEL_HEIGHT;
+            srand(LPC_RTC->CTIME0 + attempts);
+            uint8_t spawn_x = rand() % LEVEL_WIDTH;
+            uint8_t spawn_y = rand() % LEVEL_HEIGHT;
 
             int16_t dx = (int16_t)spawn_x - (int16_t)player.pos.x;
             int16_t dy = (int16_t)spawn_y - (int16_t)player.pos.y;
@@ -270,9 +270,9 @@ void initialize_level() {
     uint8_t attempts = 0;
 
     while (initial_enemies < 2 && num_entities < MAX_ENTITIES && attempts < 50) {
-        std::srand(LPC_RTC->CTIME0 + attempts);
-        int8_t offset_x = (std::rand() % 11) - 5;
-        int8_t offset_y = (std::rand() % 11) - 5;
+        srand(LPC_RTC->CTIME0 + attempts);
+        int8_t offset_x = (rand() % 11) - 5;
+        int8_t offset_y = (rand() % 11) - 5;
 
         if (abs(offset_x) < 3 && abs(offset_y) < 3) {
             attempts++;
@@ -307,10 +307,10 @@ void initialize_level() {
 
     attempts = 0;
     while (num_entities < MIN_ENTITIES && attempts < 100) {
-        std::srand(LPC_RTC->CTIME0 + attempts + 100);
+        srand(LPC_RTC->CTIME0 + attempts + 100);
 
-        uint8_t spawn_x = std::rand() % LEVEL_WIDTH;
-        uint8_t spawn_y = std::rand() % LEVEL_HEIGHT;
+        uint8_t spawn_x = rand() % LEVEL_WIDTH;
+        uint8_t spawn_y = rand() % LEVEL_HEIGHT;
 
         int16_t dx = (int16_t)spawn_x - (int16_t)player.pos.x;
         int16_t dy = (int16_t)spawn_y - (int16_t)player.pos.y;
@@ -1045,7 +1045,7 @@ void DoomView::on_show() {
 void DoomView::paint(Painter& painter) {
     if (!initialized) {
         initialized = true;
-        std::srand(LPC_RTC->CTIME0);
+        srand(LPC_RTC->CTIME0);
         scene = 0;
         up = down = left = right = fired = false;
         jogging = view_height = 0;
@@ -1081,7 +1081,7 @@ void DoomView::paint(Painter& painter) {
             int hud_y = RENDER_HEIGHT + 5;
             painter.draw_string({5, hud_y}, style_yellow, "Health: " + std::to_string(player.health));
             painter.draw_string({UI_POS_X_CENTER(15), hud_y}, style_red, "Kills: " + std::to_string(kills));
-            painter.draw_string({UI_POS_X_RIGHT(80), hud_y}, style_blue, "Ammo: " + std::to_string(player.ammo));
+            painter.draw_string({UI_POS_X_RIGHT(10), hud_y}, style_blue, "Ammo: " + std::to_string(player.ammo));
 
             prev_velocity_moving = (player.velocity != 0);
             needs_redraw = false;
@@ -1113,7 +1113,7 @@ void DoomView::paint(Painter& painter) {
             int hud_y = RENDER_HEIGHT + 5;
             painter.draw_string({5, hud_y}, style_yellow, "Health: " + std::to_string(player.health));
             painter.draw_string({UI_POS_X_CENTER(15), hud_y}, style_red, "Kills: " + std::to_string(kills));
-            painter.draw_string({UI_POS_X_RIGHT(80), hud_y}, style_blue, "Ammo: " + std::to_string(player.ammo));
+            painter.draw_string({UI_POS_X_RIGHT(10), hud_y}, style_blue, "Ammo: " + std::to_string(player.ammo));
 
             needs_gun_redraw = false;
         }

firmware/application/external/external.cmake

@@ -83,6 +83,10 @@ set(EXTCPPSRC
 	external/tpmsrx/main.cpp
 	external/tpmsrx/tpms_app.cpp
 
+	#tpmstx 800 bytes - TPMS transmit with editable fields
+	external/tpmstx/main.cpp
+	external/tpmstx/tpms_tx_app.cpp
+
 	#protoview 8 byte
 	external/protoview/main.cpp
 	external/protoview/ui_protoview.cpp
@@ -91,9 +95,9 @@ set(EXTCPPSRC
 	external/adsbtx/main.cpp
 	external/adsbtx/ui_adsb_tx.cpp
 
-	#morse_tx 768 bytes
-	external/morse_tx/main.cpp
-	external/morse_tx/ui_morse.cpp
+	#morse_tx 768 bytes -- disabled because of the new morse tx app with more functions
+	#external/morse_tx/main.cpp
+	#external/morse_tx/ui_morse.cpp
 
 	#sstvtx 456 bytes
 	external/sstvtx/main.cpp
@@ -109,8 +113,8 @@ set(EXTCPPSRC
 	external/random_password/sha512.cpp
 
 	#acars
-	#external/acars_rx/main.cpp
-	#external/acars_rx/acars_app.cpp
+	external/acars_rx/main.cpp
+	external/acars_rx/acars_app.cpp
 
 	#wefax_rx 192 bytes
 	external/wefax_rx/main.cpp
@@ -222,7 +226,11 @@ set(EXTCPPSRC
 
 	#gfxEQ 80 byte
 	external/gfxeq/main.cpp
-	external/gfxeq/ui_gfxeq.cpp
+	external/gfxeq/ui_gfxeq.cpp	
+
+	#waterfall designer
+	external/waterfall_designer/main.cpp
+	external/waterfall_designer/ui_waterfall_designer.cpp
 
 	#detector_rx  168 byte
 	external/detector_rx/main.cpp
@@ -276,6 +284,34 @@ set(EXTCPPSRC
 	#subcarrx
 	external/subcarrx/main.cpp
 	external/subcarrx/ui_subcar.cpp
+
+	#siggen
+	external/siggen/main.cpp
+	external/siggen/ui_siggen.cpp
+
+	#morse_radio
+	external/morse_radio/main.cpp
+	external/morse_radio/ui_morse_radio.cpp
+
+	#morseradiotx
+	external/morseradiotx/main.cpp
+	external/morseradiotx/ui_morse_radiotx.cpp
+
+  external/keeloqtx/main.cpp
+  external/keeloqtx/ui_keeloqtx.cpp
+	#rtty_rx
+	external/rtty_rx/main.cpp
+	external/rtty_rx/ui_rtty_rx.cpp
+	external/rtty_rx/baudot.cpp
+
+	#rtty_tx
+	external/rtty_tx/main.cpp
+	external/rtty_tx/ui_rtty_tx.cpp
+	external/rtty_tx/baudot.cpp
+
+    #pocsag_tx
+	external/pocsag_tx/main.cpp
+	external/pocsag_tx/ui_pocsag_tx.cpp
 )
 
 set(EXTAPPLIST
@@ -298,13 +334,14 @@ set(EXTAPPLIST
 	audio_test
 	wardrivemap
 	tpmsrx
+	tpmstx
 	protoview
 	adsbtx
-	morse_tx
+	#morse_tx
 	sstvtx
 	sstvrx
 	random_password
-	# acars_rx --not working
+	acars_rx
 	wefax_rx
 	noaaapt_rx
 	shoppingcart_lock
@@ -332,6 +369,7 @@ set(EXTAPPLIST
 	scanner
 	level
 	gfxeq
+	waterfall_designer
 	detector_rx
 	spaceinv
 	blackjack
@@ -345,4 +383,21 @@ set(EXTAPPLIST
 	adult_toys_controller
 	flex_rx
 	subcarrx
+	siggen
+	morse_radio
+	morseradiotx
+  keeloqtx
+	rtty_rx
+	rtty_tx
+	pocsag_tx
 )
+
+# sdusb has type conflicts with PRALINE (HackRF Pro) - add only for non-PRALINE builds
+if(NOT BOARD STREQUAL "PRALINE")
+       list(APPEND EXTCPPSRC
+               external/sdusb/main.cpp
+               external/sdusb/ui_sd_over_usb.cpp
+       )
+       list(APPEND EXTAPPLIST sdusb)
+endif()
+

firmware/application/external/external.ld

@@ -89,7 +89,16 @@ MEMORY
     ram_external_app_flex_rx  (rwx) : org = 0xADF00000, len = 32k
     ram_external_app_sstvrx  (rwx) : org = 0xADF10000, len = 32k
     ram_external_app_subcarrx  (rwx) : org = 0xADF20000, len = 32k
-
+    ram_external_app_siggen  (rwx) : org = 0xADF30000, len = 32k
+    ram_external_app_sdusb  (rwx) : org = 0xADF40000, len = 32k
+    ram_external_app_morse_radio  (rwx) : org = 0xADF50000, len = 32k
+    ram_external_app_waterfall_designer (rwx) : org = 0xADF60000, len = 32k
+    ram_external_app_morseradiotx  (rwx) : org = 0xADF70000, len = 32k
+    ram_external_app_keeloqtx (rwx) : org = 0xADF80000, len = 32k
+    ram_external_app_rtty_rx  (rwx) : org = 0xADF90000, len = 32k
+    ram_external_app_rtty_tx  (rwx) : org = 0xADFA0000, len = 32k
+    ram_external_app_tpmstx   (rwx) : org = 0xADFB0000, len = 32k
+    ram_external_app_pocsag_tx (rwx) : org = 0xADFC0000, len = 32k
 }
 
 SECTIONS
@@ -208,6 +217,12 @@ SECTIONS
         *(*ui*external_app*tpmsrx*);
     } > ram_external_app_tpmsrx
 
+   .external_app_tpmstx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_tpmstx.application_information));
+        *(*ui*external_app*tpmstx*);
+    } > ram_external_app_tpmstx
+
    .external_app_protoview : ALIGN(4) SUBALIGN(4)
     {
         KEEP(*(.external_app.app_protoview.application_information));
@@ -400,6 +415,12 @@ SECTIONS
         *(*ui*external_app*gfxeq*);
     } > ram_external_app_gfxeq
 
+    .external_app_waterfall_designer : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_waterfall_designer.application_information));
+        *(*ui*external_app*waterfall_designer*);
+    } > ram_external_app_waterfall_designer
+
     .external_app_detector_rx : ALIGN(4) SUBALIGN(4)
     {
         KEEP(*(.external_app.app_detector_rx.application_information));
@@ -492,6 +513,51 @@ SECTIONS
         *(*ui*external_app*subcarrx*);
     } > ram_external_app_subcarrx
 
-    
+    .external_app_siggen : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_siggen.application_information));
+        *(*ui*external_app*siggen*);
+    } > ram_external_app_siggen
+
+     .external_app_sdusb : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_sdusb.application_information));
+        *(*ui*external_app*sdusb*);
+    } > ram_external_app_sdusb
+   
+    .external_app_morse_radio : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_morse_radio.application_information));
+        *(*ui*external_app*morse_radio*);
+    } > ram_external_app_morse_radio
+
+    .external_app_morseradiotx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_morseradiotx.application_information));
+        *(*ui*external_app*morseradiotx*);
+    } > ram_external_app_morseradiotx
+
+    .external_app_keeloqtx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_keeloqtx.application_information));
+        *(*ui*external_app*keeloqtx*);
+    } > ram_external_app_keeloqtx
+    .external_app_rtty_rx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_rtty_rx.application_information));
+        *(*ui*external_app*rtty_rx*);
+    } > ram_external_app_rtty_rx
+
+    .external_app_rtty_tx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_rtty_tx.application_information));
+        *(*ui*external_app*rtty_tx*);
+    } > ram_external_app_rtty_tx
+
+    .external_app_pocsag_tx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_pocsag_tx.application_information));
+        *(*ui*external_app*pocsag_tx*);
+    } > ram_external_app_pocsag_tx
 }
 

firmware/application/external/flippertx/ui_flippertx.cpp

@@ -80,7 +80,7 @@ bool FlipperTxView::on_file_changed(std::filesystem::path new_file_path) {
         return false;
     }
     preset = submeta.value().preset;
-    if (preset != FLIPPER_PRESET_OOK) {
+    if (preset != FLIPPER_PRESET_OOK && preset != FLIPPER_PRESET_2FSK) {
         field_filename.set_text("File: err, not supp. preset");
         return false;
     }
@@ -108,8 +108,13 @@ void FlipperTxView::stop() {
 bool FlipperTxView::start() {
     if (filename.empty()) return false;
     baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+    transmitter_model.set_sampling_rate(OOK_SAMPLERATE);
     transmitter_model.enable();
     button_startstop.set_text(LanguageHelper::currentMessages[LANG_STOP]);
+    uint8_t mode = 0;
+    if (preset == FLIPPER_PRESET_2FSK)
+        mode = 1;
+    baseband::set_bitstream_config(FM_DEVIATION, mode);
     // start thread
     replay_thread = std::make_unique<FlipperPlayThread>(
         filename,

firmware/application/external/flippertx/ui_flippertx.hpp

@@ -28,6 +28,8 @@ using namespace ui;
 namespace ui::external_app::flippertx {
 
 #define OOK_SAMPLERATE 2280000U
+#define FM_DEVIATION 60000U
+
 class FlipperPlayThread;
 class FlipperTxView : public View {
    public:

firmware/application/external/game2048/ui_game2048.cpp

@@ -33,7 +33,7 @@ Game2048View::Game2048View(NavigationView& nav)
 
 void Game2048View::on_show() {
     if (!initialized) {
-        std::srand(LPC_RTC->CTIME0);
+        srand(LPC_RTC->CTIME0);
         reset_game();
         initialized = true;
     }

firmware/application/external/keeloqtx/main.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2026 lifegame1lu111
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_keeloqtx.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::ui_keeloqtx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<KeeloqTXView>();
+}
+}  // namespace ui::external_app::ui_keeloqtx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_keeloqtx.application_information"), used)) application_information_t _application_information_keeloqtx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::ui_keeloqtx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+    /*.app_name = */ "KeeLoq TX",
+    /*.bitmap_data = */ {
+        0x20,
+        0x00,
+        0x20,
+        0x00,
+        0x20,
+        0x00,
+        0x20,
+        0x00,
+        0xE0,
+        0x07,
+        0xF0,
+        0x0F,
+        0x30,
+        0x0C,
+        0x30,
+        0x0C,
+        0xF0,
+        0x0F,
+        0xF0,
+        0x0F,
+        0x70,
+        0x0D,
+        0xB0,
+        0x0E,
+        0x70,
+        0x0D,
+        0xB0,
+        0x0E,
+        0xF0,
+        0x0F,
+        0xE0,
+        0x07,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+    /*.m4_app_tag = portapack::spi_flash::image_tag_ook */ {'P', 'O', 'O', 'K'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/keeloqtx/ui_keeloqtx.cpp

@@ -0,0 +1,248 @@
+#include "ui_keeloqtx.hpp"
+#include "ui_fileman.hpp"
+#include "baseband_api.hpp"
+#include "../../keeloq_common.hpp"
+#include "../../baseband/fprotos/fprotogeneral.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+namespace fs = std::filesystem;
+
+namespace ui::external_app::ui_keeloqtx {
+
+void KeeloqTXView::focus() {
+    button_open.focus();
+}
+
+void KeeloqTXView::update_hop() {
+    hop = data.btn << 28 | (data.serial & 0x3FF) << 16 | data.counter;
+
+    if (data.mf_name == "Aprimatic") {
+        uint32_t apri_serial = data.serial;
+        uint8_t apr1 = 0;
+
+        for (uint16_t i = 1; i != 0b10000000000; i <<= 1) {
+            if (apri_serial & i) apr1++;
+        }
+
+        apri_serial &= 0b00001111111111;
+
+        if (apr1 % 2 == 0) {
+            apri_serial |= 0b110000000000;
+        }
+
+        hop = data.btn << 28 | (apri_serial & 0xFFF) << 16 | data.counter;
+    } else if (
+        data.mf_name == "DTM_Neo" || data.mf_name == "FAAC_RC,XT" || data.mf_name == "Mutanco_Mutancode" || data.mf_name == "Came_Space" || data.mf_name == "Genius_Bravo" || data.mf_name == "GSN" || data.mf_name == "Rosh" || data.mf_name == "Rossi" || data.mf_name == "Peccinin" || data.mf_name == "Steelmate" || data.mf_name == "Cardin_S449") {
+        hop = data.btn << 28 | (data.serial & 0xFFF) << 16 | data.counter;
+    } else if (
+        data.mf_name == "NICE_Smilo" || data.mf_name == "NICE_MHOUSE" || data.mf_name == "JCM_Tech") {
+        hop = data.btn << 28 | (data.serial & 0xFF) << 16 | data.counter;
+    } else if (data.mf_name == "Merlin") {
+        hop = data.btn << 28 | (0x000) << 16 | data.counter;
+    } else if (data.mf_name == "Centurion") {
+        hop = data.btn << 28 | (0x1CE) << 16 | data.counter;
+    } else if (data.mf_name == "Monarch") {
+        hop = data.btn << 28 | (0x100) << 16 | data.counter;
+    } else if (data.mf_name == "Dea_Mio") {
+        uint8_t first_disc_num = (data.serial >> 8) & 0xF;
+        uint8_t result_disc = (0xC + (first_disc_num % 4));
+
+        uint32_t dea_serial = (data.serial & 0xFF) | (((uint32_t)result_disc) << 8);
+
+        hop = data.btn << 28 | (dea_serial & 0xFFF) << 16 | data.counter;
+    }
+
+    text_hop.set(to_string_hex(hop));
+}
+
+void KeeloqTXView::update_payload() {
+    uint64_t encrypt = 0;
+
+    switch (current_key.type) {
+        case KEELOQ_SIMPLE_LEARNING: {
+            encrypt = keeloq_encrypt(hop, current_key.key);
+
+            break;
+        }
+        case KEELOQ_NORMAL_LEARNING: {
+            uint64_t man = keeloq_normal_learning(fix, current_key.key);
+
+            encrypt = keeloq_encrypt(hop, man);
+
+            break;
+        }
+    }
+
+    payload = (uint64_t)fix << 32 | encrypt;
+
+    uint64_t preview_payload = FProtoGeneral::subghz_protocol_blocks_reverse_key(payload, 64);
+
+    text_payload.set(to_string_hex(preview_payload));
+    encode_data();
+}
+
+void KeeloqTXView::encode_data() {
+    std::string fragments{};
+
+    for (uint32_t i = 0; i < 64; ++i) {
+        fragments += keeloq_fragments[bit(payload, i)];
+    }
+
+    encoded_data = KEELOQ_HEADER + fragments + "1001";
+
+    if (data.mf_name == "Sommer") {
+        pause_duration = 28;
+    } else {
+        pause_duration = 39;
+    }
+}
+
+KeeloqTXView::KeeloqTXView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_ook);
+
+    add_children({&labels,
+                  &text_mf_name,
+                  &text_serial,
+                  &text_fix,
+                  &text_hop,
+                  &field_counter,
+                  &field_button,
+                  &field_repeat,
+                  &text_payload,
+                  &button_open,
+                  &text_status,
+                  &progressbar,
+                  &tx_view});
+
+    field_counter.on_change = [this](uint32_t value) {
+        data.counter = (uint16_t)value;
+
+        update_hop();
+        update_payload();
+    };
+
+    field_button.on_change = [this](uint32_t value) {
+        data.btn = (uint8_t)value;
+
+        fix &= 0xFFFFFFF;
+        fix |= data.btn << 28;
+
+        text_fix.set(to_string_hex(fix));
+
+        update_hop();
+        update_payload();
+    };
+
+    field_repeat.on_change = [this](uint32_t value) {
+        repeat = value;
+    };
+
+    field_repeat.set_value(4, true);
+
+    tx_view.on_edit_frequency = [this, &nav]() {
+        auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.target_frequency());
+        new_view->on_changed = [this](rf::Frequency f) {
+            transmitter_model.set_target_frequency(f);
+        };
+    };
+
+    tx_view.on_start = [this]() {
+        start_tx();
+    };
+
+    tx_view.on_stop = [this]() {
+        baseband::kill_ook();
+        stop_tx();
+    };
+
+    button_open.on_select = [this](const Button&) {
+        auto open_view = nav_.push<FileLoadView>(".KEELOQ");
+
+        ensure_directory(keeloq_remotes_dir);
+        open_view->push_dir(keeloq_remotes_dir);
+        open_view->on_changed = [this](fs::path path) {
+            nav_.set_on_pop([this, path]() {
+                if (!read_keeloq_file(path, data)) {
+                    return;
+                }
+
+                file_path = path;
+
+                for (const auto& key : keystore.get_keys()) {
+                    if (key.mf_name == data.mf_name) {
+                        current_key = key;
+
+                        break;
+                    }
+                }
+
+                fix = data.btn << 28 | data.serial;
+
+                update_hop();
+
+                text_mf_name.set(data.mf_name);
+                text_serial.set(to_string_hex(data.serial));
+                text_fix.set(to_string_hex(fix));
+
+                field_counter.set_value(data.counter, false);
+                field_button.set_value(data.btn, false);
+
+                update_payload();
+
+                field_counter.focus();
+            });
+        };
+    };
+}
+
+void KeeloqTXView::start_tx() {
+    size_t bitstream_length = encoders::make_bitstream(encoded_data);
+
+    progressbar.set_max(repeat);
+    tx_view.set_transmitting(true);
+
+    transmitter_model.enable();
+
+    baseband::set_ook_data(
+        bitstream_length,
+        OOK_SAMPLERATE * (400.0 / 1000000.0),
+        repeat,
+        pause_duration);
+}
+
+void KeeloqTXView::stop_tx() {
+    transmitter_model.disable();
+    text_status.set("Ready");
+    progressbar.set_value(0);
+    tx_view.set_transmitting(false);
+
+    data.counter += 1;
+
+    field_counter.set_value(data.counter, false);
+
+    update_hop();
+    update_payload();
+
+    write_keeloq_file(file_path, data);
+}
+
+void KeeloqTXView::on_tx_progress(uint32_t progress, bool done) {
+    if (!done) {
+        text_status.set(to_string_dec_uint(progress + 1) + "/" + to_string_dec_uint(repeat));
+        progressbar.set_value(progress + 1);
+    } else {
+        chThdSleepMilliseconds(10);
+
+        stop_tx();
+    }
+}
+
+KeeloqTXView::~KeeloqTXView() {
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+}  // namespace ui::external_app::ui_keeloqtx

firmware/application/external/keeloqtx/ui_keeloqtx.hpp

@@ -0,0 +1,129 @@
+#ifndef __KEELOQTX__
+#define __KEELOQTX__
+
+#include "ui.hpp"
+#include "ui_transmitter.hpp"
+#include "transmitter_model.hpp"
+#include "file_path.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "encoders.hpp"
+#include "string_format.hpp"
+#include "../../keeloq_file.hpp"
+#include "../../keeloq_keystore.hpp"
+
+#define KEELOQ_HEADER "101010101010101010101010000000000"
+
+namespace ui::external_app::ui_keeloqtx {
+
+class KeeloqTXView : public View {
+   public:
+    KeeloqTXView(NavigationView& nav);
+    ~KeeloqTXView();
+
+    void focus() override;
+
+    std::string title() const override {
+        return "KeeLoqTX";
+    }
+
+   private:
+    const std::string keeloq_fragments[2] = {"110", "100"};
+
+    NavigationView& nav_;
+
+    TxRadioState radio_state_{
+        433920000,
+        1750000,
+        OOK_SAMPLERATE};
+
+    app_settings::SettingsManager settings_{
+        "tx_keeloq", app_settings::Mode::TX};
+
+    std::filesystem::path file_path{};
+
+    KeeloqKeystore keystore{};
+    KeeloqKey current_key{};
+    KeeloqData data{};
+
+    uint32_t fix = 0;
+    uint32_t hop = 0;
+    uint64_t payload = 0;
+
+    void update_hop();
+
+    Labels labels{
+        {{UI_POS_X(1), UI_POS_Y(0)}, "Manufacturer:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(1), UI_POS_Y(1)}, "Serial:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(1), UI_POS_Y(2)}, "Fix:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(1), UI_POS_Y(3)}, "Hop:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(1), UI_POS_Y(4)}, "Counter:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(1), UI_POS_Y(5)}, "Button:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(1), UI_POS_Y(6)}, "Repeat:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(8)}, "Payload:", Theme::getInstance()->fg_light->foreground},
+    };
+
+    Text text_mf_name{{UI_POS_X(15), UI_POS_Y(0), 128, 16}, ""};
+    Text text_serial{{UI_POS_X(9), UI_POS_Y(1), 64, 16}, "00000000"};
+    Text text_fix{{UI_POS_X(6), UI_POS_Y(2), 64, 16}, "00000000"};
+    Text text_hop{{UI_POS_X(6), UI_POS_Y(3), 64, 16}, "00000000"};
+
+    NumberField field_counter{
+        {UI_POS_X(10), UI_POS_Y(4)},
+        5,
+        {0, 65535},
+        1,
+        ' '};
+    NumberField field_button{
+        {UI_POS_X(9), UI_POS_Y(5)},
+        2,
+        {0, 15},
+        1,
+        ' '};
+    NumberField field_repeat{
+        {UI_POS_X(10), UI_POS_Y(6)},
+        3,
+        {0, 100},
+        1,
+        ' '};
+
+    Text text_payload{{UI_POS_X(2), UI_POS_Y(9), 128, 16}, "0000000000000000"};
+
+    void update_payload();
+
+    Button button_open{{UI_POS_X(0), UI_POS_Y(11), screen_width, 32}, "Open file"};
+
+    Text text_status{{UI_POS_X(2), UI_POS_Y_BOTTOM(7), 128, 16}, "Ready"};
+
+    ProgressBar progressbar{
+        {UI_POS_X(2), UI_POS_Y_BOTTOM(7) + 20, UI_POS_WIDTH_REMAINING(4), 16}};
+
+    TransmitterView tx_view{
+        (int16_t)UI_POS_Y_BOTTOM(4),
+        50000,
+        9};
+
+    std::string encoded_data{};
+
+    void encode_data();
+
+    uint32_t repeat = 4;
+    uint32_t pause_duration = 0;
+
+    void start_tx();
+    void stop_tx();
+
+    void update_progress();
+    void on_tx_progress(uint32_t progress, bool done);
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.progress, message.done);
+        }};
+};
+
+}  // namespace ui::external_app::ui_keeloqtx
+
+#endif

firmware/application/external/level/ui_level.cpp

@@ -137,6 +137,7 @@ LevelView::LevelView(NavigationView& nav)
             else
                 v = SPEC_MODULATION;
             field_mode.set_selected_index(v);
+            return;  // Important ! Guru will occur if you don't return when modifying field from within on_change !
         }
         last_mode = v;
         change_mode(v);

firmware/application/external/morse_practice/morsedecoder.hpp

@@ -24,8 +24,7 @@
 
 #include <cstdint>
 #include <string>
-
-#define MORSEDEC_ERROR "<ERR>"
+#include "string_format.hpp"
 
 namespace ui::external_app::morse_practice {
 
@@ -89,21 +88,28 @@ class MorseDecoder {
     };
 
     MorseDecoder() {}
-    DecodeResult handleInput(int32_t duration_ms) {
+
+    DecodeResult
+    handleInput(int32_t duration_ms) {
         DecodeResult result = {"", 0.0};
+
+        if (duration_ms < 5 && duration_ms > -5) return result;
+
         if (duration_ms > 0) {
             pulse_history_.push_back(duration_ms);
             double dah_prob = getDahProbability(duration_ms);
             current_sequence_ += (dah_prob > 0.5) ? '-' : '.';
             last_confidence_ = (dah_prob > 0.5) ? dah_prob : (1.0 - dah_prob);
             last_sequence_ = current_sequence_;
+
         } else {
             uint32_t gap_duration = -duration_ms;
             pulse_gaps_.push_back(gap_duration);
 
             if (gap_duration >= getInterCharThreshold() && !current_sequence_.empty()) {
                 result.text = lookupMorse(current_sequence_);
-                result.confidence = (result.text != MORSEDEC_ERROR) ? last_confidence_ : 0.0;
+
+                result.confidence = (result.text[0] != '{') ? last_confidence_ : 0.0;
                 if (gap_duration >= getInterWordThreshold()) {
                     result.text += " ";
                 }
@@ -116,9 +122,9 @@ class MorseDecoder {
         return result;
     }
 
-    inline double getInterElementThreshold() { return time_unit_ms_ * 2.0; }
-    inline double getInterCharThreshold() { return time_unit_ms_ * 4.0; }
-    inline double getInterWordThreshold() { return time_unit_ms_ * 7.0; }
+    inline double getInterElementThreshold() { return time_unit_ms_ * 0.8; }
+    inline double getInterCharThreshold() { return time_unit_ms_ * 2.5; }
+    inline double getInterWordThreshold() { return time_unit_ms_ * 6.0; }
 
     inline double getCurrentTimeUnit() { return time_unit_ms_; }
     inline std::string getLastSequence() { return last_sequence_; }
@@ -126,7 +132,7 @@ class MorseDecoder {
    private:
     std::string current_sequence_ = "";
     std::string last_sequence_ = "";
-    double time_unit_ms_ = 160.0;
+    double time_unit_ms_ = 119.0;
     double last_confidence_ = 0.0;
     MorseRingBuffer pulse_history_{};
     MorseRingBuffer pulse_gaps_{};
@@ -136,7 +142,7 @@ class MorseDecoder {
             if (seq == morse_table_[i].code)
                 return morse_table_[i].letter;
         }
-        return MORSEDEC_ERROR;  // not found
+        return "{" + seq + "}";  // not found
     }
 
     double getDahProbability(uint32_t duration_ms) {
@@ -298,8 +304,8 @@ class MorseDecoder {
         time_unit_ms_ = (time_unit_ms_ * (1.0 - learning_factor)) + (new_time_unit * learning_factor);
     }
 
-    size_t morse_table_size_ = 41;
-    MorseEntry morse_table_[41] = {
+    size_t morse_table_size_ = 50;
+    MorseEntry morse_table_[50] = {
         {".-", "A"},
         {"-...", "B"},
         {"-.-.", "C"},
@@ -340,7 +346,16 @@ class MorseDecoder {
         {"..--..", "?"},
         {"-.-.--", "!"},
         {"--..--", ","},
-        {"-...-", "="}};
+        {"-...-", "="},
+        {"-..-.", "/"},
+        {".--.-.", "@"},
+        {"---...", ":"},
+        {"-....-", "-"},
+        {".----.", "'"},
+        {".-..-.", "\""},
+        {"-.--.", "("},
+        {"-.--.-", ")"},
+        {".-.-.", "+"}};
 };
 
 }  // namespace ui::external_app::morse_practice

firmware/application/external/morse_practice/ui_morse_practice.cpp

@@ -12,6 +12,13 @@ MorsePracticeView::MorsePracticeView(ui::NavigationView& nav)
                   &btn_clear,
                   &console_text,
                   &field_volume});
+
+    initial_switch_config_ = get_switches_repeat_config();
+
+    SwitchesState config = initial_switch_config_;
+    config[toUType(Switch::Sel)] = false;
+    set_switches_repeat_config(config);
+
     audio::set_rate(audio::Rate::Hz_24000);
 
     btn_tt.on_select = [this](Button&) {
@@ -43,6 +50,7 @@ MorsePracticeView::MorsePracticeView(ui::NavigationView& nav)
 }
 
 MorsePracticeView::~MorsePracticeView() {
+    set_switches_repeat_config(initial_switch_config_);
     receiver_model.disable();
     baseband::shutdown();
     audio::output::stop();
@@ -98,7 +106,7 @@ void MorsePracticeView::writeCharToConsole(const std::string& ch, double confide
 
     if (ch == " ") {
         color_id = 0;
-    } else if (ch == MORSEDEC_ERROR) {
+    } else if (ch[0] == '{') {  // no match
         color_id = 0;
     } else {
         if (confidence < 0.8)

firmware/application/external/morse_practice/ui_morse_practice.hpp

@@ -47,7 +47,7 @@ class MorsePracticeView : public ui::View {
     MorsePracticeView(ui::NavigationView& nav);
     ~MorsePracticeView();
 
-    std::string title() { return "Morse P"; }
+    std::string title() const override { return "Morse Practice"; }
     void focus() override;
     void on_show() override;
 
@@ -68,7 +68,7 @@ class MorsePracticeView : public ui::View {
     ui::Text txt_last{{UI_POS_X(0), UI_POS_Y(6), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)}, ""};
     ui::Button btn_clear{{UI_POS_X(0), UI_POS_Y_BOTTOM(2), UI_POS_WIDTH(6), UI_POS_HEIGHT(1)}, "CLR"};
     ui::Console console_text{{UI_POS_X(0), UI_POS_Y(7), UI_POS_MAXWIDTH, UI_POS_HEIGHT_REMAINING(10)}};
-    AudioVolumeField field_volume{{UI_POS_X_RIGHT(2), UI_POS_X(0)}};
+    AudioVolumeField field_volume{{UI_POS_X_RIGHT(2), UI_POS_Y(0)}};
 
     uint8_t last_color_id = 255;
     uint8_t color_id = 255;
@@ -77,6 +77,7 @@ class MorsePracticeView : public ui::View {
     bool button_touch = false;
     bool button_was_selected = false;
     bool decode_timeout_calc = false;
+    SwitchesState initial_switch_config_{};
 
     MessageHandlerRegistration message_handler_framesync{
         Message::ID::DisplayFrameSync,

firmware/application/external/morse_radio/main.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2026 Pezsma
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_morse_radio.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::morse_radio {
+
+void initialize_app(NavigationView& nav) {
+    nav.push<MorseRadioView>();
+}
+
+}  // namespace ui::external_app::morse_radio
+
+extern "C" {
+
+__attribute__((section(".external_app.app_morse_radio.application_information"), used))
+application_information_t _application_information_morse_radio = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::morse_radio::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Morse",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0xFE,
+        0x7F,
+        0xFF,
+        0xFF,
+        0xBB,
+        0xD0,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x0B,
+        0xE1,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xEB,
+        0xD0,
+        0xFF,
+        0xFF,
+        0xFE,
+        0x7F,
+        0x70,
+        0x00,
+        0x30,
+        0x00,
+        0x10,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_morse_radio */ {'P', 'M', 'R', 'S'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/morse_radio/morsedecoder.hpp

@@ -0,0 +1,378 @@
+#ifndef __MORSEDECODER_HPP__
+#define __MORSEDECODER_HPP__
+
+/*
+ * Copyright (C) 2025 Pezsma
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <cstdint>
+#include <string>
+#include "string_format.hpp"
+
+namespace ui::external_app::morse_radio {
+
+class MorseRingBuffer {
+   public:
+    MorseRingBuffer()
+        : head_(0), tail_(0), count_(0) {}
+
+    void push_back(const uint32_t& value) {
+        data_[head_] = value;
+        head_ = (head_ + 1) % 40;
+        if (count_ < 40) {
+            count_++;
+        } else {
+            // overwrite oldest element
+            tail_ = (tail_ + 1) % 40;
+        }
+    }
+
+    void pop_front() {
+        if (count_ > 0) {
+            tail_ = (tail_ + 1) % 40;
+            count_--;
+        }
+    }
+
+    size_t size() const { return count_; }
+    bool empty() const { return count_ == 0; }
+    const uint32_t& front() const { return data_[tail_]; }
+    // Access by index (0 = oldest)
+    uint32_t operator[](size_t idx) const {
+        return data_[(tail_ + idx) % 40];
+    }
+    // Convert to vector-like access for sorting etc.
+    void copy_to_array(uint32_t* out) const {
+        for (size_t i = 0; i < count_; ++i)
+            out[i] = (*this)[i];
+    }
+
+    void clear() {
+        head_ = 0;
+        tail_ = 0;
+        count_ = 0;
+    }
+
+   private:
+    uint32_t data_[40];
+    size_t head_;
+    size_t tail_;
+    size_t count_;
+};
+
+class MorseDecoder {
+   public:
+    struct DecodeResult {
+        std::string text = "";
+        double confidence = 0.0;
+
+        bool isValid() const {
+            return !text.empty();
+        }
+    };
+
+    struct MorseEntry {
+        std::string code;
+        std::string letter;
+    };
+
+    MorseDecoder() {}
+
+    void resetLearning() {
+        time_unit_ms_ = 119.0;
+        current_sequence_ = "";
+        last_sequence_ = "";
+        last_confidence_ = 0.0;
+        pulse_history_.clear();
+        pulse_gaps_.clear();
+    }
+
+    DecodeResult
+    handleInput(int32_t duration_ms) {
+        DecodeResult result = {"", 0.0};
+
+        if (duration_ms < 5 && duration_ms > -5) return result;
+
+        if (duration_ms > 0) {
+            pulse_history_.push_back(duration_ms);
+            double dah_prob = getDahProbability(duration_ms);
+            current_sequence_ += (dah_prob > 0.5) ? '-' : '.';
+            last_confidence_ = (dah_prob > 0.5) ? dah_prob : (1.0 - dah_prob);
+            last_sequence_ = current_sequence_;
+
+        } else {
+            uint32_t gap_duration = -duration_ms;
+            pulse_gaps_.push_back(gap_duration);
+
+            if (gap_duration >= getInterCharThreshold() && !current_sequence_.empty()) {
+                result.text = lookupMorse(current_sequence_);
+
+                result.confidence = (result.text[0] != '{') ? last_confidence_ : 0.0;
+                if (gap_duration >= getInterWordThreshold()) {
+                    result.text += " ";
+                }
+                current_sequence_ = "";
+            }
+        }
+
+        updateLearning();
+
+        return result;
+    }
+
+    inline double getInterElementThreshold() { return time_unit_ms_ * 0.8; }
+    inline double getInterCharThreshold() { return time_unit_ms_ * 2.5; }
+    inline double getInterWordThreshold() { return time_unit_ms_ * 6.0; }
+
+    inline double getCurrentTimeUnit() { return time_unit_ms_; }
+    inline std::string getLastSequence() { return last_sequence_; }
+
+   private:
+    std::string current_sequence_ = "";
+    std::string last_sequence_ = "";
+    double time_unit_ms_ = 119.0;
+    double last_confidence_ = 0.0;
+    MorseRingBuffer pulse_history_{};
+    MorseRingBuffer pulse_gaps_{};
+
+    std::string lookupMorse(const std::string& seq) {
+        for (size_t i = 0; i < morse_table_size_; i++) {
+            if (seq == morse_table_[i].code)
+                return morse_table_[i].letter;
+        }
+        return "{" + seq + "}";  // not found
+    }
+
+    double getDahProbability(uint32_t duration_ms) {
+        double start_interp = 1.5 * time_unit_ms_;
+        double end_interp = 2.5 * time_unit_ms_;
+
+        if (duration_ms <= start_interp) return 0.0;
+        if (duration_ms >= end_interp) return 1.0;
+        return ((double)(duration_ms)-start_interp) / (end_interp - start_interp);
+    }
+
+    size_t findDecisionBoundary(uint32_t* sorted_data, size_t sorted_data_size) {
+        if (sorted_data_size < 4) return 0;
+
+        size_t best_split_index = 0;
+        uint32_t max_diff = 0;
+
+        for (size_t i = 1; i < sorted_data_size; ++i) {
+            uint32_t diff = sorted_data[i] - sorted_data[i - 1];
+            if (diff > sorted_data[i - 1] * 0.5 && diff > max_diff) {
+                max_diff = diff;
+                best_split_index = i;
+            }
+        }
+        return best_split_index;
+    }
+
+    bool calculatePulseUnit(double& unit, double& confidence) {
+        if (pulse_history_.size() < 10) return false;
+        uint32_t sorted_pulses[pulse_history_.size()];
+        pulse_history_.copy_to_array(sorted_pulses);
+        sort_uint32(sorted_pulses, pulse_history_.size());
+
+        size_t split_index = findDecisionBoundary(sorted_pulses, pulse_history_.size());
+        if (split_index == 0 || split_index < 3 || (pulse_history_.size() - split_index) < 2) {
+            return false;
+        }
+        double dit_sum = sum_uint32_range(sorted_pulses, 0, split_index);
+        double dah_sum = sum_uint32_range(sorted_pulses, split_index, pulse_history_.size());
+
+        double avg_dit = dit_sum / split_index;
+        double avg_dah = dah_sum / (pulse_history_.size() - split_index);
+        if (avg_dah <= avg_dit) return false;
+
+        double ratio = avg_dah / avg_dit;
+        if (ratio > 1.5 && ratio < 5.0) {
+            unit = avg_dit;
+            double tmpabs = ratio - 3.0;
+            if (tmpabs < 0) tmpabs *= -1;
+            tmpabs /= 3.0;
+            tmpabs = 1.0 - tmpabs;
+            if (tmpabs < 0) tmpabs = 0;
+            confidence = tmpabs;  // 0..1
+            return true;
+        }
+
+        return false;
+    }
+
+    bool calculateGapUnit(double& unit, double& confidence) {
+        if (pulse_gaps_.size() < 10) return false;
+        double threshold = getInterElementThreshold();
+        double valid_gaps[pulse_gaps_.size()];
+        size_t valid_count = 0;
+        for (size_t i = 0; i < pulse_gaps_.size(); i++) {
+            double gap = pulse_gaps_[i];
+            if (gap <= threshold) {
+                valid_gaps[valid_count++] = gap;
+            }
+        }
+        if (valid_count < 2) {
+            return false;
+        }
+        double sum = sum_double_range(valid_gaps, 0, valid_count);
+        size_t count_to_average = valid_count;
+
+        if (count_to_average > 0) {
+            unit = sum / count_to_average;
+            confidence = 0.8;
+            return true;
+        }
+
+        return false;
+    }
+
+    double sum_uint32_range(const uint32_t* data, size_t start, size_t end) {
+        double sum = 0.0;
+        for (size_t i = start; i < end; i++) {
+            sum += data[i];
+        }
+        return sum;
+    }
+    double sum_double_range(const double* data, size_t start, size_t end) {
+        double sum = 0.0;
+        for (size_t i = start; i < end; i++) {
+            sum += data[i];
+        }
+        return sum;
+    }
+
+    void sort_uint32(uint32_t* data, size_t size) {
+        if (size < 2)
+            return;
+
+        for (size_t i = 1; i < size; i++) {
+            uint32_t key = data[i];
+            size_t j = i;
+
+            while (j > 0 && data[j - 1] > key) {
+                data[j] = data[j - 1];
+                j--;
+            }
+
+            data[j] = key;
+        }
+    }
+
+    double clamp_double(double value, double min_val, double max_val) {
+        if (value < min_val)
+            return min_val;
+        else if (value > max_val)
+            return max_val;
+        else
+            return value;
+    }
+
+    void updateLearning() {
+        double pulse_unit = -1.0, pulse_confidence = 0.0;
+        double gap_unit = -1.0, gap_confidence = 0.0;
+
+        bool pulse_success = calculatePulseUnit(pulse_unit, pulse_confidence);
+        bool gap_success = calculateGapUnit(gap_unit, gap_confidence);
+
+        double new_time_unit = -1.0;
+        if (pulse_success && pulse_confidence > 0.5) {
+            new_time_unit = pulse_unit;
+        } else if (pulse_success && gap_success) {
+            gap_confidence = 0.2;
+            double total_confidence = pulse_confidence + gap_confidence;
+            new_time_unit = (pulse_unit * pulse_confidence + gap_unit * gap_confidence) / total_confidence;
+        } else if (gap_success) {
+            new_time_unit = gap_unit;
+        } else {
+            return;
+        }
+
+        double max_change = time_unit_ms_ * 0.25;
+        new_time_unit = clamp_double(new_time_unit, time_unit_ms_ - max_change, time_unit_ms_ + max_change);
+        double DEFAULT_TIME_UNIT = 160.0;
+        double BASE_LEARNING_RATE = 0.05;
+        double MAX_LEARNING_RATE = 0.25;
+        double tudeltaabs = new_time_unit - DEFAULT_TIME_UNIT;
+        if (tudeltaabs < 0) tudeltaabs *= -1;
+        double deviation_from_default = tudeltaabs / DEFAULT_TIME_UNIT;
+        double tpp = deviation_from_default * 2.0;
+        if (tpp > 1) tpp = 1;
+        double learning_factor = BASE_LEARNING_RATE + (MAX_LEARNING_RATE - BASE_LEARNING_RATE) * tpp;
+
+        time_unit_ms_ = (time_unit_ms_ * (1.0 - learning_factor)) + (new_time_unit * learning_factor);
+    }
+
+    size_t morse_table_size_ = 50;
+    MorseEntry morse_table_[50] = {
+        {".-", "A"},
+        {"-...", "B"},
+        {"-.-.", "C"},
+        {"-..", "D"},
+        {".", "E"},
+        {"..-.", "F"},
+        {"--.", "G"},
+        {"....", "H"},
+        {"..", "I"},
+        {".---", "J"},
+        {"-.-", "K"},
+        {".-..", "L"},
+        {"--", "M"},
+        {"-.", "N"},
+        {"---", "O"},
+        {".--.", "P"},
+        {"--.-", "Q"},
+        {".-.", "R"},
+        {"...", "S"},
+        {"-", "T"},
+        {"..-", "U"},
+        {"...-", "V"},
+        {".--", "W"},
+        {"-..-", "X"},
+        {"-.--", "Y"},
+        {"--..", "Z"},
+        {".----", "1"},
+        {"..---", "2"},
+        {"...--", "3"},
+        {"....-", "4"},
+        {".....", "5"},
+        {"-....", "6"},
+        {"--...", "7"},
+        {"---..", "8"},
+        {"----.", "9"},
+        {"-----", "0"},
+        {".-.-.-", "."},
+        {"..--..", "?"},
+        {"-.-.--", "!"},
+        {"--..--", ","},
+        {"-...-", "="},
+        {"-..-.", "/"},
+        {".--.-.", "@"},
+        {"---...", ":"},
+        {"-....-", "-"},
+        {".----.", "'"},
+        {".-..-.", "\""},
+        {"-.--.", "("},
+        {"-.--.-", ")"},
+        {".-.-.", "+"}};
+};
+
+}  // namespace ui::external_app::morse_radio
+
+#endif  // __MORSEDECODER_HPP__

firmware/application/external/morse_radio/ui_morse_radio.cpp

@@ -0,0 +1,282 @@
+#include "ui_morse_radio.hpp"
+#include "portapack_persistent_memory.hpp"
+
+using namespace portapack;
+
+namespace ui::external_app::morse_radio {
+
+MorseRadioView::MorseRadioView(ui::NavigationView& nav)
+    : nav_(nav) {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+    add_children({&rssi,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_volume,
+                  &field_frequency,
+                  &txt_last,
+                  &txt_speed,
+                  &txt_freq,
+                  &txt_clip,
+                  &options_mode,
+                  &btn_clear,
+                  &console_text,
+                  &labels,
+                  &chk_log,
+                  &field_squelch});
+    field_frequency.set_step(100);
+
+    btn_clear.on_select = [this](Button&) {
+        console_text.clear(true);
+        txt_last.set("");
+        time_stamp = false;
+        if (logger && save_log)
+            logger->init_daily_log(logs_dir);
+    };
+
+    field_squelch.on_change = [this](int32_t v) {
+        receiver_model.set_squelch_level(v);
+    };
+
+    options_mode.on_change = [this](size_t, int32_t mode) {
+        audio::output::stop();
+        receiver_model.disable();
+        morse_decoder_.resetLearning();
+        if (mode == MORSE_NFM) {
+            receiver_model.set_am_configuration(4);
+            receiver_model.set_modulation(ReceiverModel::Mode::NarrowbandFMAudio);
+            field_squelch.set_style(Theme::getInstance()->option_active);
+            field_squelch.set_focusable(true);
+            field_squelch.set_value(receiver_model.squelch_level());
+            audio::set_rate(audio::Rate::Hz_24000);
+        } else {
+            audio::set_rate(audio::Rate::Hz_12000);
+            receiver_model.set_modulation(ReceiverModel::Mode::AMAudio);
+            if (mode == MORSE_AM_CW || mode == MORSE_AM_DSB)
+                receiver_model.set_am_configuration(7);
+            else if (mode == MORSE_AM_USB)
+                receiver_model.set_am_configuration(9);
+            else  // LSB
+                receiver_model.set_am_configuration(10);
+            field_squelch.set_style(Theme::getInstance()->fg_dark);
+            field_squelch.set_focusable(false);
+        }
+        baseband::set_moreserx_config(mode);
+        saved_mode = mode;
+
+        audio::output::start();
+        receiver_model.set_headphone_volume(receiver_model.headphone_volume());  // WM8731 hack.
+
+        receiver_model.set_sampling_rate(3072000);
+        receiver_model.set_baseband_bandwidth(1750000);
+        receiver_model.enable();
+    };
+    options_mode.set_selected_index(saved_mode);
+
+    logger = std::make_unique<MorseLogger>();
+    chk_log.on_select = [this](Checkbox&, bool save) {
+        save_log = save;
+        if (logger && save_log)
+            logger->init_daily_log(logs_dir);
+    };
+}
+
+void MorseLogger::init_daily_log(const std::filesystem::path& log_dir) {
+    auto now = rtc_time::now();
+    std::string pattern = "morse_";
+    uint16_t y = now.year();
+    pattern += (char)('0' + (y / 1000) % 10);
+    pattern += (char)('0' + (y / 100) % 10);
+    pattern += (char)('0' + (y / 10) % 10);
+    pattern += (char)('0' + (y % 10));
+
+    uint8_t m = now.month();
+    pattern += (char)('0' + (m / 10) % 10);
+    pattern += (char)('0' + (m % 10));
+
+    uint8_t d = now.day();
+    pattern += (char)('0' + (d / 10) % 10);
+    pattern += (char)('0' + (d % 10));
+
+    pattern += "_???.TXT";
+
+    auto full_pattern_path = log_dir / pattern;
+    auto final_path = next_filename_matching_pattern(full_pattern_path);
+    if (!final_path.empty()) {
+        this->append(final_path);
+    }
+}
+
+void MorseLogger::radio_set_log(const std::string& morse_mode) {
+    int64_t freq = receiver_model.target_frequency();
+    std::string header = "Freq:" + to_string_rounded_freq(freq, 4);
+    header += "MHz, ";
+    header += "RX MODE:" + morse_mode;
+    header += "\r\nMessage:";
+    log_file.write_raw(header);
+}
+
+bool MorseLogger::on_packet(const std::string& content, bool time, const std::string& morse_mode) {
+    if (!time) {
+        log_file.write_raw_no_newline("\r\n\r\n");
+        auto timestamp = to_string_datetime(rtc_time::now(), YMDHMS);
+        log_file.write_raw("[" + timestamp + "] ");
+        radio_set_log(morse_mode);
+        char_count = 0;
+        time = true;
+    }
+
+    if (content.empty()) return time;
+    std::string s;
+    for (char c : content) {
+        s = c;
+        if ((char_count >= 35 && c == ' ') || (char_count >= 47)) {
+            log_file.write_raw_no_newline("\r\n");
+
+            if (c != ' ') {
+                log_file.write_raw_no_newline(s);
+                char_count = 1;
+            } else {
+                char_count = 0;
+            }
+        } else {
+            log_file.write_raw_no_newline(s);
+            char_count++;
+        }
+    }
+
+    return time;
+}
+
+MorseRadioView::~MorseRadioView() {
+    receiver_model.disable();
+    baseband::shutdown();
+    audio::output::stop();
+}
+
+void MorseRadioView::focus() {
+    field_frequency.focus();
+    txt_clip.set_style(Theme::getInstance()->fg_red);
+    txt_clip.hidden(true);
+}
+
+void MorseRadioView::check_for_timeout() {
+    uint64_t now = chTimeNow();
+    if (last_activity_time == 0) {
+        last_activity_time = now;
+        return;
+    }
+    uint64_t quiet_duration = now - last_activity_time;
+    if (quiet_duration >= 60000) {
+        morse_decoder_.resetLearning();
+        time_stamp = false;
+        last_activity_time = now;
+    }
+}
+
+int32_t MorseRadioView::ProcessSignal(int32_t sig_time_us) {
+    int8_t sign = (sig_time_us > 0) ? 1 : ((sig_time_us < 0) ? -1 : 0);
+    int32_t result = 0;
+
+    if (last_sign_ == 0) {
+        last_sign_ = sign;
+        accumulator_us_ = sig_time_us;
+        long_pause_sent_ = false;
+        return 0;
+    }
+    if (sign == last_sign_) {
+        accumulator_us_ += sig_time_us;
+
+        if (sign < 0) {
+            int32_t threshold_us = morse_decoder_.getInterWordThreshold() * 1000;
+            if (!long_pause_sent_ && accumulator_us_ <= -threshold_us) {
+                result = accumulator_us_ / 1000;
+                long_pause_sent_ = true;
+            }
+        }
+    } else {
+        // state change
+        if (!long_pause_sent_) {
+            result = accumulator_us_ / 1000;
+        } else {
+            result = 0;
+        }
+        accumulator_us_ = sig_time_us;
+        last_sign_ = sign;
+        long_pause_sent_ = false;
+    }
+    return result;
+}
+
+void MorseRadioView::on_data(const MorseRXDataMessage* message) {
+    int32_t r;
+
+    txt_clip.hidden(!message->clipped);
+
+    for (uint8_t i = 0; i <= message->state_cnt; ++i) {
+        r = ProcessSignal(message->state_durations[i]);
+        auto result = morse_decoder_.handleInput((r != 0) ? r : 0);
+        if (result.isValid()) {
+            last_activity_time = chTimeNow();  // start reset timer on valid input
+            writeCharToConsole(result.text, result.confidence);
+            if (logger && save_log) {
+                time_stamp = logger->on_packet(result.text, time_stamp, options_mode.selected_index_name());
+            }
+            float dah_time = morse_decoder_.getCurrentTimeUnit() * 3.0f;
+            if (dah_time > 0) {
+                uint16_t wpm = (uint16_t)(3600.0f / (dah_time + 18.0f) + 0.5f);
+                txt_speed.set(to_string_dec_uint(wpm));
+            }
+        }
+    }
+}
+
+void MorseRadioView::on_freq(const MorseRXfreqMessage* message) {
+    std::string ret = " ";
+    uint32_t freq = message->measured_frequency;
+    if (freq < 301) {
+        ret = "<";
+        freq = 300;
+    }
+    if (freq > 2299) {
+        freq = 2300;
+        ret = ">";
+    }
+    if (freq < 400 || freq > 1400)
+        txt_freq.set_style(Theme::getInstance()->fg_red);
+    else if (freq <= 580 || freq >= 1220)
+        txt_freq.set_style(Theme::getInstance()->fg_yellow);
+    else
+        txt_freq.set_style(Theme::getInstance()->fg_green);
+    ret += to_string_dec_uint(freq);
+    txt_freq.set(ret);
+}
+
+void MorseRadioView::writeCharToConsole(const std::string& ch, double confidence) {
+    if (ch.empty()) {
+        return;
+    }
+
+    txt_last.set(morse_decoder_.getLastSequence().c_str());
+
+    last_color_id = color_id;
+    std::string color = "";
+
+    if (ch == " ") {
+        color_id = 0;
+    } else if (ch[0] == '{') {  // no match
+        color_id = 0;
+    } else {
+        if (confidence < 0.8)
+            color_id = 1;
+        else if (confidence < 0.9)
+            color_id = 2;
+        else
+            color_id = 3;
+    }
+    color = arr_color[color_id];
+    last_color_id = color_id;
+    console_text.write(color + ch);
+}
+
+}  // namespace ui::external_app::morse_radio

firmware/application/external/morse_radio/ui_morse_radio.hpp

@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2026 Pezsma
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __MORSE_RADIO_H__
+#define __MORSE_RADIO_H__
+
+#include "ui.hpp"
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "string_format.hpp"
+#include "external_app.hpp"
+#include "ui_freq_field.hpp"
+#include "radio_state.hpp"
+#include "portapack.hpp"
+#include "message.hpp"
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "receiver_model.hpp"
+#include "tone_key.hpp"
+#include "log_file.hpp"
+#include "file_path.hpp"
+#include "file.hpp"
+#include "rtc_time.hpp"
+#include "morsedecoder.hpp"
+
+#include <cstdint>
+
+namespace ui::external_app::morse_radio {
+
+class MorseRadioView;
+
+class MorseLogger {
+   public:
+    Optional<File::Error> append(const std::filesystem::path& filename) {
+        return log_file.append(filename);
+    }
+
+    void init_daily_log(const std::filesystem::path& log_dir);
+    bool on_packet(const std::string& content, bool time, const std::string& morse_mode);
+    void radio_set_log(const std::string& morse_mode);
+
+   private:
+    LogFile log_file{};
+    uint8_t char_count{0};  // log file line break
+};
+
+class MorseRadioView : public ui::View {
+   public:
+    MorseRadioView(ui::NavigationView& nav);
+    ~MorseRadioView();
+    std::string title() const override {
+        return "Morse";
+    }
+    void focus() override;
+
+   private:
+    void writeCharToConsole(const std::string& ch, double confidence);
+    void on_data(const MorseRXDataMessage* message);
+    void on_freq(const MorseRXfreqMessage* message);
+    void on_message(const Message* const p);
+    void check_for_timeout();
+    int32_t ProcessSignal(int32_t sig_time_us);
+    ui::NavigationView& nav_;
+    MorseDecoder morse_decoder_{};
+    RxRadioState radio_state_{};
+    std::unique_ptr<MorseLogger> logger{};
+
+    enum morse_modes : uint8_t {
+        MORSE_AM_CW = 0,
+        MORSE_NFM,
+        MORSE_AM_DSB,
+        MORSE_AM_USB,
+        MORSE_AM_LSB,
+    };
+    uint8_t saved_mode = MORSE_AM_CW;
+
+    app_settings::SettingsManager settings_{
+        "rx_morse_radio",
+        app_settings::Mode::RX,
+        {
+            {"cwmode"sv, &saved_mode},
+        }};
+
+    RxFrequencyField field_frequency{
+        {UI_POS_X(0), UI_POS_Y(0)},
+        nav_};
+    RFAmpField field_rf_amp{
+        {UI_POS_X(13), UI_POS_Y(0)}};
+    LNAGainField field_lna{
+        {UI_POS_X(15), UI_POS_Y(0)}};
+    VGAGainField field_vga{
+        {UI_POS_X(18), UI_POS_Y(0)}};
+    RSSI rssi{
+        {UI_POS_X(21), UI_POS_Y(0), UI_POS_WIDTH_REMAINING(24), 4}};
+
+    AudioVolumeField field_volume{
+        {UI_POS_X_RIGHT(2), UI_POS_Y(0)}};
+
+    NumberField field_squelch{
+        {UI_POS_X(10), UI_POS_Y(1)},
+        2,
+        {0, 99},
+        1,
+        ' ',
+    };
+    ui::Text txt_speed{{UI_POS_X(23), UI_POS_Y(1), UI_POS_WIDTH(3), UI_POS_HEIGHT(1)}, "??"};
+    ui::Text txt_last{{UI_POS_X(12), UI_POS_Y(4), UI_POS_WIDTH_REMAINING(12), UI_POS_HEIGHT(1)}, ""};
+    ui::Text txt_freq{{UI_POS_X(21), UI_POS_Y(2), UI_POS_WIDTH(5), UI_POS_HEIGHT(1)}, "??"};
+    ui::Text txt_clip{{UI_POS_X(15), UI_POS_Y(3), UI_POS_WIDTH(5), UI_POS_HEIGHT(1)}, "clipping"};
+    ui::Console console_text{{UI_POS_X(0), UI_POS_Y(5), UI_POS_MAXWIDTH, UI_POS_HEIGHT_REMAINING(7)}};
+    ui::Labels labels{
+        {{UI_POS_X(0), UI_POS_Y(1)}, "Squelch:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(15), UI_POS_Y(1)}, "Speed:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(26), UI_POS_Y(1)}, "wpm", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(4)}, "Last seq.:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(15), UI_POS_Y(2)}, "Tone:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(27), UI_POS_Y(2)}, "Hz", Theme::getInstance()->fg_light->foreground}};
+
+    ui::OptionsField options_mode{
+        {UI_POS_X(8), UI_POS_Y(2) + 4},  // +4 to align with 'Log' checkbox text
+        6,
+        {
+            {"AM/CW", MORSE_AM_CW},
+            {"NFM", MORSE_NFM},
+            {"AM/DSB", MORSE_AM_DSB},
+            {"AM/USB", MORSE_AM_USB},
+            {"AM/LSB", MORSE_AM_LSB},
+        }};
+
+    Checkbox chk_log{{UI_POS_X(0), UI_POS_Y(2)}, 12, "Log", false};
+    ui::Button btn_clear{{UI_POS_X(0), UI_POS_Y_BOTTOM(2), UI_POS_WIDTH(6), UI_POS_HEIGHT(1)}, "CLR"};
+
+    std::string arr_color[4] = {STR_COLOR_WHITE, STR_COLOR_RED, STR_COLOR_YELLOW, STR_COLOR_GREEN};
+
+    bool long_pause_sent_{false};
+    bool save_log{false};
+    bool reset_triggered_{false};
+    bool time_stamp{false};
+    uint8_t last_color_id{255};
+    uint8_t color_id{255};
+    int8_t last_sign_{0};
+    uint8_t space_timer{0};
+    int32_t accumulator_us_{0};
+    uint64_t last_activity_time{0};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::MorseRXData,
+        [this](Message* const p) {
+            const auto message = static_cast<const MorseRXDataMessage*>(p);
+            this->on_data(message);
+        }};
+
+    MessageHandlerRegistration message_handler_freq{
+        Message::ID::MorseRXfreq,
+        [this](Message* const p) {
+            const auto message = static_cast<const MorseRXfreqMessage*>(p);
+            this->on_freq(message);
+        }};
+
+    MessageHandlerRegistration message_handler_framesync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const p) {
+            (void)p;
+            this->check_for_timeout();
+        }};
+};
+
+}  // namespace ui::external_app::morse_radio
+
+#endif  // __MORSE_RADIO_H__

firmware/application/external/morseradiotx/main.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2026 Pezsma
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_morse_radiotx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::morseradiotx {
+
+void initialize_app(NavigationView& nav) {
+    nav.push<MorseRadiotxView>();
+}
+
+}  // namespace ui::external_app::morseradiotx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_morseradiotx.application_information"), used))
+application_information_t _application_information_morseradiotx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::morseradiotx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Morse TX",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0xFE,
+        0x7F,
+        0xFF,
+        0xFF,
+        0xBB,
+        0xD0,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x0B,
+        0xE1,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xEB,
+        0xD0,
+        0xFF,
+        0xFF,
+        0xFE,
+        0x7F,
+        0x70,
+        0x00,
+        0x30,
+        0x00,
+        0x10,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_none */ {'P', 'M', 'R', 'T'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+
+}  // extern "C"

firmware/application/external/morseradiotx/morsedecoder.hpp

@@ -0,0 +1,389 @@
+#ifndef __MORSEDECODER_HPP__
+#define __MORSEDECODER_HPP__
+
+/*
+ * Copyright (C) 2025 Pezsma
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <cstdint>
+#include <string>
+#include "string_format.hpp"
+
+namespace ui::external_app::morseradiotx {
+
+class MorseRingBuffer {
+   public:
+    MorseRingBuffer()
+        : head_(0), tail_(0), count_(0) {}
+
+    void push_back(const uint32_t& value) {
+        data_[head_] = value;
+        head_ = (head_ + 1) % 40;
+        if (count_ < 40) {
+            count_++;
+        } else {
+            // overwrite oldest element
+            tail_ = (tail_ + 1) % 40;
+        }
+    }
+
+    void pop_front() {
+        if (count_ > 0) {
+            tail_ = (tail_ + 1) % 40;
+            count_--;
+        }
+    }
+
+    size_t size() const { return count_; }
+    bool empty() const { return count_ == 0; }
+    const uint32_t& front() const { return data_[tail_]; }
+    // Access by index (0 = oldest)
+    uint32_t operator[](size_t idx) const {
+        return data_[(tail_ + idx) % 40];
+    }
+    // Convert to vector-like access for sorting etc.
+    void copy_to_array(uint32_t* out) const {
+        for (size_t i = 0; i < count_; ++i)
+            out[i] = (*this)[i];
+    }
+
+    void clear() {
+        head_ = 0;
+        tail_ = 0;
+        count_ = 0;
+    }
+
+   private:
+    uint32_t data_[40];
+    size_t head_;
+    size_t tail_;
+    size_t count_;
+};
+
+class MorseDecoder {
+   public:
+    struct DecodeResult {
+        std::string text = "";
+        double confidence = 0.0;
+
+        bool isValid() const {
+            return !text.empty();
+        }
+    };
+
+    struct MorseEntry {
+        std::string code;
+        std::string letter;
+    };
+
+    MorseDecoder() {}
+
+    void resetLearning() {
+        time_unit_ms_ = 119.0;
+        current_sequence_ = "";
+        last_sequence_ = "";
+        last_confidence_ = 0.0;
+        pulse_history_.clear();
+        pulse_gaps_.clear();
+    }
+
+    const char* get_morse_pattern(char c) {
+        char upper_c = (c >= 'a' && c <= 'z') ? c - 32 : c;
+
+        for (size_t i = 0; i < morse_table_size_; ++i) {
+            if (morse_table_[i].letter[0] == upper_c) {
+                return morse_table_[i].code.c_str();
+            }
+        }
+        return nullptr;
+    }
+
+    DecodeResult
+    handleInput(int32_t duration_ms) {
+        DecodeResult result = {"", 0.0};
+
+        if (duration_ms < 5 && duration_ms > -5) return result;
+
+        if (duration_ms > 0) {
+            pulse_history_.push_back(duration_ms);
+            double dah_prob = getDahProbability(duration_ms);
+            current_sequence_ += (dah_prob > 0.5) ? '-' : '.';
+            last_confidence_ = (dah_prob > 0.5) ? dah_prob : (1.0 - dah_prob);
+            last_sequence_ = current_sequence_;
+
+        } else {
+            uint32_t gap_duration = -duration_ms;
+            pulse_gaps_.push_back(gap_duration);
+
+            if (gap_duration >= getInterCharThreshold() && !current_sequence_.empty()) {
+                result.text = lookupMorse(current_sequence_);
+
+                result.confidence = (result.text[0] != '{') ? last_confidence_ : 0.0;
+                if (gap_duration >= getInterWordThreshold()) {
+                    result.text += " ";
+                }
+                current_sequence_ = "";
+            }
+        }
+
+        updateLearning();
+
+        return result;
+    }
+
+    inline double getInterElementThreshold() { return time_unit_ms_ * 0.8; }
+    inline double getInterCharThreshold() { return time_unit_ms_ * 2.5; }
+    inline double getInterWordThreshold() { return time_unit_ms_ * 6.0; }
+
+    inline double getCurrentTimeUnit() { return time_unit_ms_; }
+    inline std::string getLastSequence() { return last_sequence_; }
+
+   private:
+    std::string current_sequence_ = "";
+    std::string last_sequence_ = "";
+    double time_unit_ms_ = 119.0;
+    double last_confidence_ = 0.0;
+    MorseRingBuffer pulse_history_{};
+    MorseRingBuffer pulse_gaps_{};
+
+    std::string lookupMorse(const std::string& seq) {
+        for (size_t i = 0; i < morse_table_size_; i++) {
+            if (seq == morse_table_[i].code)
+                return morse_table_[i].letter;
+        }
+        return "{" + seq + "}";  // not found
+    }
+
+    double getDahProbability(uint32_t duration_ms) {
+        double start_interp = 1.5 * time_unit_ms_;
+        double end_interp = 2.5 * time_unit_ms_;
+
+        if (duration_ms <= start_interp) return 0.0;
+        if (duration_ms >= end_interp) return 1.0;
+        return ((double)(duration_ms)-start_interp) / (end_interp - start_interp);
+    }
+
+    size_t findDecisionBoundary(uint32_t* sorted_data, size_t sorted_data_size) {
+        if (sorted_data_size < 4) return 0;
+
+        size_t best_split_index = 0;
+        uint32_t max_diff = 0;
+
+        for (size_t i = 1; i < sorted_data_size; ++i) {
+            uint32_t diff = sorted_data[i] - sorted_data[i - 1];
+            if (diff > sorted_data[i - 1] * 0.5 && diff > max_diff) {
+                max_diff = diff;
+                best_split_index = i;
+            }
+        }
+        return best_split_index;
+    }
+
+    bool calculatePulseUnit(double& unit, double& confidence) {
+        if (pulse_history_.size() < 10) return false;
+        uint32_t sorted_pulses[pulse_history_.size()];
+        pulse_history_.copy_to_array(sorted_pulses);
+        sort_uint32(sorted_pulses, pulse_history_.size());
+
+        size_t split_index = findDecisionBoundary(sorted_pulses, pulse_history_.size());
+        if (split_index == 0 || split_index < 3 || (pulse_history_.size() - split_index) < 2) {
+            return false;
+        }
+        double dit_sum = sum_uint32_range(sorted_pulses, 0, split_index);
+        double dah_sum = sum_uint32_range(sorted_pulses, split_index, pulse_history_.size());
+
+        double avg_dit = dit_sum / split_index;
+        double avg_dah = dah_sum / (pulse_history_.size() - split_index);
+        if (avg_dah <= avg_dit) return false;
+
+        double ratio = avg_dah / avg_dit;
+        if (ratio > 1.5 && ratio < 5.0) {
+            unit = avg_dit;
+            double tmpabs = ratio - 3.0;
+            if (tmpabs < 0) tmpabs *= -1;
+            tmpabs /= 3.0;
+            tmpabs = 1.0 - tmpabs;
+            if (tmpabs < 0) tmpabs = 0;
+            confidence = tmpabs;  // 0..1
+            return true;
+        }
+
+        return false;
+    }
+
+    bool calculateGapUnit(double& unit, double& confidence) {
+        if (pulse_gaps_.size() < 10) return false;
+        double threshold = getInterElementThreshold();
+        double valid_gaps[pulse_gaps_.size()];
+        size_t valid_count = 0;
+        for (size_t i = 0; i < pulse_gaps_.size(); i++) {
+            double gap = pulse_gaps_[i];
+            if (gap <= threshold) {
+                valid_gaps[valid_count++] = gap;
+            }
+        }
+        if (valid_count < 2) {
+            return false;
+        }
+        double sum = sum_double_range(valid_gaps, 0, valid_count);
+        size_t count_to_average = valid_count;
+
+        if (count_to_average > 0) {
+            unit = sum / count_to_average;
+            confidence = 0.8;
+            return true;
+        }
+
+        return false;
+    }
+
+    double sum_uint32_range(const uint32_t* data, size_t start, size_t end) {
+        double sum = 0.0;
+        for (size_t i = start; i < end; i++) {
+            sum += data[i];
+        }
+        return sum;
+    }
+    double sum_double_range(const double* data, size_t start, size_t end) {
+        double sum = 0.0;
+        for (size_t i = start; i < end; i++) {
+            sum += data[i];
+        }
+        return sum;
+    }
+
+    void sort_uint32(uint32_t* data, size_t size) {
+        if (size < 2)
+            return;
+
+        for (size_t i = 1; i < size; i++) {
+            uint32_t key = data[i];
+            size_t j = i;
+
+            while (j > 0 && data[j - 1] > key) {
+                data[j] = data[j - 1];
+                j--;
+            }
+
+            data[j] = key;
+        }
+    }
+
+    double clamp_double(double value, double min_val, double max_val) {
+        if (value < min_val)
+            return min_val;
+        else if (value > max_val)
+            return max_val;
+        else
+            return value;
+    }
+
+    void updateLearning() {
+        double pulse_unit = -1.0, pulse_confidence = 0.0;
+        double gap_unit = -1.0, gap_confidence = 0.0;
+
+        bool pulse_success = calculatePulseUnit(pulse_unit, pulse_confidence);
+        bool gap_success = calculateGapUnit(gap_unit, gap_confidence);
+
+        double new_time_unit = -1.0;
+        if (pulse_success && pulse_confidence > 0.5) {
+            new_time_unit = pulse_unit;
+        } else if (pulse_success && gap_success) {
+            gap_confidence = 0.2;
+            double total_confidence = pulse_confidence + gap_confidence;
+            new_time_unit = (pulse_unit * pulse_confidence + gap_unit * gap_confidence) / total_confidence;
+        } else if (gap_success) {
+            new_time_unit = gap_unit;
+        } else {
+            return;
+        }
+
+        double max_change = time_unit_ms_ * 0.25;
+        new_time_unit = clamp_double(new_time_unit, time_unit_ms_ - max_change, time_unit_ms_ + max_change);
+        double DEFAULT_TIME_UNIT = 160.0;
+        double BASE_LEARNING_RATE = 0.05;
+        double MAX_LEARNING_RATE = 0.25;
+        double tudeltaabs = new_time_unit - DEFAULT_TIME_UNIT;
+        if (tudeltaabs < 0) tudeltaabs *= -1;
+        double deviation_from_default = tudeltaabs / DEFAULT_TIME_UNIT;
+        double tpp = deviation_from_default * 2.0;
+        if (tpp > 1) tpp = 1;
+        double learning_factor = BASE_LEARNING_RATE + (MAX_LEARNING_RATE - BASE_LEARNING_RATE) * tpp;
+
+        time_unit_ms_ = (time_unit_ms_ * (1.0 - learning_factor)) + (new_time_unit * learning_factor);
+    }
+
+    size_t morse_table_size_ = 50;
+    MorseEntry morse_table_[50] = {
+        {".-", "A"},
+        {"-...", "B"},
+        {"-.-.", "C"},
+        {"-..", "D"},
+        {".", "E"},
+        {"..-.", "F"},
+        {"--.", "G"},
+        {"....", "H"},
+        {"..", "I"},
+        {".---", "J"},
+        {"-.-", "K"},
+        {".-..", "L"},
+        {"--", "M"},
+        {"-.", "N"},
+        {"---", "O"},
+        {".--.", "P"},
+        {"--.-", "Q"},
+        {".-.", "R"},
+        {"...", "S"},
+        {"-", "T"},
+        {"..-", "U"},
+        {"...-", "V"},
+        {".--", "W"},
+        {"-..-", "X"},
+        {"-.--", "Y"},
+        {"--..", "Z"},
+        {".----", "1"},
+        {"..---", "2"},
+        {"...--", "3"},
+        {"....-", "4"},
+        {".....", "5"},
+        {"-....", "6"},
+        {"--...", "7"},
+        {"---..", "8"},
+        {"----.", "9"},
+        {"-----", "0"},
+        {".-.-.-", "."},
+        {"..--..", "?"},
+        {"-.-.--", "!"},
+        {"--..--", ","},
+        {"-...-", "="},
+        {"-..-.", "/"},
+        {".--.-.", "@"},
+        {"---...", ":"},
+        {"-....-", "-"},
+        {".----.", "'"},
+        {".-..-.", "\""},
+        {"-.--.", "("},
+        {"-.--.-", ")"},
+        {".-.-.", "+"}};
+};
+
+}  // namespace ui::external_app::morseradiotx
+
+#endif  // __MORSEDECODER_HPP__

firmware/application/external/morseradiotx/ui_morse_radiotx.cpp

@@ -0,0 +1,437 @@
+#include "ui_morse_radiotx.hpp"
+
+using namespace portapack;
+
+namespace ui::external_app::morseradiotx {
+
+static msg_t tx_thread_fn(void* arg) {
+    auto view = reinterpret_cast<MorseRadiotxView*>(arg);
+    chRegSetThreadName("morse_tx_thread");
+    view->transmit_morse_message();
+    return 0;
+}
+
+MorseRadiotxView::MorseRadiotxView(ui::NavigationView& nav)
+    : current_timings(calculate_morse_timings(20)),
+      nav_(nav) {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+    add_children({&tx_view,
+                  &field_volume,
+                  &labels,
+                  &options_mode,
+                  &tone_,
+                  &wpm_,
+                  &txt_msg,
+                  &btn_message,
+                  &btn_calls,
+                  &chk_trans,
+                  &bandwidth,
+                  &chk_callsgn,
+                  &txt_last,
+                  &console_text,
+                  &btn_clear,
+                  &btn_ptt});
+
+    initial_switch_config_ = get_switches_repeat_config();
+
+    SwitchesState config = initial_switch_config_;
+    config[toUType(Switch::Sel)] = false;
+    set_switches_repeat_config(config);
+
+    audio::set_rate(audio::Rate::Hz_24000);
+
+    btn_clear.on_select = [this](Button&) {
+        console_text.clear(true);
+        txt_last.set("");
+    };
+
+    options_mode.on_change = [this](size_t, int32_t value) {
+        current_mode = (uint8_t)value;
+        baseband::set_morsetx_config(current_mode, tone, band);
+        ui_toggle();
+    };
+
+    tone_.on_change = [this](int32_t v) {
+        tone = static_cast<uint32_t>(v);
+        baseband::set_morsetx_config(current_mode, tone, band);
+    };
+
+    wpm_.on_change = [this](int16_t v) {
+        wpm = v;
+        current_timings = calculate_morse_timings(wpm);
+    };
+
+    bandwidth.on_change = [this](float v) {
+        band = v;
+        baseband::set_morsetx_config(current_mode, tone, band);
+    };
+
+    options_mode.set_selected_index(current_mode, true);
+    tone_.set_value(tone, true);
+    wpm_.set_value(wpm, true);
+    bandwidth.set_value(band, true);
+
+    btn_ptt.on_select = [this](Button&) {
+        if (button_touch) {
+            button_touch = false;
+            return;
+        }
+        button_was_selected = true;
+        onPress();
+    };
+
+    btn_ptt.on_touch_press = [this](Button&) {
+        button_touch = true;
+        button_was_selected = false;
+        onPress();
+    };
+    btn_ptt.on_touch_release = [this](Button&) {
+        if (chk_trans.value() && transmit) {
+            button_touch = true;
+            button_was_selected = false;
+            onRelease();
+        }
+    };
+
+    btn_message.on_select = [this, &nav](Button&) {
+        if (!transmit)
+            text_prompt(nav, msg_buffer, 27, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& buffer) {
+                msg_buffer = buffer;
+                txt_msg.set("[" + msg_buffer + "] ");
+            });
+    };
+
+    btn_calls.on_select = [this, &nav](Button&) {
+        if (!transmit) {
+            text_prompt(nav, call_sign, 10, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& buffer) {
+                call_sign = buffer;
+                if (call_sign.empty())
+                    btn_calls.set_text("call sign?");
+                else
+                    btn_calls.set_text(call_sign);
+            });
+        }
+    };
+
+    audio::output::start();
+    auto vol = field_volume.value();
+    field_volume.set_value(0);
+    field_volume.set_value(vol);
+
+    tx_view.on_start = [this]() {
+        if (!chk_trans.value() && msg_buffer.empty()) {
+            tx_view.set_transmitting(false);
+            return;
+        }
+        tx_view.focus();
+        if (!tx_thread && !thread_running) {
+            thread_running = true;
+            tx_thread = chThdCreateFromHeap(NULL, 1024, NORMALPRIO + 5, tx_thread_fn, this);
+            tx_view.set_transmitting(true);
+        }
+
+        else
+            tx_view.set_transmitting(false);
+    };
+
+    tx_view.on_stop = [this]() {
+        baseband::set_morsetx_key(false);
+        transmitter_model.disable();
+
+        if (tx_thread) {
+            chThdTerminate(tx_thread);
+            chThdWait(tx_thread);
+        }
+        transmit = false;
+        transmit_time = 0;
+        tx_thread = nullptr;
+        thread_running = false;
+        tx_view.set_transmitting(false);
+        ui_toggle();
+    };
+
+    tx_view.on_edit_frequency = [this, &nav]() {
+        auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.target_frequency());
+        new_view->on_changed = [this](rf::Frequency f) {
+            transmitter_model.set_target_frequency(f);
+        };
+    };
+}
+
+MorseRadiotxView::~MorseRadiotxView() {
+    set_switches_repeat_config(initial_switch_config_);
+    if (tx_thread) {
+        chThdTerminate(tx_thread);
+        chThdWait(tx_thread);
+        if (!thread_running) tx_thread = nullptr;
+    }
+
+    transmitter_model.disable();
+    baseband::shutdown();
+    audio::output::stop();
+}
+
+void MorseRadiotxView::on_show() {
+    ptt_button_visibility(true);
+    start_time = 0;
+    end_time = 0;
+    transmit_time = 0;
+}
+
+void MorseRadiotxView::focus() {
+    options_mode.focus();
+}
+
+MorseRadiotxView::MorseTimings MorseRadiotxView::calculate_morse_timings(uint32_t wpm) {
+    MorseRadiotxView::MorseTimings t;
+    if (wpm < 10) wpm = 10;
+    if (wpm > 45) wpm = 45;
+    t.dot_ms = 1200 / wpm;
+
+    t.dash_ms = 3 * t.dot_ms;
+    t.symbol_gap = t.dot_ms;
+    t.char_gap = 3 * t.dot_ms;
+    t.word_gap = 7 * t.dot_ms;
+    return t;
+}
+
+void MorseRadiotxView::transmit_morse_message() {
+    std::string full_message = "";
+    // cal sign
+    if (chk_callsgn.value() && !call_sign.empty()) {
+        full_message = call_sign;
+        if (!chk_trans.value() && !msg_buffer.empty()) {
+            full_message += " " + msg_buffer;
+        }
+    } else {
+        if (!chk_trans.value()) full_message = msg_buffer;
+    }
+
+    if (full_message.empty() && !chk_trans.value()) {
+        ptt_button_visibility(false);
+        return;
+    }
+
+    // enable transmit
+    if (!transmit) {
+        transmit = true;
+        transmitter_model.enable();
+        ui_toggle();
+    }
+
+    for (size_t i = 0; i < full_message.length(); i++) {
+        if (chThdShouldTerminate()) break;
+
+        char c = full_message[i];
+
+        std::string s_char(1, c);
+        // space
+        if (c == ' ') {
+            console_text.write(" ");
+            chThdSleepMilliseconds(current_timings.word_gap);
+            continue;
+        }
+
+        const char* pattern = morse_decoder_.get_morse_pattern(c);
+
+        if (pattern != nullptr) {
+            txt_last.set(pattern);
+
+            // write blue char to console
+            console_text.write(STR_COLOR_BLUE + s_char);
+
+            // Morze (dih/dah) send
+            for (int j = 0; pattern[j] != '\0'; j++) {
+                baseband::set_morsetx_key(true);
+                if (pattern[j] == '.') {
+                    chThdSleepMilliseconds(current_timings.dot_ms);
+                } else if (pattern[j] == '-') {
+                    chThdSleepMilliseconds(current_timings.dash_ms);
+                }
+                if (chThdShouldTerminate()) break;
+                // pause between signs
+                baseband::set_morsetx_key(false);
+                chThdSleepMilliseconds(current_timings.symbol_gap);
+            }
+            if (chThdShouldTerminate()) break;
+            if (current_timings.char_gap > current_timings.symbol_gap) {
+                chThdSleepMilliseconds(current_timings.char_gap - current_timings.symbol_gap);
+            }
+        }
+    }
+
+    if (chk_trans.value()) ptt_button_visibility(false);
+    baseband::set_morsetx_key(false);
+    transmit_time = chTimeNow();
+    decode_timeout_calc = false;
+    thread_running = false;
+}
+
+void MorseRadiotxView::onPress() {
+    start_time = chTimeNow();
+    if (!transmit) {
+        transmit = true;
+        transmitter_model.enable();
+    }
+    baseband::set_morsetx_key(true);
+    if (end_time != 0) {
+        int64_t gap_delta = (chTimeNow() - end_time);
+        auto result = morse_decoder_.handleInput(-gap_delta);
+        if (result.isValid()) {
+            writeCharToConsole(result.text, result.confidence);
+        }
+    }
+    end_time = 0;
+    transmit_time = 0;
+    decode_timeout_calc = false;
+}
+
+void MorseRadiotxView::onRelease() {
+    end_time = chTimeNow();
+    transmit_time = end_time;
+    baseband::set_morsetx_key(false);
+    if (start_time != 0) {
+        int32_t press_delta = (end_time - start_time);
+        auto result = morse_decoder_.handleInput(press_delta);
+        if (result.isValid()) {
+            writeCharToConsole(result.text, result.confidence);
+        }
+    }
+    start_time = 0;
+    decode_timeout_calc = true;
+    baseband::request_beep_stop();
+}
+
+void MorseRadiotxView::writeCharToConsole(const std::string& ch, double confidence) {
+    if (ch.empty()) {
+        return;
+    }
+
+    txt_last.set(morse_decoder_.getLastSequence().c_str());
+
+    last_color_id = color_id;
+    std::string color = "";
+
+    if (ch == " ") {
+        color_id = 0;
+    } else if (ch[0] == '{') {  // no match
+        color_id = 0;
+    } else {
+        if (confidence == 1.5)
+            color_id = 4;
+        else if (confidence < 0.8)
+            color_id = 1;
+        else if (confidence < 0.9)
+            color_id = 2;
+        else
+            color_id = 3;
+    }
+    color = arr_color[color_id];
+    last_color_id = color_id;
+    console_text.write(color + ch);
+}
+
+void MorseRadiotxView::ptt_button_visibility(bool hidden) {
+    bool hiddenorig = btn_ptt.hidden();
+    if (hiddenorig != hidden) {
+        btn_ptt.hidden(hidden);
+        if (!hidden) btn_ptt.focus();
+        if (hidden) {
+            // hack fix until widget hidig problem is not solved.
+            auto r = btn_ptt.screen_rect();
+            Painter p;
+            p.fill_rectangle_unrolled8(r, Theme::getInstance()->fg_light->background);
+        }
+    }
+}
+
+void MorseRadiotxView::ui_toggle() {
+    // 0=AM, 1=FM, 2=DSB, 3=USB, 4=LSB
+
+    if (transmit) {
+        options_mode.set_style(Theme::getInstance()->fg_dark);
+        options_mode.set_focusable(false);
+        tone_.set_style(Theme::getInstance()->fg_dark);
+        tone_.set_focusable(false);
+        wpm_.set_style(Theme::getInstance()->fg_dark);
+        wpm_.set_focusable(false);
+        btn_message.set_style(Theme::getInstance()->fg_dark);
+        btn_calls.set_style(Theme::getInstance()->fg_dark);
+        chk_trans.set_style(Theme::getInstance()->fg_dark);
+        chk_trans.set_focusable(false);
+        bandwidth.set_style(Theme::getInstance()->fg_dark);
+        bandwidth.set_focusable(false);
+        chk_callsgn.set_style(Theme::getInstance()->fg_dark);
+        chk_callsgn.set_focusable(false);
+
+    } else {
+        options_mode.set_style(Theme::getInstance()->bg_darker);
+        options_mode.set_focusable(true);
+        wpm_.set_style(Theme::getInstance()->bg_darker);
+        wpm_.set_focusable(true);
+        btn_message.set_style(Theme::getInstance()->bg_darker);
+        btn_calls.set_style(Theme::getInstance()->bg_darker);
+        chk_trans.set_style(Theme::getInstance()->bg_darker);
+        chk_trans.set_focusable(true);
+        chk_callsgn.set_style(Theme::getInstance()->bg_darker);
+        chk_callsgn.set_focusable(true);
+        ptt_button_visibility(true);
+        tone_.set_style(Theme::getInstance()->bg_darker);
+        tone_.set_focusable(true);
+
+        if (current_mode == 1) {  // FM mode
+            bandwidth.set_style(Theme::getInstance()->bg_darker);
+            bandwidth.set_focusable(true);
+        } else {
+            bandwidth.set_style(Theme::getInstance()->fg_dark);
+            bandwidth.set_focusable(false);
+        }
+    }  // transmit false
+}
+
+inline bool MorseRadiotxView::tx_button_held() {
+    const auto switches_state = get_switches_state();
+    return switches_state[(size_t)ui::KeyEvent::Select];
+}
+
+void MorseRadiotxView::on_framesync() {
+    if (button_was_selected && !button_touch && !tx_button_held()) {
+        button_was_selected = false;
+        onRelease();
+    }
+
+    if (end_time != 0 && decode_timeout_calc) {
+        int64_t gap_delta = (chTimeNow() - end_time);
+
+        if (gap_delta >= morse_decoder_.getInterCharThreshold()) {
+            auto result = morse_decoder_.handleInput(-(int32_t)gap_delta);
+            if (result.isValid()) {
+                writeCharToConsole(result.text, result.confidence);
+            }
+        }
+        if (gap_delta >= morse_decoder_.getInterWordThreshold()) {
+            writeCharToConsole(" ", 1.0);
+            end_time = 0;
+            decode_timeout_calc = false;
+        }
+    }
+    if (transmit_time != 0 && transmit) {  // Tx disable if time is up
+        int64_t gap_delta = (chTimeNow() - transmit_time);
+        if (gap_delta >= ((morse_decoder_.getInterWordThreshold() * ((chk_trans.value()) ? 10 : 1)))) {
+            if (tx_thread) {
+                chThdTerminate(tx_thread);
+                chThdWait(tx_thread);
+            }
+            transmit = false;
+            tx_view.set_transmitting(false);
+            transmitter_model.disable();
+            thread_running = false;
+            tx_thread = nullptr;
+            transmit_time = 0;
+            if (!chk_trans.value()) writeCharToConsole(" ", 1.0);
+            ui_toggle();
+        }
+    }
+}
+
+}  // namespace ui::external_app::morseradiotx

firmware/application/external/morseradiotx/ui_morse_radiotx.hpp

@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2026 Pezsma
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __MORSE_RADIOTX_H__
+#define __MORSE_RADIOTX_H__
+
+#include "ui.hpp"
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_language.hpp"
+#include "ui_painter.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_textentry.hpp"
+#include "string_format.hpp"
+#include "morsedecoder.hpp"
+#include "irq_controls.hpp"
+#include "radio_state.hpp"
+#include "portapack.hpp"
+#include "message.hpp"
+#include "volume.hpp"
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "external_app.hpp"
+#include "string_format.hpp"
+#include <ch.h>
+#include <hal.h>
+
+namespace ui::external_app::morseradiotx {
+
+class MorseRadiotxView : public ui::View {
+   public:
+    MorseRadiotxView(ui::NavigationView& nav);
+    ~MorseRadiotxView();
+
+    MorseRadiotxView(const MorseRadiotxView&) = delete;
+    MorseRadiotxView(MorseRadiotxView&&) = delete;
+    MorseRadiotxView& operator=(const MorseRadiotxView&) = delete;
+    MorseRadiotxView& operator=(MorseRadiotxView&&) = delete;
+
+    std::string title() const override { return "Morse Tx"; }
+    void focus() override;
+    void on_show() override;
+    void transmit_morse_message();
+
+   private:
+    struct MorseTimings {
+        uint32_t dot_ms;
+        uint32_t dash_ms;
+        uint32_t symbol_gap;
+        uint32_t char_gap;
+        uint32_t word_gap;
+    };
+
+    MorseTimings current_timings{};
+
+    std::string msg_indicator{""};
+    MorseTimings calculate_morse_timings(uint32_t wpm);
+    void onPress();
+    void onRelease();
+    void on_framesync();
+    void writeCharToConsole(const std::string& ch, double confidence);
+    void ui_toggle();
+    bool tx_button_held();
+    void ptt_button_visibility(bool hidden);
+
+    ui::NavigationView& nav_;
+    MorseDecoder morse_decoder_{};
+    TxRadioState radio_state_{};
+    Thread* tx_thread{nullptr};
+
+    std::string msg_buffer{"PORTAPACK"};
+    uint8_t current_mode{0};  // 0=AM, 1=FM, 2=DSB, 3=USB, 4=LSB
+    uint8_t wpm{20};
+    uint32_t tone{700};
+    float band{5.8};
+    std::string call_sign{""};
+
+    app_settings::SettingsManager settings_{
+        "tx_morseradio",
+        app_settings::Mode::TX,
+        {
+            {"cmode"sv, &current_mode},
+            {"audtone"sv, &tone},
+            {"wpm"sv, &wpm},
+            {"message"sv, &msg_buffer},
+            {"bandwith"sv, &band},
+            {"call_sign"sv, &call_sign},
+        }};
+
+    TransmitterView tx_view{
+        (int16_t)UI_POS_Y_BOTTOM(4),
+        10000,
+        0, false};
+
+    AudioVolumeField field_volume{{UI_POS_X_RIGHT(2), UI_POS_Y_BOTTOM(5)}};
+    ui::OptionsField options_mode{
+        {UI_POS_X(5), UI_POS_Y(0)},
+        3,
+        {{"AM", 0}, {"FM", 1}, {"DSB", 2}, {"USB", 3}, {"LSB", 4}}};
+    NumberField tone_{{UI_POS_X(14), UI_POS_Y(0)}, 4, {400, 1400}, 10, ' ', true};
+    NumberField wpm_{{UI_POS_X(25), UI_POS_Y(0)}, 2, {10, 45}, 1, ' ', true};
+    FloatField bandwidth{{UI_POS_X(20), UI_POS_Y(3)}, 4, {1.0, 16.0}, 0.1, ' ', true, 1};
+
+    ui::Text txt_msg{{UI_POS_X(0), UI_POS_Y(1), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)}, "[" + msg_buffer + "] "};
+    ui::Button btn_message{{UI_POS_X(0), UI_POS_Y(2), UI_POS_WIDTH(11), UI_POS_HEIGHT(1)}, "Message"};
+    ui::Button btn_calls{{UI_POS_X(0), UI_POS_Y(4), UI_POS_WIDTH(11), UI_POS_HEIGHT(1)}, (call_sign.empty()) ? "call sign?" : call_sign};
+    Checkbox chk_trans{{UI_POS_X(14), UI_POS_Y(2)}, 13, "Manual trans.", true};
+    Checkbox chk_callsgn{{UI_POS_X(14), UI_POS_Y(4)}, 13, "Call sign", true};
+    ui::Text txt_last{{UI_POS_X(10), UI_POS_Y(5), UI_POS_WIDTH_REMAINING(10), UI_POS_HEIGHT(1)}, ""};
+    ui::Console console_text{{UI_POS_X(0), UI_POS_Y(7), UI_POS_MAXWIDTH, UI_POS_HEIGHT_REMAINING(14)}};
+    ui::Button btn_clear{{UI_POS_X(0), UI_POS_Y_BOTTOM(5), UI_POS_WIDTH(5), UI_POS_HEIGHT(1)}, "CLR"};
+    ui::Button btn_ptt{{UI_POS_X_CENTER(12), UI_POS_Y_BOTTOM(7), UI_POS_WIDTH(12), UI_POS_HEIGHT(3)}, "PTT"};
+
+    ui::Labels labels{
+        {{UI_POS_X(0), UI_POS_Y(0)}, "Mode:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(9), UI_POS_Y(0)}, "Tone:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(18), UI_POS_Y(0)}, "Hz", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(21), UI_POS_Y(0)}, "WPM:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(14), UI_POS_Y(3)}, "BandW:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(24), UI_POS_Y(3)}, "kHz", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(5)}, "Last seq:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(6)}, "Sent Message:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_RIGHT(7), UI_POS_Y_BOTTOM(5)}, "Vol.:", Theme::getInstance()->fg_light->foreground},
+    };
+
+    uint8_t last_color_id{255};
+    uint8_t color_id{255};
+    std::string arr_color[4] = {STR_COLOR_WHITE, STR_COLOR_RED, STR_COLOR_YELLOW, STR_COLOR_GREEN};
+
+    bool button_touch{false};
+    bool button_was_selected{false};
+    bool decode_timeout_calc{false};
+    bool transmit{false};
+    bool thread_running = false;
+
+    uint8_t send_indicator{5};
+    int64_t start_time{0};
+    int64_t end_time{0};
+    int64_t transmit_time{0};
+    SwitchesState initial_switch_config_{};
+
+    MessageHandlerRegistration message_handler_framesync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const p) {
+            (void)p;
+            this->on_framesync();
+        }};
+};
+
+}  // namespace ui::external_app::morseradiotx
+
+#endif  // __MORSE_RADIOTX_H__

firmware/application/external/pocsag_tx/main.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_pocsag_tx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::pocsag_tx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<POCSAGTXView>();
+}
+}  // namespace ui::external_app::pocsag_tx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_pocsag_tx.application_information"), used)) application_information_t _application_information_pocsag_tx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::pocsag_tx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "POCSG TX",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xFC,
+        0x3F,
+        0xFE,
+        0x7F,
+        0x02,
+        0x40,
+        0xBA,
+        0x45,
+        0x02,
+        0x40,
+        0xFE,
+        0x7F,
+        0xFE,
+        0x7F,
+        0x92,
+        0x7C,
+        0x92,
+        0x7C,
+        0xFC,
+        0x3F,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_fsktx */ {'P', 'F', 'S', 'K'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/pocsag_tx/ui_pocsag_tx.cpp

@@ -31,7 +31,7 @@
 using namespace portapack;
 using namespace pocsag;
 
-namespace ui {
+namespace ui::external_app::pocsag_tx {
 
 #define MAX_POCSAG_LENGTH 80
 
@@ -159,7 +159,7 @@ void POCSAGTXView::on_set_text(NavigationView& nav) {
 POCSAGTXView::POCSAGTXView(
     NavigationView& nav)
     : nav_(nav) {
-    baseband::run_image(portapack::spi_flash::image_tag_fsktx);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
 
     add_children({&labels,
                   &options_bitrate,
@@ -205,4 +205,4 @@ POCSAGTXView::POCSAGTXView(
     };
 }
 
-} /* namespace ui */
+} /* namespace ui::external_app::pocsag_tx */

firmware/application/external/pocsag_tx/ui_pocsag_tx.hpp

@@ -37,7 +37,7 @@
 
 using namespace pocsag;
 
-namespace ui {
+namespace ui::external_app::pocsag_tx {
 
 class POCSAGTXView : public View {
    public:
@@ -155,6 +155,6 @@ class POCSAGTXView : public View {
         }};
 };
 
-} /* namespace ui */
+} /* namespace ui::external_app::pocsag_tx */
 
 #endif /*__POCSAG_TX_H__*/

firmware/application/external/random_password/ui_random_password.cpp

@@ -239,10 +239,10 @@ void RandomPasswordView::on_freqchg(int64_t freq) {
 }
 
 void RandomPasswordView::set_random_freq() {
-    std::srand(LPC_RTC->CTIME0);
+    srand(LPC_RTC->CTIME0);
     // this is only for seed to visit random freq, the radio is still real random
 
-    auto random_freq = 100000000 + (std::rand() % 900000000);  // 100mhz to 1ghz
+    auto random_freq = 100000000 + (rand() % 900000000);  // 100mhz to 1ghz
     receiver_model.set_target_frequency(random_freq);
     field_frequency.set_value(random_freq);
 }
@@ -297,12 +297,12 @@ void RandomPasswordView::new_password() {
     /// roll worker
     for (int i = 0; i < password_length * 2; i += 2) {
         unsigned int seed = seeds_deque[i];
-        std::srand(seed);
+        srand(seed);
         uint8_t rollnum = (uint8_t)(seeds_deque[i + 1] % 128);
         uint8_t nu = 0;
-        for (uint8_t o = 0; o < rollnum; ++o) nu = std::rand();
+        for (uint8_t o = 0; o < rollnum; ++o) nu = rand();
         nu++;
-        char c = charset[std::rand() % charset.length()];
+        char c = charset[rand() % charset.length()];
         initial_password += c;
     }
 

firmware/application/external/rtty_rx/baudot.cpp

@@ -0,0 +1,104 @@
+#include "baudot.hpp"
+#include <cctype>
+
+namespace ui::external_app::rtty_rx {
+
+constexpr uint8_t CODE_FIGS = 0x1B;
+constexpr uint8_t CODE_LTRS = 0x1F;
+constexpr uint8_t CODE_SPACE = 0x04;
+
+char BaudotCoder::get_char_mapping(bool is_figures, uint8_t index) const {
+    if (index >= 32) return 0;  // Safety check
+
+    if (is_figures) {
+        // ITA2 FIGURES Table
+        const char figures[32] = {
+            0, '3', '\n', '-', ' ', '\'', '8', '7',
+            '\r', '$', '4', '\a', ',', '!', ':', '(',
+            '5', '+', ')', '2', '#', '6', '0', '1',
+            '9', '?', '&', 0, '.', '/', '=', 0};
+        return figures[index];
+    } else {
+        // ITA2 LETTERS Table
+        const char letters[32] = {
+            0, 'E', '\n', 'A', ' ', 'S', 'I', 'U',
+            '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K',
+            'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q',
+            'O', 'B', 'G', 0, 'M', 'X', 'V', 0};
+        return letters[index];
+    }
+}
+
+// --- DECODE ---
+char BaudotCoder::decode(uint8_t baudotCode) {
+    uint8_t code = baudotCode & 0x1F;
+    if (code == CODE_FIGS) {
+        shiftState = FIGURES;
+        return 0;
+    }
+    if (code == CODE_LTRS) {
+        shiftState = LETTERS;
+        return 0;
+    }
+    if (usos_enabled && shiftState == FIGURES && code == CODE_SPACE) {
+        shiftState = LETTERS;
+        return ' ';
+    }
+    return get_char_mapping((shiftState == FIGURES), code);
+}
+
+void BaudotCoder::encode(const std::string& src, uint8_t* dest, uint16_t* dest_length, uint16_t dest_max_size) {
+    uint16_t idx = 0;
+
+    for (char c : src) {
+        if (idx >= dest_max_size) break;
+
+        char upper_c = std::toupper(c);
+        uint8_t code = 0;
+        bool found = false;
+        bool target_is_figures = false;
+        if (upper_c == ' ') {
+            code = CODE_SPACE;
+            found = true;
+        } else {
+            for (int i = 1; i < 32; i++) {
+                if (get_char_mapping(false, i) == upper_c) {
+                    code = i;
+                    found = true;
+                    target_is_figures = false;
+                    break;
+                }
+            }
+            if (!found) {
+                for (int i = 1; i < 32; i++) {
+                    if (get_char_mapping(true, i) == upper_c) {
+                        code = i;
+                        found = true;
+                        target_is_figures = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (found) {
+            if (target_is_figures && shiftState != FIGURES) {
+                if (idx + 1 >= dest_max_size) break;
+                dest[idx++] = CODE_FIGS;
+                shiftState = FIGURES;
+            } else if (!target_is_figures && shiftState != LETTERS && code != CODE_SPACE) {
+                if (idx + 1 >= dest_max_size) break;
+                dest[idx++] = CODE_LTRS;
+                shiftState = LETTERS;
+            }
+
+            dest[idx++] = code;
+        }
+    }
+
+    if (dest_length) {
+        *dest_length = idx;
+    }
+}
+
+}  // namespace ui::external_app::rtty_rx

firmware/application/external/rtty_rx/baudot.hpp

@@ -0,0 +1,28 @@
+#ifndef BAUDOT_HPP
+#define BAUDOT_HPP
+
+#include <cstdint>
+#include <string>
+
+namespace ui::external_app::rtty_rx {
+
+class BaudotCoder {
+   public:
+    enum ShiftState { LETTERS,
+                      FIGURES };
+
+    BaudotCoder()
+        : shiftState(LETTERS) {}
+    char decode(uint8_t baudotCode);
+    void encode(const std::string& src, uint8_t* dest, uint16_t* dest_length, uint16_t dest_max_size);
+    void set_usos(bool enable) { usos_enabled = enable; }  // shift == set to letters too
+
+   private:
+    ShiftState shiftState;
+    bool usos_enabled = true;
+    char get_char_mapping(bool is_figures, uint8_t index) const;
+};
+
+}  // namespace ui::external_app::rtty_rx
+
+#endif  // BAUDOT_HPP

firmware/application/external/rtty_rx/main.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2026 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_rtty_rx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::rtty_rx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<RttyRxView>();
+}
+}  // namespace ui::external_app::rtty_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_rtty_rx.application_information"), used)) application_information_t _application_information_rtty_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::rtty_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "RTTY",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0xFE,
+        0x1F,
+        0xFE,
+        0x3F,
+        0x0E,
+        0x78,
+        0x0E,
+        0x70,
+        0x0E,
+        0x70,
+        0x0E,
+        0x70,
+        0x0E,
+        0x78,
+        0xFE,
+        0x3F,
+        0xFE,
+        0x1F,
+        0x8E,
+        0x07,
+        0x0E,
+        0x0F,
+        0x0E,
+        0x1E,
+        0x0E,
+        0x3C,
+        0x0E,
+        0x78,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::orange().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_rttyrx  */ {'P', 'R', 'T', 'R'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/rtty_rx/ui_rtty_rx.cpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2026 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or  modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_rtty_rx.hpp"
+
+#include "audio.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+// todo add timeout, so add newline and time when new data arrives after a time.
+
+namespace ui::external_app::rtty_rx {
+
+void RttyRxView::focus() {
+    field_frequency.focus();
+}
+
+RttyRxView::RttyRxView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+    add_children({
+        &rssi,
+        &field_rf_amp,
+        &field_lna,
+        &field_vga,
+        &field_volume,
+        &field_frequency,
+        &labels,
+        &options_baud,
+        &console,
+    });
+    field_frequency.set_step(100);
+    audio::set_rate(audio::Rate::Hz_24000);
+    audio::output::start();
+
+    receiver_model.set_hidden_offset(0);
+    receiver_model.set_sampling_rate(3072000);       // set the needed baseband SR.
+    receiver_model.set_baseband_bandwidth(1750000);  // set  the front-end RF BW filter.
+    receiver_model.enable();
+    console.enable_scrolling(false);
+
+    options_baud.on_change = [this](size_t, int32_t value) {
+        baseband::set_rtty_config(value, 170);
+        baud_conf = value;
+    };
+    options_baud.set_by_value(baud_conf);
+    if (baud_conf == 0) {  // to trigger it when not changed
+        baseband::set_rtty_config(0, 170);
+    }
+}
+
+void RttyRxView::got_message(std::string msg) {
+    console.write(msg);
+}
+
+RttyRxView::~RttyRxView() {
+    receiver_model.set_hidden_offset(0);
+    receiver_model.disable();
+    baseband::shutdown();
+    audio::output::stop();
+}
+
+void RttyRxView::on_data(const RTTYDataMessage* message) {
+    std::string msg = "";
+    for (size_t i = 0; i < message->data_len; i++) {
+        const auto c = baudot_decoder.decode(message->data[i]);
+        if (c != 0)
+            msg += c;
+    }
+    got_message(msg);
+}
+
+}  // namespace ui::external_app::rtty_rx

firmware/application/external/rtty_rx/ui_rtty_rx.hpp

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2026 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_RTTY_RX_H__
+#define __UI_RTTY_RX_H__
+
+#include "ui.hpp"
+#include "ui_language.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+#include "ui_fileman.hpp"
+#include "file_path.hpp"
+#include "baudot.hpp"
+
+using namespace ui;
+
+namespace ui::external_app::rtty_rx {
+
+class RttyRxView : public View {
+   public:
+    RttyRxView(NavigationView& nav);
+    ~RttyRxView();
+
+    void focus() override;
+
+    std::string title() const override { return "RTTY"; };
+
+   private:
+    NavigationView& nav_;
+    RxRadioState radio_state_{};
+    uint32_t baud_conf = 0;
+    app_settings::SettingsManager settings_{
+        "rx_rtty",
+        app_settings::Mode::RX,
+        {
+            {"baud_conf"sv, &baud_conf},
+        }};
+
+    RxFrequencyField field_frequency{
+        {UI_POS_X(0), UI_POS_Y(0)},
+        nav_};
+    RFAmpField field_rf_amp{
+        {UI_POS_X(13), UI_POS_Y(0)}};
+    LNAGainField field_lna{
+        {UI_POS_X(15), UI_POS_Y(0)}};
+    VGAGainField field_vga{
+        {UI_POS_X(18), UI_POS_Y(0)}};
+    RSSI rssi{
+        {UI_POS_X(21), UI_POS_Y(0), UI_POS_WIDTH_REMAINING(24), 4}};
+    AudioVolumeField field_volume{{UI_POS_X_RIGHT(2), UI_POS_Y(0)}};
+
+    Labels labels{
+        {{UI_POS_X(0), UI_POS_Y(1)}, "Baud:", Theme::getInstance()->fg_light->foreground}};
+
+    OptionsField options_baud{
+        {UI_POS_X(7), UI_POS_Y(1)},
+        5,
+        {{"Auto", 0},
+         {"45", 4500},
+         {"45.45", 4545},
+         {"50", 5000},
+         {"75", 7500},
+         {"100", 10000},
+         {"110", 11000},
+         {"150", 15000},
+         {"200", 20000}}};
+
+    Console console{
+        {UI_POS_X(0), UI_POS_Y(2), UI_POS_MAXWIDTH, UI_POS_HEIGHT_REMAINING(3)}};
+
+    BaudotCoder baudot_decoder{};
+
+    void on_data(const RTTYDataMessage* message);
+    void got_message(std::string msg);
+
+    MessageHandlerRegistration message_handler_data{
+        Message::ID::RTTYData,
+        [this](Message* const p) {
+            const auto message = static_cast<const RTTYDataMessage*>(p);
+            this->on_data(message);
+        }};
+};
+
+}  // namespace ui::external_app::rtty_rx
+
+#endif /*__UI_RTTY_RX_H__*/

firmware/application/external/rtty_tx/baudot.cpp

@@ -0,0 +1,104 @@
+#include "baudot.hpp"
+#include <cctype>
+
+namespace ui::external_app::rtty_tx {
+
+constexpr uint8_t CODE_FIGS = 0x1B;
+constexpr uint8_t CODE_LTRS = 0x1F;
+constexpr uint8_t CODE_SPACE = 0x04;
+
+char BaudotCoder::get_char_mapping(bool is_figures, uint8_t index) const {
+    if (index >= 32) return 0;  // Safety check
+
+    if (is_figures) {
+        // ITA2 FIGURES Table
+        const char figures[32] = {
+            0, '3', '\n', '-', ' ', '\'', '8', '7',
+            '\r', '$', '4', '\a', ',', '!', ':', '(',
+            '5', '+', ')', '2', '#', '6', '0', '1',
+            '9', '?', '&', 0, '.', '/', '=', 0};
+        return figures[index];
+    } else {
+        // ITA2 LETTERS Table
+        const char letters[32] = {
+            0, 'E', '\n', 'A', ' ', 'S', 'I', 'U',
+            '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K',
+            'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q',
+            'O', 'B', 'G', 0, 'M', 'X', 'V', 0};
+        return letters[index];
+    }
+}
+
+// --- DECODE ---
+char BaudotCoder::decode(uint8_t baudotCode) {
+    uint8_t code = baudotCode & 0x1F;
+    if (code == CODE_FIGS) {
+        shiftState = FIGURES;
+        return 0;
+    }
+    if (code == CODE_LTRS) {
+        shiftState = LETTERS;
+        return 0;
+    }
+    if (usos_enabled && shiftState == FIGURES && code == CODE_SPACE) {
+        shiftState = LETTERS;
+        return ' ';
+    }
+    return get_char_mapping((shiftState == FIGURES), code);
+}
+
+void BaudotCoder::encode(const std::string& src, uint8_t* dest, uint16_t* dest_length, uint16_t dest_max_size) {
+    uint16_t idx = 0;
+
+    for (char c : src) {
+        if (idx >= dest_max_size) break;
+
+        char upper_c = std::toupper(c);
+        uint8_t code = 0;
+        bool found = false;
+        bool target_is_figures = false;
+        if (upper_c == ' ') {
+            code = CODE_SPACE;
+            found = true;
+        } else {
+            for (int i = 1; i < 32; i++) {
+                if (get_char_mapping(false, i) == upper_c) {
+                    code = i;
+                    found = true;
+                    target_is_figures = false;
+                    break;
+                }
+            }
+            if (!found) {
+                for (int i = 1; i < 32; i++) {
+                    if (get_char_mapping(true, i) == upper_c) {
+                        code = i;
+                        found = true;
+                        target_is_figures = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (found) {
+            if (target_is_figures && shiftState != FIGURES) {
+                if (idx + 1 >= dest_max_size) break;
+                dest[idx++] = CODE_FIGS;
+                shiftState = FIGURES;
+            } else if (!target_is_figures && shiftState != LETTERS && code != CODE_SPACE) {
+                if (idx + 1 >= dest_max_size) break;
+                dest[idx++] = CODE_LTRS;
+                shiftState = LETTERS;
+            }
+
+            dest[idx++] = code;
+        }
+    }
+
+    if (dest_length) {
+        *dest_length = idx;
+    }
+}
+
+}  // namespace ui::external_app::rtty_tx

firmware/application/external/rtty_tx/baudot.hpp

@@ -0,0 +1,28 @@
+#ifndef BAUDOT_HPP
+#define BAUDOT_HPP
+
+#include <cstdint>
+#include <string>
+
+namespace ui::external_app::rtty_tx {
+
+class BaudotCoder {
+   public:
+    enum ShiftState { LETTERS,
+                      FIGURES };
+
+    BaudotCoder()
+        : shiftState(LETTERS) {}
+    char decode(uint8_t baudotCode);
+    void encode(const std::string& src, uint8_t* dest, uint16_t* dest_length, uint16_t dest_max_size);
+    void set_usos(bool enable) { usos_enabled = enable; }  // shift == set to letters too
+
+   private:
+    ShiftState shiftState;
+    bool usos_enabled = true;
+    char get_char_mapping(bool is_figures, uint8_t index) const;
+};
+
+}  // namespace ui::external_app::rtty_tx
+
+#endif  // BAUDOT_HPP

firmware/application/external/rtty_tx/main.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2026 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_rtty_tx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::rtty_tx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<RttyTxView>();
+}
+}  // namespace ui::external_app::rtty_tx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_rtty_tx.application_information"), used)) application_information_t _application_information_rtty_tx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::rtty_tx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "RTTY",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0xFE,
+        0x1F,
+        0xFE,
+        0x3F,
+        0x0E,
+        0x78,
+        0x0E,
+        0x70,
+        0x0E,
+        0x70,
+        0x0E,
+        0x70,
+        0x0E,
+        0x78,
+        0xFE,
+        0x3F,
+        0xFE,
+        0x1F,
+        0x8E,
+        0x07,
+        0x0E,
+        0x0F,
+        0x0E,
+        0x1E,
+        0x0E,
+        0x3C,
+        0x0E,
+        0x78,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::orange().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_rttytx  */ {'P', 'R', 'T', 'T'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/rtty_tx/ui_rtty_tx.cpp

@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2026 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or  modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_rtty_tx.hpp"
+
+#include "audio.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+namespace ui::external_app::rtty_tx {
+
+void RttyTxView::focus() {
+    options_baud.focus();
+}
+
+RttyTxView::RttyTxView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&tx_view,
+                  &labels,
+                  &options_baud,
+                  &options_shift,
+                  &btn_message,
+                  &text_message,
+                  &check_inverted,
+                  &options_tone,
+                  &text_tones});
+
+    options_baud.on_change = [this](size_t, int32_t value) {
+        baud_conf = value;
+    };
+    options_baud.set_by_value(baud_conf);
+
+    options_shift.on_change = [this](size_t, int32_t value) {
+        shift = value;
+        refresh_tones();
+    };
+    options_shift.set_by_value(shift);
+
+    btn_message.on_select = [this](Button&) {
+        text_prompt(nav_, message, 64, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& new_message) {
+            message = new_message;
+            text_message.set(message);  // maybe replace to console
+        });
+    };
+    text_message.set(message);
+    options_tone.set_by_value(mark_tone);
+    options_tone.on_change = [this](size_t, int32_t value) {
+        mark_tone = value;
+        refresh_tones();
+    };
+    check_inverted.on_select = [this](Checkbox&, bool) {
+        refresh_tones();
+    };
+
+    tx_view.on_edit_frequency = [this, &nav]() {
+        auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.target_frequency());
+        new_view->on_changed = [this](rf::Frequency f) {
+            transmitter_model.set_target_frequency(f);
+        };
+    };
+
+    tx_view.on_start = [this]() {
+        if (message.empty()) {
+            nav_.display_modal("Error", "Message is empty. Please set a message to transmit.");
+            return;
+        }
+        baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+        transmitter_model.set_baseband_bandwidth(2048000);
+        baseband::set_sample_rate(2048000, OversampleRate::None);
+        transmitter_model.set_sampling_rate(2048000);
+        transmitter_model.set_baseband_bandwidth(2048000);
+        transmitter_model.enable();
+        rtty_message.baud = baud_conf;
+        rtty_message.shift = shift;
+        rtty_message.inverted = false;  // check_inverted.value(); //i already invert it with the mark and space calculation
+        rtty_message.mark_tone = mark;
+        rtty_message.space_tone = space;
+        rtty_message.stopbits = stop_bits;
+        baudot_encoder.set_usos(false);  // to be compatible with all
+        baudot_encoder.encode(message, rtty_message.data, &rtty_message.data_len, rtty_message.max_len);
+        baseband::set_rtty_config(rtty_message);
+        tx_view.set_transmitting(true);
+    };
+
+    tx_view.on_stop = [this]() {
+        stop();
+    };
+
+    refresh_tones();
+}
+
+void RttyTxView::refresh_tones() {
+    std::string tones_str = "";
+
+    int16_t shift = options_shift.selected_index_value();
+    if (mark_tone == -32000) {
+        mark = -shift / 2;
+        space = shift / 2;
+    } else {
+        if (mark_tone < 0) {
+            space = -(shift + abs(mark_tone));
+        } else {
+            space = shift + mark_tone;
+        }
+        mark = mark_tone;
+    }
+
+    if (check_inverted.value()) {
+        int16_t tmp = mark;
+        mark = space;
+        space = tmp;
+    }
+    tones_str = "Mark:" + to_string_dec_int(mark) + " Hz, Space:" + to_string_dec_int(space) + " Hz";
+    text_tones.set(tones_str);
+}
+
+void RttyTxView::on_tx_progress(bool done) {
+    if (done) stop();
+}
+
+void RttyTxView::stop() {
+    tx_view.set_transmitting(false);
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+RttyTxView::~RttyTxView() {
+    stop();
+}
+
+}  // namespace ui::external_app::rtty_tx

firmware/application/external/rtty_tx/ui_rtty_tx.hpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2026 HTotoo
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_RTTY_TX_H__
+#define __UI_RTTY_TX_H__
+
+#include "ui.hpp"
+#include "ui_language.hpp"
+#include "ui_navigation.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_freq_field.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+#include "ui_fileman.hpp"
+#include "file_path.hpp"
+#include "baudot.hpp"
+
+using namespace ui;
+
+namespace ui::external_app::rtty_tx {
+
+class RttyTxView : public View {
+   public:
+    RttyTxView(NavigationView& nav);
+    ~RttyTxView();
+    void focus() override;
+    std::string title() const override { return "RTTY"; };
+
+   private:
+    void on_tx_progress(bool done);
+    void stop();
+    void refresh_tones();
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{};
+    uint32_t baud_conf = 4545;  // default to 45.45 baud, which is common for RTTY.
+    uint32_t shift = 170;       // 170 hz
+    std::string message = "PORTAPACK";
+    int32_t mark_tone = 0;  // for option
+    int16_t mark = 0, space = 170;
+    uint8_t stop_bits = 3;  // 2=1.0, 3=1.5, 4=2.0
+    app_settings::SettingsManager settings_{
+        "tx_rtty",
+        app_settings::Mode::TX,
+        {
+            {"baud_conf"sv, &baud_conf},
+            {"shift"sv, &shift},
+            {"message"sv, &message},
+            {"mark_tone"sv, &mark_tone},
+        }};
+
+    Labels labels{
+        {{UI_POS_X(0), UI_POS_Y(0)}, "Baud:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(14), UI_POS_Y(0)}, "Shift:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(15), UI_POS_Y(1)}, "Mark t:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(3)}, "Message:", Theme::getInstance()->fg_light->foreground}};
+
+    OptionsField options_baud{
+        {UI_POS_X(7), UI_POS_Y(0)},
+        5,
+        {{"45", 4500},
+         {"45.45", 4545},
+         {"50", 5000},
+         {"75", 7500},
+         {"100", 10000},
+         {"110", 11000},
+         {"150", 15000},
+         {"200", 20000}}};
+
+    OptionsField options_shift{
+        {UI_POS_X(21), UI_POS_Y(0)},
+        5,
+        {{"170", 170},
+         {"85", 85},
+         {"200", 200},
+         {"450", 450},
+         {"850", 850}}};
+
+    Checkbox check_inverted{
+        {UI_POS_X(0), UI_POS_Y(1)},
+        10,
+        "Inverted",
+        true};
+
+    OptionsField options_tone{
+        {UI_POS_X(25), UI_POS_Y(1)},
+        5,
+        {{"CNT", -32000},
+         {"0", 0},
+         {"2125", 2125},
+         {"-2125", -2125},
+         {"1275", 1275},
+         {"-1275", -1275}}};
+
+    Text text_tones{
+        {UI_POS_X(0), UI_POS_Y(2), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)},
+        "-"};
+
+    Button btn_message{
+        {UI_POS_X(0), UI_POS_Y(3), UI_POS_WIDTH(15), UI_POS_HEIGHT(2)},
+        "Set message"};
+
+    Text text_message{
+        {UI_POS_X(0), UI_POS_Y(5), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)},
+        ""};
+
+    TransmitterView tx_view{
+        (int16_t)UI_POS_Y_BOTTOM(4),
+        1000,
+        0};
+
+    RTTYDataMessage rtty_message{};
+    BaudotCoder baudot_encoder{};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.done);
+        }};
+};
+
+}  // namespace ui::external_app::rtty_tx
+
+#endif /*__UI_RTTY_TX_H__*/

firmware/application/external/scanner/ui_scanner.cpp

@@ -461,6 +461,7 @@ ScannerView::ScannerView(
             else
                 v = WFM_MODULATION;
             field_mode.set_selected_index(v);
+            return;  // Important ! Guru will occur if you don't return when modifying field from within on_change !
         }
         last_mode = v;
         receiver_model.disable();

firmware/application/external/sd_wipe/ui_sd_wipe.cpp

@@ -36,8 +36,11 @@ WipeSDView::WipeSDView(NavigationView& nav)
 }
 
 WipeSDView::~WipeSDView() {
-    if (thread)
+    if (thread) {
         chThdTerminate(thread);
+        chThdWait(thread);
+        thread = nullptr;
+    }
 }
 
 void WipeSDView::focus() {

firmware/application/external/sdusb/main.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2024 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_sd_over_usb.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::sdusb {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<SdOverUsbView>();
+}
+}  // namespace ui::external_app::sdusb
+
+extern "C" {
+
+__attribute__((section(".external_app.app_sdusb.application_information"), used)) application_information_t _application_information_sdusb = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::sdusb::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "SD Over USB",
+    /*.bitmap_data = */ {
+        0xF0,
+        0x0F,
+        0x10,
+        0x08,
+        0x50,
+        0x0A,
+        0x10,
+        0x08,
+        0x10,
+        0x08,
+        0x10,
+        0x08,
+        0xF8,
+        0x1F,
+        0xF8,
+        0x1F,
+        0xF8,
+        0x1F,
+        0xF8,
+        0x1F,
+        0xF8,
+        0x1F,
+        0xF8,
+        0x1F,
+        0xF8,
+        0x1F,
+        0xF0,
+        0x0F,
+        0x80,
+        0x01,
+        0x80,
+        0x01,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::UTILITIES,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_usb_sd */ {'P', 'U', 'S', 'B'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/sdusb/ui_sd_over_usb.cpp

@@ -23,7 +23,7 @@
 #include "ui_sd_over_usb.hpp"
 #include "portapack_shared_memory.hpp"
 
-namespace ui {
+namespace ui::external_app::sdusb {
 
 SdOverUsbView::SdOverUsbView(NavigationView& nav)
     : nav_(nav) {
@@ -46,7 +46,7 @@ SdOverUsbView::SdOverUsbView(NavigationView& nav)
         sdcStop(&SDCD1);
 
         portapack::shutdown(true);
-        m4_init(portapack::spi_flash::image_tag_usb_sd, portapack::memory::map::m4_code, false);
+        baseband::run_prepared_image(portapack::memory::map::m4_code.base());
         m0_halt();
         /* will not return*/
     };
@@ -56,4 +56,4 @@ void SdOverUsbView::focus() {
     button_run.focus();
 }
 
-} /* namespace ui */
+}  // namespace ui::external_app::sdusb

firmware/application/external/sdusb/ui_sd_over_usb.hpp

@@ -32,7 +32,7 @@
 
 #include <cstdint>
 
-namespace ui {
+namespace ui::external_app::sdusb {
 
 class SdOverUsbView : public View {
    public:
@@ -58,6 +58,6 @@ class SdOverUsbView : public View {
         "Run"};
 };
 
-} /* namespace ui */
+}  // namespace ui::external_app::sdusb
 
 #endif /*__UI_SD_OVER_USB_H__*/

firmware/application/external/siggen/main.cpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_siggen.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::siggen {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<SigGenView>();
+}
+}  // namespace ui::external_app::siggen
+extern "C" {
+
+__attribute__((section(".external_app.app_siggen.application_information"), used)) application_information_t _application_information_siggen = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::siggen::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Signal gen",
+    /*.bitmap_data = */ {
+        0x18,
+        0x00,
+        0x24,
+        0x00,
+        0x42,
+        0x00,
+        0x42,
+        0x00,
+        0x42,
+        0x00,
+        0x42,
+        0x00,
+        0x81,
+        0x00,
+        0xAB,
+        0x6A,
+        0x80,
+        0x40,
+        0x00,
+        0x21,
+        0x00,
+        0x21,
+        0x00,
+        0x21,
+        0x00,
+        0x21,
+        0x00,
+        0x12,
+        0x00,
+        0x0C,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_siggen */ {'P', 'S', 'I', 'G'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/siggen/ui_siggen.cpp

@@ -31,7 +31,7 @@
 
 using namespace portapack;
 
-namespace ui {
+namespace ui::external_app::siggen {
 
 void SigGenView::focus() {
     options_shape.focus();
@@ -75,7 +75,7 @@ void SigGenView::on_tx_progress(const uint32_t progress, const bool done) {
 
 SigGenView::SigGenView(
     NavigationView& nav) {
-    baseband::run_image(portapack::spi_flash::image_tag_siggen);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
 
     add_children({&labels,
                   &options_mod,
@@ -172,4 +172,4 @@ SigGenView::SigGenView(
     };
 }
 
-} /* namespace ui */
+}  // namespace ui::external_app::siggen

firmware/application/external/siggen/ui_siggen.hpp

@@ -33,7 +33,7 @@
 #include "portapack.hpp"
 #include "message.hpp"
 
-namespace ui {
+namespace ui::external_app::siggen {
 
 class SigGenView : public View {
    public:
@@ -139,6 +139,6 @@ class SigGenView : public View {
         }};
 };
 
-} /* namespace ui */
+}  // namespace ui::external_app::siggen
 
 #endif /*__SIGGEN_H__*/

firmware/application/external/snake/ui_snake.cpp

@@ -221,7 +221,7 @@ void SnakeView::paint(Painter& painter) {
     (void)painter;
     if (!initialized) {
         initialized = true;
-        std::srand(LPC_RTC->CTIME0);
+        srand(LPC_RTC->CTIME0);
         init_game();
     }
 }

firmware/application/external/subcarrx/ui_subcar.cpp

@@ -91,6 +91,7 @@ SubCarView::SubCarView(NavigationView& nav)
                   &button_clear_list,
                   &check_log,
                   &labels,
+                  &options_mode,
                   &recent_entries_view});
 
     baseband::run_prepared_image(portapack::memory::map::m4_code.base());
@@ -114,11 +115,17 @@ SubCarView::SubCarView(NavigationView& nav)
     recent_entries_view.on_select = [this](const SubCarRecentEntry& entry) {
         nav_.push<SubCarRecentEntryDetailView>(entry);
     };
-    baseband::set_subghzd_config(0, receiver_model.sampling_rate());  // 0=am
-    receiver_model.enable();
+
+    options_mode.on_change = [this](size_t, int32_t v) {
+        modulation = v;
+        chThdSleepMilliseconds(100);  // wait for the baseband thread to process the previous config, to avoid glitchy output when switching modes
+        baseband::set_subghzd_config(modulation, receiver_model.sampling_rate());
+    };
     signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
         on_tick_second();
     };
+    options_mode.set_selected_index(modulation, true);
+    receiver_model.enable();
 }
 
 void SubCarView::on_tick_second() {
@@ -176,6 +183,8 @@ const char* SubCarView::getSensorTypeName(FPROTO_SUBCAR_SENSOR type) {
             return "Fiat V0";
         case FPC_BMWV0:
             return "BMW V0";
+            /* case FPC_KIAV6:
+                 return "Kia V6";*/
 
         case FPC_Invalid:
         default:
@@ -266,10 +275,11 @@ void SubCarRecentEntryDetailView::parseProtocol() {
     if (entry_.sensorType == FPC_Invalid) return;
 
     if (entry_.sensorType == FPC_SUZUKI) {
-        uint32_t serial_button = (((entry_.data >> 32) & 0xFFF) << 20) | (entry_.data >> 12);
-        serial = serial_button >> 4;
-        uint8_t buttonid = serial_button & 0xF;
-        cnt = (entry_.data >> 44) & 0xFFFF;
+        uint32_t data_high = (uint32_t)(entry_.data >> 32);
+        uint32_t data_low = (uint32_t)entry_.data;
+        serial = ((data_high & 0xFFF) << 16) | (data_low >> 16);
+        uint8_t buttonid = (data_low >> 12) & 0xF;
+        cnt = (data_high << 4) >> 16;
         btn = to_string_dec_uint(buttonid);
         return;
     }
@@ -320,15 +330,78 @@ void SubCarRecentEntryDetailView::parseProtocol() {
     }
 
     if (entry_.sensorType == FPC_KIAV5) {
-        serial = (uint32_t)(((entry_.data >> 32) & 0x0FFFFFFF) >> 1);
-        uint8_t button = (entry_.data >> 61) & 0x07;
+        uint64_t yek = 0;
+        for (int i = 0; i < 8; i++) {
+            uint8_t byte = (entry_.data2 >> (i * 8)) & 0xFF;
+            uint8_t reversed = 0;
+            for (int b = 0; b < 8; b++) {
+                if (byte & (1 << b))
+                    reversed |= (1 << (7 - b));
+            }
+            yek |= ((uint64_t)reversed << ((7 - i) * 8));
+        }
+        serial = (uint32_t)((yek >> 32) & 0x0FFFFFFF);
+        uint8_t button = (uint8_t)((yek >> 60) & 0x0F);
+        uint32_t encrypted = (uint32_t)(yek & 0xFFFFFFFF);
         btn = to_string_dec_uint(button);
-        cnt = (uint16_t)(entry_.data & 0xFFFF);
+        // decode
+        uint8_t keystore_bytes[] = {0x53, 0x54, 0x46, 0x52, 0x4b, 0x45, 0x30, 0x30};
+        uint8_t s0 = (encrypted & 0xFF);
+        uint8_t s1 = (encrypted >> 8) & 0xFF;
+        uint8_t s2 = (encrypted >> 16) & 0xFF;
+        uint8_t s3 = (encrypted >> 24) & 0xFF;
+        int round_index = 1;
+        for (size_t i = 0; i < 18; i++) {
+            uint8_t r = keystore_bytes[round_index] & 0xFF;
+            int steps = 8;
+            while (steps > 0) {
+                uint8_t base;
+                if ((s3 & 0x40) == 0) {
+                    base = (s3 & 0x02) == 0 ? 0x74 : 0x2E;
+                } else {
+                    base = (s3 & 0x02) == 0 ? 0x3A : 0x5C;
+                }
+
+                if (s2 & 0x08) {
+                    base = (((base >> 4) & 0x0F) | ((base & 0x0F) << 4)) & 0xFF;
+                }
+                if (s1 & 0x01) {
+                    base = ((base & 0x3F) << 2) & 0xFF;
+                }
+                if (s0 & 0x01) {
+                    base = (base << 1) & 0xFF;
+                }
+
+                uint8_t temp = (s3 ^ s1) & 0xFF;
+                s3 = ((s3 & 0x7F) << 1) & 0xFF;
+                if (s2 & 0x80) {
+                    s3 |= 0x01;
+                }
+                s2 = ((s2 & 0x7F) << 1) & 0xFF;
+                if (s1 & 0x80) {
+                    s2 |= 0x01;
+                }
+                s1 = ((s1 & 0x7F) << 1) & 0xFF;
+                if (s0 & 0x80) {
+                    s1 |= 0x01;
+                }
+                s0 = ((s0 & 0x7F) << 1) & 0xFF;
+
+                uint8_t chk = (base ^ (r ^ temp)) & 0xFF;
+                if (chk & 0x80) {
+                    s0 |= 0x01;
+                }
+                r = ((r & 0x7F) << 1) & 0xFF;
+                steps--;
+            }
+            round_index = (round_index - 1) & 0x7;
+        }
+        cnt = (s0 + (s1 << 8)) & 0xFFFF;
     }
 
     if (entry_.sensorType == FPC_KIAV3V4) {
         // not decrypted!
-        serial = SD_NO_SERIAL;  //(uint32_t)entry_.data;
+        serial = (uint32_t)entry_.data;
         // uint8_t button = entry_.data2 & 0xFF;
         btn = "?";  // to_string_dec_uint(button);
     }
@@ -344,7 +417,7 @@ void SubCarRecentEntryDetailView::parseProtocol() {
     if (entry_.sensorType == FPC_KIAV1) {
         serial = (uint32_t)((entry_.data >> 24) & 0xFFFFFFFF);
         uint8_t button = (uint8_t)((entry_.data >> 16) & 0xFF);
-        cnt = (uint8_t)((entry_.data >> 8) & 0xFF);
+        cnt = (uint8_t)((entry_.data >> 4) & 0xF) << 8 | ((entry_.data >> 8) & 0xFF);
         btn = to_string_dec_uint(button);
     }
 
@@ -427,6 +500,13 @@ void SubCarRecentEntryDetailView::parseProtocol() {
         btn = to_string_dec_uint(button);
     }
 
+    /*if (entry_.sensorType == FPC_KIAV6) {
+        // not decrypted!
+        serial = 0;
+        btn = "?";
+        cnt = 0;
+    }*/
+
     return;
 }
 

firmware/application/external/subcarrx/ui_subcar.hpp

@@ -116,25 +116,27 @@ class SubCarView : public View {
         4'000'000 /* sampling rate */,
         ReceiverModel::Mode::AMAudio};
     bool logging = false;
+    uint8_t modulation = 0;
     app_settings::SettingsManager settings_{
         "rx_subcar",
         app_settings::Mode::RX,
         {
             {"log"sv, &logging},
+            {"modulationmode"sv, &modulation},
         }};
 
     SubCarRecentEntries recent{};
 
     RFAmpField field_rf_amp{
-        {13 * 8, UI_POS_Y(0)}};
+        {UI_POS_X(13), UI_POS_Y(0)}};
     LNAGainField field_lna{
-        {15 * 8, UI_POS_Y(0)}};
+        {UI_POS_X(15), UI_POS_Y(0)}};
     VGAGainField field_vga{
-        {18 * 8, UI_POS_Y(0)}};
+        {UI_POS_X(18), UI_POS_Y(0)}};
     RSSI rssi{
-        {21 * 8, 0, UI_POS_WIDTH_REMAINING(24), 4}};
+        {UI_POS_X(21), 0, UI_POS_WIDTH_REMAINING(24), 4}};
     Channel channel{
-        {21 * 8, 5, UI_POS_WIDTH_REMAINING(24), 4},
+        {UI_POS_X(21), 5, UI_POS_WIDTH_REMAINING(24), 4},
     };
     RxFrequencyField field_frequency{
         {UI_POS_X(0), UI_POS_Y(0)},
@@ -143,18 +145,22 @@ class SubCarView : public View {
     SignalToken signal_token_tick_second{};
 
     Button button_clear_list{
-        {0, 16, 7 * 8, 32},
+        {UI_POS_X(0), UI_POS_Y(1), UI_POS_WIDTH(7), UI_POS_HEIGHT(2)},
         "Clear"};
 
     Checkbox check_log{
-        {10 * 8, 18},
+        {UI_POS_X(8), UI_POS_Y(1)},
         3,
         "Log",
         true};
 
     Labels labels{
-        {{UI_POS_X_RIGHT(14), UI_POS_Y(1)}, "no fm yet :(", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(15), UI_POS_Y(1)}, "Mode:", Theme::getInstance()->fg_light->foreground},
     };
+    ui::OptionsField options_mode{
+        {UI_POS_X(22), UI_POS_Y(1)},
+        3,
+        {{"AM", 0}, {"FM", 1}}};
 
     static constexpr auto header_height = 3 * 16;
 
@@ -198,16 +204,16 @@ class SubCarRecentEntryDetailView : public View {
     std::string btn = "";
     uint32_t cnt = SD_NO_CNT;
 
-    Text text_type{{UI_POS_X(0), 1 * 16, 15 * 8, 16}, "?"};
-    Text text_id{{6 * 8, 2 * 16, 10 * 8, 16}, "?"};
+    Text text_type{{UI_POS_X(0), UI_POS_Y(1), UI_POS_WIDTH(15), UI_POS_HEIGHT(1)}, "?"};
+    Text text_id{{UI_POS_X(6), UI_POS_Y(2), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)}, "?"};
 
     Console console{
-        {0, 4 * 16, screen_width, screen_height - (4 * 16) - 36}};
+        {UI_POS_X(0), UI_POS_Y(4), UI_POS_MAXWIDTH, screen_height - (4 * 16) - 36}};
 
     Labels labels{
         {{UI_POS_X(0), UI_POS_Y(0)}, "Type:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 2 * 16}, "Serial: ", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), 3 * 16}, "Data:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(2)}, "Serial: ", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(3)}, "Data:", Theme::getInstance()->fg_light->foreground},
     };
 
     Button button_done{

firmware/application/external/tetris/ui_tetris.cpp

@@ -605,7 +605,7 @@ void pause_game() {
 }
 
 int main() {
-    std::srand(GenerateRandomSeed());
+    srand(GenerateRandomSeed());
     Init();
     ShowLevelMenu();
     joystick.attach(&ReadJoystickForLevel, 0.3);

firmware/application/external/tpmsrx/main.cpp

@@ -75,7 +75,7 @@ __attribute__((section(".external_app.app_tpmsrx.application_information"), used
     },
     /*.icon_color = */ ui::Color::green().v,
     /*.menu_location = */ app_location_t::RX,
-    /*.desired_menu_position = */ -1,
+    /*.desired_menu_position = */ 7,
 
     /*.m4_app_tag = portapack::spi_flash::image_tag_tpms */ {'P', 'T', 'P', 'M'},
     /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time

firmware/application/external/tpmsrx/tpms_app.cpp

@@ -42,16 +42,37 @@ std::string type(tpms::Reading::Type type) {
     return to_string_dec_uint(toUType(type), 2);
 }
 
+std::string type_name(tpms::Reading::Type type) {
+    switch (type) {
+        case tpms::Reading::Type::None:
+            return "None";
+        case tpms::Reading::Type::FLM_64:
+            return "FLM_64";
+        case tpms::Reading::Type::FLM_72:
+            return "FLM_72";
+        case tpms::Reading::Type::FLM_80:
+            return "FLM_80";
+        case tpms::Reading::Type::Schrader:
+            return "Schrader";
+        case tpms::Reading::Type::GMC_96:
+            return "GMC_96";
+        default:
+            return "Unknown";
+    }
+}
+
 std::string id(tpms::TransponderID id) {
     return to_string_hex(id.value(), 8);
 }
 
 std::string pressure(Pressure pressure) {
-    return to_string_dec_int(units_psi ? pressure.psi() : pressure.kilopascal(), 3);
+    return to_string_dec_int(pressure_unit == PRESSURE_UNIT_PSI ? pressure.psi() : pressure_unit == PRESSURE_UNIT_BAR ? pressure.bar()
+                                                                                                                      : pressure.kilopascal(),
+                             3);
 }
 
 std::string temperature(Temperature temperature) {
-    return to_string_dec_int(units_fahr ? temperature.fahrenheit() : temperature.celsius(), 3);
+    return to_string_dec_int(temp_unit == TEMP_UNIT_CELSIUS ? temperature.celsius() : temperature.fahrenheit(), 3);
 }
 
 std::string flags(tpms::Flags flags) {
@@ -99,7 +120,8 @@ void TPMSRecentEntry::update(const tpms::Reading& reading) {
     }
 }
 
-TPMSAppView::TPMSAppView(NavigationView&) {
+TPMSAppView::TPMSAppView(NavigationView& nav)
+    : nav_{nav} {
     // baseband::run_image(portapack::spi_flash::image_tag_tpms);
     baseband::run_prepared_image(portapack::memory::map::m4_code.base());
 
@@ -122,16 +144,21 @@ TPMSAppView::TPMSAppView(NavigationView&) {
     options_band.set_by_value(receiver_model.target_frequency());
 
     options_pressure.on_change = [this](size_t, int32_t i) {
-        format::units_psi = (bool)i;
+        format::pressure_unit = (uint8_t)i;
         update_view();
     };
-    options_pressure.set_selected_index(format::units_psi, true);
+    options_pressure.set_by_value(format::pressure_unit);
 
     options_temperature.on_change = [this](size_t, int32_t i) {
-        format::units_fahr = (bool)i;
+        format::temp_unit = (uint8_t)i;
         update_view();
     };
-    options_temperature.set_selected_index(format::units_fahr, true);
+    options_temperature.set_by_value(format::temp_unit);
+
+    // Add on_select handler for entries
+    recent_entries_view.on_select = [this](const TPMSRecentEntry& entry) {
+        on_show_detail(entry);
+    };
 
     logger = std::make_unique<TPMSLogger>();
     if (logger) {
@@ -176,6 +203,7 @@ void TPMSAppView::on_packet(const tpms::Packet& packet) {
         const auto reading = reading_opt.value();
         auto& entry = ::on_packet(recent, TPMSRecentEntry::Key{reading.type(), reading.id()});
         entry.update(reading);
+        entry.signal_type = packet.signal_type();
         recent_entries_view.set_dirty();
     }
 
@@ -189,6 +217,116 @@ void TPMSAppView::on_show_list() {
     recent_entries_view.focus();
 }
 
+void TPMSAppView::on_show_detail(const TPMSRecentEntry& entry) {
+    nav_.push<TPMSRecentEntryDetailView>(entry);
+}
+
+// Detail view implementation
+TPMSRecentEntryDetailView::TPMSRecentEntryDetailView(NavigationView& nav, const TPMSRecentEntry& entry)
+    : nav_{nav},
+      entry_{entry} {
+    add_children({&labels,
+                  &text_type,
+                  &text_id,
+                  &text_pressure,
+                  &text_temperature,
+                  &text_flags,
+                  &text_count,
+                  &button_done,
+                  &button_save});
+
+    // Display entry data
+    text_type.set(format::type_name(entry.type));
+    text_id.set(to_string_hex(entry.id.value(), 8));
+
+    if (entry.last_pressure.is_valid()) {
+        std::string pressure_str = format::pressure(entry.last_pressure.value());
+        std::string unit_str = format::pressure_unit == PRESSURE_UNIT_PSI ? " PSI" : format::pressure_unit == PRESSURE_UNIT_BAR ? " BAR"
+                                                                                                                                : " kPa";
+        text_pressure.set(pressure_str + unit_str);
+    } else {
+        text_pressure.set("---");
+    }
+
+    if (entry.last_temperature.is_valid()) {
+        text_temperature.set(to_string_dec_int(entry.last_temperature.value().celsius(), 3) + " C");
+    } else {
+        text_temperature.set("---");
+    }
+
+    if (entry.last_flags.is_valid()) {
+        text_flags.set(to_string_hex(entry.last_flags.value(), 2));
+    } else {
+        text_flags.set("--");
+    }
+
+    text_count.set(to_string_dec_uint(entry.received_count, 4));
+
+    button_done.on_select = [&nav](Button&) {
+        nav.pop();
+    };
+
+    button_save.on_select = [this](Button&) {
+        on_save();
+    };
+}
+
+void TPMSRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+void TPMSRecentEntryDetailView::set_entry(const TPMSRecentEntry& entry) {
+    entry_ = entry;
+}
+
+void TPMSRecentEntryDetailView::on_save() {
+    auto timestamp = to_string_timestamp(rtc_time::now());
+    std::string file_name = "TPMS_" + timestamp + ".TXT";
+    ensure_directory(tpms_dir);
+    auto file_path = tpms_dir / file_name;
+
+    if (save_file(file_path)) {
+        nav_.display_modal("Saved", "Packet saved to:\n" + file_name);
+    } else {
+        nav_.display_modal("Error", "Failed to save\npacket");
+    }
+}
+
+bool TPMSRecentEntryDetailView::save_file(const std::filesystem::path& path) {
+    File f;
+    auto error = f.create(path);
+    if (error.is_valid())
+        return false;
+
+    // Save in format compatible with TX app
+    std::string content = "Type=" + to_string_dec_uint(toUType(entry_.type), 1) + "\n";
+    content += "ID=" + to_string_hex(entry_.id.value(), 8) + "\n";
+
+    if (entry_.last_pressure.is_valid()) {
+        content += "Pressure=" + to_string_dec_int(entry_.last_pressure.value().kilopascal(), 1) + "\n";
+    } else {
+        content += "Pressure=240\n";  // Default value
+    }
+
+    if (entry_.last_temperature.is_valid()) {
+        content += "Temperature=" + to_string_dec_int(entry_.last_temperature.value().celsius(), 1) + "\n";
+    } else {
+        content += "Temperature=25\n";  // Default value
+    }
+
+    if (entry_.last_flags.is_valid()) {
+        content += "Flags=" + to_string_hex(entry_.last_flags.value(), 2) + "\n";
+    } else {
+        content += "Flags=00\n";
+    }
+
+    // Save signal type for proper retransmission
+    content += "SignalType=" + to_string_dec_uint(toUType(entry_.signal_type), 1) + "\n";
+
+    f.write(content.c_str(), content.length());
+    return true;
+}
+
 }  // namespace ui::external_app::tpmsrx
 
 namespace ui {
@@ -239,4 +377,4 @@ void RecentEntriesTable<ui::external_app::tpmsrx::TPMSRecentEntries>::draw(
     painter.draw_string(target_rect.location(), style, line);
 }
 
-}  // namespace ui
+}  // namespace ui

firmware/application/external/tpmsrx/tpms_app.hpp

@@ -42,10 +42,9 @@ namespace ui::external_app::tpmsrx {
 
 namespace format {
 
-static bool units_psi{false};
-static bool units_fahr{false};
-
-} /* namespace format */
+static uint8_t pressure_unit{PRESSURE_UNIT_KPA};
+static uint8_t temp_unit{TEMP_UNIT_CELSIUS};
+}  // namespace format
 
 struct TPMSRecentEntry {
     using Key = std::pair<tpms::Reading::Type, tpms::TransponderID>;
@@ -54,6 +53,7 @@ struct TPMSRecentEntry {
 
     tpms::Reading::Type type{invalid_key.first};
     tpms::TransponderID id{invalid_key.second};
+    tpms::SignalType signal_type{tpms::SignalType::OOK_8k192_Schrader};
 
     size_t received_count{0};
 
@@ -90,6 +90,64 @@ class TPMSLogger {
 
 using TPMSRecentEntriesView = RecentEntriesView<TPMSRecentEntries>;
 
+class TPMSRecentEntryDetailView : public View {
+   public:
+    TPMSRecentEntryDetailView(NavigationView& nav, const TPMSRecentEntry& entry);
+
+    void set_entry(const TPMSRecentEntry& entry);
+    const TPMSRecentEntry& entry() const { return entry_; }
+
+    void focus() override;
+
+   private:
+    NavigationView& nav_;
+    TPMSRecentEntry entry_;
+
+    void on_save();
+    bool save_file(const std::filesystem::path& path);
+
+    Labels labels{
+        {{0 * 8, 1 * 16}, "Type:", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 3 * 16}, "ID:", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 5 * 16}, "Pressure:", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 7 * 16}, "Temperature:", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 9 * 16}, "Flags:", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 11 * 16}, "Count:", Theme::getInstance()->fg_light->foreground},
+    };
+
+    Text text_type{
+        {8 * 8, 1 * 16, 20 * 8, 16},
+        ""};
+
+    Text text_id{
+        {8 * 8, 3 * 16, 20 * 8, 16},
+        ""};
+
+    Text text_pressure{
+        {12 * 8, 5 * 16, 16 * 8, 16},
+        ""};
+
+    Text text_temperature{
+        {14 * 8, 7 * 16, 14 * 8, 16},
+        ""};
+
+    Text text_flags{
+        {8 * 8, 9 * 16, 20 * 8, 16},
+        ""};
+
+    Text text_count{
+        {8 * 8, 11 * 16, 20 * 8, 16},
+        ""};
+
+    Button button_save{
+        {0 * 8, 13 * 16, 14 * 8, 32},
+        "Save"};
+
+    Button button_done{
+        {16 * 8, 13 * 16, 14 * 8, 32},
+        "Done"};
+};
+
 class TPMSAppView : public View {
    public:
     TPMSAppView(NavigationView& nav);
@@ -106,6 +164,8 @@ class TPMSAppView : public View {
     std::string title() const override { return "TPMS RX"; };
 
    private:
+    NavigationView& nav_;
+
     RxRadioState radio_state_{
         314900000 /* frequency*/
         ,
@@ -117,8 +177,8 @@ class TPMSAppView : public View {
         "rx_tpms",
         app_settings::Mode::RX,
         {
-            {"units_psi"sv, &format::units_psi},
-            {"units_fahr"sv, &format::units_fahr},
+            {"pressure_unit"sv, &format::pressure_unit},
+            {"temp_unit"sv, &format::temp_unit},
         }};
 
     MessageHandlerRegistration message_handler_packet{
@@ -154,15 +214,16 @@ class TPMSAppView : public View {
 
     OptionsField options_pressure{
         {6 * 8, UI_POS_Y(0)},
-        3,
-        {{"kPa", 0},
-         {"PSI", 1}}};
+        4,
+        {{"kPa", PRESSURE_UNIT_KPA},
+         {"PSI", PRESSURE_UNIT_PSI},
+         {"BAR", PRESSURE_UNIT_BAR}}};
 
     OptionsField options_temperature{
         {10 * 8, UI_POS_Y(0)},
         2,
-        {{STR_DEGREES_C, 0},
-         {STR_DEGREES_F, 1}}};
+        {{STR_DEGREES_C, TEMP_UNIT_CELSIUS},
+         {STR_DEGREES_F, TEMP_UNIT_FAHRENHEIT}}};
 
     RFAmpField field_rf_amp{
         {13 * 8, UI_POS_Y(0)}};
@@ -188,6 +249,7 @@ class TPMSAppView : public View {
 
     void on_packet(const tpms::Packet& packet);
     void on_show_list();
+    void on_show_detail(const TPMSRecentEntry& entry);
     void update_view();
 };