Random splash on boot (#2961 )

fix restore settings (#2995 )
Fix units tpms not compiling (#2994 )
2026-08-21 15:09:03 +00:00 · 2026-02-16 17:52:47 +01:00 · 2026-02-16 17:06:57 +01:00 · 2026-02-16 15:50:27 +01:00 · 2026-02-16 15:19:50 +01:00 · 2026-02-16 14:55:12 +01:00
208 changed files with 14628 additions and 1133 deletions
@@ -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
-
 ...
@@ -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
@@ -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
@@ -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
-     
@@ -83,3 +83,5 @@ venv/
 # generated bitmap arr file
 # TODO: generate bitmap during build, since we use python during build anyway, lemme know if this is a bad idea @zxkmm
 /firmware/tools/bitmap.hpp
+# flashsize is generated by cmake
+/firmware/flashsize.h
@@ -27,6 +27,40 @@ 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()
+
+#generate h files
+configure_file(flashsize.h.in ${CMAKE_CURRENT_SOURCE_DIR}/firmware/flashsize.h)
+
 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)
@@ -1 +0,0 @@
-portapack.ried.cl
@@ -56,7 +56,7 @@ 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}
+	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
@@ -67,6 +67,24 @@ add_custom_target(
 	DEPENDS ${FIRMWARE_FILENAME} ${HACKRF_FIRMWARE_DFU_FILENAME} ${HACKRF_FIRMWARE_FILENAME}
 )

+# PRALINE: Append FPGA bitstream to firmware at offset 0x180000
+# The base firmware is 1MB, FPGA goes at 1MB offset, final size is 2MB
+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)
+	add_custom_command(
+		TARGET firmware POST_BUILD
+		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}
+		COMMAND ${CMAKE_COMMAND} -E echo "PRALINE firmware with FPGA bitstream created:"
+		COMMAND ls -la ${FIRMWARE_FILENAME}
+		COMMENT "Appending PRALINE FPGA bitstream"
+		VERBATIM
+	)
+endif()
+
 if(${GCC_VERSION_MISMATCH})
 	set(COMPILER_MISMATCH_MESSAGE "WARNING: Compiler version mismatch, please use the official compiler version ${EXPECTED_GCC_VERSION} when sharing builds! Current compiler version: ${CMAKE_CXX_COMPILER_VERSION}")
 	message(${COMPILER_MISMATCH_MESSAGE})
@@ -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
@@ -296,10 +308,8 @@ set(CPPSRC
 	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})
@@ -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);
@@ -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;
@@ -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 */
@@ -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) {
@@ -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};
@@ -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,459 @@ 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"};
+};
+
+/* 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{{8, 16, 200, 16}, "Si5351 Clock Generator"};
+
+    Text text_status_label{{8, 40, 80, 16}, "Status Reg:"};
+    Text text_status_value{{96, 40, 144, 16}, ""};
+
+    Text text_pll_a_label{{8, 60, 80, 16}, "PLL A:"};
+    Text text_pll_a_status{{96, 60, 144, 16}, ""};
+
+    Text text_pll_b_label{{8, 80, 80, 16}, "PLL B:"};
+    Text text_pll_b_status{{96, 80, 144, 16}, ""};
+
+    Text text_sys_init_label{{8, 100, 80, 16}, "SYS_INIT:"};
+    Text text_sys_init_status{{96, 100, 144, 16}, ""};
+
+    Text text_xtal_cap_label{{8, 120, 80, 16}, "XTAL Cap:"};
+    Text text_xtal_cap_value{{96, 120, 144, 16}, ""};
+
+    Text text_clk0_label{{8, 150, 72, 16}, "CLK0:"};
+    Text text_clk0_status{{88, 150, 152, 16}, ""};
+
+    Text text_clk0_freq_label{{8, 170, 72, 16}, "  Freq:"};
+    Text text_clk0_freq_value{{88, 170, 152, 16}, ""};
+
+    Text text_clk0_div_label{{8, 190, 72, 16}, "  Div:"};
+    Text text_clk0_div_value{{88, 190, 152, 16}, ""};
+
+    Text text_clk1_label{{8, 210, 96, 16}, "CLK1 (SCT):"};
+    Text text_clk1_status{{112, 210, 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, 1114, 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_rf_amp{{0, 68, 114, 16}, "RF Amp:"};
+    Text text_rf_amp{{116, 68, 124, 16}, "---"};
+
+    Text text_lbl_lna{{0, 84, 114, 16}, "LNA Gain:"};
+    Text text_lna{{116, 84, 124, 16}, "---"};
+
+    Text text_lbl_vga{{0, 100, 114, 16}, "VGA Gain:"};
+    Text text_vga{{116, 100, 124, 16}, "---"};
+
+    Text text_lbl_fpga_decim{{0, 116, 114, 16}, "FPGA Decim:"};
+    Text text_fpga_decim{{116, 116, 124, 16}, "---"};
+
+    Text text_status{{0, 140, 240, 32}, ""};
+
+    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_title{{0, 0, 240, 16}, "=== RFFC5072 (1st IF) ==="};
+
+    Text text_lbl_enabled{{0, 20, 114, 16}, "Status:"};
+    Text text_enabled{{116, 20, 124, 16}, "---"};
+
+    Text text_lbl_freq{{0, 36, 114, 16}, "LO Freq:"};
+    Text text_freq{{116, 36, 124, 16}, "---"};
+
+    Text text_lbl_path{{0, 52, 114, 16}, "Path:"};
+    Text text_path{{116, 52, 124, 16}, "---"};
+
+    Text text_lbl_mixer{{0, 68, 114, 16}, "Mixer:"};
+    Text text_mixer{{116, 68, 124, 16}, "---"};
+
+    Text text_lbl_r0{{0, 92, 114, 16}, "Reg 0:"};
+    Text text_r0{{116, 92, 124, 16}, "---"};
+
+    Text text_lbl_r1{{0, 108, 114, 16}, "Reg 1 (N):"};
+    Text text_r1{{116, 108, 124, 16}, "---"};
+
+    Text text_lbl_r2{{0, 124, 114, 16}, "Reg 2:"};
+    Text text_r2{{116, 124, 124, 16}, "---"};
+
+    Text text_lbl_decode{{0, 148, 240, 16}, "--- Decoded Values ---"};
+
+    Text text_lbl_n{{0, 168, 114, 16}, "N divider:"};
+    Text text_n{{116, 168, 124, 16}, "---"};
+
+    Text text_lbl_lodiv{{0, 184, 114, 16}, "LO divider:"};
+    Text text_lodiv{{116, 184, 124, 16}, "---"};
+
+    Text text_lbl_calc{{0, 200, 114, 16}, "Calc freq:"};
+    Text text_calc{{116, 200, 124, 16}, "---"};
+
+    Text text_status{{0, 224, 240, 32}, ""};
+
+    Button button_refresh{{8, 280, 72, 24}, "Refresh"};
+    Button button_done{{168, 280, 64, 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
+
+#endif
+
 class DebugPeripheralsMenuView : public BtnGridView {
   public:
    DebugPeripheralsMenuView(NavigationView& nav);
@@ -45,10 +45,15 @@ 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 (portapack::device_type == portapack::DeviceType::DEV_PORTAPACK && file_size > 1 * 1024 * 1024) {
+            // Portapack firmware files must not be larger than 1MB
+            return false;
+        }
+        // May need to add a check to portarf and portarf pro too.
        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).
@@ -32,7 +32,9 @@
 #include "untar.hpp"
 #include <cstdint>

-#define FLASH_ROM_SIZE 1048576
+#include "../../flashsize.h"
+
+#define FLASH_ROM_SIZE (FLASH_SIZE_MB * 1024 * 1024)
 #define FLASH_STARTING_ADDRESS 0x00000000
 #define FLASH_EXPECTED_CHECKSUM 0x00000000
 #define FLASH_CHECKSUM_ERROR 0xFFFFFFFF
@@ -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");
@@ -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},
@@ -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);
@@ -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,
@@ -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>(); }});
@@ -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__*/
@@ -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 = [&]() {
@@ -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_;
@@ -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,38 @@ 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_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 +278,8 @@ const char* SubGhzDView::getSensorTypeName(FPROTO_SUBGHZD_SENSOR type) {
            return "GangQi";
        case FPS_MARANTEC24:
            return "Marantec24";
+        case FPS_HOLTEKHT6P20B:
+            return "Holtek HT6P20B";
        case FPS_Invalid:
        default:
            return "Unknown";
@@ -301,6 +339,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 +650,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 +867,11 @@ void SubGhzDRecentEntryDetailView::parseProtocol() {
        btn = entry_.data & 0xf;
        return;
    }
+
+    if (entry_.sensorType == FPS_HOLTEKHT6P20B) {
+        serial = entry_.data >> 8;
+        btn = (entry_.data >> 4) & 0xF;
+        return;
+    }
 }
-}  // namespace ui
+}  // namespace ui
@@ -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();
 };

@@ -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) {
@@ -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();
@@ -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,
@@ -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");
@@ -101,6 +118,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,7 +237,11 @@ constexpr ClockControls si5351c_clock_control_common{{
 }};

 constexpr ClockControls si5351a_clock_control_common{{
+#ifndef PRALINE
    {ClockControl::ClockCurrentDrive::_6mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Integer, ClockControl::ClockPowerDown::Power_Off},
+#else
+    {ClockControl::ClockCurrentDrive::_6mA, ClockControl::ClockSource::MS_Self, ClockControl::ClockInvert::Normal, ClockControl::MultiSynthSource::PLLA, ClockControl::MultiSynthMode::Fractional, ClockControl::ClockPowerDown::Power_Off},  // CLK0: MUST be Fractional for 8 MHz!
+#endif
    {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},
@@ -255,9 +292,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 +374,62 @@ 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 uses Si5351A with:
+     * CLK0 = AFE_CLK (codec/FPGA sample clock)
+     * CLK1 = SCT_CLK (FPGA timing clock at 2x sample rate)
+     * CLK4 = first IF (RFFC5072)
+     * CLK5 = second IF (MAX2831)
+     * Uses PLLA on XTAL only (no CLKIN support).
+     */
+
+    /* 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 */
+    clock_generator.write_ms_single_byte(0, si5351_ms_0_8m);  // MS0 = divider 50, r_div=1 for 8 MHz
+    clock_generator.write_ms_single_byte(1, si5351_ms_16m);   // MS1 = divider 50, r_div=0 for 16 MHz
+
+    /* CLK4 and CLK5 - use single-byte writes too */
+    {
+        const auto& ms4_regs = si5351c_ms_4_reg;
+        const uint8_t base_reg = ms4_regs[0];
+        for (size_t i = 1; i < ms4_regs.size(); i++) {
+            clock_generator.write_register(base_reg + i - 1, ms4_regs[i]);
+        }
+    }
+    {
+        const auto& ms5_regs = si5351c_ms_5_reg;
+        const uint8_t base_reg = ms5_regs[0];
+        for (size_t i = 1; i < ms5_regs.size(); i++) {
+            clock_generator.write_register(base_reg + i - 1, ms5_regs[i]);
+        }
+    }
+    clock_generator.write(si5351a_ms6_7_off_reg);  // MS6/7 off - short write is OK
+
+    /* 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);
+#else
    if (hackrf_r9) {
        const PLLReg pll_reg = (reference.source == ReferenceSource::Xtal)
                                   ? si5351_pll_a_xtal_reg
@@ -319,21 +450,45 @@ 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;
+#ifndef PRALINE
    while ((clock_generator.device_status() & device_status_mask) != 0);
+#else
+    uint32_t pll_timeout = 100000;
+    while ((clock_generator.device_status() & device_status_mask) != 0 && pll_timeout > 0) {
+        pll_timeout--;
+    }
+#endif

    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 +555,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 */
+    clock_generator.enable_clock(clock_generator_output_og_cpld);  /* CLK1 */
+    clock_generator.enable_output_mask(
+        (1U << clock_generator_output_og_codec) |
+        (1U << clock_generator_output_og_cpld));
+#else
    if (hackrf_r9) {
        clock_generator.enable_clock(clock_generator_output_r9_sgpio);
    } else {
@@ -417,6 +581,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 +589,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) and CLK1 (SCT_CLK) used for codec/FPGA */
+    clock_generator.disable_output_mask(
+        (1U << clock_generator_output_og_codec) |
+        (1U << clock_generator_output_og_cpld));
+    clock_generator.disable_clock(clock_generator_output_og_codec);
+    clock_generator.disable_clock(clock_generator_output_og_cpld);
+#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 +607,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 CLK4 (first IF) and CLK5 (second IF) like original HackRF One */
+    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 +627,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 +646,39 @@ 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: CLK0=AFE_CLK runs at sample rate (VCO/divider/2)
+     *          CLK1=SCT_CLK runs at 2x sample rate (VCO/divider/1)
+     * Reference: hackrf_core.c sample_rate_frac_set() lines 580-582
+     */
+
+    /* PRALINE: Match HackRF USB  sample_rate_frac_set()
+     * Reference: hackrf_usb radio.c lines 29-91, hackrf_core.c lines 501-685 */
+
+    // Set FPGA decimation to 0 (no decimation) for direct passthrough
+    fpga_debug_register_write(2, 0);
+    radio::invalidate_spi_config();
+
+    // The following was originally from @kitty. Adopting for testing radio.
+    clock_generator.set_ms_frequency(0, frequency * 2, si5351_vco_f, 1);  // CLK0: r_div=1 (÷2)
+    clock_generator.set_ms_frequency(1, frequency * 2, si5351_vco_f, 0);  // CLK1: r_div=0 (÷1)
+#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 +718,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 +737,35 @@ 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::ctrl({
+        .pd = 1,
+        .bypass = 0,
+        .directi = 0,
+        .directo = 0,
+        .clken = 0,
+        .frm = 0,
+        .autoblock = 1,
+        .pllfract_req = 0,
+        .sel_ext = 1,
+        .mod_pd = 1,
+        .clk_sel = cgu::CLK_SEL::XTAL,
+    });
+
+    cgu::pll0audio::mdiv({
+        .mdec = 22625UL,  // MDEC for MSEL=1024
+    });
+    cgu::pll0audio::np_div({
+        .pdec = 31,  // PSEL=20
+        .ndec = 69,  // NDEC for NSEL=25
+    });
+#else
    cgu::pll0audio::ctrl({
        .pd = 1,
        .bypass = 0,
@@ -549,13 +794,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);
@@ -72,6 +72,13 @@ class ClockManager {

    void set_reference_ppb(const int32_t ppb);

+#ifdef PRALINE
+    // 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;
@@ -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++;
    });
@@ -91,9 +91,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
@@ -222,7 +222,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 +280,30 @@ 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
 )

 set(EXTAPPLIST
@@ -300,7 +328,7 @@ set(EXTAPPLIST
 	tpmsrx
 	protoview
 	adsbtx
-	morse_tx
+	#morse_tx
 	sstvtx
 	sstvrx
 	random_password
@@ -332,6 +360,7 @@ set(EXTAPPLIST
 	scanner
 	level
 	gfxeq
+	waterfall_designer
 	detector_rx
 	spaceinv
 	blackjack
@@ -345,4 +374,20 @@ set(EXTAPPLIST
 	adult_toys_controller
 	flex_rx
 	subcarrx
+	siggen
+	morse_radio
+	morseradiotx
+  keeloqtx
+	rtty_rx
+	rtty_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()
+
@@ -89,7 +89,14 @@ 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
 }

 SECTIONS
@@ -400,6 +407,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 +505,45 @@ 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
 }

@@ -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,
@@ -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:
@@ -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
+};
+}
@@ -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
@@ -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
@@ -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
@@ -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)
@@ -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,
@@ -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
+};
+}
@@ -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__
@@ -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
@@ -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__
@@ -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"
@@ -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__
@@ -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
@@ -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__
@@ -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
@@ -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
@@ -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
+};
+}
@@ -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
@@ -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__*/
@@ -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
@@ -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
@@ -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
+};
+}
@@ -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
@@ -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__*/
@@ -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
+};
+}
@@ -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
@@ -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__*/
@@ -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
+};
+}
@@ -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
@@ -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__*/
@@ -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;
 }

@@ -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{
@@ -47,11 +47,13 @@ std::string id(tpms::TransponderID id) {
 }

 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) {
@@ -122,16 +124,16 @@ 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);

    logger = std::make_unique<TPMSLogger>();
    if (logger) {
@@ -239,4 +241,4 @@ void RecentEntriesTable<ui::external_app::tpmsrx::TPMSRecentEntries>::draw(
    painter.draw_string(target_rect.location(), style, line);
 }

-}  // namespace ui
+}  // namespace ui
@@ -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>;
@@ -117,8 +116,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 +153,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)}};
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2025 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_waterfall_designer.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::waterfall_designer {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<WaterfallDesignerView>();
+}
+}  // namespace ui::external_app::waterfall_designer
+
+extern "C" {
+
+__attribute__((section(".external_app.app_waterfall_designer.application_information"), used)) application_information_t _application_information_waterfall_designer = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::waterfall_designer::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Wt Design",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xFE,
+        0x7F,
+        0x03,
+        0xC0,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0x03,
+        0xC0,
+        0xFF,
+        0xFF,
+        0xFB,
+        0xD7,
+        0xFE,
+        0x7F,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::cyan().v,
+    /*.menu_location = */ app_location_t::UTILITIES,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_none */ {'P', 'C', 'A', 'P'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -0,0 +1,503 @@
+/*
+ * Copyleft Mr. Robot
+ * Copyright 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_waterfall_designer.hpp"
+#include "baseband_api.hpp"
+#include "portapack.hpp"
+#include "ui_freqman.hpp"
+#include "file_path.hpp"
+#include "ui_fileman.hpp"
+#include "file_reader.hpp"
+#include "ui_textentry.hpp"
+
+using namespace portapack;
+
+namespace ui::external_app::waterfall_designer {
+
+WaterfallDesignerView::WaterfallDesignerView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+
+    add_children({&labels,
+                  &field_frequency,
+                  &field_frequency_step,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &option_bandwidth,
+                  &record_view,
+                  &menu_view,
+                  &button_new,
+                  &button_open,
+                  &button_save,
+                  &button_add_level,
+                  &button_remove_level,
+                  &button_edit_color,
+                  &button_apply_setting,
+                  &waterfall});
+    ensure_directory(waterfalls_dir);
+    ui::Rect waterfall_rect{0, header_height, screen_rect().width(), screen_rect().height() - header_height};
+    waterfall.set_parent_rect(waterfall_rect);
+
+    menu_view.set_parent_rect({0, 1 * 16, screen_width, 7 * 16});
+
+    field_frequency_step.set_by_value(receiver_model.frequency_step());
+    field_frequency_step.on_change = [this](size_t, OptionsField::value_t v) {
+        receiver_model.set_frequency_step(v);
+        this->field_frequency.set_step(v);
+    };
+
+    freqman_set_bandwidth_option(SPEC_MODULATION, option_bandwidth);
+    option_bandwidth.on_change = [this](size_t, uint32_t new_capture_rate) {
+        /* Nyquist would imply a sample rate of 2x bandwidth, but because the ADC
+         * provides 2 values (I,Q), the sample_rate is equal to bandwidth here. */
+
+        /* capture_rate (bandwidth) is used for FFT calculation and display LCD, and also in recording writing SD Card rate. */
+        /* ex. sampling_rate values, 4Mhz, when recording 500 kHz (BW) and fs 8 Mhz, when selected 1 Mhz BW ... */
+        /* ex. recording 500kHz BW to .C16 file, base_rate clock 500kHz x2(I,Q) x 2 bytes (int signed) =2MB/sec rate SD Card. */
+
+        waterfall.stop();
+
+        // record_view determines the correct oversampling to apply and returns the actual sample rate.
+        // NB: record_view is what actually updates proc_capture baseband settings.
+        auto actual_sample_rate = record_view.set_sampling_rate(new_capture_rate);
+
+        // Update the radio model with the actual sampling rate.
+        receiver_model.set_sampling_rate(actual_sample_rate);
+
+        // Get suitable anti-aliasing BPF bandwidth for MAX2837 given the actual sample rate.
+        auto anti_alias_filter_bandwidth = filter_bandwidth_for_sampling_rate(actual_sample_rate);
+        receiver_model.set_baseband_bandwidth(anti_alias_filter_bandwidth);
+
+        capture_rate = new_capture_rate;
+
+        waterfall.start();
+    };
+
+    button_new.on_select = [this]() {
+        on_create_new_profile();
+    };
+
+    button_open.on_select = [this]() {
+        on_open_profile();
+    };
+
+    button_save.on_select = [this]() {
+        on_save_profile();
+    };
+
+    button_add_level.on_select = [this]() {
+        on_add_level();
+    };
+
+    button_remove_level.on_select = [this]() {
+        on_remove_level();
+    };
+
+    button_edit_color.on_select = [this]() {
+        on_edit_color();
+    };
+
+    button_apply_setting.on_select = [this]() {
+        if_apply_setting = true;
+        on_apply_current_to_wtf();
+        // nav_.pop();
+    };
+
+    menu_view.on_highlight = [this]() {
+        highlighted_index_ = menu_view.highlighted_index();
+    };
+
+    receiver_model.enable();
+    option_bandwidth.set_by_value(capture_rate);
+
+    record_view.on_error = [&nav](std::string message) {
+        nav.display_modal("Error", message);
+    };
+
+    button_save.hidden(true);
+    button_add_level.hidden(true);
+    button_remove_level.hidden(true);
+    button_edit_color.hidden(true);
+    button_apply_setting.hidden(true);
+
+    refresh_menu_view();
+}
+
+WaterfallDesignerView::WaterfallDesignerView(
+    NavigationView& nav,
+    ReceiverModel::settings_t override)
+    : WaterfallDesignerView(nav) {
+    // Settings to override when launched from another app (versus from AppSettings .ini file)
+    field_frequency.set_value(override.frequency_app_override);
+}
+
+WaterfallDesignerView::~WaterfallDesignerView() {
+    if (!if_apply_setting) restore_current_profile();
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+void WaterfallDesignerView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+
+    ui::Rect waterfall_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    waterfall.set_parent_rect(waterfall_rect);
+}
+
+void WaterfallDesignerView::focus() {
+    button_open.focus();
+}
+
+void WaterfallDesignerView::on_freqchg(int64_t freq) {
+    field_frequency.set_value(freq);
+}
+
+void WaterfallDesignerView::on_open_profile() {
+    auto open_view = nav_.push<FileLoadView>(".txt");
+    open_view->push_dir(waterfalls_dir);
+    open_view->on_changed = [this](std::filesystem::path new_file_path) {
+        on_profile_changed(new_file_path);
+    };
+}
+
+void WaterfallDesignerView::on_profile_changed(std::filesystem::path new_profile_path) {
+    current_profile_path = new_profile_path;
+    profile_levels.clear();
+
+    File playlist_file;
+    auto error = playlist_file.open(new_profile_path.string());
+
+    if (error) return;
+
+    menu_view.clear();
+    auto reader = FileLineReader(playlist_file);
+
+    for (const auto& line : reader) {
+        profile_levels.push_back(line);
+    }
+
+    for (auto& line : profile_levels) {
+        // remove empty lines
+        if (line == "\n" || line == "\r\n" || line == "\r") {
+            profile_levels.erase(std::remove(profile_levels.begin(), profile_levels.end(), line), profile_levels.end());
+        }
+
+        // remove line end \n etc
+        if (line.length() > 0 && (line[line.length() - 1] == '\n' || line[line.length() - 1] == '\r')) {
+            line = line.substr(0, line.length() - 1);
+        }
+    }
+
+    button_save.hidden(false);
+    button_add_level.hidden(false);
+    button_remove_level.hidden(false);
+    button_edit_color.hidden(false);
+    button_apply_setting.hidden(false);
+
+    refresh_menu_view();
+    on_apply_current_to_wtf();
+}
+
+void WaterfallDesignerView::refresh_menu_view() {
+    menu_view.clear();
+
+    for (const auto& line : profile_levels) {
+        if (line.length() == 0 || line[0] == '#') {
+            menu_view.add_item({line,
+                                ui::Color::grey(),
+                                &bitmap_icon_notepad,
+                                [this](KeyEvent) {
+                                    button_add_level.focus();
+                                }});
+        } else {
+            // index,R,G,B
+            size_t pos = 0;
+            size_t next_pos = 0;
+
+            // pass index
+            next_pos = line.find(',', pos);
+            if (next_pos == std::string::npos) continue;
+            pos = next_pos + 1;
+
+            // r
+            next_pos = line.find(',', pos);
+            if (next_pos == std::string::npos) continue;
+            uint8_t r = static_cast<uint8_t>(std::stoi(line.substr(pos, next_pos - pos)));
+            pos = next_pos + 1;
+
+            // g
+            next_pos = line.find(',', pos);
+            if (next_pos == std::string::npos) continue;
+            uint8_t g = static_cast<uint8_t>(std::stoi(line.substr(pos, next_pos - pos)));
+            pos = next_pos + 1;
+
+            // b
+            uint8_t b = static_cast<uint8_t>(std::stoi(line.substr(pos)));
+
+            ui::Color color = ui::Color(r, g, b);
+            menu_view.add_item({line,
+                                color,
+                                &bitmap_icon_cwgen,
+                                [this](KeyEvent) {
+                                    button_remove_level.focus();
+                                }});
+        }
+    }
+    set_dirty();
+}
+
+void WaterfallDesignerView::on_apply_current_to_wtf() {
+    std::filesystem::path system_read_path = "waterfall.txt";
+    copy_file(current_profile_path, system_read_path);
+
+    waterfall.load_gradient();
+
+    set_dirty();
+}
+
+void WaterfallDesignerView::on_save_profile() {
+    if (current_profile_path.empty()) {
+        nav_.display_modal("Err", "No profile file loaded");
+        return;
+    } else if (profile_levels.empty()) {
+        nav_.display_modal("Err", "List is empty");
+        return;
+    }
+
+    File profile_file;
+    auto error = profile_file.open(current_profile_path.string(), false, false);
+
+    if (error) {
+        nav_.display_modal("Err", "open err");
+        return;
+    }
+
+    // clear file
+    profile_file.seek(0);
+    profile_file.truncate();
+
+    // write new data
+    for (const auto& entry : profile_levels) {
+        profile_file.write_line(entry);
+    }
+
+    nav_.display_modal("Save", "Saved profile\n" + current_profile_path.string());
+}
+
+void WaterfallDesignerView::on_add_level() {
+    if (highlighted_index_ >= profile_levels.size()) return;
+    if (profile_levels[highlighted_index_].empty()) return;
+    if (profile_levels[highlighted_index_][0] == '#') return;
+    if (profile_levels[highlighted_index_].find(',') == std::string::npos) return;
+    size_t insert_pos = highlighted_index_;
+    std::string new_entry = "0,128,128,128";
+    profile_levels.insert(profile_levels.begin() + insert_pos, new_entry);
+    refresh_menu_view();
+    on_edit_color();
+}
+
+void WaterfallDesignerView::on_remove_level() {
+    if (highlighted_index_ >= profile_levels.size()) return;
+    if (profile_levels[highlighted_index_].empty()) return;
+    if (profile_levels[highlighted_index_][0] == '#') return;
+    if (profile_levels[highlighted_index_].find(',') == std::string::npos) return;
+    profile_levels.erase(profile_levels.begin() + highlighted_index_);
+    refresh_menu_view();
+}
+
+void WaterfallDesignerView::on_edit_color() {
+    if (highlighted_index_ >= profile_levels.size()) return;
+    if (profile_levels[highlighted_index_].empty()) return;
+    if (profile_levels[highlighted_index_][0] == '#') return;
+    if (profile_levels[highlighted_index_].find(',') == std::string::npos) return;
+
+    auto color_picker_view = nav_.push<WaterfallDesignerColorPickerView>(profile_levels[highlighted_index_]);
+    color_picker_view->on_save = [this](std::string new_color) {
+        profile_levels[highlighted_index_] = new_color;
+        refresh_menu_view();
+        on_apply_current_to_wtf();
+    };
+}
+
+void WaterfallDesignerView::backup_current_profile() {
+    std::filesystem::path curren_wtf_path = "waterfall.txt";
+    std::filesystem::path backup_path = waterfalls_dir / "wtf_des_bk.bk";
+    copy_file(curren_wtf_path, backup_path);
+}
+
+void WaterfallDesignerView::restore_current_profile() {
+    std::filesystem::path backup_path = waterfalls_dir / "wtf_des_bk.bk";
+    std::filesystem::path put_back_path = "waterfall.txt";
+    copy_file(backup_path, put_back_path);
+    delete_file(backup_path);
+}
+
+void WaterfallDesignerView::on_apply_setting() {
+}
+
+void WaterfallDesignerView::on_create_new_profile() {
+    text_prompt(
+        nav_,
+        file_name_buffer,
+        32 - 4,  // fat32
+        ENTER_KEYBOARD_MODE_ALPHA,
+        [this](std::string& buffer) {
+            if (buffer.empty()) return;
+
+            if (buffer.length() < 4 || buffer.substr(buffer.length() - 4) != ".txt") {
+                buffer += ".txt";
+            }
+
+            File new_file;
+            auto error = new_file.create(waterfalls_dir / buffer);
+            if (error) {
+                nav_.display_modal("Err", "create file err");
+                return;
+            }
+
+            profile_levels.clear();
+            current_profile_path = waterfalls_dir / buffer;
+            on_profile_changed(current_profile_path);
+        });
+}
+
+WaterfallDesignerColorPickerView::WaterfallDesignerColorPickerView(NavigationView& nav, std::string color_str)
+    : nav_{nav},
+      color_str_{color_str} {
+    add_children({&labels,
+                  &field_red,
+                  &field_green,
+                  &field_blue,
+                  &field_step,
+                  &field_index,
+                  &progressbar,
+                  &button_save});
+
+    progressbar.set_max(UINT8_MAX);
+
+    size_t pos = 0;
+    size_t next_pos = 0;
+
+    // index
+    next_pos = color_str.find(',', pos);
+    if (next_pos != std::string::npos) {
+        index_ = static_cast<uint8_t>(std::stoi(color_str.substr(pos, next_pos - pos)));
+        pos = next_pos + 1;
+    }
+
+    // r
+    next_pos = color_str.find(',', pos);
+    if (next_pos != std::string::npos) {
+        red_ = static_cast<uint8_t>(std::stoi(color_str.substr(pos, next_pos - pos)));
+        pos = next_pos + 1;
+    }
+
+    // g
+    next_pos = color_str.find(',', pos);
+    if (next_pos != std::string::npos) {
+        green_ = static_cast<uint8_t>(std::stoi(color_str.substr(pos, next_pos - pos)));
+        pos = next_pos + 1;
+    }
+
+    // b
+    blue_ = static_cast<uint8_t>(std::stoi(color_str.substr(pos)));
+
+    field_red.set_value(red_);
+    field_green.set_value(green_);
+    field_blue.set_value(blue_);
+    field_index.set_value(index_);
+
+    // cb
+    field_red.on_change = [this](int32_t) {
+        update_color_index();
+    };
+
+    field_green.on_change = [this](int32_t) {
+        update_color_index();
+    };
+
+    field_blue.on_change = [this](int32_t) {
+        update_color_index();
+    };
+
+    button_save.on_select = [this](Button&) {
+        if (on_save) on_save(build_color_str());
+        nav_.pop();
+    };
+
+    field_index.on_change = [this](int32_t) {
+        update_color_index();
+    };
+
+    field_step.on_change = [this](int32_t) {
+        field_red.set_step(field_step.value());
+        field_green.set_step(field_step.value());
+        field_blue.set_step(field_step.value());
+        field_index.set_step(field_step.value());
+    };
+
+    update_color_index();
+}
+
+void WaterfallDesignerColorPickerView::focus() {
+    button_save.focus();
+}
+
+void WaterfallDesignerColorPickerView::update_color_index() {
+    index_ = static_cast<uint8_t>(field_index.value());
+    red_ = static_cast<uint8_t>(field_red.value());
+    green_ = static_cast<uint8_t>(field_green.value());
+    blue_ = static_cast<uint8_t>(field_blue.value());
+
+    const Rect preview_rect{screen_width - 48, 1 * 16, 40, 40};
+
+    Painter painter_instance_2;
+    painter_instance_2.fill_rectangle(
+        {preview_rect.left(), preview_rect.top(), preview_rect.width(), preview_rect.height()},
+        ui::Color(red_, green_, blue_));
+}
+
+void WaterfallDesignerColorPickerView::paint(Painter& painter) {
+    // this is not duplicated code.
+    // because need to display color when enter,
+    // but it is too early to call update_color() in the constructor.
+
+    const Rect preview_rect{screen_width - 48, 1 * 16, 40, 40};
+
+    painter.fill_rectangle(
+        {preview_rect.left(), preview_rect.top(), preview_rect.width(), preview_rect.height()},
+        ui::Color(red_, green_, blue_));
+}
+
+std::string WaterfallDesignerColorPickerView::build_color_str() {
+    size_t index_pos = color_str_.find(',');
+    if (index_pos != std::string::npos) {
+        return color_str_.substr(0, index_pos + 1) +
+               to_string_dec_uint(red_) + "," +
+               to_string_dec_uint(green_) + "," +
+               to_string_dec_uint(blue_);
+    }
+    return to_string_dec_uint(index_) + "," + to_string_dec_uint(red_) + "," + to_string_dec_uint(green_) + "," + to_string_dec_uint(blue_);
+}
+
+} /* namespace ui::external_app::waterfall_designer */
@@ -0,0 +1,265 @@
+/*
+ * Copyleft Mr. Robot
+ * Copyright 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 __WATERFALL_DESIGNER_APP_HPP__
+#define __WATERFALL_DESIGNER_APP_HPP__
+
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "ui_spectrum.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "file_path.hpp"
+
+namespace ui::external_app::waterfall_designer {
+
+enum class ColorComponent {
+    RED,
+    GREEN,
+    BLUE
+};
+
+class WaterfallDesignerColorPickerView : public View {
+   public:
+    std::function<void(std::string)> on_save{};
+
+    WaterfallDesignerColorPickerView(NavigationView& nav, std::string color_str);
+
+    std::string title() const override { return "Color Picker"; };
+    void focus() override;
+    void paint(Painter& painter) override;
+
+   private:
+    NavigationView& nav_;
+    std::string color_str_;
+    uint8_t index_{0};
+    uint8_t red_{0};
+    uint8_t green_{0};
+    uint8_t blue_{0};
+
+    void update_color_index();
+    std::string build_color_str();
+
+    Labels labels{
+        {{0 * 8, 0 * 16}, "Index", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 2 * 16}, "Red", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 4 * 16}, "Green", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 6 * 16}, "Blue", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 8 * 16}, "Step", Theme::getInstance()->fg_light->foreground}};
+
+    NumberField field_index{
+        {0 * 8, 1 * 16},
+        3,
+        {0, 255},
+        1,
+        ' '};
+
+    NumberField field_red{
+        {0 * 8, 3 * 16},
+        3,
+        {0, 255},
+        1,
+        ' '};
+
+    NumberField field_green{
+        {0 * 8, 5 * 16},
+        3,
+        {0, 255},
+        1,
+        ' '};
+
+    NumberField field_blue{
+        {0 * 8, 7 * 16},
+        3,
+        {0, 255},
+        1,
+        ' '};
+
+    NumberField field_step{
+        {0 * 8, 9 * 16},
+        3,
+        {0, 255},
+        1,
+        ' '};
+
+    ProgressBar progressbar{
+        {0 * 8,
+         screen_height - 4 * 16 - 2 * 16 - 1 * 16,
+         screen_width,
+         2 * 16}};
+
+    Button button_save{
+        {0, screen_height - 4 * 16, screen_width, 4 * 16},
+        "Save"};
+};
+
+class WaterfallDesignerView : public View {
+   public:
+    WaterfallDesignerView(NavigationView& nav);
+    WaterfallDesignerView(NavigationView& nav, ReceiverModel::settings_t override);
+    ~WaterfallDesignerView();
+
+    void focus() override;
+    void set_parent_rect(const Rect new_parent_rect) override;
+
+    std::string title() const override { return "Wtf Design"; };
+
+   private:
+    uint32_t capture_rate{500000};
+    uint32_t file_format{0};
+    uint32_t highlighted_index_{0};
+    bool trim{false};
+    std::filesystem::path current_profile_path = "";
+    NavigationView& nav_;
+    RxRadioState radio_state_{ReceiverModel::Mode::Capture};
+    app_settings::SettingsManager settings_{
+        "rx_wtf_designer",
+        app_settings::Mode::RX,
+        {
+            {"capture_rate"sv, &capture_rate},
+            {"file_format"sv, &file_format},
+            {"trim"sv, &trim},
+        }};
+
+    Labels labels{
+        {{0 * 8, 1 * 16}, "Rate:", Theme::getInstance()->fg_light->foreground},
+        {{11 * 8, 1 * 16}, "Format:", Theme::getInstance()->fg_light->foreground},
+    };
+
+    RxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+
+    FrequencyStepView field_frequency_step{
+        {10 * 8, 0 * 16}};
+
+    RFAmpField field_rf_amp{
+        {16 * 8, 0 * 16}};
+
+    LNAGainField field_lna{
+        {18 * 8, 0 * 16}};
+
+    VGAGainField field_vga{
+        {21 * 8, 0 * 16}};
+
+    OptionsField option_bandwidth{
+        {24 * 8, 0 * 16},
+        5,
+        {}};
+
+    MenuView menu_view{};
+
+    NewButton button_new{
+        {0 * 8, 8 * 16, 4 * 8, 32},
+        {},
+        &bitmap_icon_file,
+        Theme::getInstance()->fg_blue->foreground};
+
+    NewButton button_open{
+        {4 * 8, 8 * 16, 4 * 8, 32},
+        {},
+        &bitmap_icon_load,
+        Theme::getInstance()->fg_blue->foreground};
+
+    NewButton button_save{
+        {8 * 8, 8 * 16, 4 * 8, 32},
+        {},
+        &bitmap_icon_save,
+        Theme::getInstance()->fg_blue->foreground};
+
+    NewButton button_add_level{
+        {12 * 8, 8 * 16, 4 * 8, 32},
+        {},
+        &bitmap_icon_add,
+        Theme::getInstance()->fg_blue->foreground};
+
+    NewButton button_remove_level{
+        {16 * 8, 8 * 16, 4 * 8, 32},
+        {},
+        &bitmap_icon_delete,
+        Theme::getInstance()->fg_blue->foreground};
+
+    NewButton button_edit_color{
+        {20 * 8, 8 * 16, 4 * 8, 32},
+        {},
+        &bitmap_icon_notepad,
+        Theme::getInstance()->fg_blue->foreground};
+
+    NewButton button_apply_setting{
+        {24 * 8, 8 * 16, 4 * 8, 32},
+        {},
+        &bitmap_icon_replay,
+        Theme::getInstance()->fg_blue->foreground};
+
+    void backup_current_profile();
+    void restore_current_profile();
+    void on_create_new_profile();
+    void on_open_profile();
+    void on_profile_changed(std::filesystem::path new_profile_path);
+    void on_save_profile();
+    void on_add_level();
+    void on_remove_level();
+    void on_edit_color();
+
+    void refresh_menu_view();
+
+    void on_apply_current_to_wtf();  // will restore if didn't apple, when distruct
+    void on_apply_setting();         // apply set
+
+    bool if_apply_setting{false};
+    /*NB:
+    this works as:
+    each time you change color, it apply as file realtime
+    however if you don't push the apply (play) btn, it would resotore in distructor,
+    if you push apply, it would apply and exit*/
+
+    std::vector<std::string> profile_levels{};
+
+    static constexpr ui::Dim header_height = 10 * 16;
+
+    RecordView record_view{// we still need it cuz it make waterfall correct
+                           {screen_width, screen_height, 30 * 8, 1 * 16},
+                           u"BBD_????.*",
+                           captures_dir,
+                           RecordView::FileType::RawS16,
+                           16384,
+                           3};
+
+    spectrum::WaterfallView waterfall{};
+    std::string file_name_buffer{};  // needed by text_prompy
+
+    MessageHandlerRegistration message_handler_freqchg{
+        Message::ID::FreqChangeCommand,
+        [this](Message* const p) {
+            const auto message = static_cast<const FreqChangeCommandMessage*>(p);
+            this->on_freqchg(message->freq);
+        }};
+
+    void on_freqchg(int64_t freq);
+};
+
+} /* namespace ui::external_app::waterfall_designer */
+
+#endif /*__WATERFALL_DESIGNER_APP_HPP__*/
@@ -53,3 +53,6 @@ const std::filesystem::path hopper_dir = u"HOPPER";
 const std::filesystem::path subghz_dir = u"SUBGHZ";
 const std::filesystem::path waterfalls_dir = u"WATERFALLS";
 const std::filesystem::path macaddress_dir = u"MACADDRESS";
+const std::filesystem::path splash_dot_bmp = u"/splash.bmp";
+const std::filesystem::path keeloq_keys_dir = u"KEELOQKEYS";
+const std::filesystem::path keeloq_remotes_dir = u"KEELOQREMOTES";
@@ -55,5 +55,9 @@ extern const std::filesystem::path hopper_dir;
 extern const std::filesystem::path subghz_dir;
 extern const std::filesystem::path waterfalls_dir;
 extern const std::filesystem::path macaddress_dir;
+extern const std::filesystem::path keeloq_keys_dir;
+extern const std::filesystem::path keeloq_remotes_dir;
+
+extern const std::filesystem::path splash_dot_bmp;

 #endif /* __FILE_PATH_H__ */
@@ -122,7 +122,7 @@ options_t freqman_steps = {
    {"1kHz        ", 1000},
    {"5kHz (SA AM)", 5000},
    {"6.25kHz(NFM)", 6250},
-    {"8.33kHz(AIR)", 8330},
+    {"8.33kHz(AIR)", 8333},
    {"9kHz (EU AM)", 9000},
    {"10kHz(US AM)", 10000},
    {"12.5kHz(NFM)", 12500},
@@ -144,7 +144,7 @@ options_t freqman_steps_short = {
    {"1kHz", 1000},
    {"5kHz", 5000},
    {"6.25kHz", 6250},
-    {"8.33kHz", 8330},
+    {"8.33kHz", 8333},
    {"9kHz", 9000},
    {"10kHz", 10000},
    {"12.5kHz", 12500},
@@ -0,0 +1,56 @@
+#include "gpio_lpc.h"
+
+typedef enum {
+    LED1 = 0,
+    LED2 = 1,
+    LED3 = 2,
+    LED4 = 3,
+} led_t;
+
+/* GPIO Output PinMux */
+static struct gpio_t gpio_led[] = {
+    GPIO(2, 1),
+    GPIO(2, 2),
+    GPIO(2, 8),
+#ifdef RAD1O
+    GPIO(5, 26),
+#endif
+};
+
+void delay(uint32_t duration) {
+    while (duration--) {
+        /* cannot be optimized out */
+        __asm__ volatile("nop");
+    }
+}
+
+void delay_us_at_mhz(uint32_t us, uint32_t mhz) {
+    /* overflow-safe multiply */
+    uint64_t cycles64 = (uint64_t)us * (uint64_t)mhz;
+    if (cycles64 > UINT32_MAX) {
+        cycles64 = UINT32_MAX;
+    }
+    delay((uint32_t)cycles64);
+}
+
+void led_on(const led_t led) {
+    gpio_set(&gpio_led[led]);
+}
+
+void led_off(const led_t led) {
+    gpio_clear(&gpio_led[led]);
+}
+
+void halt_and_flash(const uint32_t duration) {
+    /* blink LED1, LED2, and LED3 */
+    while (1) {
+        led_on(LED1);
+        led_on(LED2);
+        led_on(LED3);
+        delay(duration);
+        led_off(LED1);
+        led_off(LED2);
+        led_off(LED3);
+        delay(duration);
+    }
+}
@@ -37,6 +37,14 @@ void Debounce::enable_repeat() {
    repeat_enabled_ = true;
 }

+void Debounce::set_enable_repeat(bool enabled) {
+    repeat_enabled_ = enabled;
+}
+
+bool Debounce::get_repeat_enabled() {
+    return repeat_enabled_;
+}
+
 bool Debounce::get_long_press_enabled() const {
    return long_press_enabled_;
 }
@@ -43,6 +43,8 @@ class Debounce {
    bool feed(const uint8_t bit);
    uint8_t state();
    void enable_repeat();
+    void set_enable_repeat(bool enabled);
+    bool get_repeat_enabled();
    bool get_long_press_enabled() const;
    void set_long_press_enabled(bool v);
    bool long_press_occurred();
@@ -0,0 +1,441 @@
+/*
+ * Copyright (C) 2025 Great Scott Gadgets
+ *
+ * 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.
+ */
+
+/*
+ * MAX2831 driver ported from GSG HackRF reference implementation (max2831.c).
+ * Adapted to work with Mayhem's MAX283x abstraction layer.
+ */
+
+#ifdef PRALINE
+
+#include "max2831.hpp"
+
+#include "hackrf_hal.hpp"
+#include "hackrf_gpio.hpp"
+using namespace hackrf::one;
+
+#include "ch.h"
+#include "hal.h"
+
+#include <algorithm>
+#include <cstring>
+
+namespace max2831 {
+
+using namespace max283x;
+
+/*
+ * MAX2831 uses 9-bit SPI transfers.
+ * An 18-bit word is sent as two 9-bit transfers:
+ *   Word format: [VALUE:14][REG:4]
+ *   First transfer: bits 17:9 (high 9 bits)
+ *   Second transfer: bits 8:0 (low 9 bits)
+ *
+ * This matches the GSG reference implementation exactly.
+ */
+void MAX2831::write_reg(const uint8_t reg, const uint16_t value) {
+    uint32_t word = (((uint32_t)value & 0x3fff) << 4) | (reg & 0xf);
+    uint16_t values[2] = {
+        static_cast<uint16_t>(word >> 9),
+        static_cast<uint16_t>(word & 0x1ff)};
+    _target.transfer(values, 2);
+}
+
+void MAX2831::set_reg_field(const uint8_t reg, const uint16_t mask, const uint16_t value) {
+    _regs[reg] = (_regs[reg] & ~mask) | (value & mask);
+    mark_dirty(reg);
+}
+
+uint16_t MAX2831::get_reg_field(const uint8_t reg, const uint16_t mask, const uint8_t shift) {
+    return (_regs[reg] & mask) >> shift;
+}
+
+void MAX2831::mark_dirty(const uint8_t reg) {
+    _regs_dirty |= (1 << reg);
+}
+
+void MAX2831::mark_clean(const uint8_t reg) {
+    _regs_dirty &= ~(1 << reg);
+}
+
+void MAX2831::flush_reg(const uint8_t reg) {
+    write_reg(reg, _regs[reg]);
+    mark_clean(reg);
+}
+
+void MAX2831::flush_dirty() {
+    for (size_t r = 0; r < reg_count; r++) {
+        if ((_regs_dirty >> r) & 0x1) {
+            flush_reg(r);
+        }
+    }
+}
+
+void MAX2831::init() {
+    set_mode(Mode::Shutdown);
+
+    /* Configure GPIO pins for MAX2831 control */
+    gpio_max283x_enable.output();
+    gpio_max2831_rx_enable.output();
+    gpio_max2831_rxhp.output();
+    gpio_max2831_rxhp.write(0); /* RXHP low = 100 Hz HPF (default) */
+
+    /* Reset to default register values */
+    std::memcpy(_regs.data(), default_regs.data(), sizeof(_regs));
+    _regs_dirty = 0xFFFF;
+
+    /* Write default register values to chip */
+    flush_dirty();
+
+    /* Use SPI control instead of B1-B7 pins for gain settings.
+     * This matches the GSG reference: max2831_setup() */
+    set_reg_field(8, REG8_RXVGA_GAIN_SPI_EN, REG8_RXVGA_GAIN_SPI_EN);
+    set_reg_field(9, REG9_TXVGA_GAIN_SPI_EN, REG9_TXVGA_GAIN_SPI_EN);
+
+    /* Set initial gains - matches GSG reference */
+    set_reg_field(12, REG12_TXVGA_GAIN_MASK, 0x00); /* Minimum TX gain */
+    set_reg_field(7, REG7_RX_HPF_SEL_MASK, REG7_RX_HPF_30KHZ);
+    set_reg_field(11, REG11_LNA_GAIN_MASK, REG11_LNA_GAIN_MAX);
+    set_reg_field(11, REG11_RXVGA_GAIN_MASK, 0x18);  // Moderate RX VGA gain
+
+    /* FORCE MAXIMUM GAIN FOR TESTING */
+    // set_reg_field(11, REG11_RXVGA_GAIN_MASK, 0x1F);  // 62 dB VGA = MAX
+
+    /* Configure baseband filter for 8 MHz TX - matches GSG reference */
+    set_reg_field(8, REG8_LPF_COARSE_MASK, REG8_RX_LPF_7_5M);
+    set_reg_field(7, REG7_RX_LPF_FINE_MASK, REG7_RX_LPF_FINE_100);
+    set_reg_field(7, REG7_TX_LPF_FINE_MASK, REG7_TX_LPF_FINE_100);
+
+    /* Disable clock output */
+    set_reg_field(14, REG14_CLKOUT_PIN_EN, 0);
+
+    /* Write all modified registers */
+    flush_dirty();
+
+    set_mode(Mode::Standby);
+}
+
+void MAX2831::set_mode(const Mode mode) {
+    _mode = mode;
+
+    /*
+     * MAX2831 mode control via ENABLE and RXTX pins.
+     * From GSG hackrf max2831_target.c:
+     *
+     *   Shutdown: ENABLE=0, RXTX=0
+     *   Standby:  ENABLE=0, RXTX=1  (PLL/VCO/LO on, ready for quick TX/RX)
+     *   RX:       ENABLE=1, RXTX=0
+     *   TX:       ENABLE=1, RXTX=1
+     *
+     * Note: gpio_max2831_rx_enable is the RXTX mode select pin.
+     * RXTX=0 selects RX, RXTX=1 selects TX.
+     */
+
+    /* Handle calibration mode bits if needed */
+    bool tx_cal = (mode == Mode::Tx_Calibration);
+    bool rx_cal = (mode == Mode::Rx_Calibration);
+
+    uint16_t current_tx_cal = get_reg_field(6, REG6_TX_CAL_MODE_EN, REG6_TX_CAL_MODE_EN_SHIFT);
+    uint16_t current_rx_cal = get_reg_field(6, REG6_RX_CAL_MODE_EN, REG6_RX_CAL_MODE_EN_SHIFT);
+
+    if (current_tx_cal != (tx_cal ? 1 : 0)) {
+        set_reg_field(6, REG6_TX_CAL_MODE_EN, tx_cal ? REG6_TX_CAL_MODE_EN : 0);
+        flush_dirty();
+    }
+    if (current_rx_cal != (rx_cal ? 1 : 0)) {
+        set_reg_field(6, REG6_RX_CAL_MODE_EN, rx_cal ? REG6_RX_CAL_MODE_EN : 0);
+        flush_dirty();
+    }
+
+    switch (mode) {
+        default:
+        case Mode::Shutdown:
+            gpio_max2831_rx_enable.write(0); /* RXTX=0 */
+            gpio_max283x_enable.write(0);    /* ENABLE=0 */
+            break;
+        case Mode::Standby:
+            gpio_max2831_rx_enable.write(1); /* RXTX=1 */
+            gpio_max283x_enable.write(0);    /* ENABLE=0 */
+            break;
+        case Mode::Transmit:
+        case Mode::Tx_Calibration:
+            gpio_max2831_rx_enable.write(1); /* RXTX=1 for TX */
+            gpio_max283x_enable.write(1);    /* ENABLE=1 */
+            break;
+        case Mode::Receive:
+        case Mode::Rx_Calibration:
+            gpio_max2831_rx_enable.write(0); /* RXTX=0 for RX */
+            gpio_max283x_enable.write(1);    /* ENABLE=1 */
+            break;
+    }
+
+    /* Update LPF bandwidth for current mode */
+    if (_desired_lpf_bw > 0) {
+        set_lpf_bandwidth_internal(_desired_lpf_bw);
+    }
+}
+
+void MAX2831::set_tx_vga_gain(const int_fast8_t db) {
+    /* TX VGA gain: 0-31 dB in ~1 dB steps
+     * Register value: gain * 2 | 1, max 0x3F
+     * This matches GSG reference: max2831_set_txvga_gain() */
+    int_fast8_t db_clipped = std::max(0, std::min(31, (int)db));
+    uint16_t value = std::min((db_clipped << 1) | 1, 0x3f);
+    set_reg_field(12, REG12_TXVGA_GAIN_MASK, value);
+    flush_reg(12);
+}
+
+void MAX2831::set_lna_gain(const int_fast8_t db) {
+    /*
+     * LNA gain has 3 settings (from GSG reference):
+     *   MAX (33 dB), -16 dB from max (17 dB), -33 dB from max (0 dB)
+     * Map from MAX2837 8 dB steps for compatibility
+     */
+    uint16_t gain_val;
+    if (db >= 32) {
+        gain_val = REG11_LNA_GAIN_MAX;
+    } else if (db >= 16) {
+        gain_val = REG11_LNA_GAIN_M16;
+    } else {
+        gain_val = REG11_LNA_GAIN_M33;
+    }
+    set_reg_field(11, REG11_LNA_GAIN_MASK, gain_val);
+    flush_reg(11);
+}
+
+void MAX2831::set_vga_gain(const int_fast8_t db) {
+    /* VGA gain: 0-62 dB in 2 dB steps
+     * This matches GSG reference: max2831_set_vga_gain() */
+    if ((db & 0x1) || db > 62) {
+        return; /* Invalid: must be even and <= 62 */
+    }
+    int_fast8_t db_clipped = std::max(0, std::min(62, (int)db));
+    uint16_t value = (db_clipped >> 1) & 0x1f;
+    set_reg_field(11, REG11_RXVGA_GAIN_MASK, value);
+    flush_reg(11);
+}
+
+/*
+ * LPF bandwidth tables from GSG reference max2831.c
+ */
+struct lpf_ft_t {
+    uint32_t bandwidth_hz;
+    uint8_t ft;
+};
+
+struct lpf_ft_fine_t {
+    uint8_t percent;
+    uint8_t ft_fine;
+};
+
+/* Measured -0.5 dB complex baseband bandwidth for each register setting */
+static constexpr lpf_ft_t rx_lpf_ft[] = {
+    {11600000, REG8_RX_LPF_7_5M},
+    {15100000, REG8_RX_LPF_8_5M},
+    {22600000, REG8_RX_LPF_15M},
+    {28300000, REG8_RX_LPF_18M},
+    {0, 0},
+};
+
+static constexpr lpf_ft_fine_t rx_lpf_ft_fine[] = {
+    {90, REG7_RX_LPF_FINE_90},
+    {95, REG7_RX_LPF_FINE_95},
+    {100, REG7_RX_LPF_FINE_100},
+    {105, REG7_RX_LPF_FINE_105},
+    {110, REG7_RX_LPF_FINE_110},
+    {0, 0},
+};
+
+static constexpr lpf_ft_t tx_lpf_ft[] = {
+    {11900000, REG8_TX_LPF_8M},
+    {15800000, REG8_TX_LPF_11M},
+    {23600000, REG8_TX_LPF_16_5M},
+    {31300000, REG8_TX_LPF_22_5M},
+    {0, 0},
+};
+
+static constexpr lpf_ft_fine_t tx_lpf_ft_fine[] = {
+    {90, REG7_TX_LPF_FINE_90},
+    {95, REG7_TX_LPF_FINE_95},
+    {100, REG7_TX_LPF_FINE_100},
+    {105, REG7_TX_LPF_FINE_105},
+    {110, REG7_TX_LPF_FINE_110},
+    {115, REG7_TX_LPF_FINE_115},
+    {0, 0},
+};
+
+uint32_t MAX2831::set_lpf_bandwidth_internal(const uint32_t bandwidth_hz) {
+    const lpf_ft_t* coarse;
+    const lpf_ft_fine_t* fine;
+
+    if (_mode == Mode::Receive || _mode == Mode::Rx_Calibration) {
+        coarse = rx_lpf_ft;
+        fine = rx_lpf_ft_fine;
+    } else {
+        coarse = tx_lpf_ft;
+        fine = tx_lpf_ft_fine;
+    }
+
+    /* Find coarse and fine settings for LPF - matches GSG reference */
+    bool found = false;
+    const lpf_ft_fine_t* f = fine;
+    for (; coarse->bandwidth_hz != 0; coarse++) {
+        uint32_t coarse_aux = coarse->bandwidth_hz / 100;
+        for (f = fine; f->percent != 0; f++) {
+            if ((coarse_aux * f->percent) >= bandwidth_hz) {
+                found = true;
+                break;
+            }
+        }
+        if (found) break;
+    }
+
+    /* Use the widest setting if a wider bandwidth than our maximum is requested */
+    if (!found) {
+        coarse--;
+        f--;
+    }
+
+    /* Program found settings */
+    set_reg_field(8, REG8_LPF_COARSE_MASK, coarse->ft);
+    if (_mode == Mode::Receive || _mode == Mode::Rx_Calibration) {
+        set_reg_field(7, REG7_RX_LPF_FINE_MASK, f->ft_fine);
+    } else {
+        /* TX fine values are already shifted in the constants (REG7_TX_LPF_FINE_*) */
+        set_reg_field(7, REG7_TX_LPF_FINE_MASK, f->ft_fine);
+    }
+    flush_dirty();
+
+    return coarse->bandwidth_hz * f->percent / 100;
+}
+
+void MAX2831::set_lpf_rf_bandwidth_rx(const uint32_t bandwidth_minimum) {
+    _desired_lpf_bw = bandwidth_minimum;
+    if (_mode == Mode::Receive || _mode == Mode::Rx_Calibration) {
+        set_lpf_bandwidth_internal(bandwidth_minimum);
+    }
+}
+
+void MAX2831::set_lpf_rf_bandwidth_tx(const uint32_t bandwidth_minimum) {
+    _desired_lpf_bw = bandwidth_minimum;
+    if (_mode == Mode::Transmit || _mode == Mode::Tx_Calibration) {
+        set_lpf_bandwidth_internal(bandwidth_minimum);
+    }
+}
+
+bool MAX2831::set_frequency(const rf::Frequency lo_frequency) {
+    /*
+     * MAX2831 frequency synthesis from GSG reference max2831_set_frequency():
+     *   F_LO = F_REF * (N + F/2^20) / R
+     * Where:
+     *   F_REF = 40 MHz reference
+     *   R = reference divider (1 or 2), we use R=2
+     *   N = integer divider (8 bits)
+     *   F = fractional divider (20 bits)
+     *
+     * Using R=2: F_LO = 40M * (N + F/2^20) / 2 = 20M * (N + F/2^20)
+     */
+
+    /* MAX2831 supports 2.3-2.6 GHz */
+    if (lo_frequency < 2300000000ULL || lo_frequency > 2600000000ULL) {
+        return false;
+    }
+
+    /* From GSG reference: ASSUME 40MHz PLL. Ratio = F*R/40,000,000.
+     * TODO: fixed to R=2. Check if it's worth exploring R=1. */
+    uint32_t freq = lo_frequency;
+    freq += (20000000 >> 21); /* Round to nearest frequency */
+    uint32_t div_int = freq / 20000000;
+    uint32_t div_rem = freq % 20000000;
+    uint32_t div_frac = 0;
+    uint32_t div_cmp = 20000000;
+
+    for (int i = 0; i < 20; i++) {
+        div_frac <<= 1;
+        div_rem <<= 1;
+        if (div_rem >= div_cmp) {
+            div_frac |= 0x1;
+            div_rem -= div_cmp;
+        }
+    }
+
+    /* Write order matters - matches GSG reference */
+    /* REG 3: SYN_INT (bits 7:0) and SYN_FRAC_LO (bits 13:8) */
+    uint16_t reg3_val = (div_int & 0xFF) | ((div_frac & 0x3F) << 8);
+    _regs[3] = reg3_val;
+    mark_dirty(3);
+
+    /* REG 4: SYN_FRAC_HI (bits 13:0) - upper 14 bits of 20-bit fractional */
+    uint16_t reg4_val = (div_frac >> 6) & 0x3FFF;
+    _regs[4] = reg4_val;
+    mark_dirty(4);
+
+    flush_dirty();
+
+    return true;
+}
+
+void MAX2831::set_rx_LO_iq_phase_calibration(const size_t v) {
+    /* MAX2831 doesn't have the same IQ calibration as MAX2837 */
+    (void)v;
+}
+
+void MAX2831::set_tx_LO_iq_phase_calibration(const size_t v) {
+    /* MAX2831 doesn't have the same IQ calibration as MAX2837 */
+    (void)v;
+}
+
+void MAX2831::set_rx_buff_vcm(const size_t v) {
+    /* MAX2831 RX IQ common mode voltage is in register 15
+     * Values: 0=1.1V, 1=1.2V, 2=1.3V, 3=1.45V */
+    uint16_t vcm = std::min(v, (size_t)3) << REG15_RXIQ_VCM_SHIFT;
+    set_reg_field(15, REG15_RXIQ_VCM_MASK, vcm);
+    flush_reg(15);
+}
+
+int8_t MAX2831::temp_sense() {
+    /* MAX2831 temperature sensor can be read via RSSI MUX.
+     * This would require:
+     * 1. Switch RSSI_MUX to temperature mode
+     * 2. Read the ADC
+     * 3. Switch back to RSSI mode
+     * For now, return a placeholder value. */
+    return 25; /* Room temperature placeholder */
+}
+
+reg_t MAX2831::read(const address_t reg_num) {
+    /* MAX2831 doesn't support SPI read, return cached value */
+    if (reg_num < reg_count) {
+        return _regs[reg_num];
+    }
+    return 0;
+}
+
+void MAX2831::write(const address_t reg_num, const reg_t value) {
+    if (reg_num < reg_count) {
+        _regs[reg_num] = value & 0x3FFF; /* 14-bit registers */
+        write_reg(reg_num, _regs[reg_num]);
+        mark_clean(reg_num);
+    }
+}
+
+}  // namespace max2831
+#endif
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2025 Great Scott Gadgets
+ *
+ * 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.
+ */
+
+/*
+ * MAX2831 driver ported from GSG HackRF reference implementation.
+ * Register definitions match max2831_regs.def from hackrf firmware.
+ */
+
+#ifndef __MAX2831_H__
+#define __MAX2831_H__
+
+#include "max283x.hpp"
+#include "gpio.hpp"
+#include "spi_arbiter.hpp"
+
+#include <cstdint>
+#include <array>
+
+namespace max2831 {
+
+using namespace max283x;
+
+/* MAX2831 has 16 registers, each containing 14 bits of data */
+constexpr size_t reg_count = 16;
+
+/* Default register values from GSG HackRF reference (max2831.c) */
+constexpr std::array<uint16_t, reg_count> default_regs = {
+    0x1740, /* 0: enable fractional mode (Table 16 recommends 0x0740, clearing unknown bit) */
+    0x119a, /* 1 */
+    0x1003, /* 2 */
+    0x0079, /* 3: PLL divider settings for 2437 MHz */
+    0x3666, /* 4: PLL divider settings for 2437 MHz */
+    0x00a4, /* 5: divide reference frequency by 2 */
+    0x0060, /* 6: enable TX power detector */
+    0x1022, /* 7: 110% TX LPF bandwidth */
+    0x2021, /* 8: pin control of RX gain, 11 MHz LPF bandwidth */
+    0x03b5, /* 9: pin control of TX gain */
+    0x1d80, /* 10: 3.5 us PA enable delay, zero PA bias */
+    0x0074, /* 11: LNA high gain, RX VGA moderate gain (Table 27 recommends 0x007f, maximum gain) */
+    0x0140, /* 12: TX VGA minimum */
+    0x0e92, /* 13 */
+    0x0100, /* 14: reference clock output disabled */
+    0x0145, /* 15: RX IQ common mode 1.1 V */
+};
+
+/*
+ * Register bit field definitions from max2831_regs.def
+ * Format: REG<num>_<field>_<info>
+ */
+
+/* REG 0: PLL Mode */
+constexpr uint16_t REG0_PLL_MODE_SHIFT = 10;
+constexpr uint16_t REG0_PLL_MODE_MASK = (1 << REG0_PLL_MODE_SHIFT);
+constexpr uint16_t REG0_PLL_MODE_INTEGER = 0;
+constexpr uint16_t REG0_PLL_MODE_FRACTIONAL = 1;
+
+/* REG 3: Synthesizer Integer and Fractional Low */
+constexpr uint16_t REG3_SYN_INT_SHIFT = 0;
+constexpr uint16_t REG3_SYN_INT_MASK = 0x00FF; /* D7:D0 - Integer divider (8 bits) */
+constexpr uint16_t REG3_SYN_FRAC_LO_SHIFT = 8;
+constexpr uint16_t REG3_SYN_FRAC_LO_MASK = 0x3F00; /* D13:D8 - Low 6 bits of fractional divider */
+
+/* REG 4: Synthesizer Fractional High */
+constexpr uint16_t REG4_SYN_FRAC_HI_MASK = 0x3FFF; /* D13:D0 - High 14 bits of fractional divider */
+
+/* REG 5: Reference Divider and Lock Detect */
+constexpr uint16_t REG5_SYN_REF_DIV_SHIFT = 2;
+constexpr uint16_t REG5_SYN_REF_DIV_1 = (0 << REG5_SYN_REF_DIV_SHIFT);
+constexpr uint16_t REG5_SYN_REF_DIV_2 = (1 << REG5_SYN_REF_DIV_SHIFT);
+
+/* REG 6: Calibration Mode */
+constexpr uint16_t REG6_RX_CAL_MODE_EN_SHIFT = 0;
+constexpr uint16_t REG6_RX_CAL_MODE_EN = (1 << REG6_RX_CAL_MODE_EN_SHIFT);
+constexpr uint16_t REG6_TX_CAL_MODE_EN_SHIFT = 1;
+constexpr uint16_t REG6_TX_CAL_MODE_EN = (1 << REG6_TX_CAL_MODE_EN_SHIFT);
+constexpr uint16_t REG6_TX_POWER_DETECT_EN_SHIFT = 6;
+constexpr uint16_t REG6_TX_POWER_DETECT_EN = (1 << REG6_TX_POWER_DETECT_EN_SHIFT);
+
+/* REG 7: LPF Fine Adjustment and RX HPF */
+constexpr uint16_t REG7_RX_LPF_FINE_SHIFT = 0;
+constexpr uint16_t REG7_RX_LPF_FINE_MASK = 0x0007; /* D2:D0 */
+constexpr uint16_t REG7_RX_LPF_FINE_90 = 0;
+constexpr uint16_t REG7_RX_LPF_FINE_95 = 1;
+constexpr uint16_t REG7_RX_LPF_FINE_100 = 2;
+constexpr uint16_t REG7_RX_LPF_FINE_105 = 3;
+constexpr uint16_t REG7_RX_LPF_FINE_110 = 4;
+
+constexpr uint16_t REG7_TX_LPF_FINE_SHIFT = 3;
+constexpr uint16_t REG7_TX_LPF_FINE_MASK = 0x0038; /* D5:D3 */
+constexpr uint16_t REG7_TX_LPF_FINE_90 = (0 << REG7_TX_LPF_FINE_SHIFT);
+constexpr uint16_t REG7_TX_LPF_FINE_95 = (1 << REG7_TX_LPF_FINE_SHIFT);
+constexpr uint16_t REG7_TX_LPF_FINE_100 = (2 << REG7_TX_LPF_FINE_SHIFT);
+constexpr uint16_t REG7_TX_LPF_FINE_105 = (3 << REG7_TX_LPF_FINE_SHIFT);
+constexpr uint16_t REG7_TX_LPF_FINE_110 = (4 << REG7_TX_LPF_FINE_SHIFT);
+constexpr uint16_t REG7_TX_LPF_FINE_115 = (5 << REG7_TX_LPF_FINE_SHIFT);
+
+constexpr uint16_t REG7_RX_HPF_SEL_SHIFT = 12;
+constexpr uint16_t REG7_RX_HPF_SEL_MASK = 0x3000; /* D13:D12 */
+constexpr uint16_t REG7_RX_HPF_100HZ = (0 << REG7_RX_HPF_SEL_SHIFT);
+constexpr uint16_t REG7_RX_HPF_4KHZ = (1 << REG7_RX_HPF_SEL_SHIFT);
+constexpr uint16_t REG7_RX_HPF_30KHZ = (2 << REG7_RX_HPF_SEL_SHIFT);
+
+/* REG 8: LPF Coarse, RSSI MUX, and RX VGA SPI Enable */
+constexpr uint16_t REG8_LPF_COARSE_SHIFT = 0;
+constexpr uint16_t REG8_LPF_COARSE_MASK = 0x0003; /* D1:D0 */
+/* RX and TX share the same coarse LPF setting bits */
+constexpr uint16_t REG8_RX_LPF_7_5M = 0;
+constexpr uint16_t REG8_RX_LPF_8_5M = 1;
+constexpr uint16_t REG8_RX_LPF_15M = 2;
+constexpr uint16_t REG8_RX_LPF_18M = 3;
+constexpr uint16_t REG8_TX_LPF_8M = 0;
+constexpr uint16_t REG8_TX_LPF_11M = 1;
+constexpr uint16_t REG8_TX_LPF_16_5M = 2;
+constexpr uint16_t REG8_TX_LPF_22_5M = 3;
+
+constexpr uint16_t REG8_RSSI_MUX_SHIFT = 8;
+constexpr uint16_t REG8_RSSI_MUX_MASK = 0x0300; /* D9:D8 */
+constexpr uint16_t REG8_RSSI_MUX_RSSI = (0 << REG8_RSSI_MUX_SHIFT);
+constexpr uint16_t REG8_RSSI_MUX_TEMP = (1 << REG8_RSSI_MUX_SHIFT);
+constexpr uint16_t REG8_RSSI_MUX_TX_POWER = (2 << REG8_RSSI_MUX_SHIFT);
+
+constexpr uint16_t REG8_RXVGA_GAIN_SPI_EN_SHIFT = 12;
+constexpr uint16_t REG8_RXVGA_GAIN_SPI_EN = (1 << REG8_RXVGA_GAIN_SPI_EN_SHIFT);
+
+/* REG 9: TX VGA SPI Enable */
+constexpr uint16_t REG9_TXVGA_GAIN_SPI_EN_SHIFT = 10;
+constexpr uint16_t REG9_TXVGA_GAIN_SPI_EN = (1 << REG9_TXVGA_GAIN_SPI_EN_SHIFT);
+
+/* REG 11: RX Gain */
+constexpr uint16_t REG11_RXVGA_GAIN_SHIFT = 0;
+constexpr uint16_t REG11_RXVGA_GAIN_MASK = 0x001F; /* D4:D0 - 5 bits */
+
+constexpr uint16_t REG11_LNA_GAIN_SHIFT = 5;
+constexpr uint16_t REG11_LNA_GAIN_MASK = 0x0060;                     /* D6:D5 - 2 bits */
+constexpr uint16_t REG11_LNA_GAIN_M33 = (0 << REG11_LNA_GAIN_SHIFT); /* -33 dB from max (min) */
+constexpr uint16_t REG11_LNA_GAIN_M16 = (2 << REG11_LNA_GAIN_SHIFT); /* -16 dB from max */
+constexpr uint16_t REG11_LNA_GAIN_MAX = (3 << REG11_LNA_GAIN_SHIFT); /* Maximum LNA gain */
+
+/* REG 12: TX VGA Gain */
+constexpr uint16_t REG12_TXVGA_GAIN_SHIFT = 0;
+constexpr uint16_t REG12_TXVGA_GAIN_MASK = 0x003F; /* D5:D0 - 6 bits */
+
+/* REG 14: Clock Output */
+constexpr uint16_t REG14_CLKOUT_PIN_EN_SHIFT = 9;
+constexpr uint16_t REG14_CLKOUT_PIN_EN = (1 << REG14_CLKOUT_PIN_EN_SHIFT);
+
+/* REG 15: RX IQ Common Mode */
+constexpr uint16_t REG15_RXIQ_VCM_SHIFT = 10;
+constexpr uint16_t REG15_RXIQ_VCM_MASK = 0x0C00;                      /* D11:D10 - 2 bits */
+constexpr uint16_t REG15_RXIQ_VCM_1_1 = (0 << REG15_RXIQ_VCM_SHIFT);  /* 1.1V */
+constexpr uint16_t REG15_RXIQ_VCM_1_2 = (1 << REG15_RXIQ_VCM_SHIFT);  /* 1.2V */
+constexpr uint16_t REG15_RXIQ_VCM_1_3 = (2 << REG15_RXIQ_VCM_SHIFT);  /* 1.3V */
+constexpr uint16_t REG15_RXIQ_VCM_1_45 = (3 << REG15_RXIQ_VCM_SHIFT); /* 1.45V */
+
+class MAX2831 : public MAX283x {
+   public:
+    constexpr MAX2831(
+        spi::arbiter::Target& target)
+        : _target(target) {
+    }
+
+    void init() override;
+    void set_mode(const Mode mode) override;
+
+    void set_tx_vga_gain(const int_fast8_t db) override;
+    void set_lna_gain(const int_fast8_t db) override;
+    void set_vga_gain(const int_fast8_t db) override;
+    void set_lpf_rf_bandwidth_rx(const uint32_t bandwidth_minimum) override;
+    void set_lpf_rf_bandwidth_tx(const uint32_t bandwidth_minimum) override;
+
+    bool set_frequency(const rf::Frequency lo_frequency) override;
+
+    void set_rx_LO_iq_phase_calibration(const size_t v) override;
+    void set_tx_LO_iq_phase_calibration(const size_t v) override;
+
+    void set_rx_buff_vcm(const size_t v) override;
+
+    int8_t temp_sense() override;
+
+    reg_t read(const address_t reg_num) override;
+    void write(const address_t reg_num, const reg_t value) override;
+
+   private:
+    spi::arbiter::Target& _target;
+    Mode _mode{Mode::Standby};
+    std::array<uint16_t, reg_count> _regs{default_regs};
+    uint16_t _regs_dirty{0xFFFF}; /* Track which registers need to be written */
+    uint32_t _desired_lpf_bw{0};  /* Desired LPF bandwidth in Hz */
+
+    void write_reg(const uint8_t reg, const uint16_t value);
+    void set_reg_field(const uint8_t reg, const uint16_t mask, const uint16_t value);
+    uint16_t get_reg_field(const uint8_t reg, const uint16_t mask, const uint8_t shift);
+    void mark_dirty(const uint8_t reg);
+    void mark_clean(const uint8_t reg);
+    void flush_reg(const uint8_t reg);
+    void flush_dirty();
+    uint32_t set_lpf_bandwidth_internal(const uint32_t bandwidth_hz);
+};
+
+}  // namespace max2831
+
+#endif /*__MAX2831_H__*/
@@ -31,6 +31,24 @@ using namespace hackrf::one;

 #include "hal.h"

+#ifdef PRALINE
+// Global debug tracking - visible to other files
+struct rffc507x_debug_t {
+    uint32_t requested_freq_mhz;
+    uint32_t calculated_vco_mhz;
+    uint32_t expected_n;
+    uint8_t expected_lodiv;
+    uint8_t expected_presc;
+    bool was_called;
+    uint32_t calc_lo_freq_mhz;     // Input to calculate()
+    uint32_t calc_vco_inside_mhz;  // VCO calculated inside calculate()
+    uint8_t calc_lodiv_log2;       // LO divider log2
+    uint8_t calc_presc_log2;       // Prescaler log2
+    uint64_t calc_n_q24;           // N in Q24 format before shift
+};
+rffc507x_debug_t rffc507x_debug_info = {0, 0, 0, 0, 0, false, 0, 0, 0, 0, 0};
+#endif
+
 namespace rffc507x {

 /* Empirical tests indicate no minimum reset pulse width, but the speed
@@ -96,9 +114,31 @@ constexpr size_t divider_min = 1U << divider_log2_min;
 constexpr size_t divider_max = 1U << divider_log2_max;

 constexpr size_t divider_log2(const rf::Frequency vco_frequency) {
+#ifdef PRALINE
+    // PRALINE FIX: Avoid N register overflow (9-bit max = 511)
+    // With 40 MHz reference:
+    // - For VCO=5400 MHz, presc=÷2: N = (5400×2)/40 = 270 ✓
+    // - For VCO=5400 MHz, presc=÷4: N = (5400×4)/40 = 540 ✗ OVERFLOW!
+    //
+    // Maximum safe VCO for ÷4 prescaler:
+    // N_max = 511, so VCO_max = (511 × 40) / 4 = 5110 MHz
+    //
+    // Use ÷4 only if VCO < 5110 MHz AND VCO > 3200 MHz
+    // Use ÷2 for VCO >= 5110 MHz to avoid overflow
+
+    constexpr rf::Frequency overflow_threshold = 5110000000ULL;  // Max VCO for ÷4
+    constexpr rf::Frequency min_presc4_freq = 3200000000ULL;     // Min VCO for ÷4
+
+    if ((vco_frequency > min_presc4_freq) && (vco_frequency < overflow_threshold)) {
+        return divider_log2_max;  // ÷4 prescaler
+    } else {
+        return divider_log2_min;  // ÷2 prescaler
+    }
+#else
    return (vco_frequency > (prescaler::divider_min * prescaler::max_frequency))
               ? prescaler::divider_log2_max
               : prescaler::divider_log2_min;
+#endif
 }

 } /* namespace prescaler */
@@ -121,9 +161,22 @@ struct SynthConfig {

        const size_t prescaler_divider_log2 = prescaler::divider_log2(vco_frequency);

+#ifndef PRALINE
        const uint64_t prescaled_lo_q24 = vco_frequency << (24 - prescaler_divider_log2);
+#else
+        const uint64_t prescaled_lo_q24 = vco_frequency << (24 + prescaler_divider_log2);
+#endif
        const uint64_t n_divider_q24 = prescaled_lo_q24 / reference_frequency;

+#ifdef PRALINE
+        // DEBUG: Track everything
+        rffc507x_debug_info.calc_lo_freq_mhz = lo_frequency / 1000000;
+        rffc507x_debug_info.calc_vco_inside_mhz = vco_frequency / 1000000;
+        rffc507x_debug_info.calc_lodiv_log2 = lo_divider_log2;
+        rffc507x_debug_info.calc_presc_log2 = prescaler_divider_log2;
+        rffc507x_debug_info.calc_n_q24 = n_divider_q24;
+#endif
+
        return {
            lo_divider_log2,
            prescaler_divider_log2,
@@ -233,6 +286,20 @@ void RFFC507x::set_mixer_current(const uint8_t value) {
 void RFFC507x::set_frequency(const rf::Frequency lo_frequency) {
    const SynthConfig synth_config = SynthConfig::calculate(lo_frequency);

+#ifdef PRALINE
+    // Calculate VCO frequency from LO frequency and divider
+    const size_t lo_divider = 1U << synth_config.lo_divider_log2;  // 2^lodiv_log2
+    const rf::Frequency vco_freq = lo_frequency * lo_divider;
+
+    // Track what we calculated
+    rffc507x_debug_info.requested_freq_mhz = lo_frequency / 1000000;
+    rffc507x_debug_info.calculated_vco_mhz = vco_freq / 1000000;
+    rffc507x_debug_info.expected_n = synth_config.n_divider_q24 >> 24;
+    rffc507x_debug_info.expected_lodiv = synth_config.lo_divider_log2;
+    rffc507x_debug_info.expected_presc = synth_config.prescaler_divider_log2;
+    rffc507x_debug_info.was_called = true;
+#endif
+
    /* Boost charge pump leakage if VCO frequency > 3.2GHz, indicated by
     * prescaler divider set to 4 (log2=2) instead of 2 (log2=1).
     */
@@ -57,7 +57,15 @@ void Si5351::reset() {
    write_register(Register::CrystalInternalLoadCapacitance, 0b11010010);
    write_register(Register::FanoutEnable, 0x00);

+#ifndef PRALINE
    reset_plls();
+#endif
+    // NOTE: Do NOT call reset_plls() here!
+    // Multisynth registers are not yet configured at this point.
+    // Resetting PLLs with power-on default multisynth values (divider=6)
+    // causes Si5351 to output wrong frequencies (66.666 MHz instead of 8 MHz).
+    // The PLL reset should happen in init_clock_generator() AFTER multisynths
+    // are properly configured. This matches HackRF reference firmware.
 }

 Si5351::regvalue_t Si5351::read_register(const uint8_t reg) {
@@ -93,7 +101,16 @@ void Si5351::set_ms_frequency(
        .r_div = r_div,
    };
    const auto regs = ms.reg(ms_number);
+
+#ifdef PRALINE
+    /* PRALINE: Use single-byte writes - multi-byte I2C writes seem to fail */
+    const uint8_t base_reg = regs[0];
+    for (size_t i = 1; i < regs.size(); i++) {
+        write_register(base_reg + i - 1, regs[i]);
+    }
+#else
    write(regs);
+#endif
 }

 } /* namespace si5351 */
@@ -361,7 +361,16 @@ class Si5351 {
    }

    void wait_for_device_ready() {
+#ifndef PRALINE
        while (device_status() & 0x80);
+#else
+        // Add timeout to prevent infinite loop if I2C communication fails
+        // (e.g., on PRALINE hardware with different configuration)
+        uint32_t timeout = 100000;
+        while ((device_status() & 0x80) && (timeout > 0)) {
+            timeout--;
+        }
+#endif
    }

    bool plla_loss_of_signal() {
@@ -377,10 +386,15 @@ class Si5351 {
    }

    void reset_plls() {
+#ifndef PRALINE
        // Datasheet recommends value 0xac, though the low nibble bits are not defined in AN619.
        write_register(Register::PLLReset, 0xac);
+#else
+        // Reset both PLLA and PLLB. Use 0xA0 to match HackRF reference firmware.
+        // The low nibble bits are reserved/undefined in AN619.
+        write_register(Register::PLLReset, 0xa0);
+#endif
    }
-
    regvalue_t read_register(const uint8_t reg);

    template <size_t N>
@@ -397,6 +411,18 @@ class Si5351 {
        write(config.reg(ms_number));
    }

+#ifdef PRALINE
+    /* Write multisynth config using single-byte writes for debugging */
+    void write_ms_single_byte(const size_t ms_number, const MultisynthFractional& config) {
+        const auto regs = config.reg(ms_number);
+        // regs[0] is the base register address, regs[1-8] are the data bytes
+        const uint8_t base_reg = regs[0];
+        for (size_t i = 1; i < regs.size(); i++) {
+            write_register(base_reg + i - 1, regs[i]);
+        }
+    }
+#endif
+
    void set_ms_frequency(
        const size_t ms_number,
        const uint32_t frequency,
@@ -480,7 +506,6 @@ class Si5351 {
                                                   }});
    }
 };
-
 }  // namespace si5351

 #endif /*__SI5351_H__*/
@@ -46,6 +46,14 @@ class Arbiter {
        _bus.transfer(data, count);
    }

+#ifdef PRALINE
+    /* Invalidate cached config - forces reconfiguration on next transfer.
+     * Call this after directly manipulating SSP registers (e.g., FPGA access). */
+    void invalidate() {
+        _config = nullptr;
+    }
+#endif
+
   private:
    SPI& _bus;
    const SPIConfig* _config;
@@ -194,8 +194,12 @@ void timer0_callback(GPTDriver* const) {
    if (encoder_update(switches_raw) || encoder_read())
        event_mask |= EVT_MASK_ENCODER;

-    /* Signal event loop */
+        /* Signal event loop */
+#ifdef PRALINE
+    if (event_mask && thread_controls_event) {
+#else
    if (event_mask) {
+#endif
        chSysLockFromIsr();
        chEvtSignalI(thread_controls_event, event_mask);
        chSysUnlockFromIsr();
@@ -227,8 +231,13 @@ void controls_init() {
    gptStart(&GPTD1, &timer0_config);
    gptStartContinuous(&GPTD1, timer0_match_count);

+#ifdef PRALINE
    // Enable repeat for directional switches only
    for (auto i = Switch::Right; i <= Switch::Up; incr(i))
+#else
+    // Enable repeat for directional and Select switches only
+    for (auto i = Switch::Right; i <= Switch::Sel; incr(i))
+#endif
        switch_debounce[toUType(i)].enable_repeat();
 }

@@ -250,6 +259,22 @@ SwitchesState get_switches_state() {
    return result;
 }

+/* Gets the repeat enabled state for all the switches. */
+SwitchesState get_switches_repeat_config() {
+    SwitchesState result;
+
+    for (size_t i = 0; i < result.size(); i++)
+        result[i] = switch_debounce[i].get_repeat_enabled();
+
+    return result;
+}
+
+/* Configures which switches support repeat.*/
+void set_switches_repeat_config(SwitchesState switch_config) {
+    for (size_t i = 0; i < switch_config.size(); i++)
+        switch_debounce[i].set_enable_repeat(switch_config[i]);
+}
+
 /* Gets the long press enabled state for all the switches. */
 SwitchesState get_switches_long_press_config() {
    SwitchesState result;
@@ -48,6 +48,8 @@ uint8_t swizzled_switches();
 SwitchesState get_switches_state();
 EncoderPosition get_encoder_position();
 touch::Frame get_touch_frame();
+SwitchesState get_switches_repeat_config();
+void set_switches_repeat_config(SwitchesState switch_config);

 SwitchesState get_switches_long_press_config();
 void set_switches_long_press_config(SwitchesState switch_config);
@@ -52,10 +52,17 @@ extern "C" {

 CH_IRQ_HANDLER(PIN_INT4_IRQHandler) {
    CH_IRQ_PROLOGUE();
-
+#ifdef PRALINE
+    if (thread_lcd_frame_event) {
+        chSysLockFromIsr();
+        chEvtSignalI(thread_lcd_frame_event, EVT_MASK_LCD_FRAME_SYNC);
+        chSysUnlockFromIsr();
+    }
+#else
    chSysLockFromIsr();
    chEvtSignalI(thread_lcd_frame_event, EVT_MASK_LCD_FRAME_SYNC);
    chSysUnlockFromIsr();
+#endif

    LPC_GPIO_INT->IST = (1U << 4);

@@ -40,10 +40,17 @@ extern "C" {

 CH_IRQ_HANDLER(RTC_IRQHandler) {
    CH_IRQ_PROLOGUE();
-
+#ifdef PRALINE
+    if (thread_rtc_event) {
+        chSysLockFromIsr();
+        chEvtSignalI(thread_rtc_event, EVT_MASK_RTC_TICK);
+        chSysUnlockFromIsr();
+    }
+#else
    chSysLockFromIsr();
    chEvtSignalI(thread_rtc_event, EVT_MASK_RTC_TICK);
    chSysUnlockFromIsr();
+#endif

    rtc::interrupt::clear_all();

@@ -0,0 +1,36 @@
+#include "keeloq_common.hpp"
+
+uint32_t keeloq_encrypt(const uint32_t data, const uint64_t key) {
+    uint32_t x = data, r;
+
+    for (r = 0; r < 528; r++)
+        x = (x >> 1) ^ ((bit(x, 0) ^ bit(x, 16) ^ (uint32_t)bit(key, r & 63) ^
+                         bit(KEELOQ_NLF, g5(x, 1, 9, 20, 26, 31)))
+                        << 31);
+
+    return x;
+}
+
+uint32_t keeloq_decrypt(const uint32_t data, const uint64_t key) {
+    uint32_t x = data, r;
+
+    for (r = 0; r < 528; r++)
+        x = (x << 1) ^ bit(x, 31) ^ bit(x, 15) ^ (uint32_t)bit(key, (15 - r) & 63) ^
+            bit(KEELOQ_NLF, g5(x, 0, 8, 19, 25, 30));
+
+    return x;
+}
+
+uint64_t keeloq_normal_learning(uint32_t data, const uint64_t key) {
+    uint32_t k1, k2;
+
+    data &= 0x0FFFFFFF;
+    data |= 0x20000000;
+    k1 = keeloq_decrypt(data, key);
+
+    data &= 0x0FFFFFFF;
+    data |= 0x60000000;
+    k2 = keeloq_decrypt(data, key);
+
+    return ((uint64_t)k2 << 32) | k1;
+}
@@ -0,0 +1,16 @@
+#ifndef __KEELOQ_COMMON__
+#define __KEELOQ_COMMON__
+
+#include <cstdint>
+
+#define bit(x, n) (((x) >> (n)) & 1)
+#define g5(x, a, b, c, d, e) \
+    (bit(x, a) + bit(x, b) * 2 + bit(x, c) * 4 + bit(x, d) * 8 + bit(x, e) * 16)
+
+#define KEELOQ_NLF 0x3A5C742E
+
+uint32_t keeloq_encrypt(const uint32_t data, const uint64_t key);
+uint32_t keeloq_decrypt(const uint32_t data, const uint64_t key);
+uint64_t keeloq_normal_learning(uint32_t data, const uint64_t key);
+
+#endif
@@ -0,0 +1,72 @@
+/*
+ * 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 "keeloq_file.hpp"
+
+namespace fs = std::filesystem;
+
+bool read_keeloq_file(const fs::path& path, KeeloqData& data) {
+    File file{};
+
+    auto result = file.open(path);
+
+    if (result) {
+        return false;
+    }
+
+    FileLineReader reader{file};
+
+    std::string raw = *reader.begin();
+    auto chunks = split_string(raw, ';');
+
+    if (chunks.size() != 4) {
+        return false;
+    }
+
+    data.mf_name = std::string{chunks[0]};
+    data.serial = std::strtoul(chunks[1].data(), NULL, 16);
+    data.counter = (uint16_t)std::atoi(chunks[2].data());
+    data.btn = (uint8_t)std::atoi(chunks[3].data());
+
+    return true;
+}
+
+bool write_keeloq_file(const fs::path& path, const KeeloqData& data) {
+    delete_file(path);
+
+    File file{};
+
+    auto result = file.open(path, false, true);
+
+    if (result) {
+        return false;
+    }
+
+    std::string formatted = data.mf_name + ";" +
+                            to_string_hex(data.serial) + ";" +
+                            to_string_dec_uint(data.counter) + ";" +
+                            to_string_dec_uint(data.btn);
+
+    file.write_line(formatted);
+    file.close();
+
+    return true;
+}
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+#ifndef __KEELOQ_FILE__
+#define __KEELOQ_FILE__
+
+#include "portapack.hpp"
+#include "file_reader.hpp"
+#include "string_format.hpp"
+#include <string_view>
+
+struct KeeloqData {
+    std::string mf_name{};
+    uint32_t serial = 0;
+    uint16_t counter = 0;
+    uint8_t btn = 0;
+};
+
+bool read_keeloq_file(const std::filesystem::path&, KeeloqData&);
+bool write_keeloq_file(const std::filesystem::path&, const KeeloqData&);
+
+#endif
@@ -0,0 +1,53 @@
+/*
+ * 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 "keeloq_keystore.hpp"
+
+KeeloqKeystore::KeeloqKeystore() {
+    ensure_directory(keeloq_keys_dir);
+
+    File keeloq_keys_file{};
+
+    if (keeloq_keys_file.open(keeloq_keys_dir / "MFCODES")) {
+        return;
+    }
+
+    FileLineReader reader{keeloq_keys_file};
+
+    for (const std::string& line : reader) {
+        auto cols = split_string(line, ';');
+
+        if (cols.size() != 3) {
+            return;
+        }
+
+        KeeloqKey key{
+            std::string{cols[0]},
+            std::strtoull(cols[1].data(), NULL, 16),
+            (uint8_t)std::atoi(cols[2].data())};
+
+        keys.push_back(key);
+    }
+}
+
+const std::vector<KeeloqKey>& KeeloqKeystore::get_keys() {
+    return keys;
+}
@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef __KEELOQ_KEYSTORE__
+#define __KEELOQ_KEYSTORE__
+
+#include "file_reader.hpp"
+#include "file_path.hpp"
+#include "string_format.hpp"
+#include <string_view>
+
+#define KEELOQ_SIMPLE_LEARNING 1
+#define KEELOQ_NORMAL_LEARNING 2
+
+struct KeeloqKey {
+    std::string mf_name{};
+    uint64_t key = 0;
+    uint8_t type = 0;
+};
+
+class KeeloqKeystore {
+   public:
+    KeeloqKeystore();
+
+    const std::vector<KeeloqKey>& get_keys();
+
+   private:
+    std::vector<KeeloqKey> keys{};
+};
+
+#endif
@@ -38,3 +38,11 @@ Optional<File::Error> LogFile::write_raw(const std::string& message) {
    }
    return error;
 }
+
+Optional<File::Error> LogFile::write_raw_no_newline(const std::string& message) {
+    auto result_s = file.write(message.c_str(), message.size());
+    if (!result_s.is_error()) {
+        file.sync();
+    }
+    return {result_s.error()};
+}
@@ -40,6 +40,7 @@ class LogFile {
    Optional<File::Error> write_entry(const std::string& entry);
    Optional<File::Error> write_entry(const rtc::RTC& datetime, const std::string& entry);
    Optional<File::Error> write_raw(const std::string& message);
+    Optional<File::Error> write_raw_no_newline(const std::string& message);

   private:
    File file{};
@@ -187,7 +187,7 @@ int main(void) {
            lcd_frame_sync_configure();
            rtc_interrupt_enable();

-            Theme::SetTheme((Theme::ThemeId)portapack::persistent_memory::ui_theme_id());  // load theme
+            Theme::SetTheme((Theme::ThemeId)portapack::persistent_memory::ui_theme_id());

            event_loop();

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Pezsma	266db4b158	Random splash on boot (#2961 )	2026-02-16 17:52:47 +01:00
gullradriel	290bf543a1	fix restore settings (#2995 )	2026-02-16 17:06:57 +01:00
gullradriel	e17f4c4ab4	Fix units tpms not compiling (#2994 ) * add defines for unit types * fix compilation, units usage and variables names	2026-02-16 15:50:27 +01:00
lifegame1lu111	83a4580353	Refactor KeeLoq crypto functions and add new KeeLoq TX app (#2990 )	2026-02-16 15:19:50 +01:00
Hoite Prins	00f40bf171	feat: add BAR unit support to TPMS RX app (#2988 ) - Add bar() conversion method to Pressure class - Convert pressure units system from boolean to enum (kPa, PSI, BAR) - Add BAR option to pressure unit selector in UI - Update settings manager to persist pressure unit preference - Use ternary operators for compact pressure formatting	2026-02-16 14:55:12 +01:00
Totoo	794daf5257	Rtty tx and rx (#2977 )	2026-02-16 14:34:55 +01:00
gullradriel	95eafeb812	fix clang format workflow, update hackrf submodule, fix subghzd compilation warning, remove flashsize.h (#2992 ) * trying to fix clang format workflow * try without docker repo, classic apt install * find what installed clang format 18 version is * removed auto generated flashsize * comment on flashsize.h * modified to use repo owned clang-format binaries * code format for windows hosts * add clang-format binaries for linux x86_64/arm64, macos-arm64, windows x86_64 * add helper script to download specific llvm clang-format version * add helper to download missing libraries (use docker) * use custom clang-format * fix ui_subghzd.cpp:85:29: warning: narrowing conversion of 'this->ui::SubGhzDRecentEntryDetailView::cnt' from 'uint32_t' {aka 'long unsigned int'} to 'uint16_t' {aka 'short unsigned int'} [-Wnarrowing] * remove auto generated file * Update tools/clang-format.sh * removed fallback * updated hackrf submodule	2026-02-15 21:29:26 +00:00
gullradriel	94d46036f8	up to latest (#2984 )	2026-02-12 12:00:22 +00:00
Totoo	68000f0b94	fix compile (#2983 )	2026-02-12 12:41:12 +01:00
lifegame1lu111	eff68693ad	Add support for decrypting and saving KeeLoq signals for SubGhzD (#2982 )	2026-02-12 10:41:56 +01:00
jLynx	2f468fd37c	Add Multi-Device Build Support to Release Workflows (#2978 )	2026-02-11 10:44:07 +01:00
stafur	39424632bb	HackRF Pro (praline) arch-port initial PR (#2958 ) * Initial commit and pr for HackRF Pro (praline) arch-port to mayhem-firmware. Please see https://github.com/portapack-mayhem/mayhem-firmware/issues/2957. Added flash specifics for -DBOARD=PRALINE. This firmware only builds with toolchain v9.2.1 if hackrf codebase has -B arm in firmware/hackrf_usb/CMakeLists.txt. * Updated CMakeLists.txt per coordination with @HtoToo. For -DBOARD=PRALINE FLASH_MB_SIZE and FLASH_MB_LIMIT_SIZE are now 4. Removed praline specific variable for FLASH limits. * Updated chibios-portapack's board.cpp to support initialization of the HachRF-Pro (praline) FPGA. Added append_fpga_bitstream.py tool to ensure that praline_fgpa.bin bitstream can be appended to -DBOARD=PRALINE produced firmware. In order to ensure successful execution of append_fpga_bitstream.py to append the fpga bitstream we should expect that the bistsream will be located at 0x180000 in flash. This requires that FLASH_MB_LIMIT_SIZE must be 1.5, and FLASH_BYTES_LIMIT_SIZE must be 1535 * 1024. If we want to allow more or less space for the base firmware image sans the fpga bitstream the location of the bistream must be moved to a location other than 0x180000. * Updated location of praline_fpga.bin bitstream to 0x380000 to allow more room for firmware. Firmware now has 3.5MB, or 2MB more available than before as coordinated with @HTotoo. * Expanded #ifndef PRALINE to include og and r9 gpio and pin setup as coordinated with @HTotoo. * Added note for PRALINE FLASH_MB_LIMIT_SIZE and FLASH_BYTES_LIMIT_SIZE to explain why we are using the 3.5 and 3584 values respectively as coordinated with @HTotoo. * Next round of modifications derived heavily, if not entirely from work done by @banandana at https://github.com/Banandana/mayhem-firmware. This commit should power on the HackRF Pro (praline) display, power on the fpga, and enable gpio, and provide debug utilties. There is still a lot of work to be done to fully enable the new praline board with this build and firmware architectural porting effort. However, hackrf-one boards do not seem to be adversely impacted by the #ifdef PRALINE statements, and CMakeLists updates, as far as I have been able to test. * Ran format-code.sh. Updates for this commit are only due to formatting. Tested builds and they seem to work as exptected. * Addressed fixes in firmware/application and firmware/baseband. Stream now flows to capture and looking glass. Issues were related to thread management. Issues were originally addressed by @banandana. * Ran format-code.sh to allow for consistency with autoamted clang checks. * Update hackrf ref repo to mayhem-portapack-hackrf next from https://github.com/portapack-mayhem/hackrf * Addressed format edits necessary to pass clang-format check. * Starting addressing Si5351 Clocks for radio sampling. These updates correctly set the Si5351 clock at start up. There appears to be an issue during runtime when testing with RX Test Init, Capture and Looking glass. * Updated clock_manager.cpp to restore correct function introduced by @banandana when testing with Rx Test Init. * Switched to using decimation for setting the sample rate without changing the Si5351 clock. This assumes that for the praline board Si5351 CLK0 runs at fixed 8 MHz (constant) and the FPGA decimates to get the desired sample rate. For example, for a 1 MHz sample rate -> Si5351 outputs 8 MHz, FPGA decimates by 8. There is still more work needed here, and potential verification that this is the correct way to operate with this new archteitecture. * After deliberating on hackrf_usb hackrf_core.c and radio.c, and reviewing firmware/application/hw/si5351.cpp the original approach of using the aproach detailed in hackrf_core.c sample_rate_frac_set() lines 580-582, via the implementation in firmware/application/hw/si5351.cpp seems like the best place to continue testing efforts. * Tested at ~2.4GHz (2.3 - 2.5) with lookgin glass and was able to receive signals. Added a Signal Path debug app to test gains, and readio mode (receive/transmit). * Added two debug apps for the RFFC507x. Status View and Tuning View. This helped debug some of the potential issues with tuning. * update submodule * format code * Small touch up merging latest next and ensuring build for HackRF One. * Reverted edits to re: firmware/baseband/sd_over_usb/scsi.c and firmware/application/portapack.cpp. Source now builds, had to pull latest hackrf submodule. * Skipped detect hardware for praline board to avoid backscreen in HackRF Pro praline board. --------- Co-authored-by: gullradriel <gullradriel@users.noreply.github.com>	2026-02-11 09:15:11 +01:00
E.T.	cd30022b61	Do hardware detection on init for shell info (#2975 ) and reset gpio state afterward	2026-02-09 21:49:16 +01:00
gullradriel	be872003ec	Update hackrf submodule (#2973 ) * update submodule * fix warning missing delay declaration * update: fix get board messing up radio/waterfalls	2026-02-09 20:25:40 +00:00
gullradriel	9e7758718c	update submodule (#2971 )	2026-02-08 20:44:14 +01:00
E.T.	89b878d3bb	Better hackrf board detection for the serial info command (#2967 )	2026-02-07 15:45:26 +01:00
gullradriel	56d965f3ae	update submodule to latest (#2968 )	2026-02-06 19:55:53 +01:00
Totoo	fe9f0c228f	SubCar fm mode (#2965 )	2026-02-06 17:20:14 +01:00
Totoo	6562e596e8	OSM change detection	2026-02-06 15:07:07 +01:00
Totoo	c27192bdbb	Flipper fsk tx support (#2964 )	2026-02-06 09:48:20 +01:00
gullradriel	927e3b11e7	Morse rx cleanings (#2962 ) * fix ui overlap, align with log box * bring back enum inside the class as a simple enum * correctly restore saved setting whatever the modulation was at exit * set squelch / field_squelch / receiver model in one go, add audio/receiver model stop and start	2026-02-04 14:01:29 +01:00
Pezsma	a44a00acf0	Morse rx further development (#2959 ) * filters OK, radio configurations set * all modes are working, noise still needs work, especially in FM. A baseband enum is also needed * audio and decoding fixed, clipping and the baseband enum are still missing	2026-02-03 22:25:52 +01:00
gullradriel	6739b43914	disable select key repeat in Mic TX (#2956 )	2026-02-01 19:44:56 +01:00
gullradriel	b306a0d490	Revert "Update Map view labels to match marine navigation standards (#2951 )" (#2955 ) This reverts commit `c6130c6e8d`.	2026-01-31 21:15:12 +01:00
Herbenderbler	c6130c6e8d	Update Map view labels to match marine navigation standards (#2951 ) Replace Alt: with CoG: and Spd: with SoG: in the Map view to better align with standard marine navigation terminology and the AIS Rx screen. - Alt (Altitude) → CoG (Course over Ground) - Spd (Speed) → SoG (Speed over Ground) Rationale: AIS is primarily used for marine navigation where altitude is typically zero (sea level), while Course over Ground is essential navigation information. This change provides consistency with the AIS Rx screen which already displays CoG and SoG. Modified files: - firmware/application/ui/ui_geomap.hpp - firmware/standalone/common/ui/ui_geomap.hpp	2026-01-31 20:53:58 +01:00
Herbenderbler	97f2ca42f1	Fix aviation 8.33kHz step size to reduce frequency drift (#2950 ) Update aviation radio step size from 8330 Hz to 8333 Hz in freqman_steps and freqman_steps_short arrays. This better represents the actual 8⅓ kHz (25000/3 Hz) aviation channel spacing and significantly reduces frequency drift during dial tuning. With this fix, stepping 24 times from 123.000 MHz now correctly reaches 123.200 MHz instead of 123.199 MHz.	2026-01-31 19:35:14 +01:00
Pezsma	e2b642ae25	New Morse TX app (#2948 ) * morse tx * global button repeat function improvement	2026-01-30 17:18:13 +01:00
gullradriel	106d9b1207	updated submodule (#2947 )	2026-01-30 10:14:08 +01:00
gullradriel	c8ae419e0b	updated submodule (#2946 )	2026-01-30 00:21:36 +01:00
Totoo	2319dcd0d6	Aprs tx gps added, and save config added, path added (#2937 )	2026-01-25 10:01:33 +01:00
lifegame1lu111	44d9ce00cd	Holtek HT6P20B support for SubGhzD (#2941 )	2026-01-25 09:41:06 +01:00
Pezsma	5cc5f8faa6	Morserx added ssb modes (#2934 ) * USB receive good * LSB receive good * all mode receive good, log is dead * frequency measurement good, decode dead * total killed * szutyok, gerjed * frequenty meas only. * ui ok * Add frequency measurement handling and update Morse processing logic * fix ssb speed	2026-01-22 18:49:21 +01:00
gullradriel	3a0ca480b0	conform to clang spec (#2925 ) * conform to clang spec * proper find call * Update format-code.sh	2026-01-22 15:26:31 +01:00
Totoo	7a2b432bfa	Dyn flash size (#2933 )	2026-01-22 15:24:42 +01:00
zxkmm	86d7b345d0	waterfall color designer app (#2625 )	2026-01-19 21:46:25 +01:00
Pezsma	877ede5f86	Added morse receiver app. (#2923 ) * Adder morse receiver app. Works with cw and fm mode. Adaptive speed learning. Logging.	2026-01-16 09:57:45 +01:00
gullradriel	19eb1c40ab	fix NumberField wrapping when steps is not '1' and minimum can be negative (#2920 )	2026-01-11 22:49:18 +01:00
gullradriel	9c03a18893	Looking glass marker no encoder (#2919 ) * enable repeat mode for select button too * added marker + and marker - buttons, removed non effective iqcalc tuning	2026-01-10 20:19:10 +01:00
gullradriel	cd504eb4a7	Udpdate hackrf submodule (#2906 ) * add missing parameter to usb endpoint init * make firmware compile with latest hackrf * updated submodule * format code	2026-01-10 16:19:53 +01:00
Totoo	dc976c7f38	make sd over usb external (#2918 )	2026-01-10 15:10:23 +01:00
Totoo	266d90a600	Updated subcar processors (#2913 )	2026-01-10 14:47:33 +01:00
Totoo	2884bb9ab7	make siggen ext (#2917 )	2026-01-10 21:25:41 +08:00
Totoo	133b2d2065	fix for #2903 (#2914 )	2026-01-10 20:25:30 +08:00
Totoo	2f2671f76c	Some tweaks to support some usecases without encoder, also maximize the NewButton's text size (#2915 )	2026-01-10 20:21:57 +08:00
Totoo	f5c2c78733	fix looking glass marker on portarf (#2912 )	2026-01-09 20:32:31 +00:00
Harin Lee	e4ab7227fc	Fix typos of 'transceiver' (#2910 )	2026-01-08 10:34:05 +01:00
Harin Lee	93799bde6d	New approach to support RX-only mode more cleanly (#2908 ) * Add enabled checks in ReceiverModel and TransmitterModel * Move TX limit logic to TransmitterModel from radio API * Add TX disable functionality and UI	2026-01-07 12:29:56 +08:00
RML	3d979a613a	remove github pages CNAME (#2905 )	2026-01-04 09:25:45 +01:00
Harin Lee	ee97b51eb3	Add some features to support RX-only mode (#2904 ) * Remove duplicate LED control code * Add TX limit settings and UI * Fix App Manager to handle non-application menu items	2026-01-03 22:10:34 +01:00