Update version.txt

fix skip consecutive match

.dockerignore

@@ -0,0 +1 @@
+build

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,12 +1,18 @@
 ---
 name: Bug report
-about: Create a report to help us improve
+about: Create a report to help us improve the software
 title: ''
 labels: bug
 assignees: ''
 
 ---
 
+----
+
+(Please try the latest nightly release before submitting this. You can find the latest nightly version here: https://github.com/eried/portapack-mayhem/releases)
+
+----
+
 **Describe the bug**
 A clear and concise description of what the bug is. 
 
@@ -21,9 +27,9 @@ A clear and concise description of what you expected to happen.
 
 **Affected versions**
 Please write any difference related with the Expected behavior, on the following versions:
-* Latest Stable Release
-* Previous one (if any) that did not presented the issue
-* Old versions available here: https://github.com/eried/Research/tree/master/HackRF/PortaPack/old_legacy_firmware
+* Latest Stable release:
+* Latest Nightly release:
+* Previous working release:
 
 **Additional**
 If the bug is difficult to explain, additionally to the text please include images and videos.

.github/ISSUE_TEMPLATE/problem-upgrading-the-firmware.md

@@ -1,18 +1,39 @@
 ---
-name: Problem upgrading the firmware
-about: Deal with the firmware upgrade problems
-title: Problem upgrading the firmware
-labels: ''
+name: Problem upgrading the firmware or booting
+about: If you are having firmware upgrade or booting problems
+title: ''
+labels: 'firmware'
 assignees: ''
 
 ---
 
-**What is happening?**
-Describe here why you are unable to upgrade the firmware. Before describing your problems, **do the following**: 
+----
+Before creating this issue, **do the following**: 
+* Read the Wiki on booting: https://github.com/eried/portapack-mayhem/wiki/Won't-boot
 * Read: https://github.com/eried/portapack-havoc/wiki/Update-firmware
 * Watch carefully: https://www.youtube.com/watch?v=_zx4ZvurgOs
 * (if you are not in Windows) also check: https://www.youtube.com/watch?v=kjFB58Y1TAo
 
+----
+
+**Describe the issue**
+A clear and concise description of what the issue you are facing is. 
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Tap on '....'
+
+
+**My Hardware**
+Please specify what PortaPack hardware version you are using. 
+You can find the list of versions here: https://github.com/eried/portapack-mayhem/wiki/PortaPack-Versions
+
+**Affected versions**
+Please tell us what version you are running. 
+If your device is still functional, try the latest nightly release before submitting this. 
+You can find the latest nightly version here https://github.com/eried/portapack-mayhem/releases
+
 **Were you able to update the firmware before?**
 Things might be confusing the first time, please check the video available on the link above.
 
@@ -20,4 +41,4 @@ Things might be confusing the first time, please check the video available on th
 If is possible, swap hardware and try again. Also, try different USB cables, even if the one you are using works fine for other purposes.
 
 **Additional**
-Add photos and videos of your procedure.
+If the issue is difficult to explain, additionally to the text please include images and videos.

.github/workflows/changelog.py

@@ -0,0 +1,28 @@
+import os
+import re
+import sys
+
+raw_git = os.popen('git log next --since="24 hours" --pretty=format:"- %h - {USERNAME}*+%al-%an*: %s"').read()
+
+
+def compute_username(line):
+    stripped = re.search(r'(?<=\*)(.*?)(?=\*)', line).group(0)
+
+    pattern = re.compile("[$@+&?].*[$@+&?]")
+    if pattern.match(stripped):
+        stripped = re.sub("[$@+&?].*[$@+&?]", "", stripped)
+        stripped = re.match(r'.+?(?=-)', stripped).group(0)
+    else:
+        stripped = re.sub(r'^.*?-', "", stripped)
+    return "@" + stripped
+
+
+def compile_line(line):
+    username = compute_username(line)
+    line = re.sub(r'[*].*[*]', "", line)
+    line = line.replace("{USERNAME}", username)
+    return line
+
+
+for row in raw_git.splitlines():
+    print(compile_line(row))

.github/workflows/create_nightly_release.yml

@@ -0,0 +1,99 @@
+name: Nightly Release
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+    
+  workflow_dispatch:
+
+jobs:
+  check_date:
+    runs-on: ubuntu-latest
+    name: Check latest commit
+    outputs:
+      should_run: ${{ steps.should_run.outputs.should_run }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: print latest_commit
+        run: echo ${{ github.sha }}
+
+      - name: check latest commit is less than a day
+        id: should_run
+        continue-on-error: true
+        run: test -z $(git rev-list  --after="24 hours" ${{ github.sha }}) && echo "::set-output name=should_run::false"
+  build:
+    needs: check_date
+    if: ${{ needs.check_date.outputs.should_run != 'false' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get current date
+        id: date
+        run: echo "::set-output name=date::$(date +'%Y-%m-%d')"
+      - name: Get version date
+        id: version_date
+        run: echo "::set-output name=date::n_$(date +'%y%m%d')"
+      - name: Checkout 
+        uses: actions/checkout@master
+        with:
+          fetch-depth: 0
+          ref: next
+          submodules: true
+      - name: Git Sumbodule Update
+        run: |
+          git submodule update --init --recursive
+      - 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_date.outputs.date }} -i -v ${{ github.workspace }}:/havoc portapack-dev
+      - name: Create Firmware ZIP
+        run: |
+          zip -j firmware.zip build/firmware/portapack-h1_h2-mayhem.bin && cd flashing && zip -r ../firmware.zip *
+      - name: Create SD Card ZIP
+        run: |
+          zip -r sdcard.zip sdcard
+      - name: Create changelog
+        run: |
+          CHANGELOG=$(python3 .github/workflows/changelog.py)
+          CHANGELOG="${CHANGELOG//'%'/'%25'}"
+          CHANGELOG="${CHANGELOG//$'\n'/'%0A'}"
+          CHANGELOG="${CHANGELOG//$'\r'/'%0D'}"
+          echo "::set-output name=content::$CHANGELOG"
+        id: changelog
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: nightly-tag-${{ steps.date.outputs.date }}
+          release_name: Nightly Release - ${{ steps.date.outputs.date }}
+          body: |
+            **Nightly release - ${{ steps.date.outputs.date }}**
+            This build is the latest and greatest, although may not be the most stable as this is a nightly release.
+            ## Release notes
+            ###  Revision (${{ steps.version_date.outputs.date }}):
+            ${{ steps.changelog.outputs.content }}
+          draft: false
+          prerelease: true
+      - name: Upload Firmware Asset
+        id: upload-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_content_type: application/zip
+      - name: Upload SD Card Assets
+        id: upload-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_content_type: application/zip

.github/workflows/create_stable_release.yml

@@ -0,0 +1,93 @@
+name: Stable Release
+
+on:    
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get current date
+        id: date
+        run: echo "::set-output name=date::$(date +'%Y-%m-%d')"
+      - name: Checkout 
+        uses: actions/checkout@master
+        with:
+          fetch-depth: 0
+          ref: next
+          submodules: true
+      - name: Git Sumbodule Update
+        run: |
+          git submodule update --init --recursive
+      - name: Get version
+        id: version
+        run: echo "::set-output name=version::$(cat .github/workflows/version.txt)"
+      - name: Get past version
+        id: past_version
+        run: echo "::set-output name=past_version::$(cat .github/workflows/past_version.txt)"
+      - 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
+      - name: Create Firmware ZIP
+        run: |
+          zip -j firmware.zip build/firmware/portapack-h1_h2-mayhem.bin && cd flashing && zip -r ../firmware.zip *
+      - name: Create SD Card ZIP
+        run: |
+          zip -r sdcard.zip sdcard
+      - name: Create changelog
+        run: |
+          CHANGELOG=$(python3 .github/workflows/stable_changelog.py ${{ steps.past_version.outputs.past_version }})
+          CHANGELOG="${CHANGELOG//'%'/'%25'}"
+          CHANGELOG="${CHANGELOG//$'\n'/'%0A'}"
+          CHANGELOG="${CHANGELOG//$'\r'/'%0D'}"
+          echo "::set-output name=content::$CHANGELOG"
+        id: changelog
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.version.outputs.version }}
+          release_name: Mayhem firmware ${{ steps.version.outputs.version }}
+          body: |
+            **Stable release - ${{ steps.version.outputs.version }}**
+            This is a fork of the [Havoc](https://github.com/furrtek/portapack-havoc/) firmware, which itself was a fork of the [PortaPack](https://github.com/sharebrained/portapack-hackrf) firmware, an add-on for the [HackRF](http://greatscottgadgets.com/hackrf/). Please check the [readme](https://github.com/eried/portapack-mayhem/blob/master/README.md) for details.
+            ## Release notes
+            ###  Revision (${{ steps.version.outputs.version }}):
+            ${{ steps.changelog.outputs.content }}
+            
+            **Full Changelog**: https://github.com/eried/portapack-mayhem/compare/${{ steps.past_version.outputs.past_version }}...${{ steps.version.outputs.version }}
+
+            ## Installation
+            Check the [wiki](https://github.com/eried/portapack-havoc/wiki/Update-firmware) for details how to upgrade. 
+
+            ### MicroSD card files
+
+            For certain functionality, like 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 Asset
+        id: upload-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_content_type: application/zip
+      - name: Upload SD Card Assets
+        id: upload-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_content_type: application/zip
+     

.github/workflows/past_version.txt

@@ -0,0 +1 @@
+v1.6.0

.github/workflows/stable_changelog.py

@@ -0,0 +1,30 @@
+import os
+import re
+import sys
+
+past_version = sys.argv[1]
+
+raw_git = os.popen('git log ' + past_version + '..next --pretty=format:"- %h - {USERNAME}*+%al-%an*: %s"').read()
+
+
+def compute_username(line):
+    stripped = re.search(r'(?<=\*)(.*?)(?=\*)', line).group(0)
+
+    pattern = re.compile("[$@+&?].*[$@+&?]")
+    if pattern.match(stripped):
+        stripped = re.sub("[$@+&?].*[$@+&?]", "", stripped)
+        stripped = re.match(r'.+?(?=-)', stripped).group(0)
+    else:
+        stripped = re.sub(r'^.*?-', "", stripped)
+    return "@" + stripped
+
+
+def compile_line(line):
+    username = compute_username(line)
+    line = re.sub(r'[*].*[*]', "", line)
+    line = line.replace("{USERNAME}", username)
+    return line
+
+
+for row in raw_git.splitlines():
+    print(compile_line(row))

.github/workflows/version.txt

@@ -0,0 +1 @@
+v1.7.0

.gitignore

@@ -27,7 +27,6 @@
 # Compiled Dynamic libraries
 *.so
 *.dylib
-*.dll
 
 # Fortran module files
 *.mod
@@ -39,7 +38,6 @@
 *.lib
 
 # Executables
-*.exe
 *.out
 *.app
 /firmware/baseband/*.bin

.travis.yml

@@ -53,4 +53,3 @@ addons:
       - sed
       - cmake
       - dfu-util
-

CMakeLists.txt

@@ -25,8 +25,8 @@ set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_LIST_DIR}/firmware/toolchain-arm-cortex
 
 project(portapack-h1)
 
-#set(VERSION "")
-if (NOT DEFINED VERSION)
+set(VERSION "$ENV{VERSION_STRING}")
+if ("$ENV{VERSION_STRING}" STREQUAL "")
 	execute_process(
 		COMMAND git log -n 1 --format=%h
 		WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
@@ -38,14 +38,14 @@ if (NOT DEFINED VERSION)
 	if (GIT_VERSION_FOUND)
 		set(VERSION "unknown")
 	else (GIT_VERSION_FOUND)
-		set(VERSION "local-${GIT_VERSION}")
+		set(VERSION "${GIT_VERSION}")
 	endif (GIT_VERSION_FOUND)
 endif()
 
 set(LICENSE_PATH ${CMAKE_CURRENT_LIST_DIR}/LICENSE)
 set(HARDWARE_PATH ${CMAKE_CURRENT_LIST_DIR}/hardware)
 
-add_subdirectory(hackrf/firmware/hackrf_usb)
+add_subdirectory(hackrf-portapack)
 
 set(HACKRF_FIRMWARE_DFU_FILENAME hackrf_usb.dfu)
 set(HACKRF_FIRMWARE_BIN_FILENAME hackrf_usb_ram.bin)

LICENSE.md

@@ -1,5 +1,5 @@
 # License 
-Portapack Mayhem is distributed under GPL v3.0, however some sub projects might have different (GPL v3.0 compatible) licenses.
+Portapack Mayhem is distributed under [GPL v3.0](LICENSE), however some sub projects might have different (GPL v3.0 compatible) licenses.
 
 ## Other Licenses (compatible with GPL v3.0)
 - Most of Portapack Mayhem is distributed under GPL-2.0-or-later. [license](LICENSE.GPL-2.0-or-later)

README.md

@@ -1,12 +1,12 @@
 # PortaPack Mayhem
 
-[![Build Status](https://travis-ci.com/eried/portapack-mayhem.svg?branch=master)](https://travis-ci.com/eried/portapack-mayhem) [![CodeScene Code Health](https://codescene.io/projects/8381/status-badges/code-health)](https://codescene.io/projects/8381) [![GitHub All Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/total)](https://github.com/eried/portapack-mayhem/releases) [![GitHub Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/latest/total)](https://github.com/eried/portapack-mayhem/releases/latest) [![Docker Hub Pulls](https://img.shields.io/docker/pulls/eried/portapack.svg)](https://hub.docker.com/r/eried/portapack) [![Discord Chat](https://img.shields.io/discord/719669764804444213.svg)](https://discord.gg/tuwVMv3)  [![Check bounties!](https://img.shields.io/bountysource/team/portapack-mayhem/activity?color=%2333ccff&label=bountysource%20%28USD%29&style=plastic)](https://www.bountysource.com/teams/portapack-mayhem/issues)
+[![Build Status](https://travis-ci.com/eried/portapack-mayhem.svg?branch=master)](https://travis-ci.com/eried/portapack-mayhem) [![Nightly Release](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml/badge.svg?branch=next)](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml) [![CodeScene Code Health](https://codescene.io/projects/8381/status-badges/code-health)](https://codescene.io/projects/8381) [![GitHub All Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/total)](https://github.com/eried/portapack-mayhem/releases) [![GitHub Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/latest/total)](https://github.com/eried/portapack-mayhem/releases/latest) [![Docker Hub Pulls](https://img.shields.io/docker/pulls/eried/portapack.svg)](https://hub.docker.com/r/eried/portapack) [![Discord Chat](https://img.shields.io/discord/719669764804444213.svg)](https://discord.gg/tuwVMv3)  [![Check bounties!](https://img.shields.io/bountysource/team/portapack-mayhem/activity?color=%2333ccff&label=bountysource%20%28USD%29&style=plastic)](https://www.bountysource.com/teams/portapack-mayhem/issues)
 
 This is a fork of the [Havoc](https://github.com/furrtek/portapack-havoc/) firmware, which itself was a fork of the [PortaPack](https://github.com/sharebrained/portapack-hackrf) firmware, an add-on for the [HackRF](http://greatscottgadgets.com/hackrf/). A fork is a derivate, in this case one that has extra features and fixes when compared to the older versions.
 
 [<img src="https://raw.githubusercontent.com/wiki/eried/portapack-mayhem/img/hw_overview_h2_front.png" height="400">](https://github.com/eried/portapack-mayhem/wiki/Hardware-overview) [<img src="https://raw.githubusercontent.com/wiki/eried/portapack-mayhem/img/hw_overview_h2_inside.png" height="400">](https://github.com/eried/portapack-mayhem/wiki/Hardware-overview#portapack-internals)
 
-*[PortaPack H2+HackRF+battery](https://s.click.aliexpress.com/e/_dZ7lA96) (clone) with a custom [3d printed case](https://github.com/eried/portapack-mayhem/wiki/H2-Enclosure)*
+*[PortaPack H2+HackRF+battery](https://s.click.aliexpress.com/e/_DmU7GQX) (clone) with a custom [3d printed case](https://github.com/eried/portapack-mayhem/wiki/H2-Enclosure)*
 
 # Quick overview
 
@@ -18,40 +18,40 @@ If you are new to *HackRF+PortaPack+Mayhem*, there is an awesome introductory vi
 
 This repository expands upon the previous work by many people and aims to constantly add new features, bugfixes and generate documentation to make further development easier.  [Collaboration](https://github.com/eried/portapack-mayhem/wiki/How-to-collaborate) is always welcomed and appreciated.
 
-## Does it work on H1/H2 PortaPack?
+## What to buy?
 
-Yes, both devices are the [same](https://github.com/eried/portapack-mayhem/wiki/First-steps). The one I am using to test all changes is this [PortaPack H2+HackRF+battery](https://s.click.aliexpress.com/e/_dZ7lA96), which is a kit that includes everything you need. Sadly, the people making the H2 never made the updated schematics available, which is not ideal (and goes against the terms of the license). Most members of the community are using a clone of the [PortaPack H1+HackRF+metal case](https://s.click.aliexpress.com/e/_dS6liw4), which does not include any battery functionality, but it is a cheaper alternative.
+:heavy_check_mark: A recommended one is this [PortaPack H2](https://s.click.aliexpress.com/e/_DmU7GQX) pack, that includes everything you need. Sadly, the people making the H2 never made the updated schematics available (against the terms of the license). 
 
-To support the people behind the hardware, please buy a genuine [HackRF](https://greatscottgadgets.com/hackrf/) and [PortaPack](https://store.sharebrained.com/products/portapack-for-hackrf-one-kit).
+:heavy_check_mark: Another popular option is the clone of the [PortaPack H1](https://s.click.aliexpress.com/e/_Dkbqs2X).
 
-## Where is the latest firmware?
+:warning: Be cautious , *ask* the seller about compatibility with the latest releases. Look out for the description of the item, if they provide the firmware files for an older version or they have custom setup instructions, this means it might be **NOT compatible**, for example:
 
-The current stable release is on the [![GitHub release (latest by date)](https://img.shields.io/github/v/release/eried/portapack-mayhem?label=Releases&style=social)](https://github.com/eried/portapack-mayhem/releases/latest) page. Follow the instructions you can find in the release description. 
+![image](https://user-images.githubusercontent.com/1091420/214579017-9ad970b9-0917-48f6-a550-588226d3f89b.png)
 
-## Is this the newest firmware for my PortaPack? 
-Most probably: **YES**. *If you find new features somewhere else, please [suggest](https://github.com/eried/portapack-mayhem/issues/new/choose) them*.
+:warning: If it looks **too different**, this might mean that they are using their own recipe, check the [different models](https://github.com/eried/portapack-mayhem/wiki/PortaPack-Versions) in our wiki. For example all the H3 and clones of that version use their own version of the firmware. They do not contribute the changes back and eventually you will be left with a device that nobody maintains:
 
-## Which one is actually the newest?
-There is a lot of confusion of which is the latest version because no old version used any actual "version number". Additionally, since the files were distributed on facebook groups, github issue links and similar temporal sources, then there was no central location for them. 
+![image](https://user-images.githubusercontent.com/1091420/214581333-424900ee-26f8-4e96-be2f-69d8dc995ba9.png)
 
-This fork (**Mayhem**) uses *major.minor.release* [semantic versioning](https://en.wikipedia.org/wiki/Software_versioning), so you can always compare your current version with the latest from [Releases](https://github.com/eried/portapack-mayhem/releases/latest).
+## Where is the latest version?
 
-## What about Havoc/GridRF/jamesshao8/jboone's?
-* jboone's PortaPack: the [vanilla](https://en.wikipedia.org/wiki/Vanilla_software) experience
-* Havoc: It was the most popular fork of jboone's PortaPack, currrently, it is not being maintained nor updated
-* jamesshao8: He keeps his own version of the fork, while not attached as a fork to anything. Latest functions do not follow the license and are not being published with source code, so keep this in mind
-* GridRF: They sell PortaPack clones with their own firmware based on a old version, which has no sourcecode available
+The current **stable release** is on the [![GitHub release (latest by date)](https://img.shields.io/github/v/release/eried/portapack-mayhem?label=Releases&style=social)](https://github.com/eried/portapack-mayhem/releases/latest) page. Follow the instructions you can find in the release description. The **latest (nightly) release** can be found [here](https://github.com/eried/portapack-mayhem/releases/).
 
 ## How can I collaborate
 You can write [documentation](https://github.com/eried/portapack-mayhem/wiki), fix bugs and [answer issues](https://github.com/eried/portapack-mayhem/issues) or add new functionality. Please check the following [guide](https://github.com/eried/portapack-mayhem/wiki/How-to-collaborate) with details.
 
-Consider that the hardware and firmware has been created and maintain by a [lot](https://github.com/mossmann/hackrf/graphs/contributors) of [people](https://github.com/eried/portapack-mayhem/graphs/contributors), so always try colaborating your time and effort first. For coding related questions, if something does not fit as an issue, please join our Discord by clicking the chat badge on [top](#portapack-mayhem).
+Consider that the hardware and firmware has been created and maintain by a [lot](https://github.com/mossmann/hackrf/graphs/contributors) of [people](https://github.com/eried/portapack-mayhem/graphs/contributors), so always try collaborating your time and effort first. For coding related questions, if something does not fit as an issue, please join our Discord by clicking the chat badge on [top](#portapack-mayhem).
+
+[![Contributors](https://contrib.rocks/image?repo=eried/portapack-mayhem)](https://github.com/eried/portapack-mayhem/graphs/contributors)
+
+To support the people behind the hardware, please buy a genuine [HackRF](https://greatscottgadgets.com/hackrf/) and [PortaPack](https://store.sharebrained.com/products/portapack-for-hackrf-one-kit).
 
 As a last option, if you want to send money directly to me for getting more boards, antennas and such:
 
 [![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=CBPQA4HRRPJQ6&source=url)
 
-## What if I really want to pay for something?
+## What if I really want something specific?
+If what you need can be relevant in general, you can [request a feature](https://github.com/eried/portapack-mayhem/issues/new?labels=enhancement&template=feature_request.md).
+
 You can create a bounty and invite people to your own bounty. This will incentivize coders to work on a new feature, solving a bug or even writting documentation. Start a bounty by [creating](https://github.com/eried/portapack-mayhem/issues/new/choose) or [choosing](https://github.com/eried/portapack-mayhem/issues/) an existing issue. Then, go to [Bountysource](https://www.bountysource.com/) and post a bounty using the link to that specific [issue](https://www.bountysource.com/teams/portapack-mayhem/issues).
 
 Promote your bounty over our Discord by clicking the chat badge on [top](#portapack-mayhem).
@@ -60,6 +60,3 @@ Promote your bounty over our Discord by clicking the chat badge on [top](#portap
 First, check the [documentation](https://github.com/eried/portapack-mayhem/wiki). If you find a bug or you think the problem is related to the current repository, please open an [issue](https://github.com/eried/portapack-mayhem/issues/new/choose).
 
 You can reach the [official community](https://www.facebook.com/groups/177623356165819) in Facebook, and our Discord by clicking the chat badge on [top](#portapack-mayhem).
-
-## What if I find incongruencies, or grammatical errors in the text?
-If is on the [Wiki](https://github.com/eried/portapack-mayhem/wiki), you can modify it directly. If is on files of the repository, you can send corrections as [pull requests](https://github.com/eried/portapack-mayhem/wiki/How-to-collaborate#coding-new-stuff-or-fixing-bugs). As a last resource, open an [issue](https://github.com/eried/portapack-mayhem/issues/new/choose).

docker-compose-nogit.yml

@@ -0,0 +1,9 @@
+version: '3.9'
+
+services:
+  portapack-mayhem-dev:
+    build:
+      context: .
+      dockerfile: dockerfile-nogit-alpine
+    volumes:
+      - ".:/havoc"

docker-compose.yml

@@ -0,0 +1,9 @@
+version: '3.9'
+
+services:
+  portapack-mayhem-dev:
+    build:
+      context: .
+      dockerfile: dockerfile-alpine
+    volumes:
+      - "./bin:/havocbin"

dockerfile

@@ -1,6 +1,6 @@
 #Download base image.
-#The ubuntu:latest tag points to the "latest LTS"
-FROM ubuntu:latest
+#The ubuntu:20.04 tag points to the "20.04 LTS"
+FROM ubuntu:20.04
 
 #Set location to download ARM toolkit from.
 # This will need to be changed over time or replaced with a static link to the latest release.
@@ -14,17 +14,19 @@ COPY ./ /havocsrc
 
 #Fetch dependencies from APT
 RUN apt-get update && \
-	apt-get install -y tar wget dfu-util cmake python bzip2 curl && \
-	apt-get -qy autoremove
+        apt-get install -y tar wget dfu-util cmake python bzip2 lz4 curl python3 python3-yaml && \
+        apt-get -qy autoremove
 
 #Install current pip from PyPa
 RUN curl https://bootstrap.pypa.io/pip/3.4/get-pip.py -o get-pip.py && \
-	python get-pip.py
+        python get-pip.py
 
 #Fetch additional dependencies from Python 2.x pip
 RUN pip install pyyaml
-RUN ln -s /usr/bin/python3 /usr/bin/python && \
-    ln -s /usr/bin/pip3 /usr/bin/pip
+RUN rm -rf /usr/bin/python && \
+        rm -rf /usr/bin/pip && \
+        ln -s /usr/bin/python3 /usr/bin/python && \
+        ln -s /usr/bin/pip3 /usr/bin/pip
 
 ENV LANG C.UTF-8
 ENV LC_ALL C.UTF-8
@@ -32,14 +34,15 @@ ENV LC_ALL C.UTF-8
 #Grab the GNU ARM toolchain from arm.com
 #Then extract contents to /opt/build/armbin/
 RUN mkdir /opt/build && cd /opt/build && \
-	wget -O gcc-arm-none-eabi $ARMBINURL && \
-	mkdir armbin && \
-	tar --strip=1 -xjvf gcc-arm-none-eabi -C armbin
-    
+        wget -O gcc-arm-none-eabi $ARMBINURL && \
+        mkdir armbin && \
+        tar --strip=1 -xjvf gcc-arm-none-eabi -C armbin
+
 #Set environment variable so compiler knows where the toolchain lives
 ENV PATH=$PATH:/opt/build/armbin/bin
 
 CMD cd /havocsrc && \
-    mkdir build && cd build && \ 
-    cmake .. && make firmware && \
-    cp /portapack-havoc/firmware/portapack-h1-havoc.bin /havocbin
+        mkdir build && cd build && \ 
+        cmake .. && make firmware && \
+        cp /portapack-havoc/firmware/portapack-h1-havoc.bin /havocbin
+

dockerfile-alpine

@@ -0,0 +1,29 @@
+# Download base image.
+FROM alpine:edge
+
+# Download ARM toolkit.
+RUN apk add --no-cache gcc-arm-none-eabi gcc
+
+# Create volume /havocbin for compiled firmware binaries
+VOLUME /havocbin
+
+# Copy build context (repository root) to /havocsrc
+COPY ./ /havocsrc
+
+# Fetch dependencies from APK
+RUN echo "http://dl-cdn.alpinelinux.org/alpine/edge/testing" >> /etc/apk/repositories
+RUN apk update -U
+RUN apk add --no-cache git tar wget cmake curl bzip2 lz4 make
+RUN apk add --no-cache dfu-util ccache icu-data-full
+RUN apk add --no-cache python3 py3-pip py3-yaml
+RUN apk add --no-cache py3-pyyaml-env-tag
+RUN apk add --no-cache g++ gcc clang clang-static clang-dev llvm-dev llvm-static
+
+ENV LANG C.UTF-8
+ENV LC_ALL C.UTF-8
+
+CMD cd /havocsrc && \
+        mkdir build && cd build && \ 
+        cmake .. && make firmware && \
+        cp /portapack-havoc/firmware/portapack-h1-havoc.bin /havocbin
+

dockerfile-nogit

@@ -11,7 +11,7 @@ WORKDIR /havoc/firmware
 
 # Fetch dependencies from APT
 RUN apt-get update && \
-	apt-get install -y git tar wget dfu-util cmake python3 ccache bzip2 curl && \
+	apt-get install -y git tar wget dfu-util cmake python3 ccache bzip2 liblz4-tool curl && \
 	apt-get -qy autoremove
 
 #Install current pip from PyPa
@@ -21,7 +21,7 @@ RUN curl https://bootstrap.pypa.io/pip/3.4/get-pip.py -o get-pip.py && \
 #Fetch additional dependencies from Python 3.x pip
 RUN pip install pyyaml
 RUN ln -s /usr/bin/python3 /usr/bin/python && \
-    ln -s /usr/bin/pip3 /usr/bin/pip
+	ln -s /usr/bin/pip3 /usr/bin/pip
 
 ENV LANG C.UTF-8
 ENV LC_ALL C.UTF-8
@@ -38,4 +38,4 @@ RUN mkdir ~/bin && cd ~/bin && \
 	for tool in gcc g++ cpp c++;do ln -s $(which ccache) arm-none-eabi-$tool;done
 
 CMD cd .. && cd build && \
-    cmake .. && make firmware
+	cmake .. && make firmware

dockerfile-nogit-alpine

@@ -0,0 +1,27 @@
+FROM alpine:edge
+
+# Download ARM toolkit.
+RUN apk add --no-cache gcc-arm-none-eabi gcc
+
+# Create volume /havoc/bin for compiled firmware binaries
+VOLUME /havoc
+WORKDIR /havoc/firmware
+
+# Fetch dependencies from APK
+RUN echo "http://dl-cdn.alpinelinux.org/alpine/edge/testing" >> /etc/apk/repositories
+RUN apk update -U
+RUN apk add --no-cache git tar wget cmake curl bzip2 lz4 make
+RUN apk add --no-cache dfu-util ccache icu-data-full
+RUN apk add --no-cache python3 py3-pip py3-yaml
+RUN apk add --no-cache py3-pyyaml-env-tag
+RUN apk add --no-cache g++ gcc clang clang-static clang-dev llvm-dev llvm-static
+
+ENV LANG C.UTF-8
+ENV LC_ALL C.UTF-8
+
+# Configure CCACHE
+RUN mkdir ~/bin && cd ~/bin && \
+    for tool in gcc g++ cpp c++;do ln -s $(which ccache) arm-none-eabi-$tool;done
+
+CMD cd .. && cd build && \
+    cmake .. && make firmware

firmware/CMakeLists.txt

@@ -28,6 +28,7 @@ set(CHIBIOS_PORTAPACK ${PROJECT_SOURCE_DIR}/chibios-portapack)
 set(EXTRACT_CPLD_DATA ${PROJECT_SOURCE_DIR}/tools/extract_cpld_data.py)
 set(MAKE_SPI_IMAGE ${PROJECT_SOURCE_DIR}/tools/make_spi_image.py)
 set(MAKE_IMAGE_CHUNK ${PROJECT_SOURCE_DIR}/tools/make_image_chunk.py)
+set(LZ4 lz4)
 
 set(FIRMWARE_NAME portapack-h1_h2-mayhem)
 set(FIRMWARE_FILENAME ${FIRMWARE_NAME}.bin)

firmware/application/CMakeLists.txt

@@ -103,6 +103,7 @@ set(CSRC
 	${PLATFORMSRC}
 	${BOARDSRC}
 	${FATFSSRC}
+	firmware_info.c
 )
 
 # C++ sources that can be compiled in ARM or THUMB mode depending on the global
@@ -124,7 +125,7 @@ set(CPPSRC
 	${COMMON}/cpld_max5.cpp
 	${COMMON}/cpld_update.cpp
 	${COMMON}/cpld_xilinx.cpp
-	${COMMON}/debug.cpp
+	debug.cpp
 	${COMMON}/ert_packet.cpp
 	${COMMON}/event.cpp
 	${COMMON}/gcc.cpp
@@ -154,11 +155,14 @@ set(CPPSRC
 	${COMMON}/ui_widget.cpp
 	${COMMON}/utility.cpp
 	${COMMON}/wm8731.cpp
+	${COMMON}/performance_counter.cpp
+	app_settings.cpp
 	audio.cpp
 	baseband_api.cpp
 	capture_thread.cpp
 	clock_manager.cpp
 	core_control.cpp
+	database.cpp
 	de_bruijn.cpp
 	#emu_cc1101.cpp
 	rfm69.cpp
@@ -172,6 +176,7 @@ set(CPPSRC
 	irq_rtc.cpp
 	log_file.cpp
 	portapack.cpp
+	qrcodegen.cpp
 	radio.cpp
 	receiver_model.cpp
 	recent_entries.cpp
@@ -190,6 +195,7 @@ set(CPPSRC
 	hw/debounce.cpp
 	hw/encoder.cpp
 	hw/max2837.cpp
+	hw/max2839.cpp
 	hw/max5864.cpp
 	hw/rffc507x.cpp
 	hw/rffc507x_spi.cpp
@@ -206,6 +212,7 @@ set(CPPSRC
 	ui/ui_channel.cpp
 	ui/ui_font_fixed_8x16.cpp
 	ui/ui_geomap.cpp
+        ui/ui_qrcode.cpp
 	ui/ui_menu.cpp
 	ui/ui_btngrid.cpp
 	ui/ui_receiver.cpp
@@ -224,10 +231,13 @@ set(CPPSRC
 	apps/ui_nrf_rx.cpp
 	apps/ui_aprs_tx.cpp
 	apps/ui_bht_tx.cpp
+	apps/ui_dfu_menu.cpp
 	apps/ui_coasterp.cpp
 	apps/ui_debug.cpp
 	apps/ui_encoders.cpp
 	apps/ui_fileman.cpp
+	apps/ui_flash_utility.cpp
+	apps/ui_sd_over_usb.cpp
 	apps/ui_freqman.cpp
 	apps/ui_jammer.cpp
 	apps/ui_keyfob.cpp
@@ -263,8 +273,13 @@ set(CPPSRC
 	apps/lge_app.cpp
 	apps/pocsag_app.cpp
 	apps/replay_app.cpp
+	apps/ui_playlist.cpp
 	apps/gps_sim_app.cpp
 	apps/soundboard_app.cpp
+	apps/ui_recon.cpp  
+	apps/ui_recon_settings.cpp
+	apps/ui_level.cpp  
+	apps/tpms_app.cpp
 	apps/tpms_app.cpp
 	protocols/aprs.cpp
 	protocols/ax25.cpp
@@ -306,7 +321,10 @@ set(TCSRC)
 set(TCPPSRC)
 
 # List ASM source files here
-set(ASMSRC ${PORTASM})
+set(ASMSRC
+	${PORTASM}
+	lz4.S
+)
 
 set(INCDIR ${CMAKE_CURRENT_BINARY_DIR} ${COMMON} ${PORTINC} ${KERNINC} ${TESTINC}
 	${HALINC} ${PLATFORMINC} ${BOARDINC}

firmware/application/app_settings.cpp

@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ * Copyright (C) 2022 Arjan Onwezen
+ *
+ * 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 "app_settings.hpp"
+
+#include "file.hpp"
+#include "portapack.hpp"
+#include "portapack_persistent_memory.hpp"
+#include <cstring>
+#include <algorithm>
+
+namespace std {
+
+int app_settings::load(std::string application, AppSettings* settings) {
+
+	if (portapack::persistent_memory::load_app_settings()) {
+		file_path = folder+"/"+application+".ini";
+
+		auto error = settings_file.open(file_path);
+		if (!error.is_valid()) {
+			auto error = settings_file.read(file_content, std::min((int)settings_file.size(), MAX_FILE_CONTENT_SIZE));
+
+			settings->baseband_bandwidth=std::app_settings::read_long_long(file_content, "baseband_bandwidth=");
+			settings->channel_bandwidth=std::app_settings::read_long_long(file_content, "channel_bandwidth=");
+			settings->lna=std::app_settings::read_long_long(file_content, "lna=");
+			settings->modulation=std::app_settings::read_long_long(file_content, "modulation=");
+			settings->rx_amp=std::app_settings::read_long_long(file_content, "rx_amp=");
+			settings->rx_frequency=std::app_settings::read_long_long(file_content, "rx_frequency=");
+			settings->sampling_rate=std::app_settings::read_long_long(file_content, "sampling_rate=");
+			settings->vga=std::app_settings::read_long_long(file_content, "vga=");
+			settings->tx_amp=std::app_settings::read_long_long(file_content, "tx_amp=");
+			settings->tx_frequency=std::app_settings::read_long_long(file_content, "tx_frequency=");
+			settings->tx_gain=std::app_settings::read_long_long(file_content, "tx_gain=");
+			settings->step=std::app_settings::read_long_long(file_content, "step=");
+			settings->modulation=std::app_settings::read_long_long(file_content, "modulation=");
+			settings->am_config_index=std::app_settings::read_long_long(file_content, "am_config_index=");
+			settings->nbfm_config_index=std::app_settings::read_long_long(file_content, "nbfm_config_index=");
+			settings->wfm_config_index=std::app_settings::read_long_long(file_content, "wfm_config_index=");
+			settings->squelch=std::app_settings::read_long_long(file_content, "squelch=");
+
+			rc = SETTINGS_OK;
+		}
+		else rc = SETTINGS_UNABLE_TO_LOAD;
+	}
+	else rc = SETTINGS_DISABLED;
+	return(rc);
+}
+
+int app_settings::save(std::string application, AppSettings* settings) {
+
+	if (portapack::persistent_memory::save_app_settings()) {
+		file_path = folder+"/"+application+".ini";
+		make_new_directory(folder);
+
+		auto error = settings_file.create(file_path);
+		if (!error.is_valid()) {
+			// Save common setting
+			settings_file.write_line("baseband_bandwidth="+to_string_dec_uint(portapack::receiver_model.baseband_bandwidth()));
+			settings_file.write_line("channel_bandwidth="+to_string_dec_uint(portapack::transmitter_model.channel_bandwidth()));
+			settings_file.write_line("lna="+to_string_dec_uint(portapack::receiver_model.lna()));
+			settings_file.write_line("rx_amp="+to_string_dec_uint(portapack::receiver_model.rf_amp()));
+			settings_file.write_line("sampling_rate="+to_string_dec_uint(portapack::receiver_model.sampling_rate()));
+			settings_file.write_line("tx_amp="+to_string_dec_uint(portapack::transmitter_model.rf_amp()));
+			settings_file.write_line("tx_gain="+to_string_dec_uint(portapack::transmitter_model.tx_gain()));
+			settings_file.write_line("vga="+to_string_dec_uint(portapack::receiver_model.vga()));
+			// Save other settings from struct
+			settings_file.write_line("rx_frequency="+to_string_dec_uint(settings->rx_frequency));
+			settings_file.write_line("tx_frequency="+to_string_dec_uint(settings->tx_frequency));
+			settings_file.write_line("step="+to_string_dec_uint(settings->step));
+			settings_file.write_line("modulation="+to_string_dec_uint(settings->modulation));
+			settings_file.write_line("am_config_index="+to_string_dec_uint(settings->am_config_index));
+			settings_file.write_line("nbfm_config_index="+to_string_dec_uint(settings->nbfm_config_index));
+			settings_file.write_line("wfm_config_index="+to_string_dec_uint(settings->wfm_config_index));
+			settings_file.write_line("squelch="+to_string_dec_uint(settings->squelch));
+
+			rc = SETTINGS_OK;
+		}
+		else rc = SETTINGS_UNABLE_TO_SAVE;
+	}
+	else rc = SETTINGS_DISABLED;
+	return(rc);
+}
+
+
+long long int app_settings::read_long_long(char* file_content, const char* setting_text) {
+	auto position = strstr(file_content, (char *)setting_text);
+	if (position) {
+		position += strlen((char *)setting_text);
+		setting_value = strtoll(position, nullptr, 10);
+	}
+	return(setting_value);
+}
+
+
+} /* namespace std */

firmware/application/app_settings.hpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ * Copyright (C) 2022 Arjan Onwezen
+ *
+ * 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 __APP_SETTINGS_H__
+#define __APP_SETTINGS_H__
+
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include "file.hpp"
+#include "string_format.hpp"
+
+
+namespace std {
+class app_settings {
+
+
+
+public:
+
+#define SETTINGS_OK	 	 	0		// settings found
+#define SETTINGS_UNABLE_TO_LOAD		-1		// settings (file) not found
+#define SETTINGS_UNABLE_TO_SAVE		-2		// unable to save settings
+#define SETTINGS_DISABLED		-3		// load/save settings disabled in settings
+
+
+
+	struct AppSettings {
+		uint32_t 	baseband_bandwidth;
+		uint32_t 	channel_bandwidth;
+		uint8_t 	lna;
+		uint8_t		modulation;
+		uint8_t 	rx_amp;
+		uint32_t 	rx_frequency;
+		uint32_t 	sampling_rate;
+		uint8_t 	tx_amp;
+		uint32_t 	tx_frequency;
+		uint8_t 	tx_gain;
+		uint8_t 	vga;
+		uint32_t 	step;
+		uint8_t 	am_config_index;
+		uint8_t 	nbfm_config_index;
+		uint8_t 	wfm_config_index;
+		uint8_t 	squelch;
+	};
+
+	int load(std::string application, AppSettings* settings);
+	int save(std::string application, AppSettings* settings);
+
+
+private:
+
+#define MAX_FILE_CONTENT_SIZE 1000
+
+	char 		file_content[MAX_FILE_CONTENT_SIZE] = {};	
+	std::string 	file_path = "";
+	std::string 	folder = "SETTINGS";
+	int		rc = SETTINGS_OK;
+	File 		settings_file { };
+	long long int	setting_value {} ;	
+
+	long long int read_long_long(char* file_content, const char* setting_text);
+
+
+}; // class app_settings
+} // namespace std
+
+
+
+#endif/*__APP_SETTINGS_H__*/

firmware/application/apps/ais_app.cpp

@@ -22,6 +22,7 @@
 #include "ais_app.hpp"
 
 #include "string_format.hpp"
+#include "database.hpp"
 
 #include "baseband_api.hpp"
 
@@ -59,7 +60,32 @@ static float latlon_float(const int32_t normalized) {
 static std::string mmsi(
 	const ais::MMSI& mmsi
 ) {
-	return to_string_dec_uint(mmsi, 9);
+	return to_string_dec_uint(mmsi, 9, '0'); // MMSI is always is always 9 characters pre-padded with zeros
+}
+
+
+static std::string mid(
+	const ais::MMSI& mmsi
+) {
+	std::database 			db;
+	std::string 			mid_code = "";
+	std::database::MidDBRecord 	mid_record = {};
+	int 				return_code = 0;
+
+	// Try getting the country name from mids.db using MID code for given MMSI
+	mid_code = to_string_dec_uint(mmsi, 9, ' ').substr(0, 3);
+	return_code = db.retrieve_mid_record(&mid_record, mid_code);
+	switch(return_code) {
+		case DATABASE_RECORD_FOUND: 	return mid_record.country;
+		case DATABASE_NOT_FOUND: 	return "No mids.db file";
+		default:			return "";
+	}
+}
+
+static std::string text(const std::string &text) {
+	size_t end = text.find_last_not_of("@");
+    return (end == std::string::npos) ? "" : text.substr(0, end + 1);
+
 }
 
 static std::string navigational_status(const unsigned int value) {
@@ -144,7 +170,7 @@ void AISLogger::on_packet(const ais::Packet& packet) {
 	}
 
 	log_file.write_entry(packet.received_at(), entry);
-}	
+}
 
 void AISRecentEntry::update(const ais::Packet& packet) {
 	received_count++;
@@ -175,6 +201,15 @@ void AISRecentEntry::update(const ais::Packet& packet) {
 		destination = packet.text(302, 20);
 		break;
 
+	case 18:
+	    last_position.timestamp = packet.received_at();
+		last_position.speed_over_ground = packet.read(46, 10);
+		last_position.latitude = packet.latitude(85);
+		last_position.longitude = packet.longitude(57);
+		last_position.course_over_ground = packet.read(112, 12);
+		last_position.true_heading = packet.read(124, 9);
+	    break;
+
 	case 21:
 		name = packet.text(43, 20);
 		last_position.timestamp = packet.received_at();
@@ -182,6 +217,23 @@ void AISRecentEntry::update(const ais::Packet& packet) {
 		last_position.longitude = packet.longitude(164);
 		break;
 
+	case 24:
+		switch (packet.read(38, 2))
+		{
+		case 0:
+			name = packet.text(40, 20);
+			break;
+
+		case 1:
+			call_sign = packet.text(90, 7);
+			break;
+
+		default:
+			break;
+		}
+
+		break;
+
 	default:
 		break;
 	}
@@ -198,9 +250,9 @@ void RecentEntriesTable<AISRecentEntries>::draw(
 ) {
 	std::string line = ais::format::mmsi(entry.mmsi) + " ";
 	if( !entry.name.empty() ) {
-		line += entry.name;
+		line += ais::format::text(entry.name);
 	} else {
-		line += entry.call_sign;
+		line += ais::format::text(entry.call_sign);
 	}
 
 	line.resize(target_rect.width() / 8, ' ');
@@ -221,7 +273,7 @@ AISRecentEntryDetailView::AISRecentEntryDetailView(NavigationView& nav) {
 
 	button_see_map.on_select = [this, &nav](Button&) {
 		geomap_view = nav.push<GeoMapView>(
-			entry_.name,
+			ais::format::text(entry_.name),
 			0,
 			GeoPos::alt_unit::METERS,
 			ais::format::latlon_float(entry_.last_position.latitude.normalized()),
@@ -232,15 +284,25 @@ AISRecentEntryDetailView::AISRecentEntryDetailView(NavigationView& nav) {
 			});
 			send_updates = true;
 
-		
+
 	};
-	
-	
+}
+
+
+AISRecentEntryDetailView::AISRecentEntryDetailView(const AISRecentEntryDetailView&Entry) : View()
+{
+    (void)Entry;
+}
+
+AISRecentEntryDetailView & AISRecentEntryDetailView::operator=(const AISRecentEntryDetailView&Entry)
+{
+    (void)Entry;
+    return *this;
 }
 
 void AISRecentEntryDetailView::update_position() {
 	if (send_updates)
-		geomap_view->update_position(ais::format::latlon_float(entry_.last_position.latitude.normalized()), ais::format::latlon_float(entry_.last_position.longitude.normalized()), (float)entry_.last_position.true_heading);
+		geomap_view->update_position(ais::format::latlon_float(entry_.last_position.latitude.normalized()), ais::format::latlon_float(entry_.last_position.longitude.normalized()), (float)entry_.last_position.true_heading, 0);
 }
 
 void AISRecentEntryDetailView::focus() {
@@ -271,9 +333,10 @@ void AISRecentEntryDetailView::paint(Painter& painter) {
 	auto field_rect = Rect { rect.left(), rect.top() + 16, rect.width(), 16 };
 
 	field_rect = draw_field(painter, field_rect, s, "MMSI", ais::format::mmsi(entry_.mmsi));
-	field_rect = draw_field(painter, field_rect, s, "Name", entry_.name);
-	field_rect = draw_field(painter, field_rect, s, "Call", entry_.call_sign);
-	field_rect = draw_field(painter, field_rect, s, "Dest", entry_.destination);
+	field_rect = draw_field(painter, field_rect, s, "Ctry", ais::format::mid(entry_.mmsi));
+	field_rect = draw_field(painter, field_rect, s, "Name", ais::format::text(entry_.name));
+	field_rect = draw_field(painter, field_rect, s, "Call", ais::format::text(entry_.call_sign));
+	field_rect = draw_field(painter, field_rect, s, "Dest", ais::format::text(entry_.destination));
 	field_rect = draw_field(painter, field_rect, s, "Last", to_string_datetime(entry_.last_position.timestamp));
 	field_rect = draw_field(painter, field_rect, s, "Pos ", ais::format::latlon(entry_.last_position.latitude, entry_.last_position.longitude));
 	field_rect = draw_field(painter, field_rect, s, "Stat", ais::format::navigational_status(entry_.navigational_status));
@@ -304,19 +367,23 @@ AISAppView::AISAppView(NavigationView& nav) : nav_ { nav } {
 		&recent_entry_detail_view,
 	});
 
+
+	// load app settings
+	auto rc = settings.load("rx_ais", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+		target_frequency_ = app_settings.rx_frequency;
+	}
+	else target_frequency_ = initial_target_frequency;
+
 	recent_entry_detail_view.hidden(true);
 
-	target_frequency_ = initial_target_frequency;
-
-	radio::enable({
-		tuning_frequency(),
-		sampling_rate,
-		baseband_bandwidth,
-		rf::Direction::Receive,
-		receiver_model.rf_amp(),
-		static_cast<int8_t>(receiver_model.lna()),
-		static_cast<int8_t>(receiver_model.vga()),
-	});
+    	receiver_model.set_tuning_frequency(tuning_frequency());
+    	receiver_model.set_sampling_rate(sampling_rate);
+    	receiver_model.set_baseband_bandwidth(baseband_bandwidth);
+    	receiver_model.enable();  // Before using radio::enable(), but not updating Ant.DC-Bias.
 
 	options_channel.on_change = [this](size_t, OptionsField::value_t v) {
 		this->on_frequency_changed(v);
@@ -337,7 +404,12 @@ AISAppView::AISAppView(NavigationView& nav) : nav_ { nav } {
 }
 
 AISAppView::~AISAppView() {
-	radio::disable();
+
+	// save app settings
+	app_settings.rx_frequency = target_frequency_;
+	settings.save("rx_ais", &app_settings);
+
+	receiver_model.disable();   // to switch off all, including DC bias.
 
 	baseband::shutdown();
 }

firmware/application/apps/ais_app.hpp

@@ -33,7 +33,7 @@
 #include "event_m0.hpp"
 
 #include "log_file.hpp"
-
+#include "app_settings.hpp"
 #include "ais_packet.hpp"
 
 #include "lpc43xx_cpp.hpp"
@@ -127,15 +127,18 @@ public:
 	void focus() override;
 	void paint(Painter&) override;
 
+    AISRecentEntryDetailView(const AISRecentEntryDetailView&Entry);
+    AISRecentEntryDetailView &operator=(const AISRecentEntryDetailView&Entry);
+
 private:
 	AISRecentEntry entry_ { };
 
 	Button button_done {
-		{ 125, 216, 96, 24 },
+		{ 125, 224, 96, 24 },
 		"Done"
 	};
 	Button button_see_map {
-		{ 19, 216, 96, 24 },
+		{ 19, 224, 96, 24 },
 		"See on map"
 	};
 	GeoMapView* geomap_view { nullptr };
@@ -163,12 +166,18 @@ public:
 
 	void focus() override;
 
-	std::string title() const override { return "AIS"; };
+	std::string title() const override { return "AIS RX"; };
 
 private:
 	static constexpr uint32_t initial_target_frequency = 162025000;
 	static constexpr uint32_t sampling_rate = 2457600;
 	static constexpr uint32_t baseband_bandwidth = 1750000;
+
+
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	NavigationView& nav_;
 
 	AISRecentEntries recent { };

firmware/application/apps/analog_audio_app.cpp

@@ -129,11 +129,26 @@ AnalogAudioView::AnalogAudioView(
 		&waterfall
 	});
 
-	field_frequency.set_value(receiver_model.tuning_frequency());
-	field_frequency.set_step(receiver_model.frequency_step());
+	// Set on_change before initialising the field
 	field_frequency.on_change = [this](rf::Frequency f) {
 		this->on_tuning_frequency_changed(f);
 	};
+
+	// load app settings
+	auto rc = settings.load("rx_audio", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		receiver_model.set_rf_amp(app_settings.rx_amp);
+		// field_frequency.set_value(app_settings.rx_frequency);
+		receiver_model.set_configuration_without_init(static_cast<ReceiverModel::Mode>(app_settings.modulation), app_settings.step, app_settings.am_config_index, app_settings.nbfm_config_index, app_settings.wfm_config_index, app_settings.squelch);
+	}
+	field_frequency.set_value(receiver_model.tuning_frequency());
+	
+	//Filename Datetime and Frequency
+	record_view.set_filename_date_frequency(true);
+
+	field_frequency.set_step(receiver_model.frequency_step());
 	field_frequency.on_edit = [this, &nav]() {
 		// TODO: Provide separate modal method/scheme?
 		auto new_view = nav.push<FrequencyKeypadView>(receiver_model.tuning_frequency());
@@ -157,6 +172,7 @@ AnalogAudioView::AnalogAudioView(
 
 	const auto modulation = receiver_model.modulation();
 	options_modulation.set_by_value(toUType(modulation));
+
 	options_modulation.on_change = [this](size_t, OptionsField::value_t v) {
 		this->on_modulation_changed(static_cast<ReceiverModel::Mode>(v));
 	};
@@ -180,33 +196,47 @@ AnalogAudioView::AnalogAudioView(
 	audio::output::start();
 
 	update_modulation(static_cast<ReceiverModel::Mode>(modulation));
-    on_modulation_changed(static_cast<ReceiverModel::Mode>(modulation));
+	on_modulation_changed(static_cast<ReceiverModel::Mode>(modulation));
 }
 
 size_t AnalogAudioView::get_spec_bw_index() {
-    return spec_bw_index;
+	return spec_bw_index;
 }
 
 void AnalogAudioView::set_spec_bw(size_t index, uint32_t bw) {
-    spec_bw_index = index;
-    spec_bw = bw;
+	spec_bw_index = index;
+	spec_bw = bw;
 
-    baseband::set_spectrum(bw, spec_trigger);
-    receiver_model.set_sampling_rate(bw);
-    receiver_model.set_baseband_bandwidth(bw/2);
+	baseband::set_spectrum(bw, spec_trigger);
+	receiver_model.set_sampling_rate(bw);
+	receiver_model.set_baseband_bandwidth(bw/2);
 }
 
 uint16_t AnalogAudioView::get_spec_trigger() {
-    return spec_trigger;
+	return spec_trigger;
 }
 
 void AnalogAudioView::set_spec_trigger(uint16_t trigger) {
-    spec_trigger = trigger;
+	spec_trigger = trigger;
 
-    baseband::set_spectrum(spec_bw, spec_trigger);
+	baseband::set_spectrum(spec_bw, spec_trigger);
 }
 
 AnalogAudioView::~AnalogAudioView() {
+
+	// save app settings
+	app_settings.rx_frequency = field_frequency.value();
+	app_settings.lna = receiver_model.lna();
+	app_settings.vga = receiver_model.vga();
+	app_settings.rx_amp = receiver_model.rf_amp();
+	app_settings.step = receiver_model.frequency_step();
+	app_settings.modulation = (uint8_t)receiver_model.modulation();
+	app_settings.am_config_index = receiver_model.am_configuration();
+	app_settings.nbfm_config_index = receiver_model.nbfm_configuration();
+	app_settings.wfm_config_index = receiver_model.wfm_configuration();
+	app_settings.squelch = receiver_model.squelch_level();
+	settings.save("rx_audio", &app_settings);
+
 	// TODO: Manipulating audio codec here, and in ui_receiver.cpp. Good to do
 	// both?
 	audio::output::stop();
@@ -394,9 +424,6 @@ void AnalogAudioView::update_modulation(const ReceiverModel::Mode modulation) {
 	}
 }
 
-/*void AnalogAudioView::squelched() {
-	if (exit_on_squelch) nav_.pop();
-}*/
 
 void AnalogAudioView::handle_coded_squelch(const uint32_t value) {
 	float diff, min_diff = value;

firmware/application/apps/analog_audio_app.hpp

@@ -28,11 +28,11 @@
 #include "ui_receiver.hpp"
 #include "ui_spectrum.hpp"
 #include "ui_record_view.hpp"
-
 #include "ui_font_fixed_8x16.hpp"
-
+#include "app_settings.hpp"
 #include "tone_key.hpp"
 
+
 namespace ui {
 
 constexpr Style style_options_group {
@@ -53,12 +53,13 @@ private:
 
 	OptionsField options_config {
 		{ 3 * 8, 0 * 16 },
-		4,
+		5,
 		{
-			{ "DSB ", 0 },
-			{ "USB ", 0 },
-			{ "LSB ", 0 },
-			{ "CW  ", 0 },
+			{ "DSB 9k ", 0 },
+			{ "DSB 6k ", 0 },
+			{ "USB+3k ", 0 },
+			{ "LSB-3k ", 0 },
+			{ "CW     ", 0 },
 		}
 	};
 };
@@ -116,6 +117,7 @@ private:
 			{ " 2m ", 2000000 },
 			{ " 1m ", 1000000 },
 			{ "500k", 500000 },
+			{ "100k", 100000 },
 		}
 	};
 	
@@ -143,7 +145,7 @@ public:
 
 	void focus() override;
 
-	std::string title() const override { return "Analog audio"; };
+	std::string title() const override { return "Audio RX"; };
 
 	size_t get_spec_bw_index();
 	void set_spec_bw(size_t index, uint32_t bw);
@@ -154,6 +156,10 @@ public:
 private:
 	static constexpr ui::Dim header_height = 3 * 16;
 
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	const Rect options_view_rect { 0 * 8, 1 * 16, 30 * 8, 1 * 16 };
 	const Rect nbfm_view_rect { 0 * 8, 1 * 16, 18 * 8, 1 * 16 };
 
@@ -216,7 +222,10 @@ private:
 
 	RecordView record_view {
 		{ 0 * 8, 2 * 16, 30 * 8, 1 * 16 },
-		u"AUD_????", RecordView::FileType::WAV, 4096, 4
+		u"AUD",
+		RecordView::FileType::WAV, 
+		4096, 
+		4
 	};
 
 	spectrum::WaterfallWidget waterfall { true };

firmware/application/apps/analog_tv_app.cpp

@@ -57,11 +57,23 @@ AnalogTvView::AnalogTvView(
 		&tv
 	});
 
-	field_frequency.set_value(receiver_model.tuning_frequency());
-	field_frequency.set_step(receiver_model.frequency_step());
+	// Set on_change before initialising the field
 	field_frequency.on_change = [this](rf::Frequency f) {
 		this->on_tuning_frequency_changed(f);
 	};
+
+	// load app settings
+	auto rc = settings.load("rx_tv", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		receiver_model.set_rf_amp(app_settings.rx_amp);
+		field_frequency.set_value(app_settings.rx_frequency);
+	}
+	else field_frequency.set_value(receiver_model.tuning_frequency());
+
+
+	field_frequency.set_step(receiver_model.frequency_step());
 	field_frequency.on_edit = [this, &nav]() {
 		// TODO: Provide separate modal method/scheme?
 		auto new_view = nav.push<FrequencyKeypadView>(receiver_model.tuning_frequency());
@@ -106,12 +118,15 @@ AnalogTvView::AnalogTvView(
 }
 
 AnalogTvView::~AnalogTvView() {
+
+	// save app settings
+	app_settings.rx_frequency = field_frequency.value();
+	settings.save("rx_tv", &app_settings);
+
 	// TODO: Manipulating audio codec here, and in ui_receiver.cpp. Good to do
 	// both?
 	audio::output::stop();
-
 	receiver_model.disable();
-
 	baseband::shutdown();
 }
 

firmware/application/apps/analog_tv_app.hpp

@@ -29,7 +29,7 @@
 #include "ui_receiver.hpp"
 #include "ui_tv.hpp"
 #include "ui_record_view.hpp"
-
+#include "app_settings.hpp"
 #include "ui_font_fixed_8x16.hpp"
 
 #include "tone_key.hpp"
@@ -53,11 +53,15 @@ public:
 
 	void focus() override;
 
-	std::string title() const override { return "Analog TV"; };
+	std::string title() const override { return "AnalogTV RX"; };
 	
 private:
 	static constexpr ui::Dim header_height = 3 * 16;
 
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	const Rect options_view_rect { 0 * 8, 1 * 16, 30 * 8, 1 * 16 };
 	const Rect nbfm_view_rect { 0 * 8, 1 * 16, 18 * 8, 1 * 16 };
 

firmware/application/apps/capture_app.cpp

@@ -75,8 +75,8 @@ CaptureAppView::CaptureAppView(NavigationView& nav) {
 	option_bandwidth.on_change = [this](size_t, uint32_t base_rate) {
 		sampling_rate = 8 * base_rate;	// Decimation by 8 done on baseband side
   	    /* base_rate  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  */
+		/* 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.on_hide();
 		record_view.set_sampling_rate(sampling_rate);
@@ -85,12 +85,12 @@ CaptureAppView::CaptureAppView(NavigationView& nav) {
 		
 		switch(sampling_rate) {   // we use the var fs (sampling_rate) , to set up BPF aprox < fs_max/2 by Nyquist theorem. 
 	  
-	  			case 0 ... 2000000:  //  BW Captured range  (0 <= 250Khz max )  fs = 8 x 250 Khz 
+	  			case 0 ... 2000000:  //  BW Captured range  (0 <= 250kHz max )  fs = 8 x 250 kHz 
 					anti_alias_baseband_bandwidth_filter = 1750000;  // Minimum BPF MAX2837 for all those lower BW options.
         	 		break;
 
-				case 4000000 ... 6000000:    // BW capture  range (500k ... 750Khz max )  fs_max = 8 x 750Khz = 6Mhz 
-     				//  BW 500k ... 750khz   ,  ex. 500khz   (fs = 8*BW =  4Mhz) , BW 600Khz (fs = 4,8Mhz) , BW  750 Khz (fs = 6Mhz)  
+				case 4000000 ... 6000000:    // BW capture  range (500k ... 750kHz max )  fs_max = 8 x 750kHz = 6Mhz 
+     				//  BW 500k ... 750kHz   ,  ex. 500kHz   (fs = 8*BW =  4Mhz) , BW 600kHz (fs = 4,8Mhz) , BW  750 kHz (fs = 6Mhz)  
 					anti_alias_baseband_bandwidth_filter = 2500000;  // in some IC MAX2837 appear 2250000 , but both works similar. 
 					break;	
 
@@ -123,7 +123,7 @@ CaptureAppView::CaptureAppView(NavigationView& nav) {
 		waterfall.on_show();
 	};
 	
-	option_bandwidth.set_selected_index(7);		// 500k,  Preselected starting default option 500khz 
+	option_bandwidth.set_selected_index(7);		// 500k,  Preselected starting default option 500kHz 
 	
 	receiver_model.set_modulation(ReceiverModel::Mode::Capture);
 	receiver_model.enable();

firmware/application/apps/ert_app.cpp

@@ -41,6 +41,7 @@ std::string type(Packet::Type value) {
 	case Packet::Type::Unknown:	return "???";
 	case Packet::Type::IDM:		return "IDM";
 	case Packet::Type::SCM:		return "SCM";
+	case Packet::Type::SCMPLUS:	return "SCM+";
 	}
 }
 
@@ -62,7 +63,8 @@ std::string commodity_type(CommodityType value) {
 
 void ERTLogger::on_packet(const ert::Packet& packet) {
 	const auto formatted = packet.symbols_formatted();
-	log_file.write_entry(packet.received_at(), formatted.data + "/" + formatted.errors);
+	std::string entry = ert::format::type(packet.type()) + " " + formatted.data + "/" + formatted.errors;
+	log_file.write_entry(packet.received_at(), entry);
 }
 
 const ERTRecentEntry::Key ERTRecentEntry::invalid_key { };
@@ -105,7 +107,20 @@ ERTAppView::ERTAppView(NavigationView&) {
 		&recent_entries_view,
 	});
 
-	radio::enable({
+	// load app settings
+	auto rc = settings.load("rx_ert", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+	}
+
+	receiver_model.set_tuning_frequency(initial_target_frequency);
+	receiver_model.set_sampling_rate(sampling_rate);
+	receiver_model.set_baseband_bandwidth(baseband_bandwidth);
+	receiver_model.enable();  // Before using radio::enable(), but not updating Ant.DC-Bias.
+
+/*	radio::enable({
 		initial_target_frequency,
 		sampling_rate,
 		baseband_bandwidth,
@@ -113,7 +128,7 @@ ERTAppView::ERTAppView(NavigationView&) {
 		receiver_model.rf_amp(),
 		static_cast<int8_t>(receiver_model.lna()),
 		static_cast<int8_t>(receiver_model.vga()),
-	});
+	}); */
 
 	logger = std::make_unique<ERTLogger>();
 	if( logger ) {
@@ -122,7 +137,11 @@ ERTAppView::ERTAppView(NavigationView&) {
 }
 
 ERTAppView::~ERTAppView() {
-	radio::disable();
+
+	// save app settings
+	settings.save("rx_ert", &app_settings);
+
+	receiver_model.disable(); // to switch off all, including DC bias and change flag enabled_
 
 	baseband::shutdown();
 }

firmware/application/apps/ert_app.hpp

@@ -28,7 +28,7 @@
 #include "ui_channel.hpp"
 
 #include "event_m0.hpp"
-
+#include "app_settings.hpp"
 #include "log_file.hpp"
 
 #include "ert_packet.hpp"
@@ -125,12 +125,17 @@ public:
 
 	void focus() override;
 
-	std::string title() const override { return "ERT"; };
+	std::string title() const override { return "ERT RX"; };
 
 private:
 	ERTRecentEntries recent { };
 	std::unique_ptr<ERTLogger> logger { };
 
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
+
 	const RecentEntriesColumns columns { {
 		{ "ID", 10 },
 		{ "Tp", 2 },

firmware/application/apps/gps_sim_app.cpp

@@ -29,6 +29,7 @@
 
 #include "baseband_api.hpp"
 #include "portapack.hpp"
+#include "cpld_update.hpp"
 #include "portapack_persistent_memory.hpp"
 
 using namespace portapack;
@@ -140,13 +141,24 @@ void GpsSimAppView::start() {
 			}
 		);
 	}
+	field_rfgain.on_change = [this](int32_t v) {
+		tx_gain = v;
+	};  
+	field_rfgain.set_value(tx_gain);
+	receiver_model.set_tx_gain(tx_gain); 
+    
+
+ 	field_rfamp.on_change = [this](int32_t v) {
+		rf_amp = (bool)v;
+	};
+	field_rfamp.set_value(rf_amp ? 14 : 0);
 	
 	radio::enable({
 		receiver_model.tuning_frequency(),
 		sample_rate ,
 		baseband_bandwidth,
 		rf::Direction::Transmit,
-		receiver_model.rf_amp(),
+		rf_amp,         //  previous code line : "receiver_model.rf_amp()," was passing the same rf_amp of all Receiver Apps  
 		static_cast<int8_t>(receiver_model.lna()),
 		static_cast<int8_t>(receiver_model.vga())
 	});
@@ -181,6 +193,9 @@ GpsSimAppView::GpsSimAppView(
 	NavigationView& nav
 ) : nav_ (nav)
 {
+	tx_gain = 35;field_rfgain.set_value(tx_gain);  // Initial default  value (-12 dB's max 47dBs ).
+	field_rfamp.set_value(rf_amp ? 14 : 0);  // Initial default value True. (TX RF amp on , +14dB's)
+	
 	baseband::run_image(portapack::spi_flash::image_tag_gps);
 
 	add_children({
@@ -191,8 +206,8 @@ GpsSimAppView::GpsSimAppView(
 		&text_duration,
 		&progressbar,
 		&field_frequency,
-		&field_lna,
-		&field_rf_amp,
+		&field_rfgain,
+		&field_rfamp,       // let's not use common persistent rf_amp , local rfamp is enough
 		&check_loop,
 		&button_play,
 		&waterfall,
@@ -228,7 +243,8 @@ GpsSimAppView::GpsSimAppView(
 
 GpsSimAppView::~GpsSimAppView() {
 	radio::disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit .
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void GpsSimAppView::on_hide() {

firmware/application/apps/gps_sim_app.hpp

@@ -44,7 +44,7 @@ public:
 	void set_parent_rect(const Rect new_parent_rect) override;
 	void focus() override;
 
-	std::string title() const override { return "GPS Simulator"; };
+	std::string title() const override { return "GPS Sim TX"; };
 	
 private:
 	NavigationView& nav_;
@@ -52,6 +52,8 @@ private:
 	static constexpr ui::Dim header_height = 3 * 16;
 	
 	uint32_t sample_rate = 0;
+	int32_t tx_gain { 47 };
+	bool rf_amp { true }; // aux private var to store temporal, same as Replay App rf_amp user selection.
 	static constexpr uint32_t baseband_bandwidth = 3000000; //filter bandwidth
 	const size_t read_size { 16384 };
 	const size_t buffer_count { 3 };
@@ -76,7 +78,7 @@ private:
 	bool ready_signal { false };
 
 	Labels labels {
-		{ { 10 * 8, 2 * 16 }, "LNA:   A:", Color::light_grey() }
+		{ { 10 * 8, 2 * 16 }, "GAIN   A:", Color::light_grey() }
 	};
 	
 	Button button_open {
@@ -104,11 +106,19 @@ private:
 	FrequencyField field_frequency {
 		{ 0 * 8, 2 * 16 },
 	};
-	LNAGainField field_lna {
-		{ 14 * 8, 2 * 16 }
+	NumberField field_rfgain {
+		{ 14 * 8, 2 * 16 },
+		2,
+		{ 0, 47 },
+		1,
+		' '	
 	};
-	RFAmpField field_rf_amp {
-		{ 19 * 8, 2 * 16 }
+	NumberField field_rfamp {     // previously we were using "RFAmpField field_rf_amp" but that is general Receiver amp setting.
+		{ 19 * 8, 2 * 16 },
+		2,
+		{ 0, 14 },                // this time we will display GUI , 0 or 14 dBs same as Mic and Replay App
+		14,
+		' '
 	};
 	Checkbox check_loop {
 		{ 21 * 8, 2 * 16 },

firmware/application/apps/lge_app.cpp

@@ -27,6 +27,7 @@
 #include "lge_app.hpp"
 
 #include "baseband_api.hpp"
+#include "cpld_update.hpp"
 #include "ui_textentry.hpp"
 
 #include "string_format.hpp"
@@ -39,12 +40,17 @@ using namespace portapack;
 namespace ui {
 
 void LGEView::focus() {
-	options_trame.focus();
+	options_frame.focus();
 }
 
 LGEView::~LGEView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_lge", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit .
+	baseband::shutdown();// better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void LGEView::generate_lge_frame(const uint8_t command, const uint16_t address_a, const uint16_t address_b, std::vector<uint8_t>& data) {
@@ -70,10 +76,10 @@ void LGEView::generate_frame_touche() {
 	std::vector<uint8_t> data { 0x46, 0x28, 0x01, 0x45, 0x27, 0x01, 0x44, 0x23 };
 	
 	console.write("\n\x1B\x07Touche:\x1B\x10");
-	generate_lge_frame(0x96, (field_joueur.value() << 8) | field_salle.value(), 0x0001, data);
+	generate_lge_frame(0x96, (field_player.value() << 8) | field_room.value(), 0x0001, data);
 }
 
-void LGEView::generate_frame_pseudo() {
+void LGEView::generate_frame_nickname() {
 	// 0040.48s:
 	// 30 02 1A 00 19 00 FF 00 02 19 42 52 45 42 49 53 20 00 00 00 00 00 00 00 00 00
 	// 04 01 B0 04 7F 1F 11 33 40 1F 22 01 07 00 00 01 07 00 00 63 05 00 00 99 A2 
@@ -90,15 +96,15 @@ void LGEView::generate_frame_pseudo() {
 	};
 	uint32_t c;
 	
-	//data_header[2] = field_salle.value();	// ?
-	//data_footer[0] = field_salle.value();	// ?
+	//data_header[2] = field_room.value();	// ?
+	//data_footer[0] = field_room.value();	// ?
 	
 	data.insert(data.begin(), data_header.begin(), data_header.end());
 	
-	data.push_back(field_joueur.value());
+	data.push_back(field_player.value());
 	
 	c = 0;
-	for (auto &ch : pseudo) {
+	for (auto &ch : nickname) {
 		data.push_back(ch);
 		c++;
 	}
@@ -108,16 +114,16 @@ void LGEView::generate_frame_pseudo() {
 	while (++c < 16)
 		data.push_back(0x00);
 	
-	data.push_back(field_equipe.value());
+	data.push_back(field_team.value());
 	
 	data.insert(data.end(), data_footer.begin(), data_footer.end());
 	
-	console.write("\n\x1B\x0ESet pseudo:\x1B\x10");
+	console.write("\n\x1B\x0ESet nickname:\x1B\x10");
 	
-	generate_lge_frame(0x02, 0x001A, field_joueur.value(), data);
+	generate_lge_frame(0x02, 0x001A, field_player.value(), data);
 }
 
-void LGEView::generate_frame_equipe() {
+void LGEView::generate_frame_team() {
 	// 0041.83s:
 	// 3D 03 FF FF FF FF 02 03 01 52 4F 55 47 45 00 00 00 00 00 00 00 00 00 00 00 00
 	// 02 56 45 52 54 45 00 00 00 00 00 00 00 00 00 00 00 01 03 42 4C 45 55 45 00 00
@@ -129,10 +135,10 @@ void LGEView::generate_frame_equipe() {
 
 	data.insert(data.begin(), data_header.begin(), data_header.end());
 	
-	data.push_back(field_equipe.value());
+	data.push_back(field_team.value());
 	
 	c = 0;
-	for (auto &ch : pseudo) {
+	for (auto &ch : nickname) {
 		data.push_back(ch);
 		c++;
 	}
@@ -140,14 +146,14 @@ void LGEView::generate_frame_equipe() {
 	while (c++ < 16)
 		data.push_back(0x00);
 	
-	data.push_back(field_equipe.value() - 1);	// Color ?
+	data.push_back(field_team.value() - 1);	// Color ?
 	
-	console.write("\n\x1B\x0ASet equipe:\x1B\x10");
+	console.write("\n\x1B\x0ASet team:\x1B\x10");
 	
 	generate_lge_frame(0x03, data);
 }
 
-void LGEView::generate_frame_broadcast_pseudo() {
+void LGEView::generate_frame_broadcast_nickname() {
 	// 0043.86s:
 	// 3D 04 FF FF FF FF 02 03 19 42 52 45 42 49 53 20 00 00 00 00 00 00 00 00 00 04
 	// 07 50 4F 4E 45 59 20 00 00 00 00 00 00 00 00 00 00 05 1B 41 42 42 59 20 00 00
@@ -159,10 +165,10 @@ void LGEView::generate_frame_broadcast_pseudo() {
 
 	data.insert(data.begin(), data_header.begin(), data_header.end());
 	
-	data.push_back(field_joueur.value());
+	data.push_back(field_player.value());
 	
 	c = 0;
-	for (auto &ch : pseudo) {
+	for (auto &ch : nickname) {
 		data.push_back(ch);
 		c++;
 	}
@@ -172,9 +178,9 @@ void LGEView::generate_frame_broadcast_pseudo() {
 	while (++c < 16)
 		data.push_back(0x00);
 	
-	data.push_back(field_equipe.value());
+	data.push_back(field_team.value());
 	
-	console.write("\n\x1B\x09" "Broadcast pseudo:\x1B\x10");
+	console.write("\n\x1B\x09" "Broadcast nickname:\x1B\x10");
 	
 	generate_lge_frame(0x04, data);
 }
@@ -184,14 +190,14 @@ void LGEView::generate_frame_start() {
 	// 0A 05 FF FF FF FF 02 EC FF FF FF A3 35
 	std::vector<uint8_t> data { 0x02, 0xEC, 0xFF, 0xFF, 0xFF };
 	
-	//data[0] = field_salle.value();	// ?
+	//data[0] = field_room.value();	// ?
 	
 	console.write("\n\x1B\x0DStart:\x1B\x10");
 	generate_lge_frame(0x05, data);
 }
 
 void LGEView::generate_frame_gameover() {
-	std::vector<uint8_t> data { (uint8_t)field_salle.value() };
+	std::vector<uint8_t> data { (uint8_t)field_room.value() };
 	
 	console.write("\n\x1B\x0CGameover:\x1B\x10");
 	generate_lge_frame(0x0D, data);
@@ -203,7 +209,7 @@ void LGEView::generate_frame_collier() {
 	// Custom
 	// 0C 00 13 37 13 37 id flags channel playerid zapduty zaptime checksum CRC CRC
 	// channel: field_channel
-	// playerid: field_joueur
+	// playerid: field_player
 	// zapduty: field_power
 	// zaptime: field_duration
 	
@@ -218,8 +224,8 @@ void LGEView::generate_frame_collier() {
 	std::vector<uint8_t> data {
 		id,
 		flags,
-		(uint8_t)field_salle.value(),
-		(uint8_t)field_joueur.value(),
+		(uint8_t)field_room.value(),
+		(uint8_t)field_player.value(),
 		(uint8_t)field_power.value(),
 		(uint8_t)(field_duration.value() * 10)
 	};
@@ -285,11 +291,11 @@ LGEView::LGEView(NavigationView& nav) {
 	
 	add_children({
 		&labels,
-		&options_trame,
-		&field_salle,
-		&button_texte,
-		&field_equipe,
-		&field_joueur,
+		&options_frame,
+		&field_room,
+		&button_text,
+		&field_team,
+		&field_player,
 		&field_id,
 		&field_power,
 		&field_duration,
@@ -300,20 +306,29 @@ LGEView::LGEView(NavigationView& nav) {
 		&tx_view
 	});
 	
-	field_salle.set_value(1);
-	field_equipe.set_value(1);
-	field_joueur.set_value(1);
+	// load app settings
+	auto rc = settings.load("tx_lge", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
+	field_room.set_value(1);
+	field_team.set_value(1);
+	field_player.set_value(1);
 	field_id.set_value(1);
 	field_power.set_value(1);
 	field_duration.set_value(2);
 	
-	button_texte.on_select = [this, &nav](Button&) {
+	button_text.on_select = [this, &nav](Button&) {
 		text_prompt(
 			nav,
-			pseudo,
+			nickname,
 			15,
 			[this](std::string& buffer) {
-				button_texte.set_text(buffer);
+				button_text.set_text(buffer);
 			});
 	};
 	
@@ -326,15 +341,15 @@ LGEView::LGEView(NavigationView& nav) {
 	
 	tx_view.on_start = [this]() {
 		if (tx_mode == IDLE) {
-			auto i = options_trame.selected_index_value();
+			auto i = options_frame.selected_index_value();
 			if (i == 0)
 				generate_frame_touche();
 			else if (i == 1)
-				generate_frame_pseudo();
+				generate_frame_nickname();
 			else if (i == 2)
-				generate_frame_equipe();
+				generate_frame_team();
 			else if (i == 3)
-				generate_frame_broadcast_pseudo();
+				generate_frame_broadcast_nickname();
 			else if (i == 4)
 				generate_frame_start();
 			else if (i == 5)

firmware/application/apps/lge_app.hpp

@@ -30,6 +30,7 @@
 #include "message.hpp"
 #include "transmitter_model.hpp"
 #include "portapack.hpp"
+#include "app_settings.hpp"
 
 namespace ui {
 
@@ -40,7 +41,7 @@ public:
 	
 	void focus() override;
 	
-	std::string title() const override { return "LGE tool"; };
+	std::string title() const override { return "LGE tool TX"; };
 
 private:
 	enum tx_modes {
@@ -48,15 +49,19 @@ private:
 		SINGLE,
 		ALL
 	};
+
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
 	
 	tx_modes tx_mode = IDLE;
 	
-    RFM69 rfm69 { 5, 0x2DD4, true, true };
+    	RFM69 rfm69 { 5, 0x2DD4, true, true };
     
 	uint32_t frame_size { 0 };
 	uint32_t repeats { 0 };
 	uint32_t channel_index { 0 };
-	std::string pseudo { "ABCDEF" };
+	std::string nickname { "ABCDEF" };
 	
 	rf::Frequency channels[3] = { 868067000, 868183000, 868295000 };
 
@@ -68,9 +73,9 @@ private:
 	}
 	void generate_lge_frame(const uint8_t command, const uint16_t address_a, const uint16_t address_b, std::vector<uint8_t>& data);
 	void generate_frame_touche();
-	void generate_frame_pseudo();
-	void generate_frame_equipe();
-	void generate_frame_broadcast_pseudo();
+	void generate_frame_nickname();
+	void generate_frame_team();
+	void generate_frame_broadcast_nickname();
 	void generate_frame_start();
 	void generate_frame_gameover();
 	void generate_frame_collier();
@@ -79,28 +84,28 @@ private:
 	
 	Labels labels {
 		//{ { 7 * 8, 1 * 8 }, "NO FUN ALLOWED !", Color::red() },
-		{ { 1 * 8, 1 * 8 }, "Trame:", Color::light_grey() },
-		{ { 1 * 8, 3 * 8 }, "Salle:", Color::light_grey() },
-		{ { 14 * 8, 3 * 8 }, "Texte:", Color::light_grey() },
-		{ { 0 * 8, 5 * 8 }, "Equipe:", Color::light_grey() },
-		{ { 0 * 8, 7 * 8 }, "Joueur:", Color::light_grey() },
-		{ { 0 * 8, 10 * 8 }, "Collier:", Color::light_grey() },
+		{ { 1 * 8, 1 * 8 }, "Frame:", Color::light_grey() },
+		{ { 2 * 8, 3 * 8 }, "Room:", Color::light_grey() },
+		{ { 14 * 8, 3 * 8 }, "Text:", Color::light_grey() },
+		{ { 2 * 8, 5 * 8 }, "Team:", Color::light_grey() },
+		{ { 0 * 8, 7 * 8 }, "Player:", Color::light_grey() },
+		{ { 0 * 8, 10 * 8 }, "Vest:", Color::light_grey() },
 		{ { 4 * 8, 12 * 8 }, "ID:", Color::light_grey() },
 		{ { 3 * 8, 14 * 8 }, "Pow:  /10", Color::light_grey() },
-		{ { 1 * 8, 16 * 8 }, "Duree:  x100ms", Color::light_grey() }
+		{ { 2 * 8, 16 * 8 }, "Time:  x100ms", Color::light_grey() }
 	};
 	
-	OptionsField options_trame {
+	OptionsField options_frame {
 		{ 7 * 8, 1 * 8 },
 		13,
 		{
-			{ "Touche", 0 },
-			{ "Set pseudo", 1 },
-			{ "Set equipe", 2 },
-			{ "Brdcst pseudo", 3 },
+			{ "Key", 0 },
+			{ "Set nickname", 1 },
+			{ "Set team", 2 },
+			{ "Brdcst nick", 3 },
 			{ "Start", 4 },
 			{ "Game over", 5 },
-			{ "Set collier", 6 }
+			{ "Set vest", 6 }
 		}
 	};
 	
@@ -111,7 +116,7 @@ private:
 		true
 	};
 	
-	NumberField field_salle {
+	NumberField field_room {
 		{ 7 * 8, 3 * 8 },
 		1,
 		{ 1, 2 },
@@ -119,12 +124,12 @@ private:
 		'0'
 	};
 	
-	Button button_texte {
+	Button button_text {
 		{ 14 * 8, 5 * 8, 16 * 8, 3 * 8 },
 		"ABCDEF"
 	};
 	
-	NumberField field_equipe {
+	NumberField field_team {
 		{ 7 * 8, 5 * 8 },
 		1,
 		{ 1, 6 },
@@ -132,7 +137,7 @@ private:
 		'0'
 	};
 	
-	NumberField field_joueur {
+	NumberField field_player {
 		{ 7 * 8, 7 * 8 },
 		2,
 		{ 1, 50 },

firmware/application/apps/pocsag_app.cpp

@@ -77,15 +77,28 @@ POCSAGAppView::POCSAGAppView(NavigationView& nav) {
 		&console
 	});
 	
+	// Set on_change before initialising the field
+	field_frequency.on_change = [this](rf::Frequency f) {
+		update_freq(f);
+	};
+
+	// load app settings
+	auto rc = settings.load("rx_pocsag", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+		field_frequency.set_value(app_settings.rx_frequency);
+	}
+	else field_frequency.set_value(receiver_model.tuning_frequency());
+
+	receiver_model.set_modulation(ReceiverModel::Mode::NarrowbandFMAudio);
+
 	receiver_model.set_sampling_rate(3072000);
 	receiver_model.set_baseband_bandwidth(1750000);
 	receiver_model.enable();
 	
-	field_frequency.set_value(receiver_model.tuning_frequency());
 	field_frequency.set_step(receiver_model.frequency_step());
-	field_frequency.on_change = [this](rf::Frequency f) {
-		update_freq(f);
-	};
 	field_frequency.on_edit = [this, &nav]() {
 		// TODO: Provide separate modal method/scheme?
 		auto new_view = nav.push<FrequencyKeypadView>(receiver_model.tuning_frequency());
@@ -127,6 +140,11 @@ POCSAGAppView::POCSAGAppView(NavigationView& nav) {
 }
 
 POCSAGAppView::~POCSAGAppView() {	
+
+	// save app settings
+	app_settings.rx_frequency = field_frequency.value();
+	settings.save("rx_pocsag", &app_settings);
+
 	audio::output::stop();
 
 	// Save ignored address

firmware/application/apps/pocsag_app.hpp

@@ -28,7 +28,7 @@
 #include "ui_rssi.hpp"
 
 #include "log_file.hpp"
-
+#include "app_settings.hpp"
 #include "pocsag.hpp"
 #include "pocsag_packet.hpp"
 
@@ -60,6 +60,10 @@ public:
 private:
 	static constexpr uint32_t initial_target_frequency = 466175000;
 
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	bool logging { true };
 	bool ignore { true };
 	uint32_t last_address = 0xFFFFFFFF;

firmware/application/apps/replay_app.cpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
+ * Copyleft  (ↄ) 2022 NotPike
  *
  * This file is part of PortaPack.
  *
@@ -25,7 +26,7 @@
 
 #include "ui_fileman.hpp"
 #include "io_file.hpp"
-
+#include "cpld_update.hpp"
 #include "baseband_api.hpp"
 #include "portapack.hpp"
 #include "portapack_persistent_memory.hpp"
@@ -121,6 +122,7 @@ void ReplayAppView::start() {
 	auto open_error = p->open(file_path);
 	if( open_error.is_valid() ) {
 		file_error();
+		return;                               // Fixes TX bug if there's a file error
 	} else {
 		reader = std::move(p);
 	}
@@ -145,16 +147,31 @@ void ReplayAppView::start() {
 	field_rfgain.set_value(tx_gain);
 	receiver_model.set_tx_gain(tx_gain); 
     
+
+ 	field_rfamp.on_change = [this](int32_t v) {
+		rf_amp = (bool)v;
+	};
+	field_rfamp.set_value(rf_amp ? 14 : 0);
+
+	//Enable Bias Tee if selected
+	radio::set_antenna_bias(portapack::get_antenna_bias());
+		
 	radio::enable({
 		receiver_model.tuning_frequency(),
-		sample_rate * 8 ,
+		sample_rate * 8,
 		baseband_bandwidth,
 		rf::Direction::Transmit,
-		receiver_model.rf_amp(),
+		rf_amp,         //  previous code line : "receiver_model.rf_amp()," was passing the same rf_amp of all Receiver Apps  
 		static_cast<int8_t>(receiver_model.lna()),
 		static_cast<int8_t>(receiver_model.vga())
-	});
-}
+	});  
+	
+	if (portapack::persistent_memory::stealth_mode()){
+		DisplaySleepMessage message;
+		EventDispatcher::send_message(message);
+	}
+	
+} 
 
 void ReplayAppView::stop(const bool do_loop) {
 	if( is_active() )
@@ -163,6 +180,7 @@ void ReplayAppView::stop(const bool do_loop) {
 	if (do_loop && check_loop.value()) {
 		start();
 	} else {
+		radio::set_antenna_bias(false);    //Turn off Bias Tee
 		radio::disable();
 		button_play.set_bitmap(&bitmap_play);
 	}
@@ -186,7 +204,19 @@ ReplayAppView::ReplayAppView(
 ) : nav_ (nav)
 {
 
-	tx_gain = 35;field_rfgain.set_value(tx_gain);
+	tx_gain = 35;field_rfgain.set_value(tx_gain);  // Initial default  value (-12 dB's max ).
+	field_rfamp.set_value(rf_amp ? 14 : 0);  // Initial default value True. (TX RF amp on , +14dB's)
+
+	field_rfamp.on_change = [this](int32_t v) {	// allow initial value change just after opened file.	
+		rf_amp = (bool)v;
+	};
+	field_rfamp.set_value(rf_amp ? 14 : 0);
+
+    field_rfgain.on_change = [this](int32_t v) { // allow initial value change just after opened file.
+		tx_gain = v;
+	};  
+	field_rfgain.set_value(tx_gain);
+
 	baseband::run_image(portapack::spi_flash::image_tag_replay);
 
 	add_children({
@@ -198,7 +228,7 @@ ReplayAppView::ReplayAppView(
 		&progressbar,
 		&field_frequency,
 		&field_rfgain, 
-		&field_rf_amp,
+		&field_rfamp,       // let's not use common rf_amp
 		&check_loop,
 		&button_play,
 		&waterfall,
@@ -234,7 +264,12 @@ ReplayAppView::ReplayAppView(
 
 ReplayAppView::~ReplayAppView() {
 	radio::disable();
-	baseband::shutdown();
+ 
+ 	display.fill_rectangle({ 0,0,240, 320 },Color::black()); //Solving sometimes visible bottom waterfall artifacts, clearing all LCD  pixels. 
+	chThdSleepMilliseconds(40);	// (that happened sometimes if we interrupt the waterfall play at the beggining of the play  around 25% and exit )  
+	hackrf::cpld::load_sram_no_verify();  // to leave all  RX reception ok, without "ghost interference signal problem" at the exit .
+
+	baseband::shutdown(); // better this function at the end, after load_sram(). If not , sometimes produced hang up (now not , it is ok).
 }
 
 void ReplayAppView::on_hide() {

firmware/application/apps/replay_app.hpp

@@ -52,6 +52,7 @@ private:
 	
 	uint32_t sample_rate = 0;
 	int32_t tx_gain { 47 };
+	bool rf_amp { true }; // aux private var to store temporal, Replay App rf_amp user selection.
 	static constexpr uint32_t baseband_bandwidth = 2500000;
 	const size_t read_size { 16384 };
 	const size_t buffer_count { 3 };
@@ -112,8 +113,12 @@ private:
 		1,
 		' '	
 	};
-	RFAmpField field_rf_amp {
-		{ 19 * 8, 2 * 16 }
+	NumberField field_rfamp {     // previously  I was using "RFAmpField field_rf_amp" but that is general Receiver amp setting.
+		{ 19 * 8, 2 * 16 },
+		2,
+		{ 0, 14 },                // this time we will display GUI , 0 or 14 dBs same as Mic App
+		14,
+		' '
 	};
 	Checkbox check_loop {
 		{ 21 * 8, 2 * 16 },

firmware/application/apps/soundboard_app.cpp

@@ -25,6 +25,7 @@
 #include "soundboard_app.hpp"
 #include "string_format.hpp"
 #include "tonesets.hpp"
+#include "cpld_update.hpp"
 
 using namespace tonekey;
 using namespace portapack;
@@ -110,6 +111,7 @@ void SoundBoardView::start_tx(const uint32_t id) {
 		1536000 / 20,		// Update vu-meter at 20Hz
 		transmitter_model.channel_bandwidth(),
 		0,	// Gain is unused
+		8,	// shift_bits_s16, default 8 bits, but  also unused
 		TONES_F2D(tone_key_frequency(tone_key_index), 1536000),
 		0, //AM
 		0, //DSB
@@ -204,7 +206,7 @@ void SoundBoardView::refresh_list() {
 				file_list[n].string().substr(0, 30),
 				ui::Color::white(),
 				nullptr,
-				[this](){
+				[this](KeyEvent){
 					on_select_entry();
 				}
 			});
@@ -240,6 +242,15 @@ SoundBoardView::SoundBoardView(
 		&button_next_page,
 		&tx_view
 	});
+
+	// load app settings
+	auto rc = settings.load("tx_soundboard", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
 	
 	refresh_list();
 
@@ -280,9 +291,14 @@ SoundBoardView::SoundBoardView(
 }
 
 SoundBoardView::~SoundBoardView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_soundboard", &app_settings);
+
 	stop();
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit.
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 }

firmware/application/apps/soundboard_app.hpp

@@ -30,6 +30,7 @@
 #include "lfsr_random.hpp"
 #include "io_wave.hpp"
 #include "tone_key.hpp"
+#include "app_settings.hpp"
 
 namespace ui {
 
@@ -45,10 +46,14 @@ public:
 
 	void focus() override;
 	
-	std::string title() const override { return "Soundboard"; };
+	std::string title() const override { return "Soundbrd TX"; };
 	
 private:
 	NavigationView& nav_;
+
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
 	
 	enum tx_modes {
 		NORMAL = 0,

firmware/application/apps/tpms_app.cpp

@@ -34,6 +34,9 @@ namespace tpms {
 
 namespace format {
 
+static bool use_kpa = true;
+static bool use_celsius = true;
+
 std::string type(Reading::Type type) {
 	return to_string_dec_uint(toUType(type), 2);
 }
@@ -43,11 +46,11 @@ std::string id(TransponderID id) {
 }
 
 std::string pressure(Pressure pressure) {
-	return to_string_dec_int(pressure.kilopascal(), 3);
+	return to_string_dec_int(use_kpa? pressure.kilopascal():pressure.psi(), 3);
 }
 
 std::string temperature(Temperature temperature) {
-	return to_string_dec_int(temperature.celsius(), 3);
+	return to_string_dec_int(use_celsius? temperature.celsius():temperature.fahrenheit(), 3);
 }
 
 std::string flags(Flags flags) {
@@ -105,15 +108,15 @@ void RecentEntriesTable<TPMSRecentEntries>::draw(
 	std::string line = tpms::format::type(entry.type) + " " + tpms::format::id(entry.id);
 
 	if( entry.last_pressure.is_valid() ) {
-		line += " " + tpms::format::pressure(entry.last_pressure.value());
+		line += "  " + tpms::format::pressure(entry.last_pressure.value());
 	} else {
-		line += " " "   ";
+		line += "  " "   ";
 	}
 
 	if( entry.last_temperature.is_valid() ) {
-		line += " " + tpms::format::temperature(entry.last_temperature.value());
+		line += "  " + tpms::format::temperature(entry.last_temperature.value());
 	} else {
-		line += " " "   ";
+		line += "  " "   ";
 	}
 
 	if( entry.received_count > 999 ) {
@@ -139,13 +142,30 @@ TPMSAppView::TPMSAppView(NavigationView&) {
 		&rssi,
 		&channel,
 		&options_band,
+		&options_pressure,
+		&options_temperature,	
 		&field_rf_amp,
 		&field_lna,
 		&field_vga,
-		&recent_entries_view,
+		&recent_entries_view
 	});
 
-	radio::enable({
+	// load app settings
+	auto rc = settings.load("rx_tpms", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+		options_band.set_by_value(app_settings.rx_frequency);
+	}
+	else options_band.set_by_value(receiver_model.tuning_frequency());
+
+    receiver_model.set_tuning_frequency(tuning_frequency());
+    receiver_model.set_sampling_rate(sampling_rate);
+    receiver_model.set_baseband_bandwidth(baseband_bandwidth);
+    receiver_model.enable();  // Before using radio::enable(), but not updating Ant.DC-Bias.
+	
+/*	radio::enable({
 		tuning_frequency(),
 		sampling_rate,
 		baseband_bandwidth,
@@ -153,13 +173,27 @@ TPMSAppView::TPMSAppView(NavigationView&) {
 		receiver_model.rf_amp(),
 		static_cast<int8_t>(receiver_model.lna()),
 		static_cast<int8_t>(receiver_model.vga()),
-	});
+	}); */
 
 	options_band.on_change = [this](size_t, OptionsField::value_t v) {
 		this->on_band_changed(v);
 	};
 	options_band.set_by_value(target_frequency());
 
+	options_pressure.on_change = [this](size_t, int32_t i) {		
+		tpms::format::use_kpa = !i;
+		update_view();
+	};
+
+	options_pressure.set_selected_index(0, true);
+
+	options_temperature.on_change = [this](size_t, int32_t i) {		
+		tpms::format::use_celsius = !i;
+		update_view();
+	};
+
+	options_temperature.set_selected_index(0, true);
+
 	logger = std::make_unique<TPMSLogger>();
 	if( logger ) {
 		logger->append(u"tpms.txt");
@@ -167,7 +201,13 @@ TPMSAppView::TPMSAppView(NavigationView&) {
 }
 
 TPMSAppView::~TPMSAppView() {
-	radio::disable();
+
+
+	// save app settings
+	app_settings.rx_frequency = target_frequency_;
+	settings.save("rx_tpms", &app_settings);
+
+	receiver_model.disable(); // to switch off all, including DC bias and change flag enabled_
 
 	baseband::shutdown();
 }
@@ -176,9 +216,16 @@ void TPMSAppView::focus() {
 	options_band.focus();
 }
 
+void TPMSAppView::update_view() {
+	recent_entries_view.set_parent_rect(view_normal_rect);
+}
+
 void TPMSAppView::set_parent_rect(const Rect new_parent_rect) {
 	View::set_parent_rect(new_parent_rect);
-	recent_entries_view.set_parent_rect({ 0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height });
+
+	view_normal_rect  = { 0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height };
+
+	update_view();
 }
 
 void TPMSAppView::on_packet(const tpms::Packet& packet) {

firmware/application/apps/tpms_app.hpp

@@ -27,7 +27,7 @@
 #include "ui_receiver.hpp"
 #include "ui_rssi.hpp"
 #include "ui_channel.hpp"
-
+#include "app_settings.hpp"
 #include "event_m0.hpp"
 
 #include "log_file.hpp"
@@ -102,14 +102,18 @@ public:
 	void paint(Painter&) override { };
 
 	void focus() override;
-
-	std::string title() const override { return "TPMS"; };
+	
+	std::string title() const override { return "TPMS RX"; };
 
 private:
 	static constexpr uint32_t initial_target_frequency = 315000000;
 	static constexpr uint32_t sampling_rate = 2457600;
 	static constexpr uint32_t baseband_bandwidth = 1750000;
 
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	MessageHandlerRegistration message_handler_packet {
 		Message::ID::TPMSPacket,
 		[this](Message* const p) {
@@ -121,6 +125,8 @@ private:
 
 	static constexpr ui::Dim header_height = 1 * 16;
 
+	ui::Rect view_normal_rect { };
+
 	RSSI rssi {
 		{ 21 * 8, 0, 6 * 8, 4 },
 	};
@@ -134,7 +140,25 @@ private:
 		3,
 		{
 			{ "315", 315000000 },
-			{ "434", 433920000 },
+			{ "433", 433920000 },
+		}
+	};
+
+	OptionsField options_pressure {
+		{ 5 * 8, 0 * 16 },
+		3,
+		{
+			{ "kPa", 0 },
+			{ "PSI", 1 }
+		}
+	};
+
+	OptionsField options_temperature {
+		{ 9 * 8, 0 * 16 },
+		1,
+		{
+			{ "C", 0 },
+			{ "F", 1 }
 		}
 	};
 
@@ -156,8 +180,8 @@ private:
 	const RecentEntriesColumns columns { {
 		{ "Tp", 2 },
 		{ "ID", 8 },
-		{ "kPa", 3 },
-		{ "C", 3 },
+		{ "Pres", 4 },
+		{ "Temp", 4 },
 		{ "Cnt", 3 },
 		{ "Fl", 2 },
 	} };
@@ -167,6 +191,7 @@ private:
 
 	void on_packet(const tpms::Packet& packet);
 	void on_show_list();
+	void update_view();
 
 	void on_band_changed(const uint32_t new_band_frequency);
 

firmware/application/apps/ui_about_simple.cpp

@@ -36,14 +36,16 @@ namespace ui
                 console.writeln("East2West,fossum,ArjanOnwezen");
                 console.writeln("vXxOinvizioNxX,teixeluis");
                 console.writeln("Brumi-2021,texasyojimbo");
-                console.writeln("heurist1,intoxsick");
+                console.writeln("heurist1,intoxsick,ckuethe");
+                console.writeln("notpike,jLynx,zigad");
+                console.writeln("MichalLeonBorsuk,jimilinuxguy");
                 console.writeln("");
                 break;
 
             case 2:
                 // https://github.com/eried/portapack-mayhem/graphs/contributors?to=2020-04-12&from=2015-07-31&type=c
                 console.writeln("\x1B\x06Havoc:\x1B\x10");
-                console.writeln("furrtek,mrmookie,notpike");
+                console.writeln("furrtek,mrmookie,NotPike");
                 console.writeln("mjwaxios,ImDroided,Giorgiofox");
                 console.writeln("F4GEV,z4ziggy,xmycroftx");
                 console.writeln("troussos,silascutler");

firmware/application/apps/ui_adsb_rx.cpp

@@ -46,10 +46,10 @@ void RecentEntriesTable<AircraftRecentEntries>::draw(
 	auto entry_age = entry.age;
 	
 	// Color decay for flights not being updated anymore
-	if (entry_age < ADSB_DECAY_A) {
+	if (entry_age < ADSB_CURRENT) {
 		aged_color = 0x10;
 		target_color = Color::green();
-	} else if (entry_age < ADSB_DECAY_B) {
+	} else if (entry_age < ADSB_RECENT) {
 		aged_color = 0x07;
 		target_color = Color::light_grey();
 	} else {
@@ -59,21 +59,13 @@ void RecentEntriesTable<AircraftRecentEntries>::draw(
 	
 	std::string entry_string = "\x1B";
 	entry_string += aged_color;
-#if false
-	entry_string += to_string_hex(entry.ICAO_address, 6) + " " +
-		entry.callsign + "  " +
-		(entry.hits <= 999 ? to_string_dec_uint(entry.hits, 4) : "999+") + " " + 
-		entry.time_string;
-#else
-	// SBT
 	entry_string += 
-		(entry.callsign[0]!=' ' ? entry.callsign + " " : to_string_hex(entry.ICAO_address, 6) + "   ") +
-		to_string_dec_uint((unsigned int)((entry.pos.altitude+50)/100),4) +
+		(entry.callsign[0]!=' ' ? entry.callsign + " " : entry.icaoStr + "   ") +
+		to_string_dec_uint((unsigned int)(entry.pos.altitude/100),4) +
 		to_string_dec_uint((unsigned int)entry.velo.speed,4) +
 		to_string_dec_uint((unsigned int)(entry.amp>>9),4) + " " +
 		(entry.hits <= 999 ? to_string_dec_uint(entry.hits, 3) + " " : "1k+ ") +
-		to_string_dec_uint(entry.age, 3);
-#endif
+		to_string_dec_uint(entry.age, 4);
 	
 	painter.draw_string(
 		target_rect.location(),
@@ -91,6 +83,115 @@ void ADSBLogger::log_str(std::string& logline) {
 	log_file.write_entry(datetime,logline);
 }
 
+
+// Aircraft Details
+void ADSBRxAircraftDetailsView::focus() {
+	button_close.focus();
+}
+
+ADSBRxAircraftDetailsView::~ADSBRxAircraftDetailsView() {
+	on_close_();
+}
+
+ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
+	NavigationView& nav,
+	const AircraftRecentEntry& entry,
+	const std::function<void(void)> on_close
+) : entry_copy(entry),
+	on_close_(on_close)
+{	
+	
+	add_children({
+		&labels,
+		&text_icao_address,
+		&text_registration,
+		&text_manufacturer,
+		&text_model,
+		&text_type,
+		&text_number_of_engines,
+		&text_engine_type,
+		&text_owner,
+		&text_operator,
+		&button_close
+	});
+	
+	std::unique_ptr<ADSBLogger> logger { };
+
+	icao_code = to_string_hex(entry_copy.ICAO_address, 6);
+	text_icao_address.set(to_string_hex(entry_copy.ICAO_address, 6));
+
+	// Try getting the aircraft information from icao24.db
+	return_code = db.retrieve_aircraft_record(&aircraft_record, icao_code);
+	switch(return_code) {
+		case DATABASE_RECORD_FOUND: 
+			text_registration.set(aircraft_record.aircraft_registration);
+			text_manufacturer.set(aircraft_record.aircraft_manufacturer);
+			text_model.set(aircraft_record.aircraft_model);	
+			text_owner.set(aircraft_record.aircraft_owner);
+			text_operator.set(aircraft_record.aircraft_operator);
+			// Check for ICAO type, e.g. L2J
+			if(strlen(aircraft_record.icao_type) == 3) {
+				switch(aircraft_record.icao_type[0]) {
+					case 'L': 
+						text_type.set("Landplane"); 
+						break;
+					case 'S': 
+						text_type.set("Seaplane"); 
+						break;
+					case 'A': 
+						text_type.set("Amphibian"); 
+						break;
+					case 'H': 
+						text_type.set("Helicopter"); 
+						break;
+					case 'G': 
+						text_type.set("Gyrocopter"); 
+						break;
+					case 'T': 
+						text_type.set("Tilt-wing aircraft"); 
+						break;					
+				}
+				text_number_of_engines.set(std::string(1, aircraft_record.icao_type[1]));
+				switch(aircraft_record.icao_type[2]) {
+					case 'P': 
+						text_engine_type.set("Piston engine"); 
+						break;
+					case 'T': 
+						text_engine_type.set("Turboprop/Turboshaft engine"); 
+						break;
+					case 'J': 
+						text_engine_type.set("Jet engine"); 
+						break;
+					case 'E': 
+						text_engine_type.set("Electric engine"); 
+						break;
+				}
+
+			}
+			// Check for ICAO type designator
+			else if(strlen(aircraft_record.icao_type) == 4) {
+				if(strcmp(aircraft_record.icao_type,"SHIP") == 0) text_type.set("Airship");
+				else if(strcmp(aircraft_record.icao_type,"BALL") == 0) text_type.set("Balloon");
+				else if(strcmp(aircraft_record.icao_type,"GLID") == 0) text_type.set("Glider / sailplane");
+				else if(strcmp(aircraft_record.icao_type,"ULAC") == 0) text_type.set("Micro/ultralight aircraft");
+				else if(strcmp(aircraft_record.icao_type,"GYRO") == 0) text_type.set("Micro/ultralight autogyro");
+				else if(strcmp(aircraft_record.icao_type,"UHEL") == 0) text_type.set("Micro/ultralight helicopter");
+				else if(strcmp(aircraft_record.icao_type,"SHIP") == 0) text_type.set("Airship");
+				else if(strcmp(aircraft_record.icao_type,"PARA") == 0) text_type.set("Powered parachute/paraplane");
+			}
+			break;
+		case DATABASE_NOT_FOUND: 
+			text_manufacturer.set("No icao24.db file");
+			break;	
+	}
+	button_close.on_select =  [&nav](Button&){
+		nav.pop();
+	};
+
+};
+
+// End of Aicraft details
+
 void ADSBRxDetailsView::focus() {
 	button_see_map.focus();
 }
@@ -114,7 +215,10 @@ void ADSBRxDetailsView::update(const AircraftRecentEntry& entry) {
 	text_frame_pos_odd.set(to_string_hex_array(entry_copy.frame_pos_odd.get_raw_data(), 14));
 	
 	if (send_updates)
-		geomap_view->update_position(entry_copy.pos.latitude, entry_copy.pos.longitude, entry_copy.velo.heading);
+	{
+		geomap_view->update_tag(trimr(entry.callsign[0]!=' ' ? entry.callsign : to_string_hex(entry.ICAO_address, 6)));
+		geomap_view->update_position(entry_copy.pos.latitude, entry_copy.pos.longitude, entry_copy.velo.heading, entry_copy.pos.altitude);
+	}
 }
 
 ADSBRxDetailsView::~ADSBRxDetailsView() {
@@ -128,14 +232,10 @@ ADSBRxDetailsView::ADSBRxDetailsView(
 ) : entry_copy(entry),
 	on_close_(on_close)
 {
-	char file_buffer[32] { 0 };
-	bool found = false;
-	int number_of_airlines = 0;	
-	std::string airline_code;
-	size_t c;
-	
+
 	add_children({
 		&labels,
+		&text_icao_address,
 		&text_callsign,
 		&text_last_seen,
 		&text_airline,
@@ -144,6 +244,7 @@ ADSBRxDetailsView::ADSBRxDetailsView(
 		&text_info2,
 		&text_frame_pos_even,
 		&text_frame_pos_odd,
+		&button_aircraft_details,
 		&button_see_map
 	});
 	
@@ -152,43 +253,31 @@ ADSBRxDetailsView::ADSBRxDetailsView(
 
 	// The following won't (shouldn't !) change for a given airborne aircraft
 	// Try getting the airline's name from airlines.db
-	auto result = db_file.open("ADSB/airlines.db");
-	if (!result.is_valid()) {
-		// Search for 3-letter code
-		number_of_airlines = (db_file.size() / 68); // determine number of airlines in file
-		airline_code = entry_copy.callsign.substr(0, 3);
-		c = 0;
-		do {
-			db_file.read(file_buffer, 4);
-			if (!file_buffer[0])
-				break;
-			if (!airline_code.compare(0, 4, file_buffer))
-				found = true;
-			else
-				c++;
-		} while (!found && (c < number_of_airlines));
-		
-		if (found) {
-			db_file.seek((number_of_airlines * 4) + (c << 6)); // seek starting after index
-			db_file.read(file_buffer, 32);
-			text_airline.set(file_buffer);
-			db_file.read(file_buffer, 32);
-			text_country.set(file_buffer);
-		} else {
-			text_airline.set("Unknown");
-			text_country.set("Unknown");
-		}
-	} else {
-		text_airline.set("No airlines.db file");
-		text_country.set("No airlines.db file");
+	airline_code = entry_copy.callsign.substr(0, 3);
+	return_code = db.retrieve_airline_record(&airline_record, airline_code);
+	switch(return_code) {
+		case DATABASE_RECORD_FOUND: 
+			text_airline.set(airline_record.airline);
+			text_country.set(airline_record.country);	
+			break;
+		case DATABASE_NOT_FOUND: 
+			text_airline.set("No airlines.db file");
+			break;
 	}
-	
+
+
 	text_callsign.set(entry_copy.callsign);
-	
+	text_icao_address.set(to_string_hex(entry_copy.ICAO_address, 6));
+
+        button_aircraft_details.on_select = [this, &nav](Button&) {
+		aircraft_details_view = nav.push<ADSBRxAircraftDetailsView>(entry_copy,	[this]() { send_updates = false;});
+		send_updates = false;
+	};
+
 	button_see_map.on_select = [this, &nav](Button&) {
-		if (!send_updates) { // Prevent recursivley launching the map
+		if (!send_updates) { // Prevent recursively launching the map
 			geomap_view = nav.push<GeoMapView>(
-				entry_copy.callsign,
+				trimr(entry_copy.callsign[0]!=' ' ? entry_copy.callsign : entry_copy.icaoStr),
 				entry_copy.pos.altitude,
 				GeoPos::alt_unit::FEET,
 				entry_copy.pos.latitude,
@@ -202,13 +291,19 @@ ADSBRxDetailsView::ADSBRxDetailsView(
 	};
 };
 
+
 void ADSBRxView::focus() {
 	field_vga.focus();
 }
 
 ADSBRxView::~ADSBRxView() {
-	receiver_model.set_tuning_frequency(prevFreq);
+	receiver_model.set_tuning_frequency(prevFreq); // Restore previous frequency on exit
 
+	// save app settings
+	settings.save("rx_adsb", &app_settings);
+
+	//TODO: once all apps keep there own settin previous frequency logic can be removed
+	receiver_model.set_tuning_frequency(prevFreq);
 	rtc_time::signal_tick_second -= signal_token_tick_second;
 	receiver_model.disable();
 	baseband::shutdown();
@@ -220,8 +315,6 @@ AircraftRecentEntry ADSBRxView::find_or_create_entry(uint32_t ICAO_address) {
 	// If not found
 	if (it == std::end(recent)){
 		recent.emplace_front(ICAO_address); // Add it
-		truncate_entries(recent); // Truncate the list
-		sort_entries_by_state();
 		it = find(recent, ICAO_address); // Find it again
 	}
 	return *it;
@@ -236,6 +329,21 @@ void ADSBRxView::replace_entry(AircraftRecentEntry & entry)
 		entry);
 }
 
+void ADSBRxView::remove_old_entries()
+{
+	auto it = recent.rbegin();
+	auto end = recent.rend();
+	while (it != end)
+	{
+		if (it->age_state>=4) {
+			std::advance(it, 1);
+			recent.erase( it.base() );
+		} else {
+			break; // stop looking because the list is sorted
+		}
+	}
+}
+
 void ADSBRxView::sort_entries_by_state()
 {
 	// Sorting List pn age_state using lambda function as comparator
@@ -243,8 +351,8 @@ void ADSBRxView::sort_entries_by_state()
 }
 
 void ADSBRxView::on_frame(const ADSBFrameMessage * message) {
+	logger = std::make_unique<ADSBLogger>();
 	rtc::RTC datetime;
-	std::string str_timestamp;
 	std::string callsign;
 	std::string str_info;
 	std::string logentry;
@@ -259,16 +367,16 @@ void ADSBRxView::on_frame(const ADSBFrameMessage * message) {
 		entry.reset_age();
 		if (entry.hits==0)
 		{ 
-			entry.amp = message->amp;
+			entry.amp = message->amp; // Store amplitude on first hit
 		} else {
-			entry.amp = ((entry.amp*15)+message->amp)>>4;
+			entry.amp = ((entry.amp*15)+message->amp)>>4; // Update smoothed amplitude on updates
 		}
-		str_timestamp = to_string_datetime(datetime, HMS);
-		entry.set_time_string(str_timestamp);
 
 		entry.inc_hit();
-		logentry += to_string_hex_array(frame.get_raw_data(), 14) + " ";
-		logentry += "ICAO:" + to_string_hex(ICAO_address, 6) + " ";
+		if (logger) {
+			logentry += to_string_hex_array(frame.get_raw_data(), 14) + " ";
+			logentry += "ICAO:" + entry.icaoStr + " ";
+		}
 		
 		if (frame.get_DF() == DF_ADSB) {
 			uint8_t msg_type = frame.get_msg_type();
@@ -279,7 +387,9 @@ void ADSBRxView::on_frame(const ADSBFrameMessage * message) {
 			if ((msg_type >= AIRCRAFT_ID_L) && (msg_type <= AIRCRAFT_ID_H)) {
 				callsign = decode_frame_id(frame);
 				entry.set_callsign(callsign);
-				logentry+=callsign+" ";
+				if (logger) {
+					logentry+=callsign+" ";
+				}
 			} 
 			// 9:
 			// 18: { // Extended squitter/non-transponder
@@ -294,30 +404,33 @@ void ADSBRxView::on_frame(const ADSBFrameMessage * message) {
 						" Lat:" + to_string_decimal(entry.pos.latitude, 2) +
 						" Lon:" + to_string_decimal(entry.pos.longitude, 2);
 
-					// printing the coordinates in the log file with more
-					// resolution, as we are not constrained by screen 
-					// real estate there:
-
-					std::string log_info = "Alt:" + to_string_dec_int(entry.pos.altitude) +
-						" Lat:" + to_string_decimal(entry.pos.latitude, 7) +
-						" Lon:" + to_string_decimal(entry.pos.longitude, 7);
 
 					entry.set_info_string(str_info);
-					logentry+=log_info + " ";
+
+					if (logger) {
+						// printing the coordinates in the log file with more
+						// resolution, as we are not constrained by screen 
+						// real estate there:
+
+						std::string log_info = "Alt:" + to_string_dec_int(entry.pos.altitude) +
+							" Lat:" + to_string_decimal(entry.pos.latitude, 7) +
+							" Lon:" + to_string_decimal(entry.pos.longitude, 7);
+						logentry+=log_info + " ";
+					}
 
 				}
 			} else if(msg_type == AIRBORNE_VEL && msg_sub >= VEL_GND_SUBSONIC && msg_sub <= VEL_AIR_SUPERSONIC){
 				entry.set_frame_velo(frame);
-				logentry += "Type:" + to_string_dec_uint(msg_sub) +
-							" Hdg:" + to_string_dec_uint(entry.velo.heading) +
-							" Spd: "+ to_string_dec_int(entry.velo.speed);
+				if (logger) {
+					logentry += "Type:" + to_string_dec_uint(msg_sub) +
+								" Hdg:" + to_string_dec_uint(entry.velo.heading) +
+								" Spd: "+ to_string_dec_int(entry.velo.speed);
+				}
 
 			}
-		}
+			replace_entry(entry);
+		} // frame.get_DF() == DF_ADSB
 
-		replace_entry(entry);
-		
-		logger = std::make_unique<ADSBLogger>();
         if (logger) {
                 logger->append(u"adsb.txt");
                 // will log each frame in format:
@@ -327,20 +440,69 @@ void ADSBRxView::on_frame(const ADSBFrameMessage * message) {
 	}
 }
 
-void ADSBRxView::on_tick_second() {
-	// Decay and refresh if needed
-	for (auto& entry : recent) {
-		entry.inc_age();
-		
-		if (details_view) {
-			if (send_updates && (entry.key() == detailed_entry_key)) // Check if the ICAO address match
-				details_view->update(entry);
+void ADSBRxView::on_tick_second() { 
+	if (recent.size() <= 16){ 		// Not many entries update everything (16 is one screen full)
+		updateDetailsAndMap(1);
+		updateRecentEntries();
+	} else if (updateState==0) { 	// Even second
+		updateState = 1;
+		updateDetailsAndMap(2);
+	} else { 						// Odd second only performed when there are many entries
+		updateState = 0;
+		updateRecentEntries();
+	}
+}
+
+void ADSBRxView::updateDetailsAndMap(int ageStep) {
+	ui::GeoMarker marker;
+	bool storeNewMarkers = false;
+
+	// Sort and truncate the entries, grouped, newest group first
+	sort_entries_by_state();
+	truncate_entries(recent);
+	remove_old_entries();
+
+	// Calculate if it is time to update markers
+	if (send_updates && details_view && details_view->geomap_view) {
+		ticksSinceMarkerRefresh += ageStep;
+		if (ticksSinceMarkerRefresh >= MARKER_UPDATE_SECONDS) { // Update other aircraft every few seconds
+			storeNewMarkers = true;
+			ticksSinceMarkerRefresh=0;
 		}
+	} else {
+		ticksSinceMarkerRefresh = MARKER_UPDATE_SECONDS; // Send the markers as soon as the geoview exists
 	}
 
-	// Sort the list if it is being displayed
-	if (!send_updates) {
-		sort_entries_by_state();
+	// Increment age, and pass updates to the details and map
+	const bool otherMarkersCanBeSent = send_updates && storeNewMarkers && details_view && details_view->geomap_view; // Save retesting all of this
+	MapMarkerStored markerStored = MARKER_NOT_STORED;
+	if (otherMarkersCanBeSent) {details_view->geomap_view->clear_markers();}
+	// Loop through all entries
+	for (auto& entry : recent) {
+		entry.inc_age(ageStep);
+		
+		// Only if there is a details view
+		if (send_updates && details_view) {
+			if (entry.key() == detailed_entry_key) // Check if the ICAO address match
+			{
+				details_view->update(entry);
+			}
+			// Store if the view is present and the list isn't full
+			else if (otherMarkersCanBeSent && (markerStored != MARKER_LIST_FULL) && entry.pos.valid && (entry.age_state<=2)) 
+			{
+				marker.lon = entry.pos.longitude;
+				marker.lat = entry.pos.latitude;
+				marker.angle = entry.velo.heading;
+				marker.tag = trimr(entry.callsign[0]!=' ' ? entry.callsign : entry.icaoStr);
+				markerStored = details_view->geomap_view->store_marker(marker);
+			}
+		}
+	}  // Loop through all entries, if only to update the age
+}
+
+void ADSBRxView::updateRecentEntries() {
+	// Redraw the list of aircraft
+	if (!send_updates){
 		recent_entries_view.set_dirty();
 	}
 }
@@ -356,6 +518,21 @@ ADSBRxView::ADSBRxView(NavigationView& nav) {
 		&recent_entries_view
 	});
 	
+
+	// load app settings
+	auto rc = settings.load("rx_adsb", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+	}
+	else
+	{
+		field_lna.set_value(40);
+		field_vga.set_value(40);
+	}
+
+
 	recent_entries_view.set_parent_rect({ 0, 16, 240, 272 });
 	recent_entries_view.on_select = [this, &nav](const AircraftRecentEntry& entry) {
 		detailed_entry_key = entry.key();
@@ -371,13 +548,11 @@ ADSBRxView::ADSBRxView(NavigationView& nav) {
 		on_tick_second();
 	};
 	
-	prevFreq = receiver_model.tuning_frequency();
+	prevFreq = receiver_model.tuning_frequency(); // Store previous frequency on creation
 
 	baseband::set_adsb();
 	
 	receiver_model.set_tuning_frequency(1090000000);
-	field_lna.set_value(40);
-	field_vga.set_value(40);
 	receiver_model.set_modulation(ReceiverModel::Mode::SpectrumAnalysis);
 	receiver_model.set_sampling_rate(2000000);
 	receiver_model.set_baseband_bandwidth(2500000);

firmware/application/apps/ui_adsb_rx.hpp

@@ -25,22 +25,24 @@
 #include "ui_receiver.hpp"
 #include "ui_geomap.hpp"
 #include "ui_font_fixed_8x16.hpp"
+#include "string_format.hpp"
 
 #include "file.hpp"
+#include "database.hpp"
 #include "recent_entries.hpp"
 #include "log_file.hpp"
 #include "adsb.hpp"
 #include "message.hpp"
-
+#include "app_settings.hpp"
 #include "crc.hpp"
 
 using namespace adsb;
 
 namespace ui {
 
-#define ADSB_DECAY_A 		10		// In seconds
-#define ADSB_DECAY_B 		30
-#define ADSB_DECAY_C 		60		// Can be used for removing old entries, RecentEntries already caps to 64
+#define ADSB_CURRENT 		10		// Seconds
+#define ADSB_RECENT 		30		// Seconds
+#define ADSB_REMOVE 		300		// Used for removing old entries
 
 #define AIRCRAFT_ID_L		1		// aircraft ID message type (lowest type id)
 #define AIRCRAFT_ID_H		4		// aircraft ID message type (highest type id)
@@ -82,14 +84,15 @@ struct AircraftRecentEntry {
 	ADSBFrame frame_pos_even { };
 	ADSBFrame frame_pos_odd { };
 	
+	std::string icaoStr {"      "};
 	std::string callsign { "        " };
-	std::string time_string { "" };
 	std::string info_string { "" };
 	
 	AircraftRecentEntry(
 		const uint32_t ICAO_address
 	) : ICAO_address { ICAO_address }
 	{
+		this->icaoStr = to_string_hex(ICAO_address, 6); 
 	}
 
 	Key key() const {
@@ -124,23 +127,20 @@ struct AircraftRecentEntry {
 		info_string = new_info_string;
 	}
 	
-	void set_time_string(std::string& new_time_string) {
-		time_string = new_time_string;
-	}
-
 	void reset_age() {
 		age = 0;
 	}
 	
-	void inc_age() {
-		age++;
-		if (age < ADSB_DECAY_A)
-		{
+	void inc_age(int delta) {
+		age+=delta;
+		if (age < ADSB_CURRENT){
 			age_state = pos.valid ? 0 : 1;
-		}
-		else
-		{
-			age_state = (age < ADSB_DECAY_B) ? 2 : 3;
+		} else if(age < ADSB_RECENT){
+			age_state = 2;
+		} else if(age < ADSB_REMOVE){
+			age_state = 3;
+		} else{
+			age_state = 4;
 		}
 	}
 };
@@ -159,6 +159,98 @@ private:
 };
 
 
+class ADSBRxAircraftDetailsView : public View {
+public:
+	ADSBRxAircraftDetailsView(NavigationView&, const AircraftRecentEntry& entry, const std::function<void(void)> on_close);
+	~ADSBRxAircraftDetailsView();
+
+	ADSBRxAircraftDetailsView(const ADSBRxAircraftDetailsView&) = delete;
+	ADSBRxAircraftDetailsView(ADSBRxAircraftDetailsView&&) = delete;
+	ADSBRxAircraftDetailsView& operator=(const ADSBRxAircraftDetailsView&) = delete;
+	ADSBRxAircraftDetailsView& operator=(ADSBRxAircraftDetailsView&&) = delete;
+	
+	void focus() override;
+	
+	void update(const AircraftRecentEntry& entry);
+	
+	std::string title() const override { return "AC Details"; };
+
+	AircraftRecentEntry get_current_entry() { return entry_copy; }
+
+	std::database::AircraftDBRecord aircraft_record = {};
+	
+private:
+	AircraftRecentEntry 		entry_copy { 0 };
+	std::function<void(void)> 	on_close_ { };
+	bool 				send_updates { false };
+	std::database 			db = { };
+	std::string 			icao_code = "";
+	int 				return_code = 0;
+
+	Labels labels {
+	        { { 0 * 8, 1 * 16 }, "ICAO:", Color::light_grey() },
+		{ { 0 * 8, 2 * 16 }, "Registration:", Color::light_grey() },
+		{ { 0 * 8, 3 * 16 }, "Manufacturer:", Color::light_grey() },
+		{ { 0 * 8, 5 * 16 }, "Model:", Color::light_grey() },
+		{ { 0 * 8, 7 * 16 }, "Type:", Color::light_grey() },
+		{ { 0 * 8, 8 * 16 }, "Number of engines:", Color::light_grey() },
+		{ { 0 * 8, 9 * 16 }, "Engine type:", Color::light_grey() },
+                { { 0 * 8, 11 * 16 }, "Owner:", Color::light_grey() },
+                { { 0 * 8, 13 * 16 }, "Operator:", Color::light_grey() }
+	};
+	
+        Text text_icao_address {
+		{ 5 * 8, 1 * 16, 6 * 8, 16},
+		"-"	
+        };
+
+	Text text_registration {
+		{ 13 * 8, 2 * 16, 8 * 8, 16 },
+		"-"
+	};
+	
+	Text text_manufacturer {
+		{ 0 * 8, 4 * 16, 19 * 8, 16 },
+		"-"
+	};
+	
+	Text text_model {
+		{ 0 * 8, 6 * 16, 30 * 8, 16 },
+		"-"
+	};
+	
+	Text text_type {
+		{ 5 * 8, 7 * 16, 22 * 8, 16 },
+		"-"
+	};
+	
+	Text text_number_of_engines {
+		{ 18 * 8, 8 * 16, 30 * 8, 16 },
+		"-"
+	};
+
+	Text text_engine_type {
+		{ 0 * 8, 10 * 16, 30 * 8, 16},
+		"-"
+	};
+
+	Text text_owner {
+		{ 0 * 8, 12 * 16, 30 * 8, 16 },
+		"-"
+	};
+
+	Text text_operator {
+		{ 0 * 8, 14 * 16, 30 * 8, 16 },
+		"-"
+	};
+
+	Button button_close {
+		{ 9 * 8, 16 * 16, 12 * 8, 3 * 16 },
+		"Back"
+	};
+};
+
+
 class ADSBRxDetailsView : public View {
 public:
 	ADSBRxDetailsView(NavigationView&, const AircraftRecentEntry& entry, const std::function<void(void)> on_close);
@@ -176,16 +268,23 @@ public:
 	std::string title() const override { return "Details"; };
 
 	AircraftRecentEntry get_current_entry() { return entry_copy; }
+
+
+	std::database::AirlinesDBRecord airline_record = {};
 	
-private:
-	AircraftRecentEntry entry_copy { 0 };
-	std::function<void(void)> on_close_ { };
 	GeoMapView* geomap_view { nullptr };
-	bool send_updates { false };
-	File db_file { };
+private:
+	AircraftRecentEntry 		entry_copy { 0 };
+	std::function<void(void)> 	on_close_ { };
+	ADSBRxAircraftDetailsView* 	aircraft_details_view { nullptr };
+	bool 				send_updates { false };
+	std::database 			db = { };	
+	std::string 			airline_code = "";
+	int 				return_code = 0;
 	
 	Labels labels {
-		{ { 0 * 8, 1 * 16 }, "Callsign:", Color::light_grey() },
+	        { { 0 * 8, 1 * 16 }, "ICAO:", Color::light_grey() },
+		{ { 13 * 8, 1 * 16 }, "Callsign:", Color::light_grey() },
 		{ { 0 * 8, 2 * 16 }, "Last seen:", Color::light_grey() },
 		{ { 0 * 8, 3 * 16 }, "Airline:", Color::light_grey() },
 		{ { 0 * 8, 5 * 16 }, "Country:", Color::light_grey() },
@@ -193,8 +292,13 @@ private:
 		{ { 0 * 8, 15 * 16 }, "Odd position frame:", Color::light_grey() }
 	};
 	
+        Text text_icao_address {
+		{ 5 * 8, 1 * 16, 6 * 8, 16},
+		"-"	
+        };
+
 	Text text_callsign {
-		{ 9 * 8, 1 * 16, 8 * 8, 16 },
+		{ 22 * 8, 1 * 16, 8 * 8, 16 },
 		"-"
 	};
 	
@@ -232,11 +336,17 @@ private:
 		"-"
 	};
 	
+	Button button_aircraft_details {
+		{ 2 * 8, 9 * 16, 12 * 8, 3 * 16 },
+		"A/C details" 
+	};		
+
 	Button button_see_map {
-		{ 8 * 8, 9 * 16, 14 * 8, 3 * 16 },
+		{ 16 * 8, 9 * 16, 12 * 8, 3 * 16 },
 		"See on map"
 	};
 };
+
 	
 class ADSBRxView : public View {
 public:
@@ -250,32 +360,35 @@ public:
 	
 	void focus() override;
 	
-	std::string title() const override { return "ADS-B receive"; };
+	std::string title() const override { return "ADS-B RX"; };
 
 	void replace_entry(AircraftRecentEntry & entry);
+	void remove_old_entries();
 	AircraftRecentEntry find_or_create_entry(uint32_t ICAO_address);
 	void sort_entries_by_state();
 
 private:
-	rf::Frequency prevFreq;
+	rf::Frequency prevFreq = { 0 };
 	std::unique_ptr<ADSBLogger> logger { };
 	void on_frame(const ADSBFrameMessage * message);
 	void on_tick_second();
+	int updateState = { 0 };
+	void updateRecentEntries();
+	void updateDetailsAndMap(int ageStep);
+
+	#define MARKER_UPDATE_SECONDS (5)
+	int ticksSinceMarkerRefresh { MARKER_UPDATE_SECONDS-1 };
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
 	
 	const RecentEntriesColumns columns { {
-#if false
-		{ "ICAO", 6 },
-		{ "Callsign", 9 },
-		{ "Hits", 4 },
-		{ "Time", 8 }
-#else
 		{ "ICAO/Call", 9 },
 		{ "Lvl", 3 },
 		{ "Spd", 3 },
 		{ "Amp", 3 },
 		{ "Hit", 3 },
-		{ "Age", 3 }
-#endif
+		{ "Age", 4 }
 	} };
 	AircraftRecentEntries recent { };
 	RecentEntriesView<RecentEntries<AircraftRecentEntry>> recent_entries_view { columns, recent };

firmware/application/apps/ui_adsb_tx.cpp

@@ -26,6 +26,7 @@
 #include "manchester.hpp"
 #include "string_format.hpp"
 #include "portapack.hpp"
+#include "cpld_update.hpp"
 #include "baseband_api.hpp"
 
 #include <cstring>
@@ -161,13 +162,16 @@ ADSBSpeedView::ADSBSpeedView(
 	
 	add_children({
 		&labels_speed,
+		&labels_vert_rate,
 		&compass,
 		&field_angle,
-		&field_speed
+		&field_speed,
+		&field_vert_rate
 	});
 	
 	field_angle.set_value(0);
 	field_speed.set_value(400);
+	field_vert_rate.set_value(0);
 	
 	field_angle.on_change = [this](int32_t v) {
 		compass.set_value(v);
@@ -180,7 +184,7 @@ void ADSBSpeedView::collect_frames(const uint32_t ICAO_address, std::vector<ADSB
 	ADSBFrame temp_frame;
 	
 	encode_frame_velo(temp_frame, ICAO_address, field_speed.value(),
-		field_angle.value(), 0);	// TODO: v_rate
+		field_angle.value(), field_vert_rate.value());				// Added v_rate ,  ft/min  ,  (+) climb ,  (-) descend .
 	
 	frame_list.emplace_back(temp_frame);
 }
@@ -203,7 +207,7 @@ void ADSBSquawkView::collect_frames(const uint32_t ICAO_address, std::vector<ADS
 	ADSBFrame temp_frame;
 	(void)ICAO_address;
 	
-	encode_frame_squawk(temp_frame, field_squawk.value_dec_u32());
+	encode_frame_squawk(temp_frame, field_squawk.concatenate_4_octal_u16());
 	
 	frame_list.emplace_back(temp_frame);
 }
@@ -284,9 +288,15 @@ void ADSBTxView::focus() {
 }
 
 ADSBTxView::~ADSBTxView() {
+
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_adsb", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
-}
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, withouth ghost signal problem at the exit .
+	baseband::shutdown();				  // better this function at the end, not load_sram() that sometimes produces hang up.
+	}
 
 void ADSBTxView::generate_frames() {
 	const uint32_t ICAO_address = sym_icao.value_hex_u64();
@@ -334,8 +344,16 @@ ADSBTxView::ADSBTxView(
 		&view_squawk,
 		&text_frame,
 		&tx_view
-	});
-	
+	});	
+
+	// load app settings
+	auto rc = settings.load("tx_adsb", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
 	tx_view.on_edit_frequency = [this, &nav]() {
 		auto new_view = nav.push<FrequencyKeypadView>(receiver_model.tuning_frequency());
 		new_view->on_changed = [this](rf::Frequency f) {

firmware/application/apps/ui_adsb_tx.hpp

@@ -28,6 +28,7 @@
 #include "ui_transmitter.hpp"
 #include "message.hpp"
 #include "transmitter_model.hpp"
+#include "app_settings.hpp"
 #include "portapack.hpp"
 
 using namespace adsb;
@@ -95,6 +96,10 @@ private:
 		{ { 1 * 8, 6 * 16 }, "Speed:    kn  Bearing:    *", Color::light_grey() }
 	};
 	
+	Labels labels_vert_rate {
+		{ { 1 * 8, 8 * 16 }, "Vert. rate:    ft/min, (+/-)", Color::light_grey() }
+	};
+
 	Compass compass {
 		{ 21 * 8, 2 * 16 }
 	};
@@ -106,6 +111,10 @@ private:
 	NumberField field_speed {
 		{ 8 * 8, 6 * 16 }, 3, { 0, 999 }, 5, ' '
 	};
+	
+	NumberField field_vert_rate {
+		{ 11 * 8, 8 * 16 }, 5, { -4096, 4096 }, 64, ' '			// Let's limit to +/-5k aprox , Ex. max safe descent vertical rate aprox -1000 ft/min on an instrument approach. , std step is 64  
+	};
 };
 
 class ADSBSquawkView : public OptionTabView {
@@ -152,7 +161,7 @@ public:
 	
 	void focus() override;
 	
-	std::string title() const override { return "ADS-B transmit"; };
+	std::string title() const override { return "ADS-B TX"; };
 
 private:
 	/*enum tx_modes {
@@ -189,6 +198,10 @@ private:
 		-1,
 		-1
 	};*/
+
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
 	
 	//tx_modes tx_mode = IDLE;
 	NavigationView& nav_;

firmware/application/apps/ui_afsk_rx.cpp

@@ -66,6 +66,15 @@ AFSKRxView::AFSKRxView(NavigationView& nav) {
 		&console
 	});
 	
+	// load app settings
+	auto rc = settings.load("rx_afsk", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+	}
+
+
 	// DEBUG
 	record_view.on_error = [&nav](std::string message) {
 		nav.display_modal("Error", message);
@@ -164,6 +173,11 @@ void AFSKRxView::on_data(uint32_t value, bool is_data) {
 }
 
 AFSKRxView::~AFSKRxView() {
+
+	// save app settings
+	app_settings.rx_frequency = field_frequency.value();
+	settings.save("rx_afsk", &app_settings);
+
 	audio::output::stop();
 	receiver_model.disable();
 	baseband::shutdown();

firmware/application/apps/ui_afsk_rx.hpp

@@ -27,7 +27,7 @@
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
 #include "ui_record_view.hpp"	// DEBUG
-
+#include "app_settings.hpp"
 #include "log_file.hpp"
 #include "utility.hpp"
 
@@ -52,11 +52,15 @@ public:
 
 	void focus() override;
 
-	std::string title() const override { return "AFSK RX (beta)"; };
+	std::string title() const override { return "AFSK RX"; };
 	
 private:
 	void on_data(uint32_t value, bool is_data);
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	uint8_t console_color { 0 };
 	uint32_t prev_value { 0 };
 	std::string str_log { "" };

firmware/application/apps/ui_aprs_rx.cpp

@@ -98,6 +98,15 @@ APRSRxView::APRSRxView(NavigationView& nav, Rect parent_rect) : View(parent_rect
 		&console
 	});
 	
+	// load app settings
+	auto rc = settings.load("rx_aprs", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+	}
+
+
 	// DEBUG
 	record_view.on_error = [&nav](std::string message) {
 		nav.display_modal("Error", message);
@@ -108,12 +117,12 @@ APRSRxView::APRSRxView(NavigationView& nav, Rect parent_rect) : View(parent_rect
 	options_region.on_change = [this](size_t, int32_t i) {		
 		if (i == 0){
 			field_frequency.set_value(144390000);			
-		}
-		if(i == 1){
+		} else if(i == 1){
 			field_frequency.set_value(144800000);
-		}
-		if(i == 2){
+		} else if(i == 2){
 			field_frequency.set_value(145175000);
+		} else if(i == 3){
+			field_frequency.set_value(144575000);
 		}		
 	};
 	
@@ -211,6 +220,10 @@ void APRSRxView::on_show(){
 }
 
 APRSRxView::~APRSRxView() {
+
+	// save app settings
+	settings.save("rx_aprs", &app_settings);
+
 	audio::output::stop();
 	receiver_model.disable();
 	baseband::shutdown();
@@ -351,7 +364,7 @@ void APRSDetailsView::update() {
 	}	
 	
 	if (send_updates)
-		geomap_view->update_position(entry_copy.pos.latitude, entry_copy.pos.longitude, 0);
+		geomap_view->update_position(entry_copy.pos.latitude, entry_copy.pos.longitude, 0, 0);
 }
 
 APRSDetailsView::~APRSDetailsView() {

firmware/application/apps/ui_aprs_rx.hpp

@@ -28,7 +28,7 @@
 #include "ui_receiver.hpp"
 #include "ui_record_view.hpp"	// DEBUG
 #include "ui_geomap.hpp"
-
+#include "app_settings.hpp"
 #include "recent_entries.hpp"
 #include "ui_tabview.hpp"
 
@@ -57,12 +57,12 @@ struct APRSRecentEntry {
 	uint16_t hits { 0 };
 	uint32_t age { 0 };	
 	
-	uint64_t source;
+	uint64_t source { 0 };
 	std::string source_formatted { "        " };
 	std::string time_string { "" };
 	std::string info_string { "" };
 	
-	aprs::aprs_pos pos;
+	aprs::aprs_pos pos { 0 , 0 , 0 , 0 };
 	bool has_position = false;
 	APRSRecentEntry(uint64_t src)
 	{
@@ -131,6 +131,7 @@ private:
 	GeoMapView* geomap_view { nullptr };
 	bool send_updates { false };
 	
+
 	Console console {
 		{ 0, 0 * 16, 240, 224 }		
 	};
@@ -192,6 +193,11 @@ private:
 	void on_data(uint32_t value, bool is_data);
 	bool reset_console = false;
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
+
 	uint8_t console_color { 0 };
 	std::string str_log { "" };
 
@@ -217,7 +223,8 @@ private:
 		{
 			{ "NA ", 0 },
 			{ "EUR", 1 },
-			{ "AUS", 2 }
+			{ "AUS", 2 },
+			{ "NZ ", 3 }
 		}
 	};
 	

firmware/application/apps/ui_aprs_tx.cpp

@@ -26,6 +26,7 @@
 #include "aprs.hpp"
 #include "string_format.hpp"
 #include "portapack.hpp"
+#include "cpld_update.hpp"
 #include "baseband_api.hpp"
 #include "portapack_shared_memory.hpp"
 #include "portapack_persistent_memory.hpp"
@@ -43,8 +44,13 @@ void APRSTXView::focus() {
 }
 
 APRSTXView::~APRSTXView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_aprs", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit.
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void APRSTXView::start_tx() {
@@ -66,7 +72,7 @@ void APRSTXView::start_tx() {
 		1200,
 		2200,
 		1,
-		10000,	//transmitter_model.channel_bandwidth(),
+		10000,	//APRS uses fixed 10k bandwidth
 		8
 	);
 }
@@ -95,6 +101,15 @@ APRSTXView::APRSTXView(NavigationView& nav) {
 		&tx_view
 	});
 	
+
+	// load app settings
+	auto rc = settings.load("tx_aprs", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
 	button_set.on_select = [this, &nav](Button&) {
 		text_prompt(
 			nav,

firmware/application/apps/ui_aprs_tx.hpp

@@ -29,6 +29,7 @@
 
 #include "message.hpp"
 #include "transmitter_model.hpp"
+#include "app_settings.hpp"
 #include "portapack.hpp"
 
 namespace ui {
@@ -40,17 +41,14 @@ public:
 	
 	void focus() override;
 	
-	std::string title() const override { return "APRS TX (beta)"; };
+	std::string title() const override { return "APRS TX"; };
 
 private:
-	/*enum tx_modes {
-		IDLE = 0,
-		SINGLE,
-		SEQUENCE
-	};
-	
-	tx_modes tx_mode = IDLE;*/
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	std::string payload { "" };
 	
 	void start_tx();
@@ -103,7 +101,7 @@ private:
 	TransmitterView tx_view {
 		16 * 16,
 		5000,
-		10
+		0 // disable setting bandwith, since APRS used fixed 10k bandwidth
 	};
 	
 	MessageHandlerRegistration message_handler_tx_progress {

firmware/application/apps/ui_bht_tx.cpp

@@ -24,6 +24,7 @@
 #include "string_format.hpp"
 
 #include "baseband_api.hpp"
+#include "cpld_update.hpp"
 #include "portapack_persistent_memory.hpp"
 
 using namespace portapack;
@@ -96,9 +97,9 @@ void BHTView::on_tx_progress(const uint32_t progress, const bool done) {
 	if (target_system == XYLOS) {
 		if (done) {
 			if (tx_mode == SINGLE) {
-				if (checkbox_cligno.value()) {
+				if (checkbox_flashing.value()) {
 					// TODO: Thread !
-					chThdSleepMilliseconds(field_tempo.value() * 1000);	// Dirty :(
+					chThdSleepMilliseconds(field_speed.value() * 1000);	// Dirty :(
 					view_xylos.flip_relays();
 					start_tx();
 				} else
@@ -120,9 +121,9 @@ void BHTView::on_tx_progress(const uint32_t progress, const bool done) {
 			} else {
 				view_EPAR.half = false;
 				if (tx_mode == SINGLE) {
-					if (checkbox_cligno.value()) {
+					if (checkbox_flashing.value()) {
 						// TODO: Thread !
-						chThdSleepMilliseconds(field_tempo.value() * 1000);	// Dirty :(
+						chThdSleepMilliseconds(field_speed.value() * 1000);	// Dirty :(
 						view_EPAR.flip_relays();
 						start_tx();
 					} else
@@ -140,7 +141,13 @@ void BHTView::on_tx_progress(const uint32_t progress, const bool done) {
 }
 
 BHTView::~BHTView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_bht", &app_settings);
+
 	transmitter_model.disable();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit .
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 BHTView::BHTView(NavigationView& nav) {
@@ -150,13 +157,22 @@ BHTView::BHTView(NavigationView& nav) {
 		&view_xylos,
 		&view_EPAR,
 		&checkbox_scan,
-		&checkbox_cligno,
-		&field_tempo,
+		&checkbox_flashing,
+		&field_speed,
 		&progressbar,
 		&tx_view
 	});
 	
-	field_tempo.set_value(1);
+	// load app settings
+	auto rc = settings.load("tx_bht", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
+	field_speed.set_value(1);
 	
 	tx_view.on_edit_frequency = [this, &nav]() {
 		auto new_view = nav.push<FrequencyKeypadView>(receiver_model.tuning_frequency());

firmware/application/apps/ui_bht_tx.hpp

@@ -32,6 +32,7 @@
 #include "message.hpp"
 #include "transmitter_model.hpp"
 #include "encoders.hpp"
+#include "app_settings.hpp"
 #include "portapack.hpp"
 
 namespace ui {
@@ -50,11 +51,11 @@ public:
 private:
 	Labels labels {
 		{ { 8 * 8, 1 * 8 }, "Header:", Color::light_grey() },
-		{ { 4 * 8, 3 * 8 }, "Code ville:", Color::light_grey() },
-		{ { 7 * 8, 5 * 8 }, "Famille:", Color::light_grey() },
-		{ { 2 * 8, 7 * 8 + 2 }, "Sous-famille:", Color::light_grey() },
-		{ { 2 * 8, 11 * 8 }, "ID recepteur:", Color::light_grey() },
-		{ { 2 * 8, 14 * 8 }, "Relais:", Color::light_grey() }
+		{ { 4 * 8, 3 * 8 }, "City code:", Color::light_grey() },
+		{ { 7 * 8, 5 * 8 }, "Family:", Color::light_grey() },
+		{ { 2 * 8, 7 * 8 + 2 }, "Subfamily:", Color::light_grey() },
+		{ { 2 * 8, 11 * 8 }, "Receiver ID:", Color::light_grey() },
+		{ { 2 * 8, 14 * 8 }, "Relay:", Color::light_grey() }
 	};
 	
 	NumberField field_header_a {
@@ -98,8 +99,8 @@ private:
 	
 	Checkbox checkbox_wcsubfamily {
 		{ 20 * 8, 6 * 8 + 6 },
-		6,
-		"Toutes"
+		3,
+		"All"
 	};
 	
 	NumberField field_receiver {
@@ -111,8 +112,8 @@ private:
 	};
 	Checkbox checkbox_wcid {
 		{ 20 * 8, 10 * 8 + 4 },
-		4,
-		"Tous"
+		3,
+		"All"
 	};
 	
 	std::array<ImageOptionsField, 4> relay_states { };
@@ -139,9 +140,9 @@ public:
 	
 private:
 	Labels labels {
-		{ { 4 * 8, 1 * 8 }, "Code ville:", Color::light_grey() },
-		{ { 8 * 8, 3 * 8 }, "Groupe:", Color::light_grey() },
-		{ { 8 * 8, 7 * 8 }, "Relais:", Color::light_grey() }
+		{ { 4 * 8, 1 * 8 }, "City code:", Color::light_grey() },
+		{ { 8 * 8, 3 * 8 }, "Group:", Color::light_grey() },
+		{ { 8 * 8, 7 * 8 }, "Relay:", Color::light_grey() }
 	};
 	
 	NumberField field_city {
@@ -178,9 +179,13 @@ public:
 
 	void focus() override;
 	
-	std::string title() const override { return "BHT transmit"; };
+	std::string title() const override { return "BHT TX"; };
 
 private:
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	void on_tx_progress(const uint32_t progress, const bool done);
 	void start_tx();
 	void stop_tx();
@@ -220,12 +225,12 @@ private:
 		"Scan"
 	};
 	
-	Checkbox checkbox_cligno {
+	Checkbox checkbox_flashing {
 		{ 16 * 8, 25 * 8 },
-		6,
-		"Cligno"
+		8,
+		"Flashing"
 	};
-	NumberField field_tempo {
+	NumberField field_speed {
 		{ 26 * 8, 25 * 8 + 4 },
 		2,
 		{ 1, 99 },

firmware/application/apps/ui_btle_rx.cpp

@@ -60,6 +60,15 @@ BTLERxView::BTLERxView(NavigationView& nav) {
 		&console
 	});
 	
+	// load app settings
+	auto rc = settings.load("rx_btle", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+	}
+
+
 	// DEBUG
 	record_view.on_error = [&nav](std::string message) {
 		nav.display_modal("Error", message);
@@ -152,6 +161,11 @@ void BTLERxView::on_data(uint32_t value, bool is_data) {
 }
 
 BTLERxView::~BTLERxView() {
+
+	// save app settings
+	app_settings.rx_frequency = field_frequency.value();
+	settings.save("rx_btle", &app_settings);
+
 	audio::output::stop();
 	receiver_model.disable();
 	baseband::shutdown();

firmware/application/apps/ui_btle_rx.hpp

@@ -27,6 +27,7 @@
 #include "ui.hpp"
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
+#include "app_settings.hpp"
 #include "ui_record_view.hpp"	// DEBUG
 
 #include "utility.hpp"
@@ -45,6 +46,11 @@ public:
 private:
 	void on_data(uint32_t value, bool is_data);
 	
+
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	uint8_t console_color { 0 };
 	uint32_t prev_value { 0 };
 	std::string str_log { "" };

firmware/application/apps/ui_coasterp.cpp

@@ -23,6 +23,7 @@
 #include "ui_coasterp.hpp"
 
 #include "baseband_api.hpp"
+#include "cpld_update.hpp"
 #include "portapack_persistent_memory.hpp"
 
 #include <cstring>
@@ -37,8 +38,13 @@ void CoasterPagerView::focus() {
 }
 
 CoasterPagerView::~CoasterPagerView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_coaster", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit .
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void CoasterPagerView::generate_frame() {
@@ -119,6 +125,15 @@ CoasterPagerView::CoasterPagerView(NavigationView& nav) {
 		&tx_view
 	});
 	
+	// load app settings
+	auto rc = settings.load("tx_coaster", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
 	// Bytes to nibbles
 	for (c = 0; c < 16; c++)
 		sym_data.set_sym(c, (data_init[c >> 1] >> ((c & 1) ? 0 : 4)) & 0x0F);

firmware/application/apps/ui_coasterp.hpp

@@ -28,6 +28,7 @@
 
 #include "message.hpp"
 #include "transmitter_model.hpp"
+#include "app_settings.hpp"
 #include "portapack.hpp"
 
 namespace ui {
@@ -39,7 +40,7 @@ public:
 	
 	void focus() override;
 	
-	std::string title() const override { return "Si44xx TX"; };
+	std::string title() const override { return "BurgerPgrTX"; };
 
 private:
 	enum tx_modes {
@@ -50,6 +51,10 @@ private:
 	
 	tx_modes tx_mode = IDLE;
 	
+	// app save settings
+	std::app_settings 		settings { };
+	std::app_settings::AppSettings 	app_settings { };
+
 	void start_tx();
 	void generate_frame();
 	void on_tx_progress(const uint32_t progress, const bool done);

firmware/application/apps/ui_debug.cpp

@@ -31,6 +31,7 @@
 #include "ui_sd_card_debug.hpp"
 
 #include "portapack.hpp"
+#include "portapack_persistent_memory.hpp"
 using namespace portapack;
 
 #include "irq_controls.hpp"
@@ -265,7 +266,9 @@ bool ControlsSwitchesWidget::on_key(const KeyEvent key) {
 }
 
 void ControlsSwitchesWidget::paint(Painter& painter) {
-	const std::array<Rect, 7> button_rects { {
+	const auto pos = screen_pos();
+
+	const std::array<Rect, 8> button_rects { {
 		{ 64, 32, 16, 16 }, // Right
 		{  0, 32, 16, 16 }, // Left
 		{ 32, 64, 16, 16 }, // Down
@@ -273,27 +276,63 @@ void ControlsSwitchesWidget::paint(Painter& painter) {
 		{ 32, 32, 16, 16 }, // Select
 		{ 16, 96, 16, 16 }, // Encoder phase 0
 		{ 48, 96, 16, 16 }, // Encoder phase 1
+		{ 96,  0, 16, 16 }, // Dfu
 	} };
-	const auto pos = screen_pos();
-	auto switches_raw = control::debug::switches();
-	auto switches_debounced = get_switches_state().to_ulong();
-	auto switches_event = key_event_mask;
 
 	for(const auto r : button_rects) {
-		const auto c =
-			((switches_event & 1) ?
-				Color::red() :
-				((switches_debounced & 1) ?
-					Color::green() :
-					((switches_raw & 1) ?
-						Color::yellow() :
-						Color::blue()
-					)
-				)
-			);
-		painter.fill_rectangle(r + pos, c);
+		painter.fill_rectangle(r + pos, Color::blue());
+	}
+
+	const std::array<Rect, 8> raw_rects { {
+		{ 64 + 1, 32 + 1, 16 - 2, 16 - 2 }, // Right
+		{  0 + 1, 32 + 1, 16 - 2, 16 - 2 }, // Left
+		{ 32 + 1, 64 + 1, 16 - 2, 16 - 2 }, // Down
+		{ 32 + 1,  0 + 1, 16 - 2, 16 - 2 }, // Up
+		{ 32 + 1, 32 + 1, 16 - 2, 16 - 2 }, // Select
+		{ 16 + 1, 96 + 1, 16 - 2, 16 - 2 }, // Encoder phase 0
+		{ 48 + 1, 96 + 1, 16 - 2, 16 - 2 }, // Encoder phase 1
+		{ 96 + 1,  0 + 1, 16 - 2, 16 - 2 }, // Dfu
+	} };
+
+	auto switches_raw = control::debug::switches();
+	for(const auto r : raw_rects) {
+		if (switches_raw & 1)
+			painter.fill_rectangle(r + pos, Color::yellow());
+
 		switches_raw >>= 1;
+	}
+
+	const std::array<Rect, 6> debounced_rects { {
+		{ 64 + 2, 32 + 2, 16 - 4, 16 - 4 }, // Right
+		{  0 + 2, 32 + 2, 16 - 4, 16 - 4 }, // Left
+		{ 32 + 2, 64 + 2, 16 - 4, 16 - 4 }, // Down
+		{ 32 + 2,  0 + 2, 16 - 4, 16 - 4 }, // Up
+		{ 32 + 2, 32 + 2, 16 - 4, 16 - 4 }, // Select
+		{ 96 + 2,  0 + 2, 16 - 4, 16 - 4 }, // Dfu
+	} };
+
+	auto switches_debounced = get_switches_state().to_ulong();
+	for(const auto r : debounced_rects) {
+		if (switches_debounced & 1)
+			painter.fill_rectangle(r + pos, Color::green());
+
 		switches_debounced >>= 1;
+	}
+
+	const std::array<Rect, 6> events_rects { {
+		{ 64 + 3, 32 + 3, 16 - 6, 16 - 6 }, // Right
+		{  0 + 3, 32 + 3, 16 - 6, 16 - 6 }, // Left
+		{ 32 + 3, 64 + 3, 16 - 6, 16 - 6 }, // Down
+		{ 32 + 3,  0 + 3, 16 - 6, 16 - 6 }, // Up
+		{ 32 + 3, 32 + 3, 16 - 6, 16 - 6 }, // Select
+		{ 96 + 3,  0 + 3, 16 - 6, 16 - 6 }, // Dfu
+	} };
+
+	auto switches_event = key_event_mask;
+	for(const auto r : events_rects) {
+		if (switches_event & 1)
+			painter.fill_rectangle(r + pos, Color::red());
+
 		switches_event >>= 1;
 	}
 }
@@ -321,17 +360,19 @@ void DebugControlsView::focus() {
 /* DebugPeripheralsMenuView **********************************************/
 
 DebugPeripheralsMenuView::DebugPeripheralsMenuView(NavigationView& nav) {
+	const char * max283x = hackrf_r9 ? "MAX2839" : "MAX2837";
+	const char * si5351x = hackrf_r9 ? "Si5351A" : "Si5351C";
 	add_items({
 		{ "RFFC5072",    ui::Color::dark_cyan(),	&bitmap_icon_peripherals_details,	[&nav](){ nav.push<RegistersView>(
 			"RFFC5072", RegistersWidgetConfig { 31, 16 },
 			[](const size_t register_number) { return radio::debug::first_if::register_read(register_number); }
 		); } },
-		{ "MAX2837",     ui::Color::dark_cyan(),	&bitmap_icon_peripherals_details,	[&nav](){ nav.push<RegistersView>(
-			"MAX2837", RegistersWidgetConfig { 32, 10 },
+		{ max283x,     ui::Color::dark_cyan(),	&bitmap_icon_peripherals_details,	[&nav, max283x](){ nav.push<RegistersView>(
+			max283x, RegistersWidgetConfig { 32, 10 },
 			[](const size_t register_number) { return radio::debug::second_if::register_read(register_number); }
 		); } },
-		{ "Si5351C",     ui::Color::dark_cyan(),	&bitmap_icon_peripherals_details,	[&nav](){ nav.push<RegistersView>(
-			"Si5351C", RegistersWidgetConfig { 96, 8 },
+		{ si5351x,     ui::Color::dark_cyan(),	&bitmap_icon_peripherals_details,	[&nav, si5351x](){ nav.push<RegistersView>(
+			si5351x, RegistersWidgetConfig { 96, 8 },
 			[](const size_t register_number) { return portapack::clock_generator.read_register(register_number); }
 		); } },
 		{ audio::debug::codec_name(), ui::Color::dark_cyan(),	&bitmap_icon_peripherals_details,	[&nav](){ nav.push<RegistersView>(
@@ -345,14 +386,17 @@ DebugPeripheralsMenuView::DebugPeripheralsMenuView(NavigationView& nav) {
 /* DebugMenuView *********************************************************/
 
 DebugMenuView::DebugMenuView(NavigationView& nav) {
+    if( portapack::persistent_memory::show_gui_return_icon() )
+    {
+        add_items( { { "..", 		ui::Color::light_grey(),&bitmap_icon_previous,	[&nav](){ nav.pop(); } } } );
+    }
 	add_items({
-		//{ "..",				ui::Color::light_grey(),&bitmap_icon_previous,	[&nav](){ nav.pop(); } },
 		{ "Memory", 		ui::Color::dark_cyan(),	&bitmap_icon_memory,	[&nav](){ nav.push<DebugMemoryView>(); } },
 		//{ "Radio State",	ui::Color::white(),	nullptr,	[&nav](){ nav.push<NotImplementedView>(); } },
 		{ "SD Card",		ui::Color::dark_cyan(),	&bitmap_icon_sdcard,	[&nav](){ nav.push<SDCardDebugView>(); } },
 		{ "Peripherals",	ui::Color::dark_cyan(),	&bitmap_icon_peripherals,	[&nav](){ nav.push<DebugPeripheralsMenuView>(); } },
 		{ "Temperature",	ui::Color::dark_cyan(),	&bitmap_icon_temperature,	[&nav](){ nav.push<TemperatureView>(); } },
-		{ "Buttons test",	ui::Color::dark_cyan(),	&bitmap_icon_controls,	[&nav](){ nav.push<DebugControlsView>(); } },
+		{ "Buttons Test",	ui::Color::dark_cyan(),	&bitmap_icon_controls,	[&nav](){ nav.push<DebugControlsView>(); } },
 	});
 	set_max_rows(2); // allow wider buttons
 }

firmware/application/apps/ui_debug.hpp

@@ -29,7 +29,6 @@
 #include "ui_navigation.hpp"
 
 #include "rffc507x.hpp"
-#include "max2837.hpp"
 #include "portapack.hpp"
 
 #include <functional>
@@ -43,6 +42,8 @@ public:
 
 	void focus() override;
 
+	std::string title() const override { return "Memory"; };
+
 private:
 	Text text_title {
 		{ 96, 96, 48, 16 },
@@ -113,6 +114,8 @@ public:
 
 	void focus() override;
 
+	std::string title() const override { return "Temperature"; };
+
 private:
 	Text text_title {
 		{ 76, 16, 240, 16 },
@@ -252,6 +255,8 @@ public:
 
 	void focus() override;
 
+	std::string title() const override { return "Buttons Test"; };
+
 private:
 	Text text_title {
 		{ 64, 16, 184, 16 },

firmware/application/apps/ui_dfu_menu.cpp

@@ -0,0 +1,99 @@
+/*
+ * 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_dfu_menu.hpp"
+#include "portapack_shared_memory.hpp"
+#include "performance_counter.hpp"
+
+namespace ui {
+
+DfuMenu::DfuMenu(NavigationView& nav) : nav_ (nav) {
+	add_children({
+		&text_head,
+		&labels,
+		&text_info_line_1,
+		&text_info_line_2,
+		&text_info_line_3,
+		&text_info_line_4,
+		&text_info_line_5,
+		&text_info_line_6,
+		&text_info_line_7,
+		&text_info_line_8
+	});
+}
+
+void DfuMenu::paint(Painter& painter) {
+	auto utilisation = get_cpu_utilisation_in_percent();
+
+	text_info_line_1.set(to_string_dec_uint(chCoreStatus(), 6));
+	text_info_line_2.set(to_string_dec_uint((uint32_t)get_free_stack_space(), 6));
+	text_info_line_3.set(to_string_dec_uint(utilisation, 6));
+	text_info_line_4.set(to_string_dec_uint(shared_memory.m4_heap_usage, 6));
+	text_info_line_5.set(to_string_dec_uint(shared_memory.m4_stack_usage, 6));
+	text_info_line_6.set(to_string_dec_uint(shared_memory.m4_cpu_usage, 6));
+	text_info_line_7.set(to_string_dec_uint(shared_memory.m4_buffer_missed, 6));
+	text_info_line_8.set(to_string_dec_uint(chTimeNow()/1000, 6));
+
+	constexpr auto margin = 5;
+	constexpr auto lines = 8 + 2;
+
+	painter.fill_rectangle(
+		{
+			{6 * CHARACTER_WIDTH - margin, 3 * LINE_HEIGHT - margin},
+			{15 * CHARACTER_WIDTH + margin * 2, lines * LINE_HEIGHT + margin * 2}
+		},
+		ui::Color::black()
+	);
+
+	painter.fill_rectangle(
+		{
+			{5 * CHARACTER_WIDTH - margin, 3 * LINE_HEIGHT - margin},
+			{CHARACTER_WIDTH, lines * LINE_HEIGHT + margin * 2}
+		},
+		ui::Color::dark_cyan()
+	);
+
+	painter.fill_rectangle(
+		{
+			{21 * CHARACTER_WIDTH + margin, 3 * LINE_HEIGHT - margin},
+			{CHARACTER_WIDTH, lines * LINE_HEIGHT + margin * 2}
+		},
+		ui::Color::dark_cyan()
+	);
+
+	painter.fill_rectangle(
+		{
+			{5 * CHARACTER_WIDTH - margin, 3 * LINE_HEIGHT - margin - 8},
+			{17 * CHARACTER_WIDTH + margin * 2, 8}
+		},
+		ui::Color::dark_cyan()
+	);
+
+	painter.fill_rectangle(
+		{
+			{5 * CHARACTER_WIDTH - margin, (lines+3) * LINE_HEIGHT + margin},
+			{17 * CHARACTER_WIDTH + margin * 2, 8}
+		},
+		ui::Color::dark_cyan()
+	);
+}
+
+} /* namespace ui */

firmware/application/apps/ui_dfu_menu.hpp

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+#ifndef __UI_DFU_MENU_H__
+#define __UI_DFU_MENU_H__
+
+#include <cstdint>
+
+#include "ui_widget.hpp"
+#include "event_m0.hpp"
+#include "debug.hpp"
+#include "string_format.hpp"
+
+#define LINE_HEIGHT 16
+#define CHARACTER_WIDTH 8
+
+namespace ui {
+class NavigationView;
+
+class DfuMenu : public View {
+public:
+	DfuMenu(NavigationView& nav);
+	~DfuMenu() = default;
+
+	void paint(Painter& painter) override;
+
+private:
+	NavigationView& nav_;
+	
+	Text text_head {{ 6 * CHARACTER_WIDTH, 3 * LINE_HEIGHT, 11 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, "Performance"};
+
+	Labels labels {
+		{ { 6 * CHARACTER_WIDTH, 5 * LINE_HEIGHT }, "M0 heap:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH, 6 * LINE_HEIGHT }, "M0 stack:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH, 7 * LINE_HEIGHT }, "M0 cpu %:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH, 8 * LINE_HEIGHT }, "M4 heap:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH, 9 * LINE_HEIGHT }, "M4 stack:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH,10 * LINE_HEIGHT }, "M4 cpu %:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH,11 * LINE_HEIGHT }, "M4 miss:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH,12 * LINE_HEIGHT }, "uptime:", Color::dark_cyan() }
+	};
+
+	Text text_info_line_1 {{ 15 * CHARACTER_WIDTH, 5 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_2 {{ 15 * CHARACTER_WIDTH, 6 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_3 {{ 15 * CHARACTER_WIDTH, 7 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_4 {{ 15 * CHARACTER_WIDTH, 8 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_5 {{ 15 * CHARACTER_WIDTH, 9 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_6 {{ 15 * CHARACTER_WIDTH,10 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_7 {{ 15 * CHARACTER_WIDTH,11 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_8 {{ 15 * CHARACTER_WIDTH,12 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+};
+
+} /* namespace ui */
+
+#endif/*__UI_DFU_MENU_H__*/

firmware/application/apps/ui_encoders.cpp

@@ -24,6 +24,7 @@
 
 #include "baseband_api.hpp"
 #include "string_format.hpp"
+#include "cpld_update.hpp"
 
 using namespace portapack;
 
@@ -35,18 +36,21 @@ EncodersConfigView::EncodersConfigView(
 	using option_t = std::pair<std::string, int32_t>;
 	std::vector<option_t> enc_options;
 	size_t i;
-	
+
 	set_parent_rect(parent_rect);
 	hidden(true);
-	
+
 	// Default encoder def
 	encoder_def = &encoder_defs[0];
-	
+
 	add_children({
 		&labels,
 		&options_enctype,
+		&field_repeat_min,
 		&field_clk,
+		&field_clk_step,
 		&field_frameduration,
+		&field_frameduration_step,
 		&symfield_word,
 		&text_format,
 		&waveform
@@ -55,18 +59,18 @@ EncodersConfigView::EncodersConfigView(
 	// Load encoder types in option field
 	for (i = 0; i < ENC_TYPES_COUNT; i++)
 		enc_options.emplace_back(std::make_pair(encoder_defs[i].name, i));
-	
+
 	options_enctype.on_change = [this](size_t index, int32_t) {
 		on_type_change(index);
 	};
-	
+
 	options_enctype.set_options(enc_options);
 	options_enctype.set_selected_index(0);
-	
+
 	symfield_word.on_change = [this]() {
 		generate_frame();
 	};
-	
+
 	// Selecting input clock changes symbol and word duration
 	field_clk.on_change = [this](int32_t value) {
 		// value is in kHz, new_value is in us
@@ -74,7 +78,11 @@ EncodersConfigView::EncodersConfigView(
 		if (new_value != field_frameduration.value())
 			field_frameduration.set_value(new_value * encoder_def->word_length, false);
 	};
-	
+
+	field_clk_step.on_change = [this](size_t, int32_t value) {
+		field_clk.set_step(value);
+	};
+
 	// Selecting word duration changes input clock and symbol duration
 	field_frameduration.on_change = [this](int32_t value) {
 		// value is in us, new_value is in kHz
@@ -82,6 +90,10 @@ EncodersConfigView::EncodersConfigView(
 		if (new_value != field_clk.value())
 			field_clk.set_value(1000000 / new_value, false);
 	};
+
+	field_frameduration_step.on_change = [this](size_t, int32_t value) {
+		field_frameduration.set_step(value);
+	};
 }
 
 void EncodersConfigView::focus() {
@@ -96,7 +108,8 @@ void EncodersConfigView::on_type_change(size_t index) {
 	encoder_def = &encoder_defs[index];
 
 	field_clk.set_value(encoder_def->default_speed / 1000);
-	
+	field_repeat_min.set_value(encoder_def->repeat_min);
+
 	// SymField setup
 	word_length = encoder_def->word_length;
 	symfield_word.set_length(word_length);
@@ -111,10 +124,10 @@ void EncodersConfigView::on_type_change(size_t index) {
 			format_string += 'D';
 		}
 	}
-	
+
 	// Ugly :( Pad to erase
 	format_string.append(24 - format_string.size(), ' ');
-	
+
 	text_format.set(format_string);
 
 	generate_frame();
@@ -130,28 +143,30 @@ void EncodersConfigView::draw_waveform() {
 
 	for (size_t n = 0; n < length; n++)
 		waveform_buffer[n] = (frame_fragments[n] == '0') ? 0 : 1;
-	
+
 	waveform.set_length(length);
 	waveform.set_dirty();
 }
 
 void EncodersConfigView::generate_frame() {
 	size_t i = 0;
-	
+
 	frame_fragments.clear();
-	
+
 	for (auto c : encoder_def->word_format) {
 		if (c == 'S')
 			frame_fragments += encoder_def->sync;
+		else if (!c)
+			break;
 		else
 			frame_fragments += encoder_def->bit_format[symfield_word.get_sym(i++)];
 	}
-	
+
 	draw_waveform();
 }
 
 uint8_t EncodersConfigView::repeat_min() {
-	return encoder_def->repeat_min;
+	return field_repeat_min.value();
 }
 
 uint32_t EncodersConfigView::samples_per_bit() {
@@ -163,7 +178,7 @@ uint32_t EncodersConfigView::pause_symbols() {
 }
 
 void EncodersScanView::focus() {
-	field_debug.focus();
+	field_length.focus();
 }
 
 EncodersScanView::EncodersScanView(
@@ -171,31 +186,17 @@ EncodersScanView::EncodersScanView(
 ) {
 	set_parent_rect(parent_rect);
 	hidden(true);
-	
+
 	add_children({
 		&labels,
-		&field_debug,
-		&text_debug,
-		&text_length
+		&field_length,
+		&bit_length_10,
+		&bit_length
 	});
-	
-	// DEBUG
-	field_debug.on_change = [this](int32_t value) {
-		uint32_t l;
-		size_t length;
-		
-		de_bruijn debruijn_seq;
-		length = debruijn_seq.init(value);
-		
-		l = 1;
-		l <<= value;
-		l--;
-		if (l > 25)
-			l = 25;
-		text_debug.set(to_string_bin(debruijn_seq.compute(l), 25));
-		
-		text_length.set(to_string_dec_uint(length));
-	};
+
+	field_length.set_value(8);
+	bit_length_10.set_value(40);
+	bit_length.set_value(0);
 }
 
 void EncodersView::focus() {
@@ -203,30 +204,22 @@ void EncodersView::focus() {
 }
 
 EncodersView::~EncodersView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();
+	settings.save("tx_ook", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify(); // ghost signal c/m to the problem at the exit .
+	baseband::shutdown(); // better this function after load_sram()
 }
 
 void EncodersView::update_progress() {
 	std::string str_buffer;
-	
-	// text_status.set("            ");
-	
-	if (tx_mode == SINGLE) {
+
+	if (tx_mode == SINGLE || tx_mode == SCAN) {
 		str_buffer = to_string_dec_uint(repeat_index) + "/" + to_string_dec_uint(repeat_min);
 		text_status.set(str_buffer);
 		progressbar.set_value(repeat_index);
-		
-	/*} else if (tx_mode == SCAN) {
-		strcpy(str, to_string_dec_uint(repeat_index).c_str());
-		strcat(str, "/");
-		strcat(str, to_string_dec_uint(portapack::persistent_memory::afsk_repeats()).c_str());
-		strcat(str, " ");
-		strcat(str, to_string_dec_uint(scan_index + 1).c_str());
-		strcat(str, "/");
-		strcat(str, to_string_dec_uint(scan_count).c_str());
-		text_status.set(str);
-		progress.set_value(scan_progress);*/
 	} else {
 		text_status.set("Ready");
 		progressbar.set_value(0);
@@ -234,89 +227,59 @@ void EncodersView::update_progress() {
 }
 
 void EncodersView::on_tx_progress(const uint32_t progress, const bool done) {
-	//char str[16];
-	
 	if (!done) {
 		// Repeating...
 		repeat_index = progress + 1;
-		
-		/*if (tx_mode == SCAN) {
-			scan_progress++;
-			update_progress();
-		} else {*/
-			update_progress();
-		//}
+		update_progress();
 	} else {
+		// make sure all samples are transmitted before disabling radio
+		chThdSleepMilliseconds(10);
+
 		// Done transmitting
-		/*if ((tx_mode == SCAN) && (scan_index < (scan_count - 1))) {
-			transmitter_model.disable();
-			if (abort_scan) {
-				// Kill scan process
-				strcpy(str, "Abort @");
-				strcat(str, rgsb);
-				text_status.set(str);
-				progress.set_value(0);
-				tx_mode = IDLE;
-				abort_scan = false;
-				button_scan.set_style(&style_val);
-				button_scan.set_text("SCAN");
-			} else {
-				// Next address
-				scan_index++;
-				strcpy(rgsb, &scan_list[options_scanlist.selected_index()].addresses[scan_index * 5]);
-				scan_progress++;
-				repeat_index = 1;
-				update_progress();
-				start_tx(true);
-			}
-		} else {*/
-			transmitter_model.disable();
-			tx_mode = IDLE;
-			text_status.set("Done");
-			progressbar.set_value(0);
-			tx_view.set_transmitting(false);
-		//}
+		transmitter_model.disable();
+		tx_mode = IDLE;
+		text_status.set("Done");
+		progressbar.set_value(0);
+		tx_view.set_transmitting(false);
 	}
 }
 
 void EncodersView::start_tx(const bool scan) {
-	(void)scan;
 	size_t bitstream_length = 0;
-	
-	repeat_min = view_config.repeat_min();
-	
-	/*if (scan) {
-		if (tx_mode != SCAN) {
-			scan_index = 0;
-			scan_count = scan_list[options_scanlist.selected_index()].count;
-			scan_progress = 1;
-			repeat_index = 1;
-			tx_mode = SCAN;
-			strcpy(rgsb, &scan_list[options_scanlist.selected_index()].addresses[0]);
-			progress.set_max(scan_count * afsk_repeats);
-			update_progress();
-		}
-	} else {*/
+	int scan_width = 0;
+	uint32_t samples_per_bit;
+
+	if (scan) {
+		tx_mode = SCAN;
+		scan_width = view_scan.field_length.value();
+		samples_per_bit =
+			((view_scan.bit_length_10.value() * 10 + view_scan.bit_length.value()) * OOK_SAMPLERATE) / 1000000UL;
+		constexpr auto sym_len = 4;
+		const uint32_t seq_len = ((1 << (scan_width - 1)) * 2) * ((uint64_t) samples_per_bit) * sym_len / 2048UL;
+		progressbar.set_max(seq_len);
+		repeat_min = seq_len;
+	} else {
 		tx_mode = SINGLE;
-		repeat_index = 1;
+		samples_per_bit = view_config.samples_per_bit();
+		view_config.generate_frame();
+		bitstream_length = make_bitstream(view_config.frame_fragments);
 		progressbar.set_max(repeat_min);
-		update_progress();
-	//}
-	
-	view_config.generate_frame();
-	
-	bitstream_length = make_bitstream(view_config.frame_fragments);
+		repeat_min = view_config.repeat_min();
+	}
+
+	repeat_index = 1;
+	update_progress();
 
 	transmitter_model.set_sampling_rate(OOK_SAMPLERATE);
-	transmitter_model.set_rf_amp(true);
 	transmitter_model.set_baseband_bandwidth(1750000);
 	transmitter_model.enable();
-	
+
 	baseband::set_ook_data(
 		bitstream_length,
-		view_config.samples_per_bit(),
+		samples_per_bit,
 		repeat_min,
-		view_config.pause_symbols()
+		view_config.pause_symbols(),
+		scan_width
 	);
 }
 
@@ -334,21 +297,32 @@ EncodersView::EncodersView(
 		&progressbar,
 		&tx_view
 	});
-	
+
+	// load app settings
+	auto rc = settings.load("tx_ook", &app_settings);
+	if (rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);
+	}
+
 	tx_view.on_edit_frequency = [this, &nav]() {
 		auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.tuning_frequency());
 		new_view->on_changed = [this](rf::Frequency f) {
 			transmitter_model.set_tuning_frequency(f);
 		};
 	};
-	
+
 	tx_view.on_start = [this]() {
 		tx_view.set_transmitting(true);
-		start_tx(false);
+		start_tx(tab_view.selected());
 	};
-	
+
 	tx_view.on_stop = [this]() {
 		tx_view.set_transmitting(false);
+		baseband::kill_ook();
+		transmitter_model.disable();
 	};
 }
 

firmware/application/apps/ui_encoders.hpp

@@ -26,6 +26,7 @@
 #include "transmitter_model.hpp"
 #include "encoders.hpp"
 #include "de_bruijn.hpp"
+#include "app_settings.hpp"
 
 using namespace encoders;
 
@@ -34,43 +35,41 @@ namespace ui {
 class EncodersConfigView : public View {
 public:
 	EncodersConfigView(NavigationView& nav, Rect parent_rect);
-	
+
 	EncodersConfigView(const EncodersConfigView&) = delete;
 	EncodersConfigView(EncodersConfigView&&) = delete;
 	EncodersConfigView& operator=(const EncodersConfigView&) = delete;
 	EncodersConfigView& operator=(EncodersConfigView&&) = delete;
-	
+
 	void focus() override;
 	void on_show() override;
-	
+
 	uint8_t repeat_min();
 	uint32_t samples_per_bit();
 	uint32_t pause_symbols();
 	void generate_frame();
-	
+
 	std::string frame_fragments = "0";
 
 private:
-	//bool abort_scan = false;
-	//uint8_t scan_count;
-	//double scan_progress;
-	//unsigned int scan_index;
 	int16_t waveform_buffer[550];
 	const encoder_def_t * encoder_def { };
-	//uint8_t enc_type = 0;
 
 	void draw_waveform();
 	void on_bitfield();
 	void on_type_change(size_t index);
-	
+
 	Labels labels {
 		{ { 1 * 8, 0 }, "Type:", Color::light_grey() },
-		{ { 16 * 8, 0 }, "Clk:", Color::light_grey() },
-		{ { 24 * 8, 0 }, "kHz", Color::light_grey() },
-		{ { 14 * 8, 2 * 8 }, "Frame:", Color::light_grey() },
-		{ { 26 * 8, 2 * 8 }, "us", Color::light_grey() },
-		{ { 2 * 8, 4 * 8 }, "Symbols:", Color::light_grey() },
-		{ { 1 * 8, 11 * 8 }, "Waveform:", Color::light_grey() }
+		{ { 17 * 8, 0 }, "Repeat:", Color::light_grey() },
+		{ { 1 * 8, 2 * 8 }, "Clk:", Color::light_grey() },
+		{ { 10 * 8, 2 * 8 }, "kHz", Color::light_grey() },
+		{ { 17 * 8, 2 * 8 }, "Step:", Color::light_grey() },
+		{ { 1 * 8, 4 * 8 }, "Frame:", Color::light_grey() },
+		{ { 13 * 8, 4 * 8 }, "us", Color::light_grey() },
+		{ { 17 * 8, 4 * 8 }, "Step:", Color::light_grey() },
+		{ { 2 * 8, 7 * 8 }, "Symbols:", Color::light_grey() },
+		{ { 1 * 8, 14 * 8 }, "Waveform:", Color::light_grey() }
 	};
 
 	OptionsField options_enctype {		// Options are loaded at runtime
@@ -81,34 +80,63 @@ private:
 	};
 
 	NumberField field_clk {
-		{ 21 * 8, 0 },
-		3,
-		{ 1, 500 },
+		{ 5 * 8, 2 * 8 },
+		4,
+		{ 1, 1000 },
 		1,
 		' '
 	};
 
+	NumberField field_repeat_min {
+		{ 24 * 8, 0 },
+		2,
+		{ 1, 99 },
+		1,
+		' '
+	};
+
+	OptionsField field_clk_step {
+		{ 22 * 8, 2 * 8 },
+		7,
+		{
+			{ "1", 1 },
+			{ "10", 10 },
+			{ "100", 100 }
+		}
+	};
+
 	NumberField field_frameduration {
-		{ 21 * 8, 2 * 8 },
+		{ 7 * 8, 4 * 8 },
 		5,
 		{ 300, 99999 },
 		100,
 		' '
 	};
-	
+
+	OptionsField field_frameduration_step {
+		{ 22 * 8, 4 * 8 },
+		7,
+		{
+			{ "1", 1 },
+			{ "10", 10 },
+			{ "100", 100 },
+			{ "1000", 1000 }
+		}
+	};
+
 	SymField symfield_word {
-		{ 2 * 8, 6 * 8 },
+		{ 2 * 8, 9 * 8 },
 		20,
 		SymField::SYMFIELD_DEF
 	};
-	
+
 	Text text_format {
-		{ 2 * 8, 8 * 8, 24 * 8, 16 },
+		{ 2 * 8, 11 * 8, 24 * 8, 16 },
 		""
 	};
-	
+
 	Waveform waveform {
-		{ 0, 14 * 8, 240, 32 },
+		{ 0, 17 * 8, 240, 32 },
 		waveform_buffer,
 		0,
 		0,
@@ -121,33 +149,38 @@ private:
 class EncodersScanView : public View {
 public:
 	EncodersScanView(NavigationView& nav, Rect parent_rect);
-	
+
+	NumberField field_length {
+		{ 8 * 8, 0 },
+		2,
+		{ 3, 24 },
+		1,
+		' '
+	};
+
+	NumberField bit_length_10 {
+		{ 12 * 8, 2 * 8 },
+		2,
+		{ 1, 88 },
+		1,
+		' '
+	};
+
+	NumberField bit_length {
+		{ 14 * 8, 2 * 8 },
+		1,
+		{ 0, 9 },
+		1,
+		' '
+	};
+
 	void focus() override;
 
 private:
 	Labels labels {
-		{ { 1 * 8, 1 * 8 }, "Coming soon...", Color::light_grey() }
-	};
-	
-	// DEBUG
-	NumberField field_debug {
-		{ 1 * 8, 6 * 8 },
-		2,
-		{ 3, 16 },
-		1,
-		' '
-	};
-	
-	// DEBUG
-	Text text_debug {
-		{ 1 * 8, 8 * 8, 24 * 8, 16 },
-		""
-	};
-	
-	// DEBUG
-	Text text_length {
-		{ 1 * 8, 10 * 8, 24 * 8, 16 },
-		""
+		{ { 1 * 8, 0 * 8 }, "Length:", Color::light_grey() },
+		{ { 1 * 8, 2 * 8 }, "Bit length:", Color::light_grey() },
+		{ { 16 * 8, 2 * 8 }, "us", Color::light_grey() },
 	};
 };
 
@@ -155,10 +188,10 @@ class EncodersView : public View {
 public:
 	EncodersView(NavigationView& nav);
 	~EncodersView();
-	
+
 	void focus() override;
-	
-	std::string title() const override { return "OOK transmit"; };
+
+	std::string title() const override { return "OOK TX"; };
 
 private:
 	NavigationView& nav_;
@@ -168,15 +201,19 @@ private:
 		SINGLE,
 		SCAN
 	};
-	
+
+	// app save settings
+	std::app_settings 		settings { };
+	std::app_settings::AppSettings 	app_settings { };
+
 	tx_modes tx_mode = IDLE;
-	uint8_t repeat_index { 0 };
-	uint8_t repeat_min { 0 };
-	
+	uint32_t repeat_index { 0 };
+	uint32_t repeat_min { 0 };
+
 	void update_progress();
 	void start_tx(const bool scan);
 	void on_tx_progress(const uint32_t progress, const bool done);
-	
+
 	/*const Style style_address {
 		.font = font::fixed_8x16,
 		.background = Color::black(),
@@ -187,32 +224,32 @@ private:
 		.background = Color::black(),
 		.foreground = Color::blue(),
 	};*/
-	
+
 	Rect view_rect = { 0, 4 * 8, 240, 168 };
-	
+
 	EncodersConfigView view_config { nav_, view_rect };
 	EncodersScanView view_scan { nav_, view_rect };
-	
+
 	TabView tab_view {
 		{ "Config", Color::cyan(), &view_config },
-		{ "Scan", Color::green(), &view_scan },
+		{ "de Bruijn", Color::green(), &view_scan },
 	};
 
 	Text text_status {
 		{ 2 * 8, 13 * 16, 128, 16 },
 		"Ready"
 	};
-	
+
 	ProgressBar progressbar {
 		{ 2 * 8, 13 * 16 + 20, 208, 16 }
 	};
-	
+
 	TransmitterView tx_view {
 		16 * 16,
 		50000,
 		9
 	};
-	
+
 	MessageHandlerRegistration message_handler_tx_progress {
 		Message::ID::TXProgress,
 		[this](const Message* const p) {

firmware/application/apps/ui_fileman.cpp

@@ -20,72 +20,173 @@
  * Boston, MA 02110-1301, USA.
  */
 
+/* TODO:
+ * - Paging menu items
+ * - Copy/Move
+ */
+
+#include <algorithm>
 #include "ui_fileman.hpp"
 #include "string_format.hpp"
 #include "portapack.hpp"
 #include "event_m0.hpp"
 
 using namespace portapack;
+namespace fs = std::filesystem;
+
+namespace {
+using namespace ui;
+
+bool is_hidden_file(const fs::path& path) {
+	return !path.empty() && path.native()[0] == u'.';
+}
+
+// Gets a truncated name from a path for display.
+std::string truncate(const fs::path& path, size_t max_length) {
+	auto name = path.string();
+	return name.length() <= max_length ? name : name.substr(0, max_length);
+}
+
+// Gets a human readable file size string.
+std::string get_pretty_size(uint32_t file_size) {
+	static const std::string suffix[5] = { "B", "kB", "MB", "GB", "??" };
+	size_t suffix_index = 0;
+	
+	while (file_size >= 1024) {
+		file_size /= 1024;
+		suffix_index++;
+	}
+
+	if (suffix_index > 4)
+		suffix_index = 4;
+	
+	return to_string_dec_uint(file_size) + suffix[suffix_index];
+}
+
+// Case insensitive path equality on underlying "native" string.
+bool iequal(
+	const fs::path& lhs,
+	const fs::path& rhs
+) {
+	const auto& lhs_str = lhs.native();
+	const auto& rhs_str = rhs.native();
+
+	// NB: Not correct for Unicode/locales.
+	if (lhs_str.length() == rhs_str.length()) {
+		for (size_t i = 0; i < lhs_str.length(); ++i)
+			if (towupper(lhs_str[i]) != towupper(rhs_str[i]))
+				return false;
+
+		return true;
+	}
+
+	return false;
+}
+
+// Inserts the entry into the entry list sorted directories first then by file name.
+void insert_sorted(std::vector<fileman_entry>& entries, fileman_entry&& entry) {
+	auto it = std::lower_bound(std::begin(entries), std::end(entries), entry,
+		[](const fileman_entry& lhs, const fileman_entry& rhs) {
+			if (lhs.is_directory && !rhs.is_directory)
+				return true;
+			else if (!lhs.is_directory && rhs.is_directory)
+				return false;
+			else
+				return lhs.path < rhs.path;
+		});
+
+	entries.insert(it, std::move(entry));
+}
+
+// Returns the partner file path or an empty path if no partner is found.
+fs::path get_partner_file(fs::path path) {
+	if (fs::is_directory(path))
+		return { };
+
+	const fs::path txt_path{ u".TXT" };
+	const fs::path c16_path{ u".C16" };
+	auto ext = path.extension();
+
+	if (iequal(ext, txt_path))
+		ext = c16_path;
+	else if (iequal(ext, c16_path))
+		ext = txt_path;
+	else
+		return { };
+
+	path.replace_extension(ext);
+	return fs::file_exists(path) && !fs::is_directory(path) ? path : fs::path{ };
+}
+
+// Modal prompt to update the partner file if it exists.
+// Runs continuation on_partner_action to update the partner file.
+// Returns true is a partner is found, otherwise false.
+// Path must be the full path to the file.
+bool partner_file_prompt(
+	NavigationView& nav,
+	const fs::path& path,
+	std::string action_name,
+	std::function<void(const fs::path&, bool)> on_partner_action
+) {
+	auto partner = get_partner_file(path);
+
+	if (partner.empty())
+		return false;
+
+	nav.push_under_current<ModalMessageView>(
+		"Partner File",
+		partner.filename().string() + "\n" + action_name + " this file too?",
+		YESNO,
+		[&nav, partner, on_partner_action](bool choice) {
+			if (on_partner_action)
+				on_partner_action(partner, choice);
+		}
+	);
+
+	return true;
+}
+
+}
 
 namespace ui {
 
-void FileManBaseView::load_directory_contents(const std::filesystem::path& dir_path) {
+/* FileManBaseView ***********************************************************/
+
+void FileManBaseView::load_directory_contents(const fs::path& dir_path) {
 	current_path = dir_path;
-	
-	text_current.set(dir_path.string().length()? dir_path.string().substr(0, 30 - 6):"(sd root)");
-
 	entry_list.clear();
-	
-	auto filtering = (bool)extension_filter.size();
-	
-	// List directories and files, put directories up top
-	if (dir_path.string().length())
-		entry_list.push_back({ u"..", 0, true });
+	auto filtering = !extension_filter.empty();
 
-	for (const auto& entry : std::filesystem::directory_iterator(dir_path, u"*")) {
+	text_current.set(dir_path.empty() ? "(sd root)" : truncate(dir_path, 24));
+	
+	for (const auto& entry : fs::directory_iterator(dir_path, u"*")) {
+		// Hide files starting with '.' (hidden / tmp).
+		if (is_hidden_file(entry.path()))
+			continue;
 
-		// do not display dir / files starting with '.' (hidden / tmp)
-		if (entry.path().string().length() && entry.path().filename().string()[0] != '.') {
-			if (std::filesystem::is_regular_file(entry.status())) {
-				bool matched = true;
-				if (filtering) {
-					auto entry_extension = entry.path().extension().string();
-				
-					for (auto &c: entry_extension)
-						c = toupper(c);
-					
-					if (entry_extension != extension_filter)
-						matched = false;
-				}
-				
-				if (matched)
-					entry_list.push_back({ entry.path(), (uint32_t)entry.size(), false });
-			} else if (std::filesystem::is_directory(entry.status())) {
-				entry_list.insert(entry_list.begin(), { entry.path(), 0, true });
-			}
+		if (fs::is_regular_file(entry.status())) {
+			if (!filtering || iequal(entry.path().extension(), extension_filter))
+				insert_sorted(entry_list, { entry.path(), (uint32_t)entry.size(), false });
+		} else if (fs::is_directory(entry.status())) {
+			insert_sorted(entry_list, { entry.path(), 0, true });
 		}
 	}
+
+	// Add "parent" directory if not at the root.
+	if (!dir_path.empty())
+		entry_list.insert(entry_list.begin(), { parent_dir_path, 0, true });
 }
 
-std::filesystem::path FileManBaseView::get_selected_path() {
-	auto selected_path_str = current_path.string();
-	auto entry_path = entry_list[menu_view.highlighted_index()].entry_path.string();
-	
-	if (entry_path == "..") {
-		selected_path_str = get_parent_dir().string();
-	} else {
-		if (selected_path_str.back() != '/')
-			selected_path_str += '/';
-		
-		selected_path_str += entry_path;
-	}
-	
-	return selected_path_str;
+fs::path FileManBaseView::get_selected_full_path() const {
+	if (get_selected_entry().path == parent_dir_path)
+		return current_path.parent_path();
+
+	return current_path / get_selected_entry().path;
 }
 
-std::filesystem::path FileManBaseView::get_parent_dir() {
-	auto current_path_str = current_path.string();
-	return current_path.string().substr(0, current_path_str.find_last_of('/'));
+const fileman_entry& FileManBaseView::get_selected_entry() const {
+	// TODO: return reference to an "empty" entry on OOB?
+	return entry_list[menu_view.highlighted_index()];
 }
 
 FileManBaseView::FileManBaseView(
@@ -105,20 +206,20 @@ FileManBaseView::FileManBaseView(
 	};
 
 	if (!sdcIsCardInserted(&SDCD1)) {
-		empty_root=true;
+		empty_root = true;
 		text_current.set("NO SD CARD!");
+		return;
+	}
+	
+	load_directory_contents(current_path);
+
+	if (!entry_list.size()) {
+		empty_root = true;
+		text_current.set("EMPTY SD CARD!");
 	} else {
-		load_directory_contents(current_path);
-		if (!entry_list.size())
-		{
-			empty_root = true;
-			text_current.set("EMPTY SD CARD!");
-		} else {
-			menu_view.on_left = [&nav, this]() {
-				load_directory_contents(get_parent_dir());
-				refresh_list();
-			};
-		}
+		menu_view.on_left = [this]() {
+			pop_dir();
+		};
 	}
 }
 
@@ -130,67 +231,83 @@ void FileManBaseView::focus() {
 	}
 }
 
+void FileManBaseView::push_dir(const fs::path& path) {
+	if (path == parent_dir_path) {
+		pop_dir();
+	} else {
+		current_path /= path;
+		saved_index_stack.push_back(menu_view.highlighted_index());
+		menu_view.set_highlighted(0);
+		reload_current();
+	}
+}
+
+void FileManBaseView::pop_dir() {
+	if (saved_index_stack.empty())
+		return;
+
+	current_path = current_path.parent_path();
+	reload_current();
+	menu_view.set_highlighted(saved_index_stack.back());
+	saved_index_stack.pop_back();
+}
+
 void FileManBaseView::refresh_list() {
 	if (on_refresh_widgets)
 		on_refresh_widgets(false);
 
+	auto prev_highlight = menu_view.highlighted_index();
 	menu_view.clear();
 	
-	for (size_t n = 0; n < entry_list.size(); n++) {
-		auto entry = &entry_list[n];
-		auto entry_name = entry->entry_path.filename().string().substr(0, 20);
-		
-		if (entry->is_directory) {
-			
+	for (const auto& entry : entry_list) {
+		auto entry_name = truncate(entry.path, 20);
+	
+		if (entry.is_directory) {
 			menu_view.add_item({
 				entry_name,
 				ui::Color::yellow(),
 				&bitmap_icon_dir,
-				[this](){
+				[this](KeyEvent key) {
 					if (on_select_entry)
-						on_select_entry();
+						on_select_entry(key);
 				}
 			});
-			
+	
 		} else {
-			
-			auto file_size = entry->size;
-			size_t suffix_index = 0;
-			
-			while (file_size >= 1024) {
-				file_size /= 1024;
-				suffix_index++;
-			}
-			if (suffix_index > 4)
-				suffix_index = 4;
-			
-			std::string size_str = to_string_dec_uint(file_size) + suffix[suffix_index];
-			
-			auto entry_extension = entry->entry_path.extension().string();
-			for (auto &c: entry_extension)
-				c = toupper(c);
-			
-			// Associate extension to icon and color
-			size_t c;
-			for (c = 0; c < file_types.size() - 1; c++) {
-				if (entry_extension == file_types[c].extension)
-					break;
-			}
+			const auto& assoc = get_assoc(entry.path.extension());
+			auto size_str = get_pretty_size(entry.size);
 			
 			menu_view.add_item({
 				entry_name + std::string(21 - entry_name.length(), ' ') + size_str,
-				file_types[c].color,
-				file_types[c].icon,
-				[this](){
+				assoc.color,
+				assoc.icon,
+				[this](KeyEvent key) {
 					if (on_select_entry)
-						on_select_entry();
+						on_select_entry(key);
 				}
 			});
-			
 		}
 	}
 	
-	menu_view.set_highlighted(0);	// Refresh
+	menu_view.set_highlighted(prev_highlight);
+}
+
+void FileManBaseView::reload_current() {
+	load_directory_contents(current_path);
+	refresh_list();
+}
+
+const FileManBaseView::file_assoc_t& FileManBaseView::get_assoc(
+	const fs::path& ext) const
+{
+	size_t index = 0;
+
+	for (; index < file_types.size() - 1; ++index)
+		if (iequal(ext, file_types[index].extension))
+			return file_types[index];
+
+	// Default to last entry in the list.
+	return file_types[index];
 }
 
 /*void FileSaveView::on_save_name() {
@@ -215,8 +332,9 @@ FileSaveView::FileSaveView(
 	};
 }*/
 
-void FileLoadView::refresh_widgets(const bool v) {
-	(void)v; //avoid unused warning
+/* FileLoadView **************************************************************/
+
+void FileLoadView::refresh_widgets(const bool) {
 	set_dirty();
 }
 
@@ -238,45 +356,92 @@ FileLoadView::FileLoadView(
 	
 	refresh_list();
 	
-	on_select_entry = [&nav, this]() {
-		if (entry_list[menu_view.highlighted_index()].is_directory) {
-			load_directory_contents(get_selected_path());
-			refresh_list();
+	on_select_entry = [this](KeyEvent) {
+		if (get_selected_entry().is_directory) {
+			push_dir(get_selected_entry().path);
 		} else {
 			nav_.pop();
 			if (on_changed)
-				on_changed(current_path.string() + '/' + entry_list[menu_view.highlighted_index()].entry_path.string());
+				on_changed(get_selected_full_path());
 		}
 	};
 }
 
-void FileManagerView::on_rename(NavigationView& nav) {
-	text_prompt(nav, name_buffer, max_filename_length, [this](std::string& buffer) {
-		std::string destination_path = current_path.string();
-		if (destination_path.back() != '/')
-			destination_path += '/';
-		destination_path = destination_path + buffer;
-		rename_file(get_selected_path(), destination_path);
-		load_directory_contents(current_path);
-		refresh_list();
-	});
+/* FileManagerView ***********************************************************/
+
+void FileManagerView::on_rename() {
+	auto& entry = get_selected_entry();
+	name_buffer = entry.path.filename().string();
+	uint32_t cursor_pos = (uint32_t)name_buffer.length();
+
+	if (auto pos = name_buffer.find_last_of(".");
+		pos != name_buffer.npos && !entry.is_directory)
+		cursor_pos = pos;
+
+	text_prompt(nav_, name_buffer, cursor_pos, max_filename_length,
+		[this](std::string& renamed) {
+			auto renamed_path = fs::path{ renamed };
+			rename_file(get_selected_full_path(), current_path / renamed_path);
+
+			auto has_partner = partner_file_prompt(nav_, get_selected_full_path(), "Rename",
+				[this, renamed_path](const fs::path& partner, bool should_rename) mutable {
+					if (should_rename) {
+						auto new_name = renamed_path.replace_extension(partner.extension());
+						rename_file(current_path / partner, current_path / new_name);
+					}
+					reload_current();
+				}
+			);
+
+			if (!has_partner)
+				reload_current();
+		});
 }
 
 void FileManagerView::on_delete() {
-	delete_file(get_selected_path());
-	load_directory_contents(current_path);
-	refresh_list();
+	auto name = get_selected_entry().path.filename().string();
+	nav_.push<ModalMessageView>("Delete", "Delete " + name + "\nAre you sure?", YESNO,
+		[this](bool choice) {
+			if (choice) {
+				delete_file(get_selected_full_path());
+
+				auto has_partner = partner_file_prompt(
+					nav_, get_selected_full_path(), "Delete",
+					[this](const fs::path& partner, bool should_delete) {
+						if (should_delete)
+							delete_file(current_path / partner);
+						reload_current();
+					}
+				);
+
+				if (!has_partner)
+					reload_current();
+			}
+		}
+	);
+}
+
+void FileManagerView::on_new_dir() {
+	name_buffer = "";
+	text_prompt(nav_, name_buffer, max_filename_length, [this](std::string& dir_name) {
+		make_new_directory(current_path / dir_name);
+		reload_current();
+	});
+}
+
+bool FileManagerView::selected_is_valid() const {
+	return !entry_list.empty() &&
+		get_selected_entry().path != parent_dir_path;
 }
 
 void FileManagerView::refresh_widgets(const bool v) {
 	button_rename.hidden(v);
-	button_new_dir.hidden(v);
 	button_delete.hidden(v);
+	button_new_dir.hidden(v);
 	set_dirty();
 }
 
 FileManagerView::~FileManagerView() {
-	// Flush ?
 }
 
 FileManagerView::FileManagerView(
@@ -293,47 +458,40 @@ FileManagerView::FileManagerView(
 			&labels,
 			&text_date,
 			&button_rename,
+			&button_delete,
 			&button_new_dir,
-			&button_delete
 		});
 		
 		menu_view.on_highlight = [this]() {
-			text_date.set(to_string_FAT_timestamp(file_created_date(get_selected_path())));
+      // TODO: enable/disable buttons.
+      if (selected_is_valid())
+  			text_date.set(to_string_FAT_timestamp(file_created_date(get_selected_full_path())));
+      else
+        text_date.set("");
 		};
 		
 		refresh_list();
-		
-		on_select_entry = [this]() {
-			if (entry_list[menu_view.highlighted_index()].is_directory) {
-				load_directory_contents(get_selected_path());
-				refresh_list();
-			} else
+	
+		on_select_entry = [this](KeyEvent key) {
+			if (key == KeyEvent::Select && get_selected_entry().is_directory) {
+				push_dir(get_selected_entry().path);
+			} else {
 				button_rename.focus();
+			}
 		};
 		
-		button_new_dir.on_select = [this, &nav](Button&) {
-			name_buffer.clear();
-			
-			text_prompt(nav, name_buffer, max_filename_length, [this](std::string& buffer) {
-				make_new_directory(current_path.string() + '/' + buffer);
-				load_directory_contents(current_path);
-				refresh_list();
-			});
+		button_rename.on_select = [this](Button&) {
+			if (selected_is_valid())
+				on_rename();
 		};
-		
-		button_rename.on_select = [this, &nav](Button&) {
-			name_buffer = entry_list[menu_view.highlighted_index()].entry_path.filename().string().substr(0, max_filename_length);
-			on_rename(nav);
+
+		button_delete.on_select = [this](Button&) {
+			if (selected_is_valid())
+				on_delete();
 		};
-		
-		button_delete.on_select = [this, &nav](Button&) {
-			// Use display_modal ?
-			nav.push<ModalMessageView>("Delete", "Delete " + entry_list[menu_view.highlighted_index()].entry_path.filename().string() + "\nAre you sure?", YESNO,
-				[this](bool choice) {
-					if (choice)
-						on_delete();
-				}
-			);
+
+		button_new_dir.on_select = [this](Button&) {
+			on_new_dir();
 		};
 	} 
 }

firmware/application/apps/ui_fileman.hpp

@@ -31,7 +31,7 @@
 namespace ui {
 
 struct fileman_entry {
-	std::filesystem::path entry_path { };
+	std::filesystem::path path { };
 	uint32_t size { };
 	bool is_directory { };
 };
@@ -43,50 +43,56 @@ public:
 		std::string filter
 	);
 
-	void focus() override;
-	
-	void load_directory_contents(const std::filesystem::path& dir_path);
-	std::filesystem::path get_selected_path();
-	
-	std::string title() const override { return "File manager"; };
+	void focus() override;	
+	std::string title() const override { return "Fileman"; };
 	
 protected:
-	NavigationView& nav_;
-	
-	static constexpr size_t max_filename_length = 30 - 2;
-	
-	const std::string suffix[5] = { "B", "kB", "MB", "GB", "??" };
-	
+	static constexpr size_t max_filename_length = 50;
+
 	struct file_assoc_t {
-		std::string extension;
+		std::filesystem::path extension;
 		const Bitmap* icon;
 		ui::Color color;
 	};
 	
 	const std::vector<file_assoc_t> file_types = {
-		{ ".TXT", &bitmap_icon_file_text, ui::Color::white() },
-		{ ".PNG", &bitmap_icon_file_image, ui::Color::green() },
-		{ ".BMP", &bitmap_icon_file_image, ui::Color::green() },
-		{ ".C8",  &bitmap_icon_file_iq, ui::Color::blue() },
-		{ ".C16", &bitmap_icon_file_iq, ui::Color::blue() },
-		{ ".WAV", &bitmap_icon_file_wav, ui::Color::dark_magenta() },
-		{ "", &bitmap_icon_file, ui::Color::light_grey() }
+		{ u".TXT", &bitmap_icon_file_text, ui::Color::white() },
+		{ u".PNG", &bitmap_icon_file_image, ui::Color::green() },
+		{ u".BMP", &bitmap_icon_file_image, ui::Color::green() },
+		{ u".C8",  &bitmap_icon_file_iq, ui::Color::dark_cyan() },
+		{ u".C16", &bitmap_icon_file_iq, ui::Color::dark_cyan() },
+		{ u".WAV", &bitmap_icon_file_wav, ui::Color::dark_magenta() },
+		{ u"", &bitmap_icon_file, ui::Color::light_grey() } // NB: Must be last.
 	};
-	
-	bool empty_root { false };
-	std::function<void(void)> on_select_entry { nullptr };
-	std::function<void(bool)> on_refresh_widgets { nullptr };
-	std::vector<fileman_entry> entry_list { };
-	std::filesystem::path current_path { u"" };
-	std::string extension_filter { "" };
-	
-	void change_category(int32_t category_id);
-	std::filesystem::path get_parent_dir();
+
+
+	std::filesystem::path get_selected_full_path() const;
+	const fileman_entry& get_selected_entry() const;
+
+	void push_dir(const std::filesystem::path& path);
+	void pop_dir();
 	void refresh_list();
+	void reload_current();
+	void load_directory_contents(const std::filesystem::path& dir_path);
+	const file_assoc_t& get_assoc(const std::filesystem::path& ext) const;
+
+	NavigationView& nav_;
+
+	bool empty_root { false };
+	std::function<void(KeyEvent)> on_select_entry { nullptr };
+	std::function<void(bool)> on_refresh_widgets { nullptr };
+
+	const std::filesystem::path parent_dir_path { u".." };
+	std::filesystem::path current_path { u"" };
+	std::filesystem::path extension_filter { u"" };
+
+	std::vector<fileman_entry> entry_list { };
+	std::vector<uint32_t> saved_index_stack { };
 	
 	Labels labels {
 		{ { 0, 0 }, "Path:", Color::light_grey() }
 	};
+
 	Text text_current {
 		{ 6 * 8, 0 * 8, 24 * 8, 16 },
 		"",
@@ -142,11 +148,16 @@ public:
 	~FileManagerView();
 
 private:
+	// Passed by ref to other views needing lifetime extension.
 	std::string name_buffer { };
 	
 	void refresh_widgets(const bool v);
-	void on_rename(NavigationView& nav);
+	void on_rename();
 	void on_delete();
+	void on_new_dir();
+
+	// True if the selected entry is a real file item.
+	bool selected_is_valid() const;
 	
 	Labels labels {
 		{ { 0, 26 * 8 }, "Created ", Color::light_grey() }
@@ -161,16 +172,16 @@ private:
 		{ 0 * 8, 29 * 8, 14 * 8, 32 },
 		"Rename"
 	};
+
 	Button button_delete {
 		{ 16 * 8, 29 * 8, 14 * 8, 32 },
 		"Delete"
 	};
-	
+
 	Button button_new_dir {
 		{ 0 * 8, 34 * 8, 14 * 8, 32 },
-		"New dir"
+		"New Dir"
 	};
-	
 };
 
 } /* namespace ui */

firmware/application/apps/ui_flash_utility.cpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * 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_flash_utility.hpp"
+#include "portapack_shared_memory.hpp"
+
+namespace ui {
+
+Thread* FlashUtilityView::thread { nullptr };
+static constexpr size_t max_filename_length = 26;
+
+FlashUtilityView::FlashUtilityView(NavigationView& nav) : nav_ (nav) {
+	add_children({
+		&labels,
+		&menu_view
+	});
+
+	menu_view.set_parent_rect({ 0, 3 * 8, 240, 33 * 8 });
+
+	for (const auto& entry : std::filesystem::directory_iterator(u"FIRMWARE", u"*.bin")) {
+		auto filename = entry.path().filename();
+		auto path = entry.path().native();
+
+		menu_view.add_item({
+			filename.string().substr(0, max_filename_length),
+			ui::Color::red(),
+			&bitmap_icon_temperature,
+			[this, path](KeyEvent) {
+				this->firmware_selected(path);
+			}
+		});
+	}
+}
+
+void FlashUtilityView::firmware_selected(std::filesystem::path::string_type path) {
+	nav_.push<ModalMessageView>(
+		"Warning!",
+		"This will replace your\ncurrent firmware.\n\nIf things go wrong you are\nrequired to flash manually\nwith dfu.",
+		YESNO,
+		[this, path](bool choice) {
+			if (choice) {
+				std::u16string full_path = std::u16string(u"FIRMWARE/") + path;
+				this->flash_firmware(full_path);
+			}
+		}
+	);
+}
+
+void FlashUtilityView::flash_firmware(std::filesystem::path::string_type path) {
+	ui::Painter painter;
+		painter.fill_rectangle(
+		{ 0, 0, portapack::display.width(), portapack::display.height() },
+		ui::Color::black()
+	);
+
+	painter.draw_string({ 12, 24 }, this->nav_.style(), "This will take 15 seconds.");
+	painter.draw_string({ 12, 64 }, this->nav_.style(), "Please wait while LEDs RX");
+	painter.draw_string({ 12, 84 }, this->nav_.style(), "and TX are flashing.");
+	painter.draw_string({ 12, 124 }, this->nav_.style(), "Then restart the device.");
+
+	std::memcpy(&shared_memory.bb_data.data[0], path.c_str(), (path.length() + 1) * 2);
+	m4_init(portapack::spi_flash::image_tag_flash_utility, portapack::memory::map::m4_code, false);
+	m0_halt();
+}
+
+void FlashUtilityView::focus() {
+	menu_view.focus();
+}
+
+} /* namespace ui */

firmware/application/apps/ui_flash_utility.hpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * 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.
+ */
+
+#ifndef __UI_FLSH_UITILTY_H__
+#define __UI_FLSH_UITILTY_H__
+
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "string_format.hpp"
+#include "ff.h"
+#include "baseband_api.hpp"
+#include "core_control.hpp"
+
+#include <cstdint>
+
+namespace ui {
+
+class FlashUtilityView : public View {
+public:
+	FlashUtilityView(NavigationView& nav);
+
+	void focus() override;
+	
+	std::string title() const override { return "Flash Utility"; };	
+
+private:
+	NavigationView& nav_;
+	
+	bool confirmed = false;
+	static Thread* thread;
+
+	Labels labels {
+		{ { 4, 4 }, "Select firmware to flash:", Color::white() }
+	};
+
+	MenuView menu_view {
+		{ 0, 2 * 8, 240, 26 * 8 },
+		true
+	};
+
+	void firmware_selected(std::filesystem::path::string_type path);
+	void flash_firmware(std::filesystem::path::string_type path);
+};
+
+} /* namespace ui */
+
+#endif/*__UI_FLSH_UITILTY_H__*/

firmware/application/apps/ui_freqman.cpp

@@ -120,7 +120,7 @@ void FreqManBaseView::refresh_list() {
 				freqman_item_string(database[n], 30),
 				ui::Color::white(),
 				nullptr,
-				[this](){
+				[this](KeyEvent){
 					if (on_select_frequency)
 						on_select_frequency();
 				}

firmware/application/apps/ui_freqman.hpp

@@ -87,7 +87,7 @@ class FrequencySaveView : public FreqManBaseView {
 public:
 	FrequencySaveView(NavigationView& nav, const rf::Frequency value);
 
-	std::string title() const override { return "Save frequency"; };
+	std::string title() const override { return "Save freq."; };
 	
 private:
 	std::string desc_buffer { };
@@ -126,7 +126,7 @@ public:
 	
 	FrequencyLoadView(NavigationView& nav);
 
-	std::string title() const override { return "Load frequency"; };
+	std::string title() const override { return "Load freq."; };
 	
 private:
 	void refresh_widgets(const bool v);
@@ -137,7 +137,7 @@ public:
 	FrequencyManagerView(NavigationView& nav);
 	~FrequencyManagerView();
 
-	std::string title() const override { return "Freq. manager"; };
+	std::string title() const override { return "Freqman"; };
 	
 private:
 	std::string desc_buffer { };

firmware/application/apps/ui_jammer.cpp

@@ -25,6 +25,7 @@
 #include "ui_freqman.hpp"
 
 #include "baseband_api.hpp"
+#include "cpld_update.hpp"
 #include "string_format.hpp"
 
 using namespace portapack;
@@ -183,7 +184,8 @@ void JammerView::focus() {
 
 JammerView::~JammerView() {
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit .
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void JammerView::on_retune(const rf::Frequency freq, const uint32_t range) {
@@ -268,9 +270,9 @@ void JammerView::start_tx() {
 		button_transmit.set_text("STOP");
 		
 		transmitter_model.set_sampling_rate(3072000U);
-		transmitter_model.set_rf_amp(true);
+		transmitter_model.set_rf_amp(field_amp.value());
 		transmitter_model.set_baseband_bandwidth(3500000U);
-		transmitter_model.set_tx_gain(47);
+		transmitter_model.set_tx_gain(field_gain.value());
 		transmitter_model.enable();
 
 		baseband::set_jammer(true, (JammerType)options_type.selected_index(), options_speed.selected_index_value());
@@ -366,6 +368,8 @@ JammerView::JammerView(
 		&field_timetx,
 		&field_timepause,
 		&field_jitter,
+		&field_gain,
+		&field_amp,
 		&button_transmit
 	});
 	
@@ -380,6 +384,8 @@ JammerView::JammerView(
 
 	field_timetx.set_value(30);
 	field_timepause.set_value(1);
+	field_gain.set_value(transmitter_model.tx_gain());
+	field_amp.set_value(transmitter_model.rf_amp());
 
 	button_transmit.on_select = [this](Button&) {
 		if (jamming || cooling)

firmware/application/apps/ui_jammer.hpp

@@ -106,7 +106,7 @@ public:
 	
 	void focus() override;
 	
-	std::string title() const override { return "Jammer"; };
+	std::string title() const override { return "Jammer TX"; };
 	
 private:
 	NavigationView& nav_;
@@ -156,7 +156,9 @@ private:
 		{ { 0 * 8, 33 * 8 }, "Jitter:", Color::light_grey() },	//Maybe the repository curator can keep the "mystype" for some versions. 
 		{ { 11 * 8, 29 * 8 }, "Secs.", Color::light_grey() }, 
 		{ { 11 * 8, 31 * 8 }, "Secs.", Color::light_grey() },
-		{ { 11 * 8, 33 * 8 }, "/60", Color::light_grey() }
+		{ { 11 * 8, 33 * 8 }, "/60", Color::light_grey() },
+		{ { 2 * 8, 35 * 8 }, "Gain:", Color::light_grey() },
+		{ { 11 * 8, 35 * 8 }, "A:", Color::light_grey() }
 	};
 	
 	OptionsField options_type {
@@ -229,8 +231,24 @@ private:
 		' ',
 	};
 
+	NumberField field_gain {
+		{ 8 * 8, 35 * 8 },
+		2,
+		{ 0, 47 },
+		1,
+		' ',
+	};
+
+	NumberField field_amp {
+		{ 13 * 8, 35 * 8 },
+		1,
+		{ 0, 1 },
+		1,
+		' ',
+	};
+
 	Button button_transmit {
-		{ 148, 212, 80, 80},
+		{ 148, 216, 80, 80},
 		"START"
 	};
 	

firmware/application/apps/ui_keyfob.cpp

@@ -23,6 +23,7 @@
 #include "ui_keyfob.hpp"
 
 #include "baseband_api.hpp"
+#include "cpld_update.hpp"
 #include "string_format.hpp"
 
 using namespace portapack;
@@ -136,8 +137,12 @@ void KeyfobView::focus() {
 }
 
 KeyfobView::~KeyfobView() {
+	// save app settings
+	settings.save("tx_keyfob", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit .
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void KeyfobView::update_progress(const uint32_t progress) {
@@ -214,6 +219,13 @@ KeyfobView::KeyfobView(
 		&tx_view
 	});
 	
+	// load app settings
+	auto rc = settings.load("tx_keyfob", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
 	frame[0] = 0x55;
 	update_symfields();
 	

firmware/application/apps/ui_keyfob.hpp

@@ -23,6 +23,7 @@
 #include "ui.hpp"
 #include "ui_transmitter.hpp"
 #include "transmitter_model.hpp"
+#include "app_settings.hpp"
 #include "encoders.hpp"
 
 using namespace encoders;
@@ -36,11 +37,15 @@ public:
 	
 	void focus() override;
 	
-	std::string title() const override { return "Keyfob (BETA)"; };
+	std::string title() const override { return "Key fob TX"; };
 
 private:
 	NavigationView& nav_;
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	// 1013210ns / bit
 	static constexpr uint32_t subaru_samples_per_bit = (OOK_SAMPLERATE * 0.00101321);
 	static constexpr uint32_t repeats = 4;

firmware/application/apps/ui_lcr.cpp

@@ -27,6 +27,7 @@
 #include "modems.hpp"
 #include "baseband_api.hpp"
 #include "string_format.hpp"
+#include "cpld_update.hpp"
 
 #include "serializer.hpp"
 
@@ -39,8 +40,13 @@ void LCRView::focus() {
 }
 
 LCRView::~LCRView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_lcr", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit.
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 /*
@@ -173,6 +179,15 @@ LCRView::LCRView(NavigationView& nav) {
 		&tx_view
 	});
 	
+	// load app settings
+	auto rc = settings.load("tx_lcr", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
 	options_scanlist.set_selected_index(0);
 	
 	const auto button_set_am_fn = [this, &nav](Button& button) {

firmware/application/apps/ui_lcr.hpp

@@ -27,6 +27,7 @@
 
 #include "message.hpp"
 #include "transmitter_model.hpp"
+#include "app_settings.hpp"
 
 namespace ui {
 	
@@ -39,7 +40,7 @@ public:
 	
 	void focus() override;
 	
-	std::string title() const override { return "LCR transmit"; };
+	std::string title() const override { return "TEDI/LCR TX"; };
 	
 private:
 	struct scan_list_t {
@@ -81,6 +82,10 @@ private:
 		SCAN
 	};
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	tx_modes tx_mode = IDLE;
 	uint8_t scan_count { 0 }, scan_index { 0 };
 	uint32_t scan_progress { 0 };

firmware/application/apps/ui_level.cpp

@@ -0,0 +1,308 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2018 Furrtek
+ *
+ * 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_level.hpp"
+#include "ui_fileman.hpp"
+#include "file.hpp"
+
+using namespace portapack;
+using portapack::memory::map::backup_ram;
+
+namespace ui {
+
+    bool LevelView::check_sd_card()
+    {
+        return (sd_card::status() == sd_card::Status::Mounted) ? true : false;
+    }
+
+    void LevelView::focus() {
+        button_frequency.focus();
+    }
+
+    LevelView::~LevelView() {
+
+        // save app settings
+        app_settings.lna = field_lna.value();
+        app_settings.vga = field_vga.value();
+        app_settings.rx_amp = field_rf_amp.value();
+
+        settings.save("level", &app_settings);
+
+        receiver_model.disable();
+        baseband::shutdown();
+    }
+
+    LevelView::LevelView( NavigationView& nav) : nav_ { nav } {
+
+        add_children( {
+                &labels,
+                &field_lna,
+                &field_vga,
+                &field_rf_amp,
+                &field_volume,
+                &field_bw,
+                &field_mode,
+                &step_mode,
+                &rssi_resolution,
+                &button_frequency,
+                &text_ctcss,
+                &freq_stats_rssi,
+                &freq_stats_db,
+                &audio_mode,
+                &peak_mode,
+                &rssi,
+                &rssi_graph
+                } );
+
+        rssi.set_vertical_rssi( true );
+
+        field_volume.on_change = [this](int32_t v) { this->on_headphone_volume_changed(v);	};
+        field_volume.set_value((receiver_model.headphone_volume() - audio::headphone::volume_range().max).decibel() + 99);
+
+        // Level directory
+        if( check_sd_card() ) {                     // Check to see if SD Card is mounted
+            make_new_directory( u"/LEVEL" );
+            sd_card_mounted = true ;
+        }
+
+        change_mode(NFM_MODULATION);	//Start on AM
+        field_mode.set_by_value(NFM_MODULATION);	//Reflect the mode into the manual selector
+
+        //HELPER: Pre-setting a manual range, based on stored frequency
+        freq = persistent_memory::tuned_frequency();
+        receiver_model.set_tuning_frequency( freq );
+        button_frequency.set_text( "<" + to_string_short_freq( freq ) + " MHz>" );
+
+        // load auto common app settings
+        if( sd_card_mounted )
+        {
+            auto rc = settings.load("level", &app_settings);
+            if(rc == SETTINGS_OK) {
+                field_lna.set_value(app_settings.lna);
+                field_vga.set_value(app_settings.vga);
+                field_rf_amp.set_value(app_settings.rx_amp);
+                receiver_model.set_rf_amp(app_settings.rx_amp);
+            }
+        }
+
+        button_frequency.on_select = [this, &nav](ButtonWithEncoder& button) {
+            auto new_view = nav_.push<FrequencyKeypadView>(freq);
+            new_view->on_changed = [this, &button](rf::Frequency f) {
+                freq = f ;
+                receiver_model.set_tuning_frequency( f );	// Retune to actual freq
+                button_frequency.set_text( "<" + to_string_short_freq( freq ) + " MHz>" );
+            };
+        };
+
+        button_frequency.on_change = [this]() {
+            int64_t def_step = freqman_entry_get_step_value( step_mode.selected_index() );
+            freq = freq + ( button_frequency.get_encoder_delta() * def_step );
+            if( freq < 1 )
+            {
+                freq = 1 ;
+            }
+            if( freq > ( MAX_UFREQ - def_step ) )
+            {
+                freq = MAX_UFREQ ;
+            }
+            button_frequency.set_encoder_delta( 0 );
+
+            receiver_model.set_tuning_frequency( freq );	// Retune to actual freq
+            button_frequency.set_text( "<" + to_string_short_freq( freq ) + " MHz>" );
+        };
+
+        field_mode.on_change = [this](size_t, OptionsField::value_t v) {
+            if( v != -1 )
+            {
+                receiver_model.disable();
+                baseband::shutdown();
+                change_mode(v);
+                if( audio_mode.selected_index() != 0 )
+                {
+                    audio::output::start();								
+                }
+                receiver_model.enable();
+            }
+        };
+
+        rssi_resolution.on_change = [this](size_t, OptionsField::value_t v) {
+            if( v != -1 )
+            {
+                rssi_graph.set_nb_columns( v );
+            }
+        };
+
+        audio_mode.on_change = [this](size_t, OptionsField::value_t v) {
+            if( v == 0 )
+            {
+                audio::output::stop();
+            }
+            else if( v == 1 )
+            {
+                audio::output::start();
+                this->on_headphone_volume_changed( (receiver_model.headphone_volume() - audio::headphone::volume_range().max).decibel() + 99 );
+            }
+            else
+            {
+
+            }
+        };
+
+
+        peak_mode.on_change = [this](size_t, OptionsField::value_t v) {
+            if( v == 0 )
+            {
+                rssi.set_peak( false , 0 );
+            }
+            else
+            {
+                rssi.set_peak( true , v );
+            }
+        };
+
+        // default peak value 
+        peak_mode.set_selected_index(2);
+        rssi_resolution.set_selected_index(1);
+        //FILL STEP OPTIONS
+        freqman_set_modulation_option( field_mode );
+        freqman_set_step_option_short( step_mode );
+        freq_stats_rssi.set_style(&style_white);
+        freq_stats_db.set_style(&style_white);
+    }
+
+    void LevelView::on_headphone_volume_changed(int32_t v) {
+        const auto new_volume = volume_t::decibel(v - 99) + audio::headphone::volume_range().max;
+        receiver_model.set_headphone_volume(new_volume);
+    }
+
+
+    void LevelView::on_statistics_update(const ChannelStatistics& statistics) {
+        static int last_max_db = -1000 ;
+        static int last_min_rssi = -1000 ;
+        static int last_avg_rssi = -1000 ;
+        static int last_max_rssi = -1000 ;
+
+        rssi_graph.add_values( rssi.get_min() , rssi.get_avg() , rssi.get_max() , statistics.max_db );
+
+        bool refresh_db = false ;
+        bool refresh_rssi = false ;
+
+        if(  last_max_db != statistics.max_db )
+        {
+            refresh_db = true ;
+        }
+        if( last_min_rssi != rssi.get_min() || last_avg_rssi != rssi.get_avg() || last_max_rssi != rssi.get_max() )
+        {
+            refresh_rssi = true ;
+        }
+        if( refresh_db )
+        {
+            last_max_db =  statistics.max_db ;
+            freq_stats_db.set( "Power: "+to_string_dec_int( statistics.max_db )+" db" );
+        }
+        if( refresh_rssi )
+        {
+            last_min_rssi = rssi.get_min();
+            last_avg_rssi = rssi.get_avg();
+            last_max_rssi = rssi.get_max();
+            freq_stats_rssi.set( "RSSI: "+to_string_dec_int( rssi.get_min() )+"/"+to_string_dec_int( rssi.get_avg() )+"/"+to_string_dec_int( rssi.get_max() )+",dt: "+to_string_dec_int( rssi.get_delta() ) );
+        }
+    } /* on_statistic_updates */
+
+    size_t LevelView::change_mode( freqman_index_t new_mod ) { 
+
+        field_bw.on_change = [this](size_t n, OptionsField::value_t) { (void)n;	};
+
+        switch( new_mod ) {
+            case AM_MODULATION:
+                freqman_set_bandwidth_option( new_mod , field_bw );
+                //bw DSB (0) default
+                field_bw.set_selected_index(0);
+                baseband::run_image(portapack::spi_flash::image_tag_am_audio);
+                receiver_model.set_modulation(ReceiverModel::Mode::AMAudio);
+                receiver_model.set_am_configuration(field_bw.selected_index());
+                field_bw.on_change = [this](size_t n, OptionsField::value_t) { receiver_model.set_am_configuration(n);	};
+                receiver_model.set_sampling_rate(3072000);	receiver_model.set_baseband_bandwidth(1750000);
+                text_ctcss.set("             ");
+                break;
+            case NFM_MODULATION:
+                freqman_set_bandwidth_option( new_mod , field_bw );
+                //bw 16k (2) default
+                field_bw.set_selected_index(2);
+                baseband::run_image(portapack::spi_flash::image_tag_nfm_audio);
+                receiver_model.set_modulation(ReceiverModel::Mode::NarrowbandFMAudio);
+                receiver_model.set_nbfm_configuration(field_bw.selected_index());
+                field_bw.on_change = [this](size_t n, OptionsField::value_t) { 	receiver_model.set_nbfm_configuration(n); };
+                receiver_model.set_sampling_rate(3072000);	receiver_model.set_baseband_bandwidth(1750000);
+                break;
+            case WFM_MODULATION:
+                freqman_set_bandwidth_option( new_mod , field_bw );
+                //bw 200k (0) only/default
+                field_bw.set_selected_index(0);
+                baseband::run_image(portapack::spi_flash::image_tag_wfm_audio);
+                receiver_model.set_modulation(ReceiverModel::Mode::WidebandFMAudio);
+                receiver_model.set_wfm_configuration(field_bw.selected_index());
+                field_bw.on_change = [this](size_t n, OptionsField::value_t) {	receiver_model.set_wfm_configuration(n); };
+                receiver_model.set_sampling_rate(3072000);	receiver_model.set_baseband_bandwidth(1750000);
+                text_ctcss.set("             ");
+                break;
+            default:
+                break;
+        }
+        return step_mode.selected_index();
+    }
+
+
+    void LevelView::handle_coded_squelch(const uint32_t value) {
+        static int32_t last_idx = -1 ;
+
+        float diff, min_diff = value;
+        size_t min_idx { 0 };
+        size_t c;
+
+        if( field_mode.selected_index() != NFM_MODULATION )
+        {
+            text_ctcss.set("             ");
+            return ;
+        }
+
+        // Find nearest match
+        for (c = 0; c < tone_keys.size(); c++) {
+            diff = abs(((float)value / 100.0) - tone_keys[c].second);
+            if (diff < min_diff) {
+                min_idx = c;
+                min_diff = diff;
+            }
+        }
+
+        // Arbitrary confidence threshold
+        if( last_idx < 0 || (unsigned)last_idx != min_idx )
+        {
+            last_idx = min_idx ;
+            if (min_diff < 40)
+                text_ctcss.set("T: "+tone_keys[min_idx].first);
+            else
+                text_ctcss.set("             ");
+        }
+    }
+
+} /* namespace ui */

firmware/application/apps/ui_level.hpp

@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2018 Furrtek
+ *
+ * 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_LEVEL
+#define _UI_LEVEL
+
+#include "ui.hpp"
+#include "receiver_model.hpp"
+#include "ui_receiver.hpp"
+#include "ui_font_fixed_8x16.hpp"
+#include "freqman.hpp"
+#include "analog_audio_app.hpp"
+#include "audio.hpp"
+#include "ui_mictx.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "baseband_api.hpp"
+#include "ui_spectrum.hpp"
+#include "string_format.hpp"
+#include "file.hpp"
+#include "app_settings.hpp"
+
+
+namespace ui {
+
+	class LevelView : public View {
+		public:
+			LevelView(NavigationView& nav);
+			~LevelView();
+
+			void focus() override;
+
+			const Style style_grey {		// level
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::grey(),
+			};
+
+			const Style style_white {		// level
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::white(),
+			};
+
+			const Style style_yellow {		//Found signal
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::yellow(),
+			};
+
+			const Style style_green {		//Found signal
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::green(),
+			};
+
+			const Style style_red {		//erasing freq
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::red(),
+			};
+
+			const Style style_blue {		// quick level, wait == 0
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::blue(),
+			};
+
+			std::string title() const override { return "Level"; };
+
+		private:
+			NavigationView& nav_;
+
+			size_t change_mode( freqman_index_t mod_type);
+			void on_statistics_update(const ChannelStatistics& statistics);
+			void set_display_freq( int64_t freq );
+			bool check_sd_card();
+
+			int32_t db { 0 };
+			long long int MAX_UFREQ = { 7200000000 }; // maximum usable freq
+			bool sd_card_mounted = false ;
+			rf::Frequency freq = { 0 } ;
+
+			Labels labels 
+			{ 
+				{ { 0  * 8 , 0  * 16      }, "LNA:   VGA:   AMP:  VOL:     ", Color::light_grey() },
+					{ { 0  * 8 , 1  * 16      }, "BW:       MODE:    S:   ", Color::light_grey() },
+			};
+
+			LNAGainField field_lna {
+				{ 4 * 8, 0 * 16 }
+			};
+
+			VGAGainField field_vga {
+				{ 11 * 8, 0 * 16 }
+			};
+
+			RFAmpField field_rf_amp {
+				{ 18 * 8, 0 * 16 }
+			};
+
+			NumberField field_volume {
+				{ 24 * 8, 0 * 16 },
+					2,
+					{ 0, 99 },
+					1,
+					' ',
+			};
+
+			OptionsField field_bw {
+				{ 3 * 8, 1 * 16 },
+					6,
+					{ }
+			};		
+
+			OptionsField field_mode {
+				{ 15 * 8, 1 * 16 },
+					3,
+					{
+					}
+			};
+
+			OptionsField step_mode {
+				{ 16 * 8, 2 * 16 + 4 },
+					12,
+					{
+					}
+			};
+
+			ButtonWithEncoder button_frequency {
+				{ 0 * 8 , 2 * 16 + 8 , 15 * 8 , 1 * 8 },
+					""
+			};
+
+			OptionsField audio_mode {
+				{ 21 * 8, 1 * 16 },
+					9,
+					{
+						{"audio off", 0},
+						{"audio on",1}
+						//{"tone on", 2},
+						//{"tone off", 2},
+					}
+			};		
+
+			Text text_ctcss {
+				{ 22 * 8, 3 * 16 + 4 , 14 * 8, 1 * 8 },
+					""
+			};
+
+			// RSSI: XX/XX/XXX,dt: XX
+			Text freq_stats_rssi {		
+				{ 0 * 8 , 3 * 16 + 4 , 22 * 8, 14 },
+			};
+
+			// Power: -XXX db
+			Text freq_stats_db {		
+				{ 0 * 8 , 4 * 16 + 4 , 14 * 8, 14 },
+			};
+
+			OptionsField peak_mode {
+				{ 40 + 10 * 8, 4 * 16 + 4 },
+					10,
+					{
+						{"peak:none", 0},
+						{"peak:0.25s",250},
+						{"peak:0.5s",500},
+						{"peak:1s",1000},
+						{"peak:3s",3000},
+						{"peak:5s",5000},
+						{"peak:10s",10000},
+					}
+			};		
+			OptionsField rssi_resolution {
+				{ 44 + 20 * 8, 4 * 16 + 4},
+					4,
+					{
+						{"16x",  16},
+						{"32x",  32},
+						{"64x",  64},
+						{"128x", 128},
+						{"240x", 240},
+					}
+			};		
+
+			RSSIGraph rssi_graph { // 240x320  => 
+				{ 0 , 5 * 16 + 4 , 240 - 5 * 8 , 320 - ( 5 * 16 + 4 ) },
+			}; 
+
+			RSSI rssi { // 240x320  =>  
+				{ 240 - 5 * 8 , 5 * 16 + 4 , 5 * 8 ,  320 - ( 5 * 16 + 4 ) },
+			}; 
+
+			void handle_coded_squelch(const uint32_t value);
+			void on_headphone_volume_changed(int32_t v);
+
+			MessageHandlerRegistration message_handler_coded_squelch {
+				Message::ID::CodedSquelch,
+					[this](const Message* const p) {
+						const auto message = *reinterpret_cast<const CodedSquelchMessage*>(p);
+						this->handle_coded_squelch(message.value);
+					}
+			};
+
+			MessageHandlerRegistration message_handler_stats {
+				Message::ID::ChannelStatistics,
+					[this](const Message* const p) {
+						this->on_statistics_update(static_cast<const ChannelStatisticsMessage*>(p)->statistics);
+					}
+			};
+			// app save settings
+			std::app_settings settings { }; 		
+			std::app_settings::AppSettings app_settings { };
+	};
+
+} /* namespace ui */
+
+#endif

firmware/application/apps/ui_looking_glass_app.cpp

@@ -22,315 +22,672 @@
 
 #include "ui_looking_glass_app.hpp"
 
-
 using namespace portapack;
 
 namespace ui
 {
-
-void GlassView::focus() {
-	field_marker.focus();
-}
-
-GlassView::~GlassView() {
-    receiver_model.set_sampling_rate(3072000); // Just a hack to avoid hanging other apps
-	receiver_model.disable();
-	baseband::shutdown();
-}
-
-void GlassView::on_lna_changed(int32_t v_db) {
-	receiver_model.set_lna(v_db);
-}
-
-void GlassView::on_vga_changed(int32_t v_db) {
-	receiver_model.set_vga(v_db);
-}
-
-void GlassView::add_spectrum_pixel(Color color)
-{
-    spectrum_row[pixel_index++] = color;
-    if (pixel_index == 240) //got an entire waterfall line
-    { 
-        const auto draw_y = display.scroll(1); //Scroll 1 pixel down
-        display.draw_pixels( {{0, draw_y}, {240, 1}}, spectrum_row); //new line at top
-        pixel_index = 0; //Start New cascade line
-    }
-}
-
-//Apparently, the spectrum object returns an array of 256 bins
-//Each having the radio signal power for it's corresponding frequency slot
-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
-    // Spectrum.db has 256 bins. Center 12 bins are ignored (DC spike is blanked) Leftmost and rightmost 2 bins are ignored
-    // All things said and done, we actually need 240 of those bins:
-    for(uint8_t bin = 0; bin < 240; bin++) 
+    void GlassView::focus()
     {
-        if (bin < 120) {
-            if (spectrum.db[134 + bin] > max_power)
-                max_power = spectrum.db[134 + bin];
-        }         
-        else
+        button_marker.focus();
+    }
+
+    GlassView::~GlassView()
+    {
+        receiver_model.set_sampling_rate(3072000); // Just a hack to avoid hanging other apps
+        receiver_model.disable();
+        baseband::shutdown();
+    }
+
+    // Returns the next multiple of num that is a multiple of multiplier
+    int64_t GlassView::next_mult_of(int64_t num, int64_t multiplier) {
+        return ((num / multiplier) + 1) * multiplier;
+    }
+
+    void GlassView::adjust_range(int64_t* f_min, int64_t* f_max, int64_t width) {
+        int64_t span = *f_max - *f_min;
+        int64_t num_intervals = span / width;
+        if( span % width != 0 )
         {
-            if (spectrum.db[bin - 118] > max_power)
-                    max_power = spectrum.db[bin - 118];  
+            num_intervals++;
         }
+        int64_t new_span = num_intervals * width;
+        int64_t delta_span = (new_span - span) / 2;
+        *f_min -= delta_span;
+        *f_max += delta_span;
+    }
 
-        bins_Hz_size += each_bin_size;   //add this bin Hz count into the "pixel fulfilled bag of Hz"
+    void GlassView::on_lna_changed(int32_t v_db)
+    {
+        receiver_model.set_lna(v_db);
+    }
 
-        if (bins_Hz_size >= marker_pixel_step) //new pixel fullfilled
+    void GlassView::on_vga_changed(int32_t v_db)
+    {
+        receiver_model.set_vga(v_db);
+    }
+
+    void GlassView::reset_live_view( bool clear_screen )
+    {
+        max_freq_hold = 0 ;
+        max_freq_power = -1000 ;
+        if( clear_screen )
         {
-            if (min_color_power < max_power)
-                add_spectrum_pixel(spectrum_rgb3_lut[max_power]); //Pixel will represent max_power
-            else
-                add_spectrum_pixel(0);  //Filtered out, show black
-
-            max_power = 0;
-
-            if (!pixel_index) //Received indication that a waterfall line has been completed
+            // only clear screen in peak mode
+            if( live_frequency_view == 2 )
             {
-                bins_Hz_size = 0;  //Since this is an entire pixel line, we don't carry "Pixels into next bin"
-                break;
-            } else {
-                bins_Hz_size -= marker_pixel_step; //reset bins size, but carrying the eventual excess Hz into next pixel
+                display.fill_rectangle( { { 0 , 108 + 16 } , { 240 , 320 - (108 + 16) } } , { 0 , 0 , 0 } );
             }
         }
     }
 
-    if (pixel_index) 
-        f_center += LOOKING_GLASS_SLICE_WIDTH; //Move into the next bandwidth slice NOTE: spectrum.sampling_rate = LOOKING_GLASS_SLICE_WIDTH
-    else
-        f_center = f_center_ini; //Start a new sweep
+    void GlassView::add_spectrum_pixel( uint8_t power )
+    {
+        static int64_t last_max_freq = 0 ;
 
-    receiver_model.set_tuning_frequency(f_center); //tune rx for this slice
-    baseband::spectrum_streaming_start();          //Do the RX
-}
+        spectrum_row[pixel_index] = spectrum_rgb3_lut[power] ; // row of colors
+        spectrum_data[pixel_index] = ( live_frequency_integrate * spectrum_data[pixel_index] + power ) / (live_frequency_integrate + 1); // smoothing 
+        pixel_index ++ ;
 
-void GlassView::on_hide()
-{
-    baseband::spectrum_streaming_stop();
-    display.scroll_disable();
-}
+        if (pixel_index == 240) // got an entire waterfall line
+        {
+            if( live_frequency_view > 0 )
+            {
+                constexpr int rssi_sample_range = 256;
+                constexpr float rssi_voltage_min = 0.4;
+                constexpr float rssi_voltage_max = 2.2;
+                constexpr float adc_voltage_max = 3.3;
+                constexpr int raw_min = rssi_sample_range * rssi_voltage_min / adc_voltage_max;
+                constexpr int raw_max = rssi_sample_range * rssi_voltage_max / adc_voltage_max;
+                constexpr int raw_delta = raw_max - raw_min;
+                const range_t<int> y_max_range { 0 , 320 - ( 108 + 16 ) };
 
-void GlassView::on_show()
-{
-    display.scroll_set_area( 109, 319); //Restart scroll on the correct coordinates
-    baseband::spectrum_streaming_start();
-}
+                //drawing and keeping track of max freq
+                for( uint16_t xpos = 0 ; xpos < 240 ; xpos ++ )
+                {
+                    // save max powerwull freq 
+                    if( spectrum_data[ xpos ] > max_freq_power )
+                    {
+                        max_freq_power = spectrum_data[ xpos ];
+                        max_freq_hold = f_min + ( (f_max - f_min) * xpos) / 240 ;
+                    }
 
-void GlassView::on_range_changed()
-{
-    f_min = field_frequency_min.value();
-    f_max = field_frequency_max.value();
-    search_span = f_max - f_min;
-
-    field_marker.set_range(f_min, f_max);              //Move the marker between range
-    field_marker.set_value(f_min + (search_span / 2)); //Put MARKER AT MIDDLE RANGE
-    text_range.set(to_string_dec_uint(search_span));
-
-    f_min = (f_min)*MHZ_DIV; //Transpose into full frequency realm
-    f_max = (f_max)*MHZ_DIV;
-    search_span = search_span * MHZ_DIV;
-
-    marker_pixel_step = search_span / 240;                                        //Each pixel value in Hz
-    text_marker_pm.set(to_string_dec_uint((marker_pixel_step / X2_MHZ_DIV) + 1)); // Give idea of +/- marker precision
-
-    int32_t marker_step = marker_pixel_step / MHZ_DIV;
-    if (!marker_step) 
-        field_marker.set_step(1); //in case selected range is less than 240 (pixels)
-    else
-        field_marker.set_step(marker_step); //step needs to be a pixel wide.
-
-    f_center_ini = f_min + (LOOKING_GLASS_SLICE_WIDTH / 2);    //Initial center frequency for sweep
-    f_center_ini += LOOKING_GLASS_SLICE_WIDTH;                 //euquiq: Why do I need to move the center ???!!! (shift needed for marker accuracy)
-
-    PlotMarker(field_marker.value()); //Refresh marker on screen
-
-    f_center = f_center_ini;                        //Reset sweep into first slice
-    pixel_index = 0;                                //reset pixel counter
-    max_power = 0;
-    bins_Hz_size = 0;                               //reset amount of Hz filled up by pixels
-    
-    baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, field_trigger.value());   
-    receiver_model.set_tuning_frequency(f_center_ini); //tune rx for this slice
-}
-
-void GlassView::PlotMarker(rf::Frequency fpos)
-{
-    int64_t pos = fpos * MHZ_DIV;
-    pos -= f_min;
-    pos = pos / marker_pixel_step; //Real pixel 
-
-    portapack::display.fill_rectangle({0, 100, 240, 8}, Color::black()); //Clear old marker and whole marker rectangle btw
-    portapack::display.fill_rectangle({(int16_t)pos - 2, 100, 5, 3}, Color::red()); //Red marker middle
-    portapack::display.fill_rectangle({(int16_t)pos - 1, 103, 3, 3}, Color::red()); //Red marker middle
-    portapack::display.fill_rectangle({(int16_t)pos, 106, 1, 2}, Color::red()); //Red marker middle
-}
-
-GlassView::GlassView(
-    NavigationView &nav) : nav_(nav)
-{
-    baseband::run_image(portapack::spi_flash::image_tag_wideband_spectrum);
-
-    add_children({&labels,
-                  &field_frequency_min,
-                  &field_frequency_max,
-                  &field_lna,
-                  &field_vga,
-                  &text_range,
-                  &filter_config,
-                  &field_rf_amp,
-                  &range_presets,
-                  &field_marker,
-                  &text_marker_pm,
-                  &field_trigger
-                });
-
-    load_Presets(); //Load available presets from TXT files (or default)
-    
-    field_frequency_min.set_value(presets_db[0].min);   //Defaults to first preset
-    field_frequency_min.on_change = [this](int32_t v) {
-        if (v >= field_frequency_max.value())
-            field_frequency_max.set_value(v + 240);
-        this->on_range_changed();
-    };
-
-    field_frequency_max.set_value(presets_db[0].max);   //Defaults to first preset
-    field_frequency_max.on_change = [this](int32_t v) {
-        if (v <= field_frequency_min.value())
-            field_frequency_min.set_value(v - 240);
-        this->on_range_changed();
-    };
-
-    field_lna.set_value(receiver_model.lna());
-    field_lna.on_change = [this](int32_t v) {
-        this->on_lna_changed(v);
-    };
-
-    field_vga.set_value(receiver_model.vga());
-    field_vga.on_change = [this](int32_t v_db) {
-        this->on_vga_changed(v_db);
-    };
-
-    filter_config.set_selected_index(0);
-	filter_config.on_change = [this](size_t n, OptionsField::value_t v) {
-		(void)n;
-		min_color_power = v;
-	};
-
-	range_presets.on_change = [this](size_t n, OptionsField::value_t v) {
-		(void)n;
-		field_frequency_min.set_value(presets_db[v].min,false);
-        field_frequency_max.set_value(presets_db[v].max,false);
-        this->on_range_changed();
-	};
-
-    field_marker.on_change = [this](int32_t v) {
-        PlotMarker(v); //Refresh marker on screen
-    };
-
-    field_marker.on_select = [this](NumberField&) {
-        f_center = field_marker.value();
-        f_center = f_center * MHZ_DIV;
-        receiver_model.set_tuning_frequency(f_center); //Center tune rx in marker freq.
-        receiver_model.set_frequency_step(MHZ_DIV); // Preset a 1 MHz frequency step into RX -> AUDIO
-        nav_.pop();
-		nav_.push<AnalogAudioView>(); //Jump into audio view
-    };
-
-    field_trigger.set_value(32);   //Defaults to 32, as normal triggering resolution
-    field_trigger.on_change = [this](int32_t v) {
-        baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, v);
-    };
-
-    display.scroll_set_area( 109, 319);
-    baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, field_trigger.value());	//trigger:
-    // Discord User jteich:  WidebandSpectrum::on_message to set the trigger value. In WidebandSpectrum::execute ,
-    // it keeps adding the output of the fft to the buffer until "trigger" number of calls are made, 
-    //at which time it pushes the buffer up with channel_spectrum.feed
-
-    on_range_changed();
-
-    receiver_model.set_modulation(ReceiverModel::Mode::SpectrumAnalysis);
-	receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH); //20mhz
-    receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH); // possible values: 1.75/2.5/3.5/5/5.5/6/7/8/9/10/12/14/15/20/24/28MHz
-    receiver_model.set_squelch_level(0);
-	receiver_model.enable();
-}
-
-void GlassView::load_Presets() {
-	File presets_file; 		//LOAD /WHIPCALC/ANTENNAS.TXT from microSD
-	auto result = presets_file.open("LOOKINGGLASS/PRESETS.TXT");
-	presets_db.clear();			//Start with fresh db
-	if (result.is_valid()) {
-		presets_Default(); 		//There is no txt, store a default range
-	} else {
-
-		std::string line;		//There is a txt file
-		char one_char[1];		//Read it char by char
-		for (size_t pointer=0; pointer < presets_file.size();pointer++) {
-			presets_file.seek(pointer);
-			presets_file.read(one_char, 1);
-			if ((int)one_char[0] > 31) {			//ascii space upwards
-				line += one_char[0];				//Add it to the textline
-			}
-			else if (one_char[0] == '\n') {			//New Line
-				txtline_process(line);				//make sense of this textline
-				line.clear();						//Ready for next textline
-			} 
-		}
-		if (line.length() > 0) txtline_process(line);	//Last line had no newline at end ?
-		if (!presets_db.size()) presets_Default();		//no antenna on txt, use default
+                    int16_t point = y_max_range.clip( ( ( spectrum_data[ xpos ] - raw_min ) * ( 320 - ( 108 + 16 ) ) ) / raw_delta );
+                    uint8_t color_gradient = (point * 255) / 212 ;
+                    // clear if not in peak view
+                    if( live_frequency_view != 2 )
+                    {
+                        display.fill_rectangle( { { xpos , 108 + 16 } , { 1 , 320 - point } } , { 0 , 0 , 0 } );
+                    }
+                    display.fill_rectangle( { { xpos , 320 - point } , { 1 , point } } , { color_gradient , 0 , uint8_t( 255 - color_gradient ) } );
+                } 
+                if( last_max_freq != max_freq_hold )
+                {
+                    last_max_freq = max_freq_hold ;
+                    freq_stats.set( "MAX HOLD: "+to_string_short_freq( max_freq_hold ) );
+                }
+                PlotMarker( marker );
+            }
+            else
+            {
+                display.draw_pixels({{0, display.scroll(1)}, {240, 1}}, spectrum_row); // new line at top, one less var, speedier
+            }
+            pixel_index = 0;                                                       // Start New cascade line
+        }
     }
 
-    populate_Presets();
-}
+    // Apparently, the spectrum object returns an array of 256 bins
+    // Each having the radio signal power for it's corresponding frequency slot
+    void GlassView::on_channel_spectrum(const ChannelSpectrum &spectrum)
+    {
+        // default fast scan offset 
+        uint8_t offset = 2 ;
+        baseband::spectrum_streaming_stop();
+        if( fast_scan || ( LOOKING_GLASS_SLICE_WIDTH < LOOKING_GLASS_SLICE_WIDTH_MAX ) )
+        {
+            // Convert bins of this spectrum slice into a representative max_power and when enough, into pixels
+            // Spectrum.db has 256 bins.
+            // All things said and done, we actually need 240 of those bins
+            for (uint8_t bin = 0; bin < 240; bin++)
+            {
+                // if the view is done in one pass, show it like in analog_audio_app
+                if( ( LOOKING_GLASS_SLICE_WIDTH < LOOKING_GLASS_SLICE_WIDTH_MAX ) )
+                {
+                    // Center 16 bins are ignored (DC spike is blanked)
+                    if (bin < 120)
+                    {
+                        if (spectrum.db[256 - 120 + bin] > max_power) // 134
+                            max_power = spectrum.db[256 - 120 + bin];
+                    }
+                    else
+                    {
+                        if (spectrum.db[ bin - 120] > max_power) // 118
+                            max_power = spectrum.db[bin - 120];
+                    }
+                }
+                else // view is made in multiple pass, use original bin picking
+                {
+                    // Center 12 bins are ignored (DC spike is blanked) Leftmost and rightmost 2 bins are ignored
+                    if (bin < 120)
+                    {
+                        if (spectrum.db[134 + bin] > max_power) // 134
+                            max_power = spectrum.db[134 + bin];
+                    }
+                    else
+                    {
+                        if (spectrum.db[bin - 118] > max_power) // 118
+                            max_power = spectrum.db[bin - 118];
+                    }
+                }
+                
+                if( bin == 120 )
+                {
+                    bins_Hz_size += 12 * each_bin_size; // add DC bin Hz count into the "pixel fulfilled bag of Hz"
+                }
+                else
+                {
+                    bins_Hz_size += each_bin_size; // add this bin Hz count into the "pixel fulfilled bag of Hz"
+                }
 
-void GlassView::txtline_process(std::string& line) 
-{
-	if (line.find("#") != std::string::npos) return;	//Line is just a comment
+                if (bins_Hz_size >= marker_pixel_step) // new pixel fullfilled
+                {
+                    if (min_color_power < max_power)
+                        add_spectrum_pixel(max_power); // Pixel will represent max_power
+                    else
+                        add_spectrum_pixel(0); // Filtered out, show black
 
-	size_t comma = line.find(",");          //Get first comma position
-    if (comma == std::string::npos) return; //No comma at all
+                    max_power = 0;
 
-	size_t previous = 0;
-	preset_entry new_preset;
-
-    new_preset.min = std::stoi(line.substr(0,comma));
-    if (!new_preset.min) return;    //No frequency!
-    
-    previous = comma + 1;
-    comma = line.find(",",previous);		//Search for next delimiter
-    if (comma == std::string::npos) return; //No comma at all
-
-    new_preset.max = std::stoi(line.substr(previous,comma - previous));
-    if (!new_preset.max) return;    //No frequency!
-
-    new_preset.label = line.substr(comma + 1);
-    if (new_preset.label.size() == 0) return; //No label ?
-    
-    presets_db.push_back(new_preset);   //Add this preset.
-}
-
-void GlassView::populate_Presets() 
-{
-    using option_t = std::pair<std::string, int32_t>;
-	using options_t = std::vector<option_t>;
-    options_t entries;
-
-	for (preset_entry preset : presets_db) 
-        {	//go thru all available presets
-            entries.emplace_back(preset.label,entries.size());
+                    if (!pixel_index) // Received indication that a waterfall line has been completed
+                    {
+                        bins_Hz_size = 0;                               // Since this is an entire pixel line, we don't carry "Pixels into next bin"
+                        f_center = f_center_ini - offset * each_bin_size ;   // Start a new sweep
+                        radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
+                        chThdSleepMilliseconds(10);
+                        baseband::spectrum_streaming_start(); // Do the RX
+                        return;
+                    }
+                    bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel
+                }
+            }
+            f_center += ( 256 - ( 2 * offset ) ) * each_bin_size ; // Move into the next bandwidth slice NOTE: spectrum.sampling_rate = LOOKING_GLASS_SLICE_WIDTH
+                                                                   // lost bins are taken in account so next slice first ignored bins overlap previous kept ones
         }
-    range_presets.set_options(entries);
-}
+        else //slow scan
+        { 
+            offset = 32 ;
+            uint8_t bin_length = 80 ;
+            for (uint8_t bin = offset ; bin < bin_length + offset ; bin++)
+            {
+                if (bin < 120)
+                {
+                    if (spectrum.db[134 + bin] > max_power) // 134
+                        max_power = spectrum.db[134 + bin];
+                }
+                else
+                {
+                    if (spectrum.db[bin - 118] > max_power) // 118
+                        max_power = spectrum.db[bin - 118];
+                }
 
-void GlassView::presets_Default() 
-{
+                bins_Hz_size += each_bin_size; // add this bin Hz count into the "pixel fulfilled bag of Hz"
+
+                if (bins_Hz_size >= marker_pixel_step) // new pixel fullfilled
+                {
+                    if (min_color_power < max_power)
+                        add_spectrum_pixel(max_power); // Pixel will represent max_power
+                    else
+                        add_spectrum_pixel(0); // Filtered out, show black
+
+                    max_power = 0;
+
+                    if (!pixel_index) // Received indication that a waterfall line has been completed
+                    {
+                        bins_Hz_size = 0;                              // Since this is an entire pixel line, we don't carry "Pixels into next bin"
+                        f_center = f_center_ini - offset * each_bin_size ;  // Start a new sweep
+                        radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
+                        chThdSleepMilliseconds(10);
+                        baseband::spectrum_streaming_start(); // Do the RX
+                        return;
+                    }
+                    bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel
+                }
+            }
+            f_center +=  bin_length * each_bin_size ;
+        }
+        radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
+        chThdSleepMilliseconds(5);
+        baseband::spectrum_streaming_start(); // Do the RX
+    }
+
+    void GlassView::on_hide()
+    {
+        baseband::spectrum_streaming_stop();
+        display.scroll_disable();
+    }
+
+    void GlassView::on_show()
+    {
+        display.scroll_set_area(109, 319); // Restart scroll on the correct coordinates
+        baseband::spectrum_streaming_start();
+    }
+
+    void GlassView::on_range_changed()
+    {
+        reset_live_view( false );
+        f_min = field_frequency_min.value();
+        f_max = field_frequency_max.value();
+        search_span = f_max - f_min;
+                                                           
+        if( locked_range )
+        {
+            button_range.set_text(">"+to_string_dec_uint(search_span)+"<");
+        }
+        else
+        {
+            button_range.set_text(" "+to_string_dec_uint(search_span)+" ");
+        }
+
+        f_min = (f_min)*MHZ_DIV; // Transpose into full frequency realm
+        f_max = (f_max)*MHZ_DIV;
+        adjust_range( &f_min , &f_max , 240 );
+
+        marker_pixel_step = (f_max - f_min) / 240;                                        // Each pixel value in Hz
+        marker = f_min + (f_max - f_min) / 2 ;
+        button_marker.set_text( to_string_short_freq( marker ) );
+        PlotMarker( marker ); // Refresh marker on screen
+
+        pixel_index = 0;         // reset pixel counter
+        max_power = 0;
+        bins_Hz_size = 0; // reset amount of Hz filled up by pixels
+        if( (f_max - f_min) <= LOOKING_GLASS_SLICE_WIDTH_MAX )
+        {
+            LOOKING_GLASS_SLICE_WIDTH = (f_max - f_min) ;
+            receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH);      
+            receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH/2); 
+        }
+        else if( LOOKING_GLASS_SLICE_WIDTH != LOOKING_GLASS_SLICE_WIDTH_MAX )
+        {
+            LOOKING_GLASS_SLICE_WIDTH = LOOKING_GLASS_SLICE_WIDTH_MAX ;
+            receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH);      
+            receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH); 
+        }
+        if( next_mult_of( LOOKING_GLASS_SLICE_WIDTH , 256 ) > LOOKING_GLASS_SLICE_WIDTH_MAX )
+            LOOKING_GLASS_SLICE_WIDTH = LOOKING_GLASS_SLICE_WIDTH_MAX ;
+        else
+            LOOKING_GLASS_SLICE_WIDTH = next_mult_of( LOOKING_GLASS_SLICE_WIDTH , 256 );
+
+        receiver_model.set_squelch_level(0);
+        each_bin_size = LOOKING_GLASS_SLICE_WIDTH / 256 ; 
+        f_center_ini = f_min + (LOOKING_GLASS_SLICE_WIDTH / 2) ; // Initial center frequency for sweep
+        f_center = f_center_ini ; // Reset sweep into first slice
+        baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, field_trigger.value());
+        receiver_model.set_tuning_frequency(f_center_ini); // tune rx for this slice
+    }
+
+    void GlassView::PlotMarker(rf::Frequency pos)
+    {
+        pos -= f_min;
+        pos = pos / marker_pixel_step; // Real pixel
+        
+        uint8_t shift_y = 0 ;
+        if( live_frequency_view > 0 ) // plot one line down when in live view
+        {
+            shift_y = 16 ;
+        }
+        portapack::display.fill_rectangle({0, 100 + shift_y, 240, 8}, Color::black());        // Clear old marker and whole marker rectangle btw
+        portapack::display.fill_rectangle({(int)pos - 2, 100 + shift_y, 5, 3}, Color::red()); // Red marker top
+        portapack::display.fill_rectangle({(int)pos - 1, 103 + shift_y, 3, 3}, Color::red()); // Red marker middle
+        portapack::display.fill_rectangle({(int)pos, 106 + shift_y, 1, 2}, Color::red());     // Red marker bottom
+    }
+
+    GlassView::GlassView(
+        NavigationView &nav) : nav_(nav)
+    {
+        baseband::run_image(portapack::spi_flash::image_tag_wideband_spectrum);
+
+        add_children({&labels,
+                      &field_frequency_min,
+                      &field_frequency_max,
+                      &field_lna,
+                      &field_vga,
+                      &button_range,
+                      &steps_config,
+                      &scan_type,
+                      &view_config,
+                      &level_integration,
+                      &filter_config,
+                      &field_rf_amp,
+                      &range_presets,
+                      &button_marker,
+                      &field_trigger,
+                      &button_jump,
+                      &button_rst,
+                      &freq_stats});
+
+        load_Presets(); // Load available presets from TXT files (or default)
+
+        field_frequency_min.on_change = [this](int32_t v)
+        {
+            reset_live_view( true );
+            int32_t min_size = steps ;
+            if( locked_range )
+                min_size = search_span ;
+            if( min_size < 2 )
+                min_size = 2 ;
+            if( v > 7200 - min_size )
+            {
+                v = 7200 - min_size ;
+                field_frequency_min.set_value( v ); 
+            }
+            if (v > (field_frequency_max.value() - min_size ) )
+                field_frequency_max.set_value( v + min_size );
+            if( locked_range )
+                field_frequency_max.set_value( v + min_size );
+            this->on_range_changed();
+        };
+        field_frequency_min.set_value(presets_db[0].min); // Defaults to first preset
+        field_frequency_min.set_step( steps );
+
+        field_frequency_min.on_select = [this, &nav](NumberField& field) {
+            auto new_view = nav_.push<FrequencyKeypadView>(field_frequency_min.value()*1000000);
+            new_view->on_changed = [this, &field](rf::Frequency f) {
+                int32_t freq = f / 1000000 ;
+                int32_t min_size = steps ;
+                if( locked_range )
+                    min_size = search_span ;
+                if( min_size < 2 )
+                    min_size = 2 ;
+                if( freq > (7200 - min_size ) )
+                    freq = 7200 - min_size  ;
+                field_frequency_min.set_value( freq );
+                if( field_frequency_max.value() < ( freq + min_size ) )
+                    field_frequency_max.set_value( freq + min_size );
+                this->on_range_changed();
+            };
+        };
+
+        field_frequency_max.on_change = [this](int32_t v)
+        {          
+            reset_live_view( true );
+            int32_t min_size = steps ;
+            if( locked_range )
+                min_size = search_span ;
+            if( min_size < 2 )
+                min_size = 2 ;
+            if( v < min_size )
+            {
+                v = min_size ;
+                field_frequency_max.set_value( v ); 
+            }
+            if (v < (field_frequency_min.value() + min_size) )
+                field_frequency_min.set_value(v - min_size);
+            if( locked_range )
+                field_frequency_min.set_value( v - min_size );
+            this->on_range_changed();
+        };
+        field_frequency_max.set_value(presets_db[0].max); // Defaults to first preset
+        field_frequency_max.set_step( steps );
+
+        field_frequency_max.on_select = [this, &nav](NumberField& field) {
+            auto new_view = nav_.push<FrequencyKeypadView>(field_frequency_max.value()*1000000);
+            new_view->on_changed = [this, &field](rf::Frequency f) {
+                int32_t min_size = steps ;
+                if( locked_range )
+                    min_size = search_span ;
+                if( min_size < 2 )
+                    min_size = 2 ;
+                int32_t freq = f / 1000000 ;
+                if( freq < min_size )
+                    freq = min_size ;
+                field_frequency_max.set_value( freq );
+                if( field_frequency_min.value() > ( freq - min_size) ) 
+                    field_frequency_min.set_value( freq - min_size );
+                this->on_range_changed();
+            };
+        };
+
+        field_lna.on_change = [this](int32_t v)
+        {
+            reset_live_view( true );
+            this->on_lna_changed(v);
+        };
+        field_lna.set_value(receiver_model.lna());
+
+        field_vga.on_change = [this](int32_t v_db)
+        {
+            reset_live_view( true );
+            this->on_vga_changed(v_db);
+        };
+        field_vga.set_value(receiver_model.vga());
+
+        steps_config.on_change = [this](size_t n, OptionsField::value_t v)
+        {
+            (void)n;
+            field_frequency_min.set_step( v );
+            field_frequency_max.set_step( v );
+            steps = v ;
+        };
+        steps_config.set_selected_index(0); //default of 1 Mhz steps
+                                            
+        scan_type.on_change = [this](size_t n, OptionsField::value_t v)
+        {
+            (void)n;
+            fast_scan = v ;
+        };
+        scan_type.set_selected_index(0); // default legacy fast scan
+
+        view_config.on_change = [this](size_t n, OptionsField::value_t v)
+        {
+            (void)n;
+            // clear between changes
+            reset_live_view( true );
+            if( v == 0 )
+            {
+                live_frequency_view = 0 ;
+                level_integration.hidden( true );
+                freq_stats.hidden( true );
+                button_jump.hidden( true );
+                button_rst.hidden( true );
+                display.scroll_set_area(109, 319); // Restart scroll on the correct coordinates
+            }
+            else if( v == 1 )
+            {
+                display.fill_rectangle( { { 0 , 108 } , { 240 , 24 } } , { 0 , 0 , 0 } );
+                live_frequency_view = 1 ;
+                display.scroll_disable();
+                level_integration.hidden( false );
+                freq_stats.hidden( false );
+                button_jump.hidden( false );
+                button_rst.hidden( false );
+            }
+            else if( v == 2 )
+            {
+                display.fill_rectangle( { { 0 , 108 } , { 240 , 24 } } , { 0 , 0 , 0 } );
+                live_frequency_view = 2 ;
+                display.scroll_disable();
+                level_integration.hidden( false );
+                freq_stats.hidden( false );
+                button_jump.hidden( false );
+                button_rst.hidden( false );
+            }
+            set_dirty();
+        };
+        view_config.set_selected_index(0); //default spectrum
+
+        level_integration.on_change = [this](size_t n, OptionsField::value_t v)
+        {
+            (void)n;
+            reset_live_view( true );
+            live_frequency_integrate = v ;
+        };
+        level_integration.set_selected_index(3); //default integration of ( 3 * old value + new_value ) / 4
+
+        filter_config.on_change = [this](size_t n, OptionsField::value_t v) {
+            (void)n;
+            reset_live_view( true );
+            min_color_power = v;
+        };
+        filter_config.set_selected_index(0);
+
+        range_presets.on_change = [this](size_t n, OptionsField::value_t v)
+        {
+            (void)n;
+            field_frequency_min.set_value(presets_db[v].min, false);
+            field_frequency_max.set_value(presets_db[v].max, false);
+            this->on_range_changed();
+        };
+
+        button_marker.on_change = [this]()
+        {
+            marker = marker + button_marker.get_encoder_delta() * marker_pixel_step ;
+            if( marker < f_min )
+                marker = f_min ;
+            if( marker > f_max )
+                marker = f_max ;
+            button_marker.set_text( to_string_short_freq( marker ) );
+			button_marker.set_encoder_delta( 0 );
+            PlotMarker( marker ); // Refresh marker on screen
+        };
+
+        button_marker.on_select = [this](ButtonWithEncoder &)
+        {
+            receiver_model.set_tuning_frequency(marker); // Center tune rx in marker freq.
+            receiver_model.set_frequency_step(MHZ_DIV);    // Preset a 1 MHz frequency step into RX -> AUDIO
+            nav_.pop();
+            nav_.push<AnalogAudioView>(); // Jump into audio view
+        };
+
+        field_trigger.on_change = [this](int32_t v)
+        {
+            baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, v);
+        };
+        field_trigger.set_value(32); // Defaults to 32, as normal triggering resolution
+                                     
+        button_range.on_select = [this](Button&) {
+            if( locked_range )
+            {
+                locked_range = false ;
+                button_range.set_style(&style_white);
+                button_range.set_text(" "+to_string_dec_uint(search_span)+" ");
+            }
+            else
+            {
+                locked_range = true ;
+                button_range.set_style(&style_red);
+                button_range.set_text(">"+to_string_dec_uint(search_span)+"<");
+            }
+        };
+
+        button_jump.on_select = [this](Button&) {
+            receiver_model.set_tuning_frequency(max_freq_hold); // Center tune rx in marker freq.
+            receiver_model.set_frequency_step(MHZ_DIV);    // Preset a 1 MHz frequency step into RX -> AUDIO
+            nav_.pop();
+            nav_.push<AnalogAudioView>(); // Jump into audio view
+        };
+
+        button_rst.on_select = [this](Button&) {
+            reset_live_view( true );
+        };
+
+        display.scroll_set_area(109, 319);
+        baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, field_trigger.value()); // trigger:
+        // Discord User jteich:  WidebandSpectrum::on_message to set the trigger value. In WidebandSpectrum::execute ,
+        // it keeps adding the output of the fft to the buffer until "trigger" number of calls are made,
+        // at which time it pushes the buffer up with channel_spectrum.feed
+
+        on_range_changed();
+
+        receiver_model.set_modulation(ReceiverModel::Mode::SpectrumAnalysis);
+        receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH);      // 20mhz
+        receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH); // possible values: 1.75/2.5/3.5/5/5.5/6/7/8/9/10/12/14/15/20/24/28MHz
+        receiver_model.set_squelch_level(0);
+        receiver_model.enable();
+    }
+
+    void GlassView::load_Presets()
+    {
+        File presets_file; // LOAD /WHIPCALC/ANTENNAS.TXT from microSD
+        auto result = presets_file.open("LOOKINGGLASS/PRESETS.TXT");
+        presets_db.clear(); // Start with fresh db
+        if (result.is_valid())
+        {
+            presets_Default(); // There is no txt, store a default range
+        }
+        else
+        {
+            std::string line; // There is a txt file
+            char one_char[1]; // Read it char by char
+            for (size_t pointer = 0; pointer < presets_file.size(); pointer++)
+            {
+                presets_file.seek(pointer);
+                presets_file.read(one_char, 1);
+                if ((int)one_char[0] > 31)
+                {                        // ascii space upwards
+                    line += one_char[0]; // Add it to the textline
+                }
+                else if (one_char[0] == '\n')
+                {                          // New Line
+                    txtline_process(line); // make sense of this textline
+                    line.clear();          // Ready for next textline
+                }
+            }
+            if (line.length() > 0)
+                txtline_process(line); // Last line had no newline at end ?
+            if (!presets_db.size())
+                presets_Default(); // no antenna on txt, use default
+        }
+        populate_Presets();
+    }
+
+    void GlassView::txtline_process(std::string &line)
+    {
+        if (line.find("#") != std::string::npos)
+            return; // Line is just a comment
+
+        size_t comma = line.find(","); // Get first comma position
+        if (comma == std::string::npos)
+            return; // No comma at all
+
+        size_t previous = 0;
+        preset_entry new_preset;
+
+        new_preset.min = std::stoi(line.substr(0, comma));
+        if (!new_preset.min)
+            return; // No frequency!
+
+        previous = comma + 1;
+        comma = line.find(",", previous); // Search for next delimiter
+        if (comma == std::string::npos)
+            return; // No comma at all
+
+        new_preset.max = std::stoi(line.substr(previous, comma - previous));
+        if (!new_preset.max)
+            return; // No frequency!
+
+        new_preset.label = line.substr(comma + 1);
+        if (new_preset.label.size() == 0)
+            return; // No label ?
+
+        presets_db.push_back(new_preset); // Add this preset.
+    }
+
+    void GlassView::populate_Presets()
+    {
+        using option_t = std::pair<std::string, int32_t>;
+        using options_t = std::vector<option_t>;
+        options_t entries;
+
+        for (preset_entry preset : presets_db)
+        { // go thru all available presets
+            entries.emplace_back(preset.label, entries.size());
+        }
+        range_presets.set_options(entries);
+    }
+
+    void GlassView::presets_Default()
+    {
         presets_db.clear();
         presets_db.push_back({2320, 2560, "DEFAULT WIFI 2.4GHz"});
-}
+    }
 
 }

firmware/application/apps/ui_looking_glass_app.hpp

@@ -1,187 +1,278 @@
 /*
-  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
-  * Copyright (C) 2020 euquiq
-  *
-  * 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.
-  */
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2020 euquiq
+ * Copyright (C) 2023 gullradriel, Nilorea Studio Inc.
+ *
+ * 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 "portapack.hpp"
- #include "baseband_api.hpp"
- #include "receiver_model.hpp"
- #include "ui_widget.hpp"
- #include "ui_navigation.hpp"
- #include "ui_receiver.hpp"
- #include "string_format.hpp"
- #include "analog_audio_app.hpp"
- #include "spectrum_color_lut.hpp"
+#ifndef _UI_GLASS
+#define _UI_GLASS
 
- namespace ui
- {
-     #define LOOKING_GLASS_SLICE_WIDTH	20000000 // Each slice bandwidth 20 MHz
-     #define MHZ_DIV	            1000000
-     #define X2_MHZ_DIV	        2000000
+#include "ui.hpp"
+#include "portapack.hpp"
+#include "baseband_api.hpp"
+#include "receiver_model.hpp"
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "string_format.hpp"
+#include "analog_audio_app.hpp"
+#include "spectrum_color_lut.hpp"
 
-     class GlassView : public View
-     {
-     public:
-         GlassView(NavigationView &nav);
+namespace ui
+{
+#define LOOKING_GLASS_SLICE_WIDTH_MAX 20000000
+#define MHZ_DIV	            1000000
+#define X2_MHZ_DIV	        2000000
 
-	 GlassView( const GlassView &);
-	 GlassView& operator=(const GlassView &nav);
+    class GlassView : public View
+    {
+        public:
+			
+            GlassView(NavigationView &nav);
 
-         ~GlassView();
-         std::string title() const override { return "Looking Glass"; };
+            GlassView( const GlassView &);
+            GlassView& operator=(const GlassView &nav);
 
- 	    void on_show() override;
- 	    void on_hide() override;
-         void focus() override;
+            ~GlassView();
+            std::string title() const override { return "LookingGlass"; };
 
-     private:
-     	NavigationView& nav_;
+            void on_show() override;
+            void on_hide() override;
+            void focus() override;
 
-        struct preset_entry
-        {
-            rf::Frequency min{};
-            rf::Frequency max{};
-            std::string label{};
-        };
+        private:
+            NavigationView& nav_;
 
-        std::vector<preset_entry> presets_db{};
-
-         void on_channel_spectrum(const ChannelSpectrum& spectrum);
-         void do_timers();
-         void on_range_changed();
-         void on_lna_changed(int32_t v_db);
- 	    void on_vga_changed(int32_t v_db);
-         void add_spectrum_pixel(Color color);
-        void PlotMarker(rf::Frequency pos);
-        void load_Presets();
-        void txtline_process(std::string& line);
-        void populate_Presets();
-        void presets_Default();
-
-         rf::Frequency f_min { 0 }, f_max { 0 };
-         rf::Frequency search_span { 0 };
-         rf::Frequency f_center { 0 };
-         rf::Frequency f_center_ini { 0 };
-         rf::Frequency marker_pixel_step { 0 };
-         rf::Frequency each_bin_size { LOOKING_GLASS_SLICE_WIDTH  / 240 };
-         rf::Frequency bins_Hz_size { 0 };
-         uint8_t min_color_power { 0 };
-         uint32_t pixel_index { 0 };
-         std::array<Color, 240> spectrum_row = { 0 };
-         ChannelSpectrumFIFO* fifo { nullptr }; 
-         uint8_t max_power = 0;
-
-        Labels labels{
-            {{0, 0}, "MIN:     MAX:     LNA   VGA  ", Color::light_grey()},
-            {{0, 1 * 16}, " RANGE:     FILTER:      AMP:", Color::light_grey()},
-            {{0, 2 * 16}, "PRESET:", Color::light_grey()},
-            {{0, 3 * 16}, "MARKER:     MHz +/-    MHz", Color::light_grey()},
-             {{0, 4 * 16}, "RESOLUTION:    (fft trigger)", Color::light_grey()}
-        };
-
-         NumberField field_frequency_min {
-             { 4 * 8, 0 * 16 },
-             4,
-             { 0, 6960 },
-             240,
-             ' '
-         };
-
-         NumberField field_frequency_max {
-             { 13 * 8, 0 * 16 },
-             4,
-             { 240, 7200 },
-             240,
-             ' '
-         };
-
-         LNAGainField field_lna {
-             { 21 * 8, 0 * 16 }
-         };
-
-         VGAGainField field_vga {
-             { 27 * 8, 0 * 16 }
-         };
-
-         Text text_range{
-            {7 * 8, 1 * 16, 4 * 8, 16},
-            ""};
-
-        OptionsField filter_config{
-            {19 * 8, 1 * 16},
-            4,
+            struct preset_entry
             {
-                {"OFF ", 0},
-                {"MID ", 118}, //85 +25 (110) + a bit more to kill all blue
-                {"HIGH", 202}, //168 + 25 (193)
-            }};
+                rf::Frequency min{};
+                rf::Frequency max{};
+                std::string label{};
+            };
+            
+            const Style style_white {		// free range
+                .font = font::fixed_8x16,
+                .background = Color::black(),
+                .foreground = Color::white(),
+            };
 
-        RFAmpField field_rf_amp{
-            {29 * 8, 1 * 16}};
+            const Style style_red {		// locked range
+                .font = font::fixed_8x16,
+                .background = Color::black(),
+                .foreground = Color::red(),
+            };
 
-        OptionsField range_presets{
-            {7 * 8, 2 * 16},
-            20,
-            {
-                {" NONE (WIFI 2.4GHz)", 0},
-            }};
+            std::vector<preset_entry> presets_db{};
+            
+            // Each slice bandwidth 20 MHz and a multiple of 256
+            // since we are using LOOKING_GLASS_SLICE_WIDTH/256 as the each_bin_size
+            // it should also be a multiple of 2 since we are using LOOKING_GLASS_SLICE_WIDTH / 2 as centering freq
+            int64_t LOOKING_GLASS_SLICE_WIDTH = 20000000;
 
-        NumberField field_marker{
-            {7 * 8, 3 * 16},
-            4,
-            {0, 7200},
-            25,
-            ' '};
+            // frequency rounding helpers
+            int64_t next_mult_of(int64_t num, int64_t multiplier);
+            void adjust_range(int64_t* f_min, int64_t* f_max, int64_t width);
 
-        Text text_marker_pm{
-            {20 * 8, 3 * 16, 2 * 8, 16},
-            ""};
+            void on_channel_spectrum(const ChannelSpectrum& spectrum);
+            void do_timers();
+            void on_range_changed();
+            void on_lna_changed(int32_t v_db);
+            void on_vga_changed(int32_t v_db);
+            void reset_live_view( bool clear_screen );
+            void add_spectrum_pixel(uint8_t power);
+            void PlotMarker(rf::Frequency pos);
+            void load_Presets();
+            void txtline_process(std::string& line);
+            void populate_Presets();
+            void presets_Default();
 
-        NumberField field_trigger{
-             {11 * 8, 4 * 16},
-             3,
-             {2, 128},
-             2,
-             ' '};
+            rf::Frequency f_min { 0 }, f_max { 0 };
+            rf::Frequency search_span { 0 };
+            rf::Frequency f_center { 0 };
+            rf::Frequency f_center_ini { 0 };
+            rf::Frequency marker { 0 };
+            rf::Frequency marker_pixel_step { 0 };
+            rf::Frequency each_bin_size { LOOKING_GLASS_SLICE_WIDTH  / 256 };
+            rf::Frequency bins_Hz_size { 0 };
+            uint8_t min_color_power { 0 };
+            uint32_t pixel_index { 0 };
+            std::array<Color, 240> spectrum_row = { 0 };
+            std::array<uint8_t, 240> spectrum_data = { 0 };
+            ChannelSpectrumFIFO* fifo { nullptr }; 
+            uint8_t max_power = 0;
+            int32_t steps = 0 ;
+            uint8_t live_frequency_view = 0 ;
+            int16_t live_frequency_integrate = 3 ;
+            int64_t max_freq_hold = 0 ;
+            int16_t max_freq_power = -1000 ;
+            bool fast_scan = true ; // default to legacy fast scan
+            bool locked_range = false ; 
 
+            Labels labels{
+                {{0, 0}, "MIN:     MAX:     LNA   VGA  ", Color::light_grey()},
+                    {{0, 1 * 16}, "RANGE:       FILTER:      AMP:", Color::light_grey()},
+                    {{0, 2 * 16}, "PRESET:", Color::light_grey()},
+                    {{0, 3 * 16}, "MARKER:            MHz", Color::light_grey()},
+                    {{0, 4 * 16}, "RES:    STEP:", Color::light_grey()}
+            };
 
-     MessageHandlerRegistration message_handler_spectrum_config {
- 		Message::ID::ChannelSpectrumConfig,
- 		[this](const Message* const p) {
- 			const auto message = *reinterpret_cast<const ChannelSpectrumConfigMessage*>(p);
- 			this->fifo = message.fifo;
- 		}
- 	};
- 	MessageHandlerRegistration message_handler_frame_sync {
- 		Message::ID::DisplayFrameSync,
- 		[this](const Message* const) {
- 			if( this->fifo ) {
- 				ChannelSpectrum channel_spectrum;
- 				while( fifo->out(channel_spectrum) ) {
- 					this->on_channel_spectrum(channel_spectrum);
- 				}
- 			}
- 		}
- 	};
+            NumberField field_frequency_min {
+                { 4 * 8, 0 * 16 },
+                    4,
+                    { 0, 7199 },
+                    1, // number of steps by encoder delta
+                    ' '
+            };
 
-     };
- } 
- 
+            NumberField field_frequency_max {
+                { 13 * 8, 0 * 16 },
+                    4,
+                    { 1, 7200 },
+                    1, // number of steps by encoder delta
+                    ' '
+            };
+
+            LNAGainField field_lna {
+                { 21 * 8, 0 * 16 }
+            };
+
+            VGAGainField field_vga {
+                { 27 * 8, 0 * 16 }
+            };
+
+            Button  button_range{
+                {7 * 8, 1 * 16, 4 * 8, 16},
+                    ""};
+
+            OptionsField filter_config{
+                {20 * 8, 1 * 16},
+                    4,
+                    {
+                        {"OFF ", 0},
+                        {"MID ", 118}, //85 +25 (110) + a bit more to kill all blue
+                        {"HIGH", 202}, //168 + 25 (193)
+                    }};
+
+            RFAmpField field_rf_amp{
+                {29 * 8, 1 * 16}};
+
+            OptionsField range_presets{
+                {7 * 8, 2 * 16},
+                    20,
+                    {
+                        {" NONE (WIFI 2.4GHz)", 0},
+                    }};
+
+            ButtonWithEncoder button_marker{
+                {7 * 8, 3 * 16 , 10 * 8 , 16},
+                " "
+            };
+
+            NumberField field_trigger{
+                {4 * 8, 4 * 16},
+                    3,
+                    {2, 128},
+                    2,
+                    ' '};
+
+            OptionsField steps_config{
+                { 13 * 8, 4 * 16},
+                3,
+                {
+                    {"1",    1},
+                    {"25",   25},
+                    {"50",   50},
+                    {"100",  100},
+                    {"250",  250}, 
+                    {"500",  500},
+                }
+            };
+
+			OptionsField scan_type{
+                { 17 * 8, 4 * 16},
+                2,
+                {
+                    {"F-", true },
+                    {"S-", false },
+                }
+            };
+
+            OptionsField view_config{
+                { 19 * 8, 4 * 16},
+                7,
+                {
+                    {"SPCTR-V", 0 },
+                    {"LEVEL-V", 1 },
+                    {"PEAK-V" , 2 },
+                }
+            };
+
+            OptionsField level_integration{
+                { 27 * 8, 4 * 16},
+                2,
+                {
+                    {"x0", 0 },
+                    {"x1", 1 },
+                    {"x2", 2 },
+                    {"x3", 3 },
+                    {"x4", 4 },
+                    {"x5", 5 },
+                    {"x6", 6 },
+                    {"x7", 7 },
+                    {"x8", 8 },
+                    {"x9", 9 },
+                    }};
+
+            Button button_jump {
+                { 240 - 4 * 8 , 5 * 16 , 4 * 8, 16 },
+                "JMP"
+            };
+
+            Button button_rst {
+                { 240 - 9 * 8 , 5 * 16 , 4 * 8, 16 },
+                "RST"
+            };
+
+            Text freq_stats{
+                {0 * 8, 5 * 16 , 240 - 10 * 8 , 8 },
+                ""
+            };
+
+            MessageHandlerRegistration message_handler_spectrum_config {
+                Message::ID::ChannelSpectrumConfig,
+                    [this](const Message* const p) {
+                        const auto message = *reinterpret_cast<const ChannelSpectrumConfigMessage*>(p);
+                        this->fifo = message.fifo;
+                    }
+            };
+            MessageHandlerRegistration message_handler_frame_sync {
+                Message::ID::DisplayFrameSync,
+                    [this](const Message* const) {
+                        if( this->fifo ) {
+                            ChannelSpectrum channel_spectrum;
+                            while( fifo->out(channel_spectrum) ) {
+                                this->on_channel_spectrum(channel_spectrum);
+                            }
+                        }
+                    }
+            };
+    };
+} 
+#endif

firmware/application/apps/ui_mictx.cpp

@@ -24,8 +24,13 @@
 
 #include "baseband_api.hpp"
 #include "audio.hpp"
+
+#include "wm8731.hpp"
+using wolfson::wm8731::WM8731;
+
 #include "tonesets.hpp"
 #include "portapack_hal.hpp"
+#include "cpld_update.hpp"
 #include "string_format.hpp"
 #include "irq_controls.hpp"
 
@@ -34,6 +39,10 @@
 using namespace tonekey;
 using namespace portapack;
 
+
+WM8731 audio_codec_wm8731 { i2c0, 0x1a };
+
+
 namespace ui {
 
 void MicTXView::focus() {
@@ -65,6 +74,7 @@ void MicTXView::configure_baseband() {
 		sampling_rate / 20,		// Update vu-meter at 20Hz
 		transmitting ? transmitter_model.channel_bandwidth() : 0,
 		mic_gain,
+		shift_bits_s16,			// to be used in dsp_modulate
 		TONES_F2D(tone_key_frequency(tone_key_index), sampling_rate),
 		enable_am,
 		enable_dsb,
@@ -149,27 +159,36 @@ void MicTXView::rxaudio(bool is_on) {
 		audio::input::stop();
 		baseband::shutdown();
 		
-		if (enable_am || enable_usb || enable_lsb || enable_dsb) {
+		if (enable_am || enable_usb || enable_lsb || enable_dsb) {		// "NFM/FM",0 ," WFM  ",1 ,  "  AM  ",2, " USB  ", 3, " LSB  ",4, " DSB-SC", 5
 			baseband::run_image(portapack::spi_flash::image_tag_am_audio);
-			receiver_model.set_modulation(ReceiverModel::Mode::AMAudio);	
-			if (options_mode.selected_index() < 4)
-				receiver_model.set_am_configuration(options_mode.selected_index() - 1);
-			else
-				receiver_model.set_am_configuration(0);
+			receiver_model.set_modulation(ReceiverModel::Mode::AMAudio);	// that AM demodulation engine is common to all Amplitude mod : AM/USB/LSB/DSB (2,3,4,5)	
+			if (options_mode.selected_index() < 5)       // We will be called here with 2,3,4,5 . We treat here demod. filter 2,3,4; (excluding DSB-C case (5) it is treated more down).  
+				receiver_model.set_am_configuration(options_mode.selected_index() - 1);  // selecting proper filter(2,3,4). 2-1=1=>6k-AM(1) , 3-1=2=>+3k-USB(2), 4-1=3=>-3K-LSB(3),
 		}
-		else {
-			baseband::run_image(portapack::spi_flash::image_tag_nfm_audio);
-			receiver_model.set_modulation(ReceiverModel::Mode::NarrowbandFMAudio);
+		else {    // We are in NFM/FM or WFM    (NFM BW:8k5 or 11k / FM BW 16k  / WFM  BW:200k) 
 			
-		}
+			if (enable_wfm) {     // WFM , BW 200Khz aprox ,
+				baseband::run_image(portapack::spi_flash::image_tag_wfm_audio);
+				receiver_model.set_modulation(ReceiverModel::Mode::WidebandFMAudio);
+				receiver_model.set_wfm_configuration(0);  // there are only  1  x config filters 200k WFM . (not like 8k5/11k/16k)
+			} else {     // NFM BW:8k5 or  11k / FM BW 16k 
+				baseband::run_image(portapack::spi_flash::image_tag_nfm_audio);
+				receiver_model.set_modulation(ReceiverModel::Mode::NarrowbandFMAudio); // 	
+				// receiver_model.set_nbfm_configuration(n); is called above  , depending 8k5, 11k, 16k  
+			}
+		} 
 		receiver_model.set_sampling_rate(3072000);
 		receiver_model.set_baseband_bandwidth(1750000);	
 //		receiver_model.set_tuning_frequency(field_frequency.value()); //probably this too can be commented out.
-		receiver_model.set_tuning_frequency(rx_frequency); // Now with seperate controls!
+	    if (bool_same_F_tx_rx_enabled) 								// when stop TX ,define to which freq RX we return 
+			    receiver_model.set_tuning_frequency(tx_frequency);  // Update freq also for RX = TX	
+		else 
+		        receiver_model.set_tuning_frequency(rx_frequency);  // Now with seperate freq controls!
 		receiver_model.set_lna(rx_lna);
 		receiver_model.set_vga(rx_vga);
 		receiver_model.set_rf_amp(rx_amp);
 		receiver_model.enable();
+		hackrf::cpld::load_sram_no_verify();  // to have a good RX without any ghost inside Mic App
 		audio::output::start();
 	} else {	//These incredibly convoluted steps are required for the vumeter to reappear when stopping RX.
 		receiver_model.set_modulation(ReceiverModel::Mode::NarrowbandFMAudio); //This fixes something with AM RX...
@@ -178,7 +197,7 @@ void MicTXView::rxaudio(bool is_on) {
 
 		baseband::run_image(portapack::spi_flash::image_tag_mic_tx);
 		audio::output::stop();
-		audio::input::start();	
+		audio::input::start(ak4951_alc_and_wm8731_boost_GUI);	// When detected AK4951 => set up ALC mode; when detected WM8731 => set up mic_boost ON/OFF.
 		portapack::pin_i2s0_rx_sda.mode(3);
 		configure_baseband();
 	}
@@ -203,10 +222,12 @@ MicTXView::MicTXView(
 	
 	baseband::run_image(portapack::spi_flash::image_tag_mic_tx);
 	
-	add_children({
-		&labels,
+	if (audio::debug::codec_name() =="WM8731" ) {
+	add_children({		
+		&labels_WM8731,		// we have audio codec WM8731, same MIC menu  as original.
 		&vumeter,
-		&options_gain,
+		&options_gain,		// MIC GAIN float factor on the GUI.
+		&options_wm8731_boost_mode,
 //		&check_va,
 		&field_va,
 		&field_va_level,
@@ -219,6 +240,7 @@ MicTXView::MicTXView(
 		&field_frequency,
 		&options_tone_key,
 		&check_rogerbeep,
+		&check_common_freq_tx_rx,	// added to handle common or separate freq- TX/RX
 		&check_rxactive,
 		&field_volume,
 		&field_rxbw,
@@ -229,6 +251,38 @@ MicTXView::MicTXView(
 		&field_rxamp,
 		&tx_button
 	});
+    
+	} else {			
+	add_children({
+		&labels_AK4951,		// we have audio codec AK4951, enable Automatic Level Control
+		&vumeter,
+		&options_gain,
+		&options_ak4951_alc_mode,
+//		&check_va,
+		&field_va,
+		&field_va_level,
+		&field_va_attack,
+		&field_va_decay,
+		&field_bw,
+		&field_rfgain,
+		&field_rfamp,
+		&options_mode,
+		&field_frequency,
+		&options_tone_key,
+		&check_rogerbeep,
+		&check_common_freq_tx_rx,	// added to handle common or separate freq- TX/RX
+		&check_rxactive,
+		&field_volume,
+		&field_rxbw,
+		&field_squelch,
+		&field_rxfrequency,
+		&field_rxlna,
+		&field_rxvga,
+		&field_rxamp,
+		&tx_button
+	});
+	
+	}
 
 	tone_keys_populate(options_tone_key);
 	options_tone_key.on_change = [this](size_t i, int32_t) {
@@ -240,15 +294,55 @@ MicTXView::MicTXView(
 		mic_gain = v / 10.0;
 		configure_baseband();
 	};
-	options_gain.set_selected_index(1);		// x1.0
+	options_gain.set_selected_index(1);		// x1.0  preselected default.
+
+ 	if (audio::debug::codec_name() =="WM8731") {
+		options_wm8731_boost_mode.on_change = [this](size_t, int8_t v) {
+
+			switch(v) {
+			case 0: 	                // +12 dB’s respect reference level orig fw 1.5.x fw FM : when +20dB's boost ON) and shift bits (>>8), 
+				shift_bits_s16 = 6; 	//  now mic-boost on (+20dBs) and shift bits (>>6), +20+12=32 dB’s (orig fw +20 dBs+ 0dBs)=> +12dB's respect ref.
+				break;					
+			case 1: 	                // +06 dB’s reference level , (when +20dB's boost ON) 
+				shift_bits_s16 = 7; 	// now mic-boost on (+20dBs) and shift bits (>>7), +20+06=26 dB’s (orig fw +20 dBs+ 0dBs) => +06dB's respect ref.	 
+				break;					
+			case 2: 	                
+				shift_bits_s16 = 4; 	// +04 dB’s respect ref level , (when +20dB's boost OFF) 
+				break;					// now mic-boost off (+00dBs) shift bits (4) (+0+24dB's)=24 dBs => +04dB's respect ref.	 
+			case 3:
+				shift_bits_s16 = 5;		// -02 dB’s respect ref level , (when +20dB's boost OFF) 
+				break;					// now mic-boost off (+00dBs) shift bits (5) (+0+18dB's)=18 dBs => -02dB's respect ref.	 
+			case 4:
+				shift_bits_s16 = 6;     // -08 dB’s respect ref level , (when +20dB's boost OFF) 
+				break;					// now mic-boost off (+00dBs) shift bits (6) (+0+12dB's)=12 dBs => -08dB's respect ref.	
+			}
+			ak4951_alc_and_wm8731_boost_GUI   = v;	//  0,..4 WM8731_boost dB's options, (combination boost on/off , and effective gain in captured data >>x) 
+			audio::input::start(ak4951_alc_and_wm8731_boost_GUI);  // Detected (WM8731) , set up the proper wm_boost on/off , 0..4 (0,1) boost_on , (2,3,4) boost_0ff
+			configure_baseband(); 					// to update in real timme,sending msg ,  var-parameters >>shift_bits FM msg ,to audio_tx from M0 to M4 Proc -
+		};
+		options_wm8731_boost_mode.set_selected_index(3);	// preset GUI index 3 as default WM -> -02 dB's .	
+	} else {
+	   	shift_bits_s16 = 8;         	// Initialized default fixed >>8_FM for FM tx mod ,  shift audio data for AK4951  ,using top 8 bits s16 data (>>8)
+	  	options_ak4951_alc_mode.on_change = [this](size_t, int8_t v) {
+	    	ak4951_alc_and_wm8731_boost_GUI   = v;   				// 0,..11,  AK4951 Mic -Automatic volume Level Control  options, 
+			audio::input::start(ak4951_alc_and_wm8731_boost_GUI);  	// Detected (AK4951) ==> Set up proper ALC mode from 0..11 options
+			configure_baseband(); 									// sending fixed >>8_FM , var-parameters msg ,  to audiotx from this M0 to M4 process.
+		};
+	}
 	
+   	// options_ak4951_alc_mode.set_selected_index(0);
+	 
 	tx_frequency = transmitter_model.tuning_frequency();
 	field_frequency.set_value(transmitter_model.tuning_frequency());
 	field_frequency.set_step(receiver_model.frequency_step());
 	field_frequency.on_change = [this](rf::Frequency f) {
 		tx_frequency = f;
-		if(!rx_enabled)
+		if(!rx_enabled) {					// not activated receiver. just update freq TX
 			transmitter_model.set_tuning_frequency(f);
+	    } else {							// activated receiver.
+			if (bool_same_F_tx_rx_enabled)	// user selected common freq- TX = RX
+			    receiver_model.set_tuning_frequency(f); //Update common freq also for RX			
+		}	
 	};
 	field_frequency.on_edit = [this, &nav]() {
 		focused_ui = 0;
@@ -256,8 +350,12 @@ MicTXView::MicTXView(
 		auto new_view = nav.push<FrequencyKeypadView>(tx_frequency);
 		new_view->on_changed = [this](rf::Frequency f) {
 			tx_frequency = f;
-			if(!rx_enabled)
+			if(!rx_enabled) {
 				transmitter_model.set_tuning_frequency(f);
+		    } else {
+				if (bool_same_F_tx_rx_enabled)
+				  receiver_model.set_tuning_frequency(f); //Update freq also for RX
+			}	
 			this->field_frequency.set_value(f);
 			set_dirty();
 		};
@@ -266,7 +364,8 @@ MicTXView::MicTXView(
 	field_bw.on_change = [this](uint32_t v) {
 		transmitter_model.set_channel_bandwidth(v * 1000);
 	};
-	field_bw.set_value(10);
+	field_bw.set_value(10);	// pre-default first time, TX  deviation FM for NFM / FM
+	
 	
 	tx_gain = transmitter_model.tx_gain();
 	field_rfgain.on_change = [this](int32_t v) {
@@ -281,36 +380,102 @@ MicTXView::MicTXView(
 	};
 	field_rfamp.set_value(rf_amp ? 14 : 0);
 	
-	options_mode.on_change = [this](size_t, int32_t v) {
-		enable_am = false;
+	options_mode.on_change = [this](size_t, int32_t v) {   //{ "NFM/FM", 0 }, { " WFM  ", 1 },{ "AM", 2 },{ "USB", 3 },{ "LSB", 4 },{ "DSB", 5 }
+		enable_am  = false;
 		enable_usb = false;
 		enable_lsb = false;
 		enable_dsb = false;
+		enable_wfm = false;
+
+		using option_t = std::pair<std::string, int32_t>;
+		using options_t = std::vector<option_t>;
+		options_t rxbw;				// Aux structure to change dynamically  field_rxbw contents,  
+		
 		switch(v) {
-			case 0:
-				enable_am = false;
+			case 0:					 //{ "FM", 0 }
+				enable_am  = false;
 				enable_usb = false;
 				enable_lsb = false;
 				enable_dsb = false;
-				field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);
+				field_bw.set_value(10);	// pre-default deviation FM for WFM
+				// field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);
 				//if (rx_enabled)
-				rxaudio(rx_enabled); //Update now if we have RX audio on
+				rxaudio(rx_enabled); 					//Update now if we have RX audio on
+				options_tone_key.hidden(0);				// we are in FM mode , we should have active the Key-tones & CTCSS option.
+				
+				rxbw.emplace_back(" NFM1:8k5  ", 0); 		// restore the original dynamic field_rxbw value.
+				rxbw.emplace_back(" NFM2:11k  ", 1);
+				rxbw.emplace_back(" FM  :16k  ", 2);			
+				field_rxbw.set_options(rxbw);			// store that aux GUI option to the field_rxbw.
+							
+				field_rxbw.hidden(0);					// we are in FM mode,  we need to allow the user set up of the RX NFM BW selection (8K5, 11K, 16K) 
+				field_bw.hidden(0);						// we are in FM mode, we need to allow FM deviation parameter , in non FM mode.
 				break;
-			case 1:
+			case 1:					 //{ "WFM", 1 }
+				enable_am  = false;
+				enable_usb = false;
+				enable_lsb = false;
+				enable_dsb = false;
+				enable_wfm = true;
+				field_bw.set_value(75);	// pre-default deviation FM for WFM
+				// field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);
+				//if (rx_enabled)
+				rxaudio(rx_enabled); 					//Update now if we have RX audio on
+				options_tone_key.hidden(0);				// we are in WFM mode , we should have active the Key-tones & CTCSS option.
+
+				rxbw.emplace_back("  200k-WFM ", 0);		// locked a fixed option , to display it .
+				field_rxbw.set_options(rxbw);			// store that aux GUI option to the field_rxbw.
+
+				field_rxbw.hidden(0);					// we are in WFM mode,  we need to show to the user the selected BW WFM filer . 
+				field_bw.hidden(0);						// we are in WFM mode, we need to allow WFM deviation parameter , in non FM mode.
+				break;
+			case 2:					 //{ "AM", 2 }
 				enable_am = true;
-				rxaudio(rx_enabled); //Update now if we have RX audio on
+				rxaudio(rx_enabled); 					//Update now if we have RX audio on
+				options_tone_key.set_selected_index(0);	// we are NOT in FM mode ,  we reset the possible previous key-tones &CTCSS selection.
+				set_dirty();							// Refresh display	
+				options_tone_key.hidden(1);				// we hide that Key-tones & CTCSS input selecction, (no meaning in AM/DSB/SSB).
+				
+				rxbw.emplace_back(" DSB1-9k   ", 0);		// we offer in AM DSB two audio BW 9k / 6k  .
+				rxbw.emplace_back(" DSB2-6k   ", 1);		
+				field_rxbw.set_options(rxbw);			// store that aux GUI option to the field_rxbw.
+	
+				field_rxbw.hidden(0);					// we show fixed RX  AM BW 6Khz 
+				field_bw.hidden(1);						// we hide the FM TX deviation parameter , in non FM mode.
+				check_rogerbeep.hidden(0);				// make visible again the "rogerbeep" selection.					
 				break;
-			case 2:
+			case 3:					 //{ "USB", 3 }
 				enable_usb = true;
-				rxaudio(rx_enabled); //Update now if we have RX audio on
+				rxaudio(rx_enabled); 					//Update now if we have RX audio on
+				check_rogerbeep.set_value(false);		// reset the possible activation of roger beep, because it is not compatible with SSB , by now. 
+				check_rogerbeep.hidden(1);				// hide that roger beep selection. 
+
+				rxbw.emplace_back("  USB+3k   ", 0);		// locked a fixed option , to display it .
+				field_rxbw.set_options(rxbw);			// store that aux GUI option to the field_rxbw.
+
+				set_dirty();							// Refresh display
 				break;
-			case 3:
+			case 4:					 //{ "LSB", 4 }
 				enable_lsb = true;
-				rxaudio(rx_enabled); //Update now if we have RX audio on
+				rxaudio(rx_enabled); 					//Update now if we have RX audio on
+				check_rogerbeep.set_value(false);		// reset the possible activation of roger beep, because it is not compatible with SSB , by now. 
+				check_rogerbeep.hidden(1);				// hide that roger beep selection. 
+				
+				rxbw.emplace_back("  LSB-3k   ", 0);		// locked a fixed option , to display it .
+				field_rxbw.set_options(rxbw);			// store that aux GUI option to the field_rxbw.
+				
+				set_dirty();							// Refresh display
 				break;
-			case 4:
+			case 5:				 	//{ "DSB-SC", 5 }
 				enable_dsb = true;
-				rxaudio(rx_enabled); //Update now if we have RX audio on
+				rxaudio(rx_enabled); 					//Update now if we have RX audio on
+				check_rogerbeep.hidden(0);				// make visible again the "rogerbeep" selection.
+			
+				rxbw.emplace_back("SSB1:USB+3k", 0); 	// added dynamically two options (index 0,1) to that DSB-C case to the  field_rxbw value.
+				rxbw.emplace_back("SSB2:LSB-3k", 1);
+		
+				field_rxbw.set_options(rxbw);			// store that aux GUI option to the field_rxbw.
+
 				break;
 		}
 		//configure_baseband();
@@ -359,6 +524,13 @@ MicTXView::MicTXView(
 		rogerbeep_enabled = v;
 	};
 
+    check_common_freq_tx_rx.on_select = [this](Checkbox&, bool v) {
+		bool_same_F_tx_rx_enabled = v;
+		field_rxfrequency.hidden(v); 	//Hide or show separated freq RX field . (When no hide user can enter down indep. freq for RX)
+		set_dirty();					//Refresh GUI interface
+		receiver_model.set_tuning_frequency(v ? tx_frequency : rx_frequency);	// To go to the proper tuned freq. when toggling it
+	};
+
 	field_va_level.on_change = [this](int32_t v) {
 		va_level = v;
 		vumeter.set_mark(v);
@@ -387,19 +559,20 @@ MicTXView::MicTXView(
 	field_volume.on_change = [this](int32_t v) { this->on_headphone_volume_changed(v);	};
 
 	field_rxbw.on_change = [this](size_t, int32_t v) {
-		switch(v) {
-			case 0:
-				receiver_model.set_nbfm_configuration(0);
-				break;
-			case 1:
-				receiver_model.set_nbfm_configuration(1);
-				break;
-			case 2:
-				receiver_model.set_nbfm_configuration(2);
-				break;
+		if (!(enable_am || enable_usb || enable_lsb || enable_dsb || enable_wfm )) { 
+				// In Previous fw versions, that nbfm_configuration(n)  was done in any mode (FM/AM/SSB/DSB)...strictly speaking only need it in (NFM/FM) 
+				receiver_model.set_nbfm_configuration(v ); // we are in  NFM/FM case, we need to  select proper NFM/FM RX channel filter , NFM BW 8K5(0), NFM BW 11K(1) , FM BW 16K (2)
 		}
+		else {					// we are not in  NFM/FM mode  .(we could be in any of the rest : AM /USB/LSB/DSB-SC)
+			if (enable_am) { 	// we are in AM TX mode , we will allow both independent RX audio BW :  AM 9K (9K00AE3 / AM 6K (6K00AE3). (In AM option v can be 0 (9k) , 1 (6k) 
+				receiver_model.set_am_configuration(v );  // we are in AM TX mode , we need to  select proper AM full path config AM-9K filter. 0+0 =>AM-9K(0), 0+1=1 =>AM-6K(1),
+			} 
+	
+			if (enable_dsb) { 	// we are in DSB-SC in TX mode , we will allow both independent RX SSB demodulation (USB / LSB side band). in that submenu, v is 0 (SSB1 USB) or 1 (SSB2 LSB)
+				receiver_model.set_am_configuration(v +2 );  // we are in DSB-SC TX mode , we need to  select proper SSB filter. 0+2 =>usb(2), 1+2=3 =>lsb(3),
+			} 
+		}		 
 	};
-	field_rxbw.set_selected_index(2);
 
 	field_squelch.on_change = [this](int32_t v) { 
 		receiver_model.set_squelch_level(100 - v);	
@@ -410,12 +583,12 @@ MicTXView::MicTXView(
 	rx_frequency = receiver_model.tuning_frequency();
 	field_rxfrequency.set_value(rx_frequency);
 	field_rxfrequency.set_step(receiver_model.frequency_step());
-	field_rxfrequency.on_change = [this](rf::Frequency f) {
+	field_rxfrequency.on_change = [this](rf::Frequency f) {		// available when field rxfrequency not hidden => user selected separated freq RX/TX-
 		rx_frequency = f;
 		if(rx_enabled)
 			receiver_model.set_tuning_frequency(f);
 	};
-	field_rxfrequency.on_edit = [this, &nav]() {
+	field_rxfrequency.on_edit = [this, &nav]() {				// available when field rxfrequency not hidden => user selected separated freq RX/TX-
 		focused_ui = 1;
 		// TODO: Provide separate modal method/scheme?
 		auto new_view = nav.push<FrequencyKeypadView>(rx_frequency);
@@ -476,9 +649,9 @@ MicTXView::MicTXView(
 	transmitter_model.set_baseband_bandwidth(1750000);
 	
 	set_tx(false);
-	
-	audio::set_rate(audio::Rate::Hz_24000);
-	audio::input::start();
+
+  	audio::set_rate(audio::Rate::Hz_24000);
+	audio::input::start(ak4951_alc_and_wm8731_boost_GUI);	// When detected AK4951 => set up ALC mode; when detected WM8731 => set up mic_boost ON/OFF.	
 }
 
 MicTXView::~MicTXView() {
@@ -487,7 +660,8 @@ MicTXView::~MicTXView() {
 	transmitter_model.disable();
 	if (rx_enabled) //Also turn off audio rx if enabled
 		rxaudio(false);
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  //  to leave all RX ok, without ghost signal problem at the exit .
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 }

firmware/application/apps/ui_mictx.hpp

@@ -58,7 +58,7 @@ public:
 	};
 	*/
 
-	std::string title() const override { return "Mic TX RX"; };
+	std::string title() const override { return "Microphone"; };
 
 private:
 	static constexpr uint32_t sampling_rate = 1536000U;
@@ -80,9 +80,11 @@ private:
 	bool va_enabled { false };
 	bool ptt_enabled { true };
 	bool rogerbeep_enabled { false };
+    bool bool_same_F_tx_rx_enabled { false };
 	bool rx_enabled { false };
 	uint32_t tone_key_index { };
 	float mic_gain { 1.0 };
+    uint8_t  ak4951_alc_and_wm8731_boost_GUI  { 0 }; 
 	uint32_t audio_level { 0 };
 	uint32_t va_level { };
 	uint32_t attack_ms { };
@@ -98,18 +100,21 @@ private:
 	rf::Frequency rx_frequency { 0 };
 	int32_t focused_ui { 2 };
 	bool button_touch { false };
+	uint8_t shift_bits_s16 {4} ; // shift bits factor to the captured ADC S16 audio sample.
 
 	//AM TX Stuff
 	bool enable_am { false };
 	bool enable_dsb { false };
 	bool enable_usb { false };
 	bool enable_lsb { false };
+	bool enable_wfm { false };	// added to distinguish in the FM mode ,  RX BW : NFM (8K5, 11K), FM (16K), WFM(200K)
 
 	
-	Labels labels {
-		{ { 3 * 8, 1 * 8 }, "MIC. GAIN:", Color::light_grey() },
+	Labels labels_WM8731 {		
+		{ { 3 * 8, 1 * 8 }, "MIC-GAIN:", Color::light_grey() },
+		{ { 17 * 8, 1 * 8 }, "Boost", Color::light_grey() },
 		{ { 3 * 8, 3 * 8 }, "F:", Color::light_grey() },
-		{ { 15 * 8, 3 * 8 }, "BW:   FM kHz", Color::light_grey() },
+		{ { 15 * 8, 3 * 8 }, "FM TXBW:    kHz", Color::light_grey() },		// to be more symetric and consistent to the below FM RXBW
 		{ { 3 * 8, 5 * 8 }, "GAIN:", Color::light_grey() },
 		{ {11 * 8, 5 * 8 }, "Amp:", Color::light_grey() },
 		{ { 18 * 8, (5 * 8) }, "Mode:", Color::light_grey() },
@@ -118,15 +123,36 @@ private:
 		{ {12 * 8, 10 * 8 }, "ATT:", Color::light_grey() },
 		{ {20 * 8, 10 * 8 }, "DEC:", Color::light_grey() },
 		{ { 4 * 8, ( 13 * 8 ) - 2 }, "TONE KEY:", Color::light_grey() },
-		{ { 9 * 8, 23 * 8 }, "VOL:", Color::light_grey() },
-		{ {17 * 8, 23 * 8 }, "FM RXBW:", Color::light_grey() },
-		{ {17 * 8, 25 * 8 }, "SQ:", Color::light_grey() },
-		{ { 5 * 8, 25 * 8 }, "F:", Color::light_grey() },
+		{ { 7 * 8, 23 * 8 }, "VOL:", Color::light_grey() },
+		{ {14 * 8, 23 * 8 }, "RXBW:", Color::light_grey() },		//we remove the label "FM" because we will display all MOD types RX_BW.
+		{ {20 * 8, 25 * 8 }, "SQ:", Color::light_grey() },
+		{ { 5 * 8, 25 * 8 }, "F_RX:", Color::light_grey() }, 			
 		{ { 5 * 8, 27 * 8 }, "LNA:", Color::light_grey()},
 		{ {12 * 8, 27 * 8 }, "VGA:", Color::light_grey()},
 		{ {19 * 8, 27 * 8 }, "AMP:", Color::light_grey()}
 	};
-	
+	Labels labels_AK4951 {
+		{ { 3 * 8, 1 * 8 }, "MIC-GAIN:", Color::light_grey() },
+		{ { 17 * 8, 1 * 8 }, "ALC", Color::light_grey() },
+		{ { 3 * 8, 3 * 8 }, "F:", Color::light_grey() },
+		{ { 15 * 8, 3 * 8 }, "FM TXBW:    kHz", Color::light_grey() },
+		{ { 3 * 8, 5 * 8 }, "GAIN:", Color::light_grey() },
+		{ {11 * 8, 5 * 8 }, "Amp:", Color::light_grey() },
+		{ { 18 * 8, (5 * 8) }, "Mode:", Color::light_grey() },
+		{ { 3 * 8, 8 * 8 }, "TX Activation:", Color::light_grey() },
+		{ { 4 * 8, 10 * 8 }, "LVL:", Color::light_grey() },
+		{ {12 * 8, 10 * 8 }, "ATT:", Color::light_grey() },
+		{ {20 * 8, 10 * 8 }, "DEC:", Color::light_grey() },
+		{ { 4 * 8, ( 13 * 8 ) - 2 }, "TONE KEY:", Color::light_grey() },
+		{ { (6 * 8)+4, 23 * 8 }, "VOL:", Color::light_grey() },
+		{ {14 * 8, 23 * 8 }, "RXBW:", Color::light_grey() },			//we remove the label "FM" because we will display all MOD types RX_BW.
+		{ {20 * 8, 25 * 8 }, "SQ:", Color::light_grey() },
+		{ { 5 * 8, 25 * 8 }, "F_RX:", Color::light_grey() },
+		{ { 5 * 8, 27 * 8 }, "LNA:", Color::light_grey()},
+		{ {12 * 8, 27 * 8 }, "VGA:", Color::light_grey()},
+		{ {19 * 8, 27 * 8 }, "AMP:", Color::light_grey()}
+	};
+
 	VuMeter vumeter {
 		{ 0 * 8, 1 * 8, 2 * 8, 33 * 8 },
 		12,
@@ -135,7 +161,7 @@ private:
 
 	
 	OptionsField options_gain {
-		{ 13 * 8, 1 * 8 },
+		{ 12 * 8, 1 * 8 },
 		4,
 		{
 			{ "x0.5", 5 },
@@ -145,11 +171,42 @@ private:
 		}
 	};
 	
+	OptionsField options_ak4951_alc_mode {
+		{ 20 * 8, 1 * 8 },				// Coordinates are: int:x (px), int:y (px)				
+		11,
+		{
+			{ " OFF-12kHz", 0 },	// Nothing changed from ORIGINAL,keeping ALL programmable  AK4951 Digital Block->OFF, sampling 24Khz)
+			{ "+12dB-6kHz", 1 },	// ALC-> on, (+12dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz + Pre-amp Mic (+21dB=original)
+			{ "+09dB-6kHz", 2 },	// ALC-> on, (+09dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz + Pre-amp Mic (+21dB=original)
+			{ "+06dB-6kHz", 3 },	// ALC-> on, (+06dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz + Pre-amp Mic (+21dB=original)
+			{ "+03dB-2kHz", 4 },	// ALC-> on, (+03dB's) Auto Vol max + Wind Noise cancel + LPF 3,5k + Pre-amp Mic (+21dB=original)+ EQ boosting ~<2kHz (f0~1k1,fb:1,7K, k=1,8)
+			{ "+03dB-4kHz", 5 },	// ALC-> on, (+03dB's) Auto Vol max + Wind Noise cancel + LPF 4kHz + Pre-amp Mic (+21dB=original)+ EQ boosting ~<3kHz (f0~1k4,fb~2,4k, k=1,8)
+			{ "+03dB-6kHz", 6 },	// ALC-> on, (+03dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz + Pre-amp Mic (+21dB=original)
+			{ "+00dB-6kHz", 7 },	// ALC-> on, (+00dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz + Pre-amp Mic (+21dB=original)
+			{ "-03dB-6kHz", 8 },	// ALC-> on, (-03dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz + Pre-amp Mic (+21dB=original)
+			{ "-06dB-6kHz", 9 },	// ALC-> on, (-06dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz + Pre-amp Mic (+21dB=original)
+			{ "-09dB-6kHz", 10 },	// ALC-> on, (-09dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz - Pre-amp MIC -3dB (18dB's) 
+			{ "-12dB-6kHz", 11 },	// ALC-> on, (-12dB's) Auto Vol max + Wind Noise cancel + LPF 6kHz - Pre-amp MIC -6dB (15dB's) 	
+		}
+	};
+
+OptionsField options_wm8731_boost_mode {
+		{ 22 * 8, 1 * 8 },				// Coordinates are: int:x (px), int:y (px)				
+		5,
+		{
+			{ "ON +12dB", 0 },	// WM8731 Mic Boost ON ,original+12dBs condition, easy to saturate ADC sat in high voice  ,relative G = +12 dB's respect ref level
+			{ "ON +06dB", 1 },	// WM8731 Mic Boost ON ,original+6 dBs condition, easy to saturate ADC sat in high voice  ,relative G = +06 dB's respect ref level
+			{ "OFF+04dB", 2 },	// WM8731 Mic Boost OFF to avoid ADC sat in high voice  ,relative  G =  +04 dB's (respect ref level) , always effective sampling 24khz 
+			{ "OFF-02dB", 3 },	// WM8731 Mic Boost OFF to avoid ADC sat in high voice  ,relative  G =  -02 dB's (respect ref level) 
+			{ "OFF-08dB", 4 },	// WM8731 Mic Boost OFF to avoid ADC sat in high voice  ,relative  G =  -12 dB's (respect ref level) 
+		}
+	};
+
 	FrequencyField field_frequency {
 		{ 5 * 8, 3 * 8 },
 	};
 	NumberField field_bw {
-		{ 18 * 8, 3 * 8 },
+		{ 23 * 8, 3 * 8 },
 		3,
 		{ 0, 150 },
 		1,
@@ -173,13 +230,14 @@ private:
 	
 	OptionsField options_mode {
 		{ 24 * 8, 5 * 8 },
-		3,
+		4,
 		{
-			{ "FM", 0 },
-			{ "AM", 1 },
-			{ "USB", 2 },
-			{ "LSB", 3 },
-			{ "DSB", 4 }
+			{ "NFM/FM", 0 },
+			{ " WFM  ", 1 },
+			{ "  AM  ", 2 },			// in fact that TX mode = AM -DSB with carrier .
+			{ " USB  ", 3 },
+			{ " LSB  ", 4 },
+			{ "DSB-SC", 5 }				// We are TX Double Side AM Band with suppressed carrier, and allowing in RX both indep SSB lateral band (USB/LSB).  
 		}
 	};
 	/*
@@ -230,7 +288,7 @@ private:
 	};
 
 	Checkbox check_rogerbeep {
-		{ 3 * 8, ( 16 * 8 ) + 4 },
+		{ 3 * 8, ( 16 * 8 ) + 7 },
 		10,
 		"Roger beep",
 		false
@@ -238,13 +296,20 @@ private:
 
 	Checkbox check_rxactive {
 		{ 3 * 8, ( 21 * 8 ) - 4 },
-		8,
+		18,								// it was 8, but if it is string size should be 18
 		"RX audio listening",
 		false
 	};
 
+	Checkbox check_common_freq_tx_rx {
+		{ 18 * 8, ( 16* 8 ) + 7 },
+		8,
+		"F = F_RX",
+		false
+	};
+
 	NumberField field_volume {
-		{ 13 * 8, 23 * 8 },
+		{ 11* 8, 23 * 8 },
 		2,
 		{ 0, 99 },
 		1,
@@ -252,17 +317,17 @@ private:
 	};
 	
 	OptionsField field_rxbw {
-	       { 25 * 8, 23 * 8},
+	       { 19* 8, 23 * 8},
 	       3,
 	       {
-	       		{"8k5", 0},
-	       		{"11k", 1},
-	       		{"16k", 2}
-	       	}
+	       		{" NFM1:8k5  ", 0},
+	       		{" NFM2:11k  ", 1},
+	       		{" FM  :16k  ", 2},
+		   	}
 	};
 	
 	NumberField field_squelch {
-		{ 20 * 8, 25 * 8 },
+		{ 23 * 8, 25 * 8 },
 		2,
 		{ 0, 99 },
 		1,
@@ -270,7 +335,7 @@ private:
 	};
 
 	FrequencyField field_rxfrequency {
-		{ 7 * 8, 25 * 8 },
+		{ 10 * 8, 25 * 8 },
 	};
 
 	NumberField field_rxlna {
@@ -290,7 +355,7 @@ private:
 	};
 
 	NumberField field_rxamp {
-		{ 23 * 8, 27 * 8 },
+		{ 24 * 8, 27 * 8 },
 		1,
 		{ 0, 1 },
 		1,

firmware/application/apps/ui_morse.cpp

@@ -26,6 +26,7 @@
 #include "baseband_api.hpp"
 #include "hackrf_gpio.hpp"
 #include "portapack_shared_memory.hpp"
+#include "cpld_update.hpp"
 #include "ui_textentry.hpp"
 #include "string_format.hpp"
 
@@ -56,13 +57,13 @@ static msg_t ookthread_fn(void * arg) {
 		v = (symbol < 2) ? 1 : 0;	// TX on for dot or dash, off for pause
 		delay = morse_symbols[symbol];
 		
-		gpio_tx.write(v);
+		gpio_og_tx.write(v);
 		arg_c->on_tx_progress(i, false);
 		
 		chThdSleepMilliseconds(delay * arg_c->time_unit_ms);
 	}
 	
-	gpio_tx.write(0);				// Ensure TX is off
+	gpio_og_tx.write(0);				// Ensure TX is off
 	arg_c->on_tx_progress(0, true);
 	chThdExit(0);
 	
@@ -97,8 +98,13 @@ void MorseView::focus() {
 }
 
 MorseView::~MorseView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_morse", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit .
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void MorseView::paint(Painter&) {
@@ -203,6 +209,15 @@ MorseView::MorseView(
 		&tx_view
 	});
 	
+	// load app settings
+	auto rc = settings.load("tx_morse", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
 	// Default settings
 	field_speed.set_value(15);					// 15wps
 	field_tone.set_value(700);					// 700Hz FM tone

firmware/application/apps/ui_morse.hpp

@@ -27,7 +27,7 @@
 #include "ui_widget.hpp"
 #include "ui_navigation.hpp"
 #include "ui_transmitter.hpp"
-
+#include "app_settings.hpp"
 #include "portapack.hpp"
 #include "message.hpp"
 #include "volume.hpp"
@@ -67,6 +67,10 @@ private:
 	std::string message { };
 	uint32_t time_units { 0 };
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	enum modulation_t {
 		CW = 0,
 		FM = 1

firmware/application/apps/ui_nrf_rx.cpp

@@ -60,6 +60,14 @@ NRFRxView::NRFRxView(NavigationView& nav) {
 		&console
 	});
 	
+	// load app settings
+	auto rc = settings.load("rx_nrf", &app_settings);
+	if(rc == SETTINGS_OK) {
+		field_lna.set_value(app_settings.lna);
+		field_vga.set_value(app_settings.vga);
+		field_rf_amp.set_value(app_settings.rx_amp);
+	}
+
 	// DEBUG
 	record_view.on_error = [&nav](std::string message) {
 		nav.display_modal("Error", message);
@@ -157,6 +165,11 @@ void NRFRxView::on_data(uint32_t value, bool is_data) {
 }
 
 NRFRxView::~NRFRxView() {
+
+	// save app settings
+	app_settings.rx_frequency = field_frequency.value();
+	settings.save("rx_nrf", &app_settings);
+
 	audio::output::stop();
 	receiver_model.disable();
 	baseband::shutdown();

firmware/application/apps/ui_nrf_rx.hpp

@@ -27,6 +27,7 @@
 #include "ui.hpp"
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
+#include "app_settings.hpp"
 #include "ui_record_view.hpp"	// DEBUG
 
 #include "utility.hpp"
@@ -45,6 +46,10 @@ public:
 private:
 	void on_data(uint32_t value, bool is_data);
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	uint8_t console_color { 0 };
 	uint32_t prev_value { 0 };
 	std::string str_log { "" };

firmware/application/apps/ui_playlist.cpp

@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ * Copyleft  (ↄ) 2022 NotPike
+ *
+ * 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_playlist.hpp"
+#include "string_format.hpp"
+
+#include "ui_fileman.hpp"
+#include "io_file.hpp"
+
+#include "baseband_api.hpp"
+#include "portapack.hpp"
+#include "portapack_persistent_memory.hpp"
+#include <unistd.h>
+
+using namespace portapack;
+
+namespace ui {
+
+void PlaylistView::set_ready() {
+	ready_signal = true;
+}
+
+
+	void PlaylistView::load_file(std::filesystem::path playlist_path) {
+		File playlist_file;
+		
+		auto error = playlist_file.open(playlist_path.string());
+		if (!error.is_valid()) {
+			std::string line;
+			char one_char[1];
+			for (size_t pointer =0 ; pointer < playlist_file.size(); pointer++) {
+				playlist_file.seek(pointer);
+				playlist_file.read(one_char, 1);
+				if ((int) one_char[0] >= ' ') {
+					line += one_char[0];
+				} else if (one_char[0] == '\n') {
+					txtline_process(line); 
+					line.clear();
+				}
+			}
+			if (line.length() > 0) {
+				txtline_process(line); 
+			}
+		}
+		playlist_masterdb = playlist_db;
+		return ;
+		}
+
+
+	void PlaylistView::txtline_process(std::string &line) {
+		playlist_entry new_item;
+				rf::Frequency f;
+				size_t previous = 0;
+				size_t current = line.find(',');
+				std::string freqs = line.substr(0, current);
+				previous = current +1;
+				current = line.find(',', previous);
+				std::string file = line.substr(previous, current - previous);
+				previous = current +1;
+				current = line.find(',', previous);
+				uint32_t sample_rate = strtoll(line.substr(previous).c_str(), nullptr,  10);
+
+				f = strtoll(freqs.c_str(), nullptr, 0);
+				new_item.replay_frequency = f;
+				new_item.replay_file = "/" + file;
+				new_item.sample_rate = sample_rate;
+				new_item.next_delay = 0;
+
+					playlist_db.push_back(std::move(new_item));
+	}
+
+void PlaylistView::on_file_changed(std::filesystem::path new_file_path, rf::Frequency replay_frequency, uint32_t replay_sample_rate) {
+	File data_file;	
+	// Get file size
+	auto data_open_error = data_file.open("/" + new_file_path.string());
+	if (data_open_error.is_valid()) {
+		file_error();
+		return;
+	}
+	
+	file_path = new_file_path;
+	field_frequency.set_value(replay_frequency);
+	
+	sample_rate = replay_sample_rate;
+	
+	text_sample_rate.set(unit_auto_scale(sample_rate, 3, 0) + "Hz");
+	
+	auto file_size = data_file.size();
+	auto duration = (file_size * 1000) / (2 * 2 * sample_rate);
+	
+	progressbar.set_max(file_size);
+	text_filename.set(file_path.filename().string().substr(0, 12));
+	text_duration.set(to_string_time_ms(duration));
+	
+	button_play.focus();
+}
+
+void PlaylistView::on_tx_progress(const uint32_t progress) {
+	progressbar.set_value(progress);
+}
+
+void PlaylistView::focus() {
+	button_open.focus();
+}
+
+void PlaylistView::file_error() {
+	nav_.display_modal("Error", "File "+file_path.string() +" read error. " +file_path.string());
+}
+
+bool PlaylistView::is_active() const {
+	return (bool)replay_thread;
+}
+
+bool PlaylistView::loop() const {
+	return (bool) playlist_db.size();
+}
+
+void PlaylistView::toggle() {
+	if( is_active() ) {
+		stop(false);
+	} else {
+
+		start();
+	}
+}
+
+void PlaylistView::start() {
+	stop(false);
+
+		playlist_entry item = playlist_db.front();
+		playlist_db.pop_front();
+	//		playlist_entry item = playlist_db[0];
+//	for (playlist_entry item : playlist_db) {
+	//	file_path = item.replay_file;
+	//	rf::Frequency replay_frequency = strtoll(item.replay_frequency.c_str(),nullptr,10);
+		on_file_changed(item.replay_file, item.replay_frequency, item.sample_rate);
+		on_target_frequency_changed(item.replay_frequency);
+
+		std::unique_ptr<stream::Reader> reader;
+		
+		auto p = std::make_unique<FileReader>();
+		auto open_error = p->open(file_path);
+		if( open_error.is_valid() ) {
+			file_error();
+			return;                               // Fixes TX bug if there's a file error
+		} else {
+			reader = std::move(p);
+		}
+
+		if( reader ) {
+			button_play.set_bitmap(&bitmap_stop);
+			baseband::set_sample_rate(sample_rate * 8);
+			
+			replay_thread = std::make_unique<ReplayThread>(
+				std::move(reader),
+				read_size, buffer_count,
+				&ready_signal,
+				[](uint32_t return_code) {
+					ReplayThreadDoneMessage message { return_code };
+					EventDispatcher::send_message(message);
+				}
+			);
+		}
+		field_rfgain.on_change = [this](int32_t v) {
+			tx_gain = v;
+		};  
+		field_rfgain.set_value(tx_gain);
+		receiver_model.set_tx_gain(tx_gain); 
+		
+
+		field_rfamp.on_change = [this](int32_t v) {
+			rf_amp = (bool)v;
+		};
+		field_rfamp.set_value(rf_amp ? 14 : 0);
+
+		//Enable Bias Tee if selected
+		radio::set_antenna_bias(portapack::get_antenna_bias());
+			
+		radio::enable({
+			receiver_model.tuning_frequency(),
+			sample_rate * 8,
+			baseband_bandwidth,
+			rf::Direction::Transmit,
+			rf_amp,         //  previous code line : "receiver_model.rf_amp()," was passing the same rf_amp of all Receiver Apps  
+			static_cast<int8_t>(receiver_model.lna()),
+			static_cast<int8_t>(receiver_model.vga())
+		});  
+
+//	}
+} 
+
+void PlaylistView::stop(const bool do_loop) {
+	if( is_active() ) {
+		replay_thread.reset();
+	}
+	if (do_loop) {
+		if (playlist_db.size() > 0 ) {
+			start();
+		} else {
+			playlist_db = playlist_masterdb;
+			start();
+		}
+	} else {
+		radio::set_antenna_bias(false);    //Turn off Bias Tee
+		radio::disable();
+		button_play.set_bitmap(&bitmap_play);
+	}
+	
+	ready_signal = false;
+}
+
+void PlaylistView::handle_replay_thread_done(const uint32_t return_code) {
+	if (return_code == ReplayThread::END_OF_FILE) {
+			stop(true);
+	} else if (return_code == ReplayThread::READ_ERROR) {
+		stop(false);
+		file_error();
+	}
+	
+	progressbar.set_value(0);
+}
+
+PlaylistView::PlaylistView(
+	NavigationView& nav
+) : nav_ (nav)
+{
+
+	tx_gain = 35;field_rfgain.set_value(tx_gain);  // Initial default  value (-12 dB's max ).
+	field_rfamp.set_value(rf_amp ? 14 : 0);  // Initial default value True. (TX RF amp on , +14dB's)
+
+	baseband::run_image(portapack::spi_flash::image_tag_replay);
+
+	add_children({
+		&labels,
+		&button_open,
+		&text_filename,
+		&text_sample_rate,
+		&text_duration,
+		&progressbar,
+		&field_frequency,
+		&field_rfgain, 
+		&field_rfamp,       // let's not use common rf_amp
+		&check_loop,
+		&button_play,
+		&waterfall,
+	});
+	
+	field_frequency.set_value(target_frequency());
+	field_frequency.set_step(receiver_model.frequency_step());
+	field_frequency.on_change = [this](rf::Frequency f) {
+		this->on_target_frequency_changed(f);
+	};
+	field_frequency.on_edit = [this, &nav]() {
+		// TODO: Provide separate modal method/scheme?
+		auto new_view = nav.push<FrequencyKeypadView>(this->target_frequency());
+		new_view->on_changed = [this](rf::Frequency f) {
+			this->on_target_frequency_changed(f);
+			this->field_frequency.set_value(f);
+		};
+	};
+
+	field_frequency.set_step(5000);
+	
+	button_play.on_select = [this](ImageButton&) {
+		this->toggle();
+	};
+	
+	button_open.on_select = [this, &nav](Button&) {
+		auto open_view = nav.push<FileLoadView>(".TXT");
+		open_view->on_changed = [this](std::filesystem::path new_file_path) {
+			load_file(new_file_path);
+		};
+	};
+}
+
+PlaylistView::~PlaylistView() {
+	radio::disable();
+	baseband::shutdown();
+}
+
+void PlaylistView::on_hide() {
+	stop(false);
+	// TODO: Terrible kludge because widget system doesn't notify Waterfall that
+	// it's being shown or hidden.
+	waterfall.on_hide();
+	View::on_hide();
+}
+
+void PlaylistView::set_parent_rect(const Rect new_parent_rect) {
+	View::set_parent_rect(new_parent_rect);
+
+	const ui::Rect waterfall_rect { 0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height };
+	waterfall.set_parent_rect(waterfall_rect);
+}
+
+void PlaylistView::on_target_frequency_changed(rf::Frequency f) {
+	set_target_frequency(f);
+}
+
+void PlaylistView::set_target_frequency(const rf::Frequency new_value) {
+	persistent_memory::set_tuned_frequency(new_value);;
+}
+
+rf::Frequency PlaylistView::target_frequency() const {
+	return persistent_memory::tuned_frequency();
+}
+
+} /* namespace ui */

firmware/application/apps/ui_playlist.hpp

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ *
+ * 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_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "replay_thread.hpp"
+#include "ui_spectrum.hpp"
+
+#include <string>
+#include <memory>
+#include <deque>
+
+namespace ui {
+
+class PlaylistView : public View {
+public:
+	PlaylistView(NavigationView& nav);
+	~PlaylistView();
+
+	void on_hide() override;
+	void set_parent_rect(const Rect new_parent_rect) override;
+	void focus() override;
+
+	std::string title() const override { return "Playlist"; };
+	
+private:
+	NavigationView& nav_;
+	
+	static constexpr ui::Dim header_height = 3 * 16;
+	
+	struct playlist_entry {
+		rf::Frequency replay_frequency { 0 };
+		std::string replay_file{};
+		uint32_t sample_rate{};
+		uint32_t next_delay{};
+	};
+	std::deque<playlist_entry> playlist_db{};
+	std::deque<playlist_entry> playlist_masterdb{};
+	uint32_t sample_rate = 0;
+	int32_t tx_gain { 47 };
+	bool rf_amp { true }; // aux private var to store temporal, Replay App rf_amp user selection.
+	static constexpr uint32_t baseband_bandwidth = 2500000;
+	const size_t read_size { 16384 };
+	const size_t buffer_count { 3 };
+	void load_file(std::filesystem::path playlist_path);
+	void txtline_process(std::string &);
+	void on_file_changed(std::filesystem::path new_file_path, rf::Frequency replay_frequency, uint32_t replay_sample_rate);
+	void on_target_frequency_changed(rf::Frequency f);
+	void on_tx_progress(const uint32_t progress);
+	
+	void set_target_frequency(const rf::Frequency new_value);
+	rf::Frequency target_frequency() const;
+
+	void toggle();
+	void start();
+	void stop(const bool do_loop);
+	bool is_active() const;
+	bool loop() const;
+	void set_ready();
+	void handle_replay_thread_done(const uint32_t return_code);
+	void file_error();
+
+	std::filesystem::path file_path { };
+	std::unique_ptr<ReplayThread> replay_thread { };
+	bool ready_signal { false };
+
+	Labels labels {
+		{ { 10 * 8, 2 * 16 }, "GAIN   A:", Color::light_grey() }
+	};
+	
+	Button button_open {
+		{ 0 * 8, 0 * 16, 10 * 8, 2 * 16 },
+		"Open file"
+	};
+
+	
+	Text text_filename {
+		{ 11 * 8, 0 * 16, 12 * 8, 16 },
+		"-"
+	};
+	Text text_sample_rate {
+		{ 24 * 8, 0 * 16, 6 * 8, 16 },
+		"-"
+	};
+	
+	Text text_duration {
+		{ 11 * 8, 1 * 16, 6 * 8, 16 },
+		"-"
+	};
+	ProgressBar progressbar {
+		{ 18 * 8, 1 * 16, 12 * 8, 16 }
+	};
+	
+	FrequencyField field_frequency {
+		{ 0 * 8, 2 * 16 },
+	};
+	
+	NumberField field_rfgain {
+		{ 14 * 8, 2 * 16 },
+		2,
+		{ 0, 47 },
+		1,
+		' '	
+	};
+	NumberField field_rfamp {     // previously  I was using "RFAmpField field_rf_amp" but that is general Receiver amp setting.
+		{ 19 * 8, 2 * 16 },
+		2,
+		{ 0, 14 },                // this time we will display GUI , 0 or 14 dBs same as Mic App
+		14,
+		' '
+	};
+	Checkbox check_loop {
+		{ 21 * 8, 2 * 16 },
+		4,
+		"Loop",
+		true
+	};
+	ImageButton button_play {
+		{ 28 * 8, 2 * 16, 2 * 8, 1 * 16 },
+		&bitmap_play,
+		Color::green(),
+		Color::black()
+	};
+
+	spectrum::WaterfallWidget waterfall { };
+
+	MessageHandlerRegistration message_handler_replay_thread_error {
+		Message::ID::ReplayThreadDone,
+		[this](const Message* const p) {
+			const auto message = *reinterpret_cast<const ReplayThreadDoneMessage*>(p);
+			this->handle_replay_thread_done(message.return_code);
+		}
+	};
+	
+	MessageHandlerRegistration message_handler_fifo_signal {
+		Message::ID::RequestSignal,
+		[this](const Message* const p) {
+			const auto message = static_cast<const RequestSignalMessage*>(p);
+			if (message->signal == RequestSignalMessage::Signal::FillRequest) {
+				this->set_ready();
+			}
+		}
+	};
+	
+	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);
+		}
+	};
+};
+
+} /* namespace ui */

firmware/application/apps/ui_pocsag_tx.cpp

@@ -23,6 +23,7 @@
 #include "ui_pocsag_tx.hpp"
 
 #include "baseband_api.hpp"
+#include "cpld_update.hpp"
 #include "string_format.hpp"
 #include "ui_textentry.hpp"
 
@@ -38,8 +39,13 @@ void POCSAGTXView::focus() {
 }
 
 POCSAGTXView::~POCSAGTXView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_pocsag", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify(); // to leave all RX ok, without ghost signal problem at the exit 
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void POCSAGTXView::on_tx_progress(const uint32_t progress, const bool done) {
@@ -141,6 +147,15 @@ POCSAGTXView::POCSAGTXView(
 		&tx_view
 	});
 
+	// load app settings
+	auto rc = settings.load("tx_pocsag", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}
+
 	options_bitrate.set_selected_index(1);	// 1200bps
 	options_type.set_selected_index(0);		// Address only
 	

firmware/application/apps/ui_pocsag_tx.hpp

@@ -31,6 +31,7 @@
 #include "bch_code.hpp"
 #include "message.hpp"
 #include "transmitter_model.hpp"
+#include "app_settings.hpp"
 #include "pocsag.hpp"
 
 using namespace pocsag;
@@ -62,6 +63,10 @@ private:
 		5, 31, 21, 2
 	};
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
 	void on_set_text(NavigationView& nav);
 	void on_tx_progress(const uint32_t progress, const bool done);
 	bool start_tx();

firmware/application/apps/ui_rds.cpp

@@ -24,6 +24,7 @@
 
 #include "portapack.hpp"
 #include "baseband_api.hpp"
+#include "cpld_update.hpp"
 #include "portapack_shared_memory.hpp"
 
 #include <cstring>
@@ -175,8 +176,13 @@ void RDSView::focus() {
 }
 
 RDSView::~RDSView() {
+	// save app settings
+	app_settings.tx_frequency = transmitter_model.tuning_frequency();	
+	settings.save("tx_rds", &app_settings);
+
 	transmitter_model.disable();
-	baseband::shutdown();
+	hackrf::cpld::load_sram_no_verify();  // to leave all RX ok, without ghost signal problem at the exit.
+	baseband::shutdown(); // better this function at the end, not load_sram() that sometimes produces hang up.
 }
 
 void RDSView::start_tx() {
@@ -226,11 +232,17 @@ RDSView::RDSView(
 		&view_radiotext,
 		&view_datetime,
 		&view_audio,
-		//&options_countrycode,
-		//&options_coverage,
 		&tx_view,
 	});
-	
+
+	// load app settings
+	auto rc = settings.load("tx_rds", &app_settings);
+	if(rc == SETTINGS_OK) {
+		transmitter_model.set_rf_amp(app_settings.tx_amp);
+		transmitter_model.set_channel_bandwidth(app_settings.channel_bandwidth);
+		transmitter_model.set_tuning_frequency(app_settings.tx_frequency);
+		transmitter_model.set_tx_gain(app_settings.tx_gain);		
+	}	
 	check_TP.set_value(true);
 	
 	sym_pi_code.set_sym(0, 0xF);
@@ -242,8 +254,6 @@ RDSView::RDSView(
 	};
 	
 	options_pty.set_selected_index(0);				// None
-	//options_countrycode.set_selected_index(18);		// Baguette du fromage
-	//options_coverage.set_selected_index(0);			// Local
 	
 	tx_view.on_edit_frequency = [this, &nav]() {
 		auto new_view = nav.push<FrequencyKeypadView>(receiver_model.tuning_frequency());

firmware/application/apps/ui_rds.hpp

@@ -24,7 +24,7 @@
 #include "ui_transmitter.hpp"
 #include "ui_textentry.hpp"
 #include "ui_tabview.hpp"
-
+#include "app_settings.hpp"
 #include "rds.hpp"
 
 using namespace rds;
@@ -144,12 +144,17 @@ public:
 	
 	void focus() override;
 
-	std::string title() const override { return "RDS transmit"; };
+	std::string title() const override { return "RDS TX"; };
 
 private:
 	NavigationView& nav_;
 	RDS_flags rds_flags { };
 	
+	// app save settings
+	std::app_settings 		settings { }; 		
+	std::app_settings::AppSettings 	app_settings { };
+
+
 	std::vector<RDSGroup> frame_psn { };
 	std::vector<RDSGroup> frame_radiotext { };
 	std::vector<RDSGroup> frame_datetime { };

firmware/application/apps/ui_recon.hpp

@@ -0,0 +1,428 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2018 Furrtek
+ *
+ * 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_RECON
+#define _UI_RECON
+
+#include "ui.hpp"
+#include "receiver_model.hpp"
+#include "ui_receiver.hpp"
+#include "ui_font_fixed_8x16.hpp"
+#include "freqman.hpp"
+#include "analog_audio_app.hpp"
+#include "audio.hpp"
+#include "ui_mictx.hpp"
+#include "ui_level.hpp"
+#include "ui_looking_glass_app.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "file.hpp"
+#include "app_settings.hpp"
+
+// maximum usable freq
+#define MAX_UFREQ 7200000000
+
+namespace ui {
+
+	class ReconThread {
+		public:
+			ReconThread(freqman_db *database );
+			~ReconThread();
+
+			void set_recon(const bool v);
+			void set_freq_delete(const bool v);
+			bool is_recon();
+
+			void set_lock_duration( const uint32_t v );
+			uint32_t get_lock_duration();
+			void set_lock_nb_match( const uint32_t v );
+			void set_match_mode( const uint32_t v );
+			uint32_t get_lock_nb_match();
+
+			void set_freq_lock(const uint32_t v);
+			uint32_t is_freq_lock();
+			int64_t get_current_freq();
+
+			void set_stepper(const int64_t v);
+			void set_index_stepper(const int64_t v);
+
+			void change_recon_direction();
+			bool get_recon_direction();
+			void set_recon_direction( const bool v);
+
+			void set_continuous(const bool v);
+
+			void set_default_modulation( freqman_index_t index );
+			freqman_index_t get_current_modulation();
+			void set_default_bandwidth( freqman_index_t index );
+			freqman_index_t get_current_bandwidth();
+			void set_default_step( freqman_index_t index );
+			void set_freq_index( int16_t index );
+			int16_t get_freq_index();
+
+			void run();
+			void stop();
+
+			ReconThread(const ReconThread&) = delete;
+			ReconThread(ReconThread&&) = delete;
+			ReconThread& operator=(const ReconThread&) = delete;
+			ReconThread& operator=(ReconThread&&) = delete;
+
+		private:
+			freqman_db &frequency_list_ ;
+			Thread* thread { nullptr };
+			int64_t freq = 0 ;
+			uint32_t step = 0 ;
+			freqman_index_t def_modulation  = 0 ;
+			freqman_index_t def_bandwidth = 0 ;
+			freqman_index_t def_step = 0 ;
+			tone_index tone = 0 ;
+			freqman_entry last_entry = { } ;
+			int16_t frequency_index = 0 ;
+
+			bool _recon { true };
+			bool _freq_delete { false };
+			bool _fwd { true };
+			bool _continuous { true };
+			bool entry_has_changed = false ;
+			int64_t _stepper { 0 };
+			int64_t _index_stepper { 0 };
+			int32_t _freq_lock { 0 };
+			uint32_t _lock_duration { 50 };
+			uint32_t _lock_nb_match { 10 };
+			static msg_t static_fn(void* arg);
+	};
+
+	class ReconView : public View {
+		public:
+			ReconView(NavigationView& nav);
+			~ReconView();
+
+			void focus() override;
+
+			const Style style_grey {		// recon
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::grey(),
+			};
+
+			const Style style_white {		// recon
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::white(),
+			};
+
+			const Style style_yellow {		//Found signal
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::yellow(),
+			};
+
+			const Style style_green {		//Found signal
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::green(),
+			};
+
+			const Style style_red {		//erasing freq
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::red(),
+			};
+
+			const Style style_blue {		// quick recon, wait == 0
+				.font = font::fixed_8x16,
+					.background = Color::black(),
+					.foreground = Color::blue(),
+			};
+
+			std::string title() const override { return "Recon"; };
+
+			//void set_parent_rect(const Rect new_parent_rect) override;
+
+		private:
+			NavigationView& nav_;
+
+			void start_recon_thread();
+			size_t change_mode( freqman_index_t mod_type);
+			void show_max( bool refresh_display = false );
+			void recon_pause();
+			void recon_resume();
+			void user_pause();
+			void user_resume();
+			void frequency_file_load( bool stop_all_before = false);
+			void on_statistics_update(const ChannelStatistics& statistics);
+			void on_headphone_volume_changed(int32_t v);
+			void set_display_freq( int64_t freq );
+			void handle_retune( int64_t freq , uint32_t index );
+			bool check_sd_card();
+			void handle_coded_squelch(const uint32_t value);
+
+			jammer::jammer_range_t frequency_range { false, 0, MAX_UFREQ };  //perfect for manual recon task too...
+			int32_t squelch { 0 };
+			int32_t db { 0 };
+			int32_t timer { 0 };
+			int32_t wait { 5000 };   // in msec. if > 0 wait duration after a lock, if < 0 duration is set to 'wait' unless there is no more activity
+			uint32_t lock_wait { 500 }; // in msec. Represent the maximum amount of time we will wait for a lock to complete before switching to next
+			int32_t def_step { 0 };
+			freqman_db frequency_list  = { };
+			uint32_t current_index { 0 };
+			bool userpause { false };
+			bool continuous_lock { false };
+			std::string input_file = { "RECON" };
+			std::string output_file = { "RECON_RESULTS" };
+			bool autosave    = { true };
+			bool autostart   = { true };
+			bool continuous  = { true }; 
+			bool filedelete  = { true };
+			bool load_freqs  = { true };
+			bool load_ranges = { true };
+			bool load_hamradios = { true };
+			bool update_ranges = { true };
+			bool fwd = { true };
+			uint32_t recon_lock_nb_match = { 10 };
+			uint32_t recon_lock_duration = { 50 };
+			uint32_t recon_match_mode = { 0 };
+			bool scanner_mode { false };
+			bool manual_mode { false };
+			bool sd_card_mounted = false ;
+			int32_t volume = 40 ;
+
+			Labels labels 
+			{ 
+				{ { 0  * 8 , 0  * 16      }, "LNA:   VGA:   AMP:  VOL:     ", Color::light_grey() },
+					{ { 0  * 8 , 1  * 16      }, "BW:      SQ:    W,L:     ,     ", Color::light_grey() },
+					{ { 3  * 8 , 10 * 16      }, "START       END     MANUAL", Color::light_grey() },
+					{ { 0  * 8 , (26 * 8) + 4 }, "MODE:", Color::light_grey() },
+					{ { 11 * 8 , (26 * 8) + 4 }, "STEP:", Color::light_grey() },
+			};
+
+			LNAGainField field_lna {
+				{ 4 * 8, 0 * 16 }
+			};
+
+			VGAGainField field_vga {
+				{ 11 * 8, 0 * 16 }
+			};
+
+			RFAmpField field_rf_amp {
+				{ 18 * 8, 0 * 16 }
+			};
+
+			NumberField field_volume {
+				{ 24 * 8, 0 * 16 },
+					2,
+					{ 0, 99 },
+					1,
+					' ',
+			};
+
+			OptionsField field_bw {
+				{ 3 * 8, 1 * 16 },
+					6,
+					{ }
+			};		
+
+			NumberField field_squelch {
+				{ 12 * 8, 1 * 16 },
+					3,
+					{ -90, 20 },
+					1,
+					' ',
+			};
+
+			NumberField field_wait {
+				{ 20 * 8, 1 * 16 },
+					5,
+					{ -9000, 9000 },
+					100,
+					' ',
+			};
+
+			NumberField field_lock_wait {
+				{ 26 * 8, 1 * 16 },
+					4,
+					{ 100 , 9000 },
+					100,
+					' ',
+			};
+
+			RSSI rssi {
+				{ 0 * 16, 2 * 16, 240 - 8 * 8 + 4 , 16 },
+			}; 
+
+			ButtonWithEncoder text_cycle {
+				{ 0, 3 * 16, 4 * 8, 16 },  
+					""
+			};
+
+			Text text_max {
+				{ 4 * 8, 3 * 16, 240 - 7 * 8 - 4 * 8 , 16 },  
+			};
+
+			Text desc_cycle {
+				{0, 4 * 16, 240 , 16 },	   
+			};
+
+			/* BigFrequency big_display {		//Show frequency in glamour
+			   { 4, 7 * 16 - 8 , 28 * 8, 52 },
+			   0
+			   }; */
+
+			Text big_display {		//Show frequency in text mode
+				{ 0, 5 * 16 , 23 * 8, 16 },
+			};
+
+			Text freq_stats {		//Show frequency stats in text mode
+				{ 0, 6 * 16 , 23 * 8, 16 },
+			};
+
+			// TIMER: 9999
+			Text text_timer {		//Show frequency stats in text mode
+				{ 0, 7 * 16 , 11 * 8, 16 },
+			};
+
+			// T: Senn. 32.000k
+			Text text_ctcss {
+				{ 12 * 8 + 4, 7 * 16 , 14 * 8, 1 * 8 },
+					""
+			};
+
+			Button button_recon_setup {
+				{ 240 - 7 * 8 , 2 * 16 , 7 * 8, 28 },
+					"CONFIG"
+			};
+
+			Button button_looking_glass {
+				{ 240 - 7 * 8 , 5 * 16 , 7 * 8, 28 },
+					"GLASS"
+			};
+
+			// Button can be RECON or SCANNER
+			Button button_scanner_mode {
+				{ 240 - 7 * 8 , 8 * 16 , 7 * 8, 28 },
+					"RECON"
+			};
+
+			Text file_name {		//Show file used
+				{ 0 , 8 * 16 + 6 , 240 - 7 * 8, 16 },
+			};
+
+			ButtonWithEncoder button_manual_start {
+				{ 0 * 8, 11 * 16, 11 * 8, 28 },
+					""
+			};
+
+			ButtonWithEncoder button_manual_end {
+				{ 12 * 8 - 6, 11 * 16, 11 * 8, 28 },
+					""
+			};
+
+			Button button_manual_recon {
+				{ 23 * 8 - 3, 11 * 16, 7 * 8 , 28 },
+					"SEARCH"
+			};
+
+			OptionsField field_mode {
+				{ 5 * 8, (26 * 8) + 4 },
+					6,
+					{
+					}
+			};
+
+			OptionsField step_mode {
+				{ 17 * 8, (26 * 8) + 4 },
+					12,
+					{
+					}
+			};
+
+			ButtonWithEncoder button_pause {
+				{ 0, (15 * 16) - 4, 72, 28 },
+					"PAUSE"
+			}; 
+
+
+			Button button_audio_app {
+				{ 84, (15 * 16) - 4, 72, 28 },
+					"AUDIO"
+			};
+
+			ButtonWithEncoder button_add {
+				{ 168, (15 * 16) - 4, 72, 28 },
+					"<STORE>"
+			};
+
+			Button button_dir {
+				{ 0,  (35 * 8) - 4, 34, 28 },
+					"FW>"
+			};
+
+			Button button_restart {
+				{ 38, (35 * 8) - 4, 34, 28 },
+					"RST"
+			};
+
+
+			Button button_mic_app {
+				{ 84,  (35 * 8) - 4, 72, 28 },
+					"MIC TX"
+			};
+
+			ButtonWithEncoder button_remove {
+				{ 168, (35 * 8) - 4, 72, 28 },
+					"<REMOVE>"
+			};
+
+			std::unique_ptr<ReconThread> recon_thread { };
+
+			MessageHandlerRegistration message_handler_coded_squelch {
+				Message::ID::CodedSquelch,
+					[this](const Message* const p) {
+						const auto message = *reinterpret_cast<const CodedSquelchMessage*>(p);
+						this->handle_coded_squelch(message.value);
+					}
+			};
+
+			MessageHandlerRegistration message_handler_retune {
+				Message::ID::Retune,
+					[this](const Message* const p) {
+						const auto message = *reinterpret_cast<const RetuneMessage*>(p);
+						this->handle_retune(message.freq,message.range);
+					}
+			};
+
+			MessageHandlerRegistration message_handler_stats {
+				Message::ID::ChannelStatistics,
+					[this](const Message* const p) {
+						this->on_statistics_update(static_cast<const ChannelStatisticsMessage*>(p)->statistics);
+					}
+			};
+			// app save settings
+			std::app_settings settings { }; 		
+			std::app_settings::AppSettings app_settings { };
+	};
+
+} /* namespace ui */
+
+#endif

firmware/application/apps/ui_recon_settings.cpp

@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ *
+ * 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_recon_settings.hpp"
+#include "ui_navigation.hpp"
+#include "ui_fileman.hpp"
+#include "ui_textentry.hpp"
+
+#include "file.hpp"
+#include "portapack.hpp"
+#include "portapack_persistent_memory.hpp"
+
+using namespace std;
+using namespace portapack;
+
+namespace ui {
+
+	bool ReconSetupLoadStrings( std::string source, std::string &input_file , std::string &output_file , uint32_t &recon_lock_duration , uint32_t &recon_lock_nb_match , int32_t &recon_squelch_level , uint32_t &recon_match_mode , int32_t &wait , uint32_t &lock_wait , int32_t &volume )
+	{
+		File settings_file;
+		size_t length, file_position = 0;
+		char * pos;
+		char * line_start;
+		char * line_end;
+		char file_data[257];
+
+		uint32_t it = 0 ;
+		uint32_t nb_params = 9 ;
+		std::string params[ 9 ];
+
+		bool check_sd_card = (sd_card::status() == sd_card::Status::Mounted) ? true : false ;
+
+		if( check_sd_card )
+		{
+			auto result = settings_file.open( source );
+			if( !result.is_valid() )
+			{
+				while( it < nb_params )
+				{
+					// Read a 256 bytes block from file
+					settings_file.seek(file_position);
+					memset(file_data, 0, 257);
+					auto read_size = settings_file.read(file_data, 256);
+					if (read_size.is_error())
+						break ;
+					file_position += 256;
+					// Reset line_start to beginning of buffer
+					line_start = file_data;
+					pos=line_start;
+					while ((line_end = strstr(line_start, "\x0A"))) {
+						length = line_end - line_start - 1 ;
+						params[ it ]  = string( pos , length );
+						it ++ ;	
+						line_start = line_end + 1;
+						pos=line_start ;
+						if (line_start - file_data >= 256) 
+							break;
+						if( it >= nb_params )
+							break ;
+					}			
+					if (read_size.value() != 256)
+						break;	// End of file
+
+					// Restart at beginning of last incomplete line
+					file_position -= (file_data + 256 - line_start);
+				}
+			}
+
+		}
+
+		if( it > 0 )
+			input_file = params[ 0 ];
+		else
+			input_file  = "RECON" ;
+
+		if( it > 1 )
+			output_file= params[ 1 ];
+		else
+			output_file = "RECON_RESULTS" ;	
+
+		if( it > 2 )
+			recon_lock_duration = strtoll( params[ 2 ].c_str() , nullptr , 10 );
+		else
+			recon_lock_duration = 50 ;
+
+		if( it > 3 )
+			recon_lock_nb_match = strtoll( params[ 3 ].c_str() , nullptr , 10 );
+		else
+			recon_lock_nb_match = 10 ;
+
+		if( it > 4 )
+			recon_squelch_level = strtoll( params[ 4 ].c_str() , nullptr , 10 );
+		else
+			recon_squelch_level = -14 ;
+
+		if( it > 5 )
+			recon_match_mode    = strtoll( params[ 5 ].c_str() , nullptr , 10 );
+		else
+			recon_match_mode = 0 ;
+
+		if( it > 6 )
+			wait = strtoll( params[ 6 ].c_str() , nullptr , 10 );
+		else
+			wait = 5000 ;
+
+		if( it > 7 )
+			lock_wait = strtoll( params[ 7 ].c_str() , nullptr , 10 );
+		else
+			lock_wait = 1000 ;
+
+		if( it > 8 )
+			volume = strtoll( params[ 8 ].c_str() , nullptr , 10 );
+		else
+			volume = 40 ;
+
+		if( it < nb_params )
+		{
+			/* bad number of params, signal defaults */
+			return false ;
+		}
+		return true ;
+	}
+
+	bool ReconSetupSaveStrings( std::string dest, std::string input_file , std::string output_file , uint32_t recon_lock_duration , uint32_t recon_lock_nb_match , int32_t recon_squelch_level , uint32_t recon_match_mode , int32_t wait , uint32_t lock_wait , int32_t volume )
+	{
+		File settings_file;
+
+		auto result = settings_file.create( dest );
+		if( result.is_valid() )
+			return false ;
+		settings_file.write_line( input_file );
+		settings_file.write_line( output_file );
+		settings_file.write_line( to_string_dec_uint( recon_lock_duration ) );
+		settings_file.write_line( to_string_dec_uint( recon_lock_nb_match ) );
+		settings_file.write_line( to_string_dec_int( recon_squelch_level ) );
+		settings_file.write_line( to_string_dec_uint( recon_match_mode ) );
+		settings_file.write_line( to_string_dec_int( wait ) );
+		settings_file.write_line( to_string_dec_uint( lock_wait ) );
+		settings_file.write_line( to_string_dec_int( volume ) );
+		return true ;
+	}
+
+	ReconSetupViewMain::ReconSetupViewMain( NavigationView &nav , Rect parent_rect , std::string input_file , std::string output_file ) : View( parent_rect ) , _input_file { input_file } , _output_file { output_file } 
+	{
+		hidden(true);
+		add_children({
+				&button_load_freqs,
+				&text_input_file,
+				&button_save_freqs,
+				&button_output_file,
+				&checkbox_autosave_freqs,
+				&checkbox_autostart_recon,
+				&checkbox_continuous,
+				&checkbox_clear_output
+				});
+
+		checkbox_autosave_freqs.set_value( persistent_memory::recon_autosave_freqs() );
+		checkbox_autostart_recon.set_value( persistent_memory::recon_autostart_recon() );
+		checkbox_continuous.set_value( persistent_memory::recon_continuous() );
+		checkbox_clear_output.set_value( persistent_memory::recon_clear_output() );
+
+		text_input_file.set( _input_file );	
+		button_output_file.set_text( _output_file );	
+
+		button_load_freqs.on_select = [this, &nav](Button&) {
+			auto open_view = nav.push<FileLoadView>(".TXT");
+			open_view->on_changed = [this,&nav](std::filesystem::path new_file_path) {
+				std::string dir_filter = "FREQMAN/";
+				std::string str_file_path = new_file_path.string();
+				if (str_file_path.find(dir_filter) != string::npos) { // assert file from the FREQMAN folder
+																	  // get the filename without txt extension so we can use load_freqman_file fcn
+					_input_file = new_file_path.stem().string();
+					text_input_file.set( _input_file );
+				} else {
+					nav.display_modal("LOAD ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
+				}
+			};
+		};
+
+		button_save_freqs.on_select = [this, &nav](Button&) {
+			auto open_view = nav.push<FileLoadView>(".TXT");
+			open_view->on_changed = [this,&nav](std::filesystem::path new_file_path) {
+				std::string dir_filter = "FREQMAN/";
+				std::string str_file_path = new_file_path.string();
+				if (str_file_path.find(dir_filter) != string::npos) { // assert file from the FREQMAN folder
+					_output_file = new_file_path.stem().string();
+					button_output_file.set_text( _output_file );	
+				} else {
+					nav.display_modal("LOAD ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
+				}
+			};
+		};
+
+		button_output_file.on_select =[this, &nav](Button&) {
+			text_prompt( nav, _output_file , 28 ,
+					[this](std::string& buffer) {
+					_output_file = buffer ;
+					button_output_file.set_text( _output_file );
+					}   );
+		};
+	};
+
+	void ReconSetupViewMain::Save( std::string &input_file , std::string &output_file ) {
+		persistent_memory::set_recon_autosave_freqs(checkbox_autosave_freqs.value());
+		persistent_memory::set_recon_autostart_recon(checkbox_autostart_recon.value());
+		persistent_memory::set_recon_continuous(checkbox_continuous.value()); 
+		persistent_memory::set_recon_clear_output(checkbox_clear_output.value()); 
+		input_file=_input_file ;
+		output_file=_output_file ;
+	};
+	void ReconSetupViewMore::Save( uint32_t &recon_lock_duration , uint32_t &recon_lock_nb_match , uint32_t &recon_match_mode ) {
+		persistent_memory::set_recon_load_freqs(checkbox_load_freqs.value()); 
+		persistent_memory::set_recon_load_ranges(checkbox_load_ranges.value()); 
+		persistent_memory::set_recon_load_hamradios(checkbox_load_hamradios.value()); 
+		persistent_memory::set_recon_update_ranges_when_recon(checkbox_update_ranges_when_recon.value()); 
+		recon_lock_duration = field_recon_lock_duration.value();
+		recon_lock_nb_match = field_recon_lock_nb_match.value();
+		recon_match_mode    = field_recon_match_mode . selected_index_value() ;
+	};
+
+	void ReconSetupViewMain::focus() {
+		button_load_freqs.focus();
+	}
+
+	ReconSetupViewMore::ReconSetupViewMore( NavigationView &nav , Rect parent_rect , uint32_t recon_lock_duration , uint32_t recon_lock_nb_match , uint32_t recon_match_mode ) : View( parent_rect ), _recon_lock_duration { recon_lock_duration } , _recon_lock_nb_match { recon_lock_nb_match } , _recon_match_mode { recon_match_mode } 
+	{
+		(void)nav;
+		hidden(true);
+
+		add_children({
+				&checkbox_load_freqs,
+				&checkbox_load_ranges,
+				&checkbox_load_hamradios,
+				&checkbox_update_ranges_when_recon,
+				&text_recon_lock_duration,
+				&field_recon_lock_duration,
+				&text_recon_lock_nb,
+				&field_recon_lock_nb_match,
+				&field_recon_match_mode,
+				});
+
+		checkbox_load_freqs.set_value( persistent_memory::recon_load_freqs() );
+		checkbox_load_ranges.set_value( persistent_memory::recon_load_ranges() );
+		checkbox_load_hamradios.set_value( persistent_memory::recon_load_hamradios() );
+		checkbox_update_ranges_when_recon.set_value( persistent_memory::recon_update_ranges_when_recon() );
+		field_recon_lock_duration.set_value( _recon_lock_duration ); 
+		field_recon_lock_nb_match.set_value( _recon_lock_nb_match ); 
+		field_recon_match_mode.set_by_value( _recon_match_mode ); 
+	};
+
+	void ReconSetupViewMore::focus() {
+		checkbox_load_freqs.focus();
+	}
+
+	void ReconSetupView::focus() {
+		viewMain.focus();
+	}
+
+	ReconSetupView::ReconSetupView(
+			NavigationView& nav , std::string _input_file , std::string _output_file , uint32_t _recon_lock_duration , uint32_t _recon_lock_nb_match , uint32_t _recon_match_mode ) : nav_ { nav } , input_file { _input_file } , output_file { _output_file } , recon_lock_duration { _recon_lock_duration } , recon_lock_nb_match { _recon_lock_nb_match } , recon_match_mode { _recon_match_mode } 
+	{
+		add_children({
+				&tab_view,
+				&viewMain,
+				&viewMore,
+				&button_save
+				});
+
+		button_save.on_select = [this,&nav](Button&) {
+			viewMain.Save( input_file , output_file );
+			viewMore.Save( recon_lock_duration , recon_lock_nb_match , recon_match_mode );
+			std::vector<std::string> messages ;
+			messages.push_back( input_file );
+			messages.push_back( output_file );
+			messages.push_back( to_string_dec_uint( recon_lock_duration ) );
+			messages.push_back( to_string_dec_uint( recon_lock_nb_match ) );
+			messages.push_back( to_string_dec_uint( recon_match_mode ) );
+			on_changed( messages );
+			nav.pop();
+		};
+	}
+} /* namespace ui */

firmware/application/apps/ui_recon_settings.hpp

@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ *
+ * 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 "serializer.hpp"
+#include "ui.hpp"
+#include "ui_widget.hpp"
+#include "ui_tabview.hpp"
+#include "ui_navigation.hpp"
+#include "string_format.hpp"
+
+namespace ui {
+
+	bool ReconSetupLoadStrings( std::string source, std::string &input_file , std::string &output_file , uint32_t &recon_lock_duration , uint32_t &recon_lock_nb_match , int32_t &recon_squelch_level , uint32_t &recon_match_mode , int32_t &wait , uint32_t &lock_wait , int32_t &volume );
+	bool ReconSetupSaveStrings( std::string dest, const std::string input_file , const std::string output_file , const uint32_t recon_lock_duration , const uint32_t recon_lock_nb_match , int32_t recon_squelch_level , uint32_t recon_match_mode , int32_t wait , uint32_t lock_wait , int32_t volume );
+
+	class ReconSetupViewMain : public View {
+		public:
+			ReconSetupViewMain( NavigationView& nav, Rect parent_rect , std::string input_file , std::string output_file );
+			void Save( std::string &input_file , std::string &output_file );
+			void focus() override;
+
+		private:
+			std::string _input_file  = { "RECON" };
+			std::string _output_file = { "RECON_RESULTS" };
+
+			Button button_load_freqs {
+				{ 1 * 8 , 12 , 18 * 8 , 22 },
+					"select input file"
+			};
+			Text text_input_file {
+				{ 1 * 8 , 4 + 2 * 16, 18 * 8, 22 },  
+					"RECON"
+			};
+
+			Button button_save_freqs {
+				{ 1 * 8 , 4 * 16 - 8 , 18 * 8 , 22 },
+					"select output file"
+			};
+			Button button_output_file {
+				{ 1 * 8 , 5 * 16 - 2, 18 * 8, 22 },  
+					"RECON_RESULTS"	
+			};
+
+			Checkbox checkbox_autosave_freqs {
+				{ 1 * 8, 7 * 16 - 4 },
+					3,
+					"autosave freqs"
+			};
+
+			Checkbox checkbox_autostart_recon {
+				{ 1 * 8, 9 * 16 - 4 },
+					3,
+					"autostart recon"
+			};
+
+			Checkbox checkbox_continuous {
+				{ 1 * 8, 11 * 16 - 4 },
+					3,
+					"continuous"
+			};
+			Checkbox checkbox_clear_output {
+				{ 1 * 8, 13 * 16 - 4 },
+					3,
+					"clear output at start"
+			};
+	};
+
+	class ReconSetupViewMore : public View {
+		public:
+			ReconSetupViewMore( NavigationView& nav, Rect parent_rect , const uint32_t _recon_lock_duration , const uint32_t _recon_lock_nb_match , const uint32_t _recon_match_mode );
+
+			void Save( uint32_t &recon_lock_duration , uint32_t &recon_lock_nb_match , uint32_t &recon_match_mode );
+
+			void focus() override;
+
+		private:
+
+			const uint32_t _recon_lock_duration = 50 ;
+			const uint32_t _recon_lock_nb_match = 10 ;
+			const uint32_t _recon_match_mode = 0 ;
+
+			Checkbox checkbox_load_freqs {
+				{ 1 * 8, 12 },
+					3,
+					"input: load freqs"
+			};
+
+			Checkbox checkbox_load_ranges {
+				{ 1 * 8, 42 },
+					3,
+					"input: load ranges"
+			};
+
+			Checkbox checkbox_load_hamradios {
+				{ 1 * 8, 72 },
+					3,
+					"input: load hamradios"
+			};
+
+			Checkbox checkbox_update_ranges_when_recon {
+				{ 1 * 8, 102 },
+					3,
+					"auto update m-ranges"
+			};
+			Text text_recon_lock_duration {
+				{ 1 * 8 , 132 , 22 * 8 , 22 },  
+					"    ms (lock duration)"
+			};
+			NumberField field_recon_lock_duration {
+				{ 1 * 8, 132 },             // position X , Y
+					4,                      // number of displayed digits (even empty)
+					{ 50 , 990 },           // range of number
+					10,                     // rotary encoder increment
+					' ',                    // filling character 
+					false                   // can loop
+			};
+			Text text_recon_lock_nb {
+				{ 1 * 8 , 162 , 25 * 8 , 22 },  
+					"    x (nb lock to match freq)"
+			};
+			NumberField field_recon_lock_nb_match {
+				{ 1 * 8, 162 },
+					4,
+					{ 1, 99 },
+					1,
+					' ',
+					false
+			};
+			OptionsField field_recon_match_mode {
+				{ 1 * 8, 192 },
+					20,   // CONTINUOUS MATCH MODE / SPARSE TIMED MATCH MODE
+					{
+						{ "SQL MATCH: CONTINOUS" , 0 },
+						{ "SQL MATCH: SPARSE" , 1 }
+					}
+			};
+	};
+
+
+	class ReconSetupView : public View {
+		public:
+			ReconSetupView( NavigationView& nav , std::string _input_file , std::string _output_file , const uint32_t _recon_lock_duration , const uint32_t _recon_lock_nb_match , const uint32_t _recon_match_mode );
+
+			std::function<void( std::vector<std::string> messages )> on_changed { };
+
+			void focus() override;
+
+			std::string title() const override { return "Recon setup"; };
+
+		private:
+
+			NavigationView& nav_ ;
+
+			std::string input_file  = { "RECON" };
+			std::string output_file = { "RECON_RESULTS" };
+			uint32_t recon_lock_duration = 50 ;
+			uint32_t recon_lock_nb_match = 10 ;
+			uint32_t recon_match_mode = 0 ;
+
+			Rect view_rect = { 0, 3 * 8, 240, 230 };
+
+			ReconSetupViewMain viewMain{ nav_ , view_rect , input_file , output_file };
+			ReconSetupViewMore viewMore{ nav_ , view_rect , recon_lock_duration , recon_lock_nb_match , recon_match_mode };
+
+			TabView tab_view {
+				{ "Main", Color::cyan() , &viewMain },
+					{ "More", Color::green(), &viewMore }
+			};
+			Button button_save {
+				{ 9 * 8, 255, 14 * 8 , 40 },
+					"SAVE"
+			};
+	};
+
+} /* namespace ui */