V1.9.1 (#1691)

* Update past_version.txt

* Update version.txt

.github/workflows/create_nightly_release.yml

@@ -49,7 +49,7 @@ jobs:
         run: docker run -e VERSION_STRING=${{ steps.version_date.outputs.date }} -i -v ${{ github.workspace }}:/havoc portapack-dev
       - name: Create Small SD Card ZIP - No World Map
         run: |
-          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-h1_h2-mayhem.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version_date.outputs.date }}.bin && zip -r sdcard-no-map.zip sdcard
+          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-h1_h2-mayhem.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version_date.outputs.date }}.bin && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && zip -r sdcard-no-map.zip sdcard
       - name: Download world map
         run: |
           wget https://github.com/eried/portapack-mayhem/releases/download/world_map/world_map.zip
@@ -61,7 +61,7 @@ jobs:
           zip -j firmware.zip build/firmware/portapack-h1_h2-mayhem.bin && cd flashing && zip -r ../firmware.zip *
       - name: Create SD Card ZIP
         run: |
-          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-h1_h2-mayhem.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version_date.outputs.date }}.bin && zip -r sdcard.zip sdcard
+          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-h1_h2-mayhem.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version_date.outputs.date }}.bin && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && zip -r sdcard.zip sdcard
       - name: Create changelog
         env:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}

.github/workflows/create_stable_release.yml

@@ -33,7 +33,7 @@ jobs:
         run: docker run -e VERSION_STRING=${{ steps.version.outputs.version }} -i -v ${{ github.workspace }}:/havoc portapack-dev
       - name: Create Small SD Card ZIP - No World Map
         run: |
-          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-h1_h2-mayhem.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version.outputs.version }}.bin && zip -r sdcard-no-map.zip sdcard
+          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-h1_h2-mayhem.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version.outputs.version }}.bin && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && zip -r sdcard-no-map.zip sdcard
       - name: Download world map
         run: |
           wget https://github.com/eried/portapack-mayhem/releases/download/world_map/world_map.zip
@@ -45,7 +45,7 @@ jobs:
           zip -j firmware.zip build/firmware/portapack-h1_h2-mayhem.bin && cd flashing && zip -r ../firmware.zip *
       - name: Create SD Card ZIP
         run: |
-          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-h1_h2-mayhem.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version.outputs.version }}.bin && zip -r sdcard.zip sdcard
+          mkdir -p sdcard/FIRMWARE && cp build/firmware/portapack-h1_h2-mayhem.bin sdcard/FIRMWARE/portapack-mayhem_${{ steps.version.outputs.version }}.bin && mkdir -p sdcard/APPS && cp build/firmware/application/*.ppma sdcard/APPS && zip -r sdcard.zip sdcard
       - name: Create changelog
         env:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}

.github/workflows/past_version.txt

@@ -1 +1 @@
-v1.7.3
+v1.9.0

.github/workflows/version.txt

@@ -1 +1 @@
-v1.7.4
+v1.9.1

.gitignore

@@ -55,10 +55,11 @@ CMakeFiles/
 # Debugging
 .gdbinit*
 
-# Editor files
+# Editor/IDE files
 *.sublime-project
 *.sublime-workspace
 .vscode
+.idea
 
 # VSCodium extensions
 .history

CMakeLists.txt

@@ -42,6 +42,12 @@ if ("$ENV{VERSION_STRING}" STREQUAL "")
 	endif (GIT_VERSION_FOUND)
 endif()
 
+execute_process(
+	COMMAND bash "-c" "echo ${VERSION} | md5sum | head -c 8"
+	OUTPUT_VARIABLE VERSION_MD5
+)
+set(VERSION_MD5 "0x${VERSION_MD5}")
+
 set(LICENSE_PATH ${CMAKE_CURRENT_LIST_DIR}/LICENSE)
 set(HARDWARE_PATH ${CMAKE_CURRENT_LIST_DIR}/hardware)
 

README.md

@@ -1,6 +1,6 @@
 # PortaPack Mayhem
 
-[![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)
+[![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://dcbadge.vercel.app/api/server/tuwVMv3?style=flat)](https://discord.gg/tuwVMv3)
 
 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.
 
@@ -8,11 +8,11 @@ This is a fork of the [Havoc](https://github.com/furrtek/portapack-havoc/) firmw
 
 *[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
+# What is this?
 
-If you are new to *HackRF+PortaPack+Mayhem*, there is an awesome introductory video by [Tech Minds](https://www.youtube.com/channel/UC9a8Z6Sp6eb2s3O79pX5Zvg) available:
+If you are new to *HackRF+PortaPack+Mayhem*, check this video:
 
-[![Setup and overview](https://img.youtube.com/vi/kjFB58Y1TAo/0.jpg)](https://www.youtube.com/watch?v=kjFB58Y1TAo)
+[![What is?](https://img.youtube.com/vi/alrFbY5vxt4/0.jpg)](https://www.youtube.com/watch?v=alrFbY5vxt4)
 
 # Frequently Asked Questions
 
@@ -20,7 +20,9 @@ This repository expands upon the previous work by many people and aims to consta
 
 ## What to buy?
 
-: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). 
+:heavy_check_mark: A recommended one is this [PortaPack H2](https://s.click.aliexpress.com/e/_DmU7GQX), that includes everything you need with the plastic case "inspired" on [this](https://github.com/eried/portapack-mayhem/wiki/H2-Enclosure).
+
+:heavy_check_mark: Our friends at OpenSourceSDRLab give away five units every three months in our discord (check the badge on top) of their [PortaPack H2](https://www.aliexpress.com/item/4000247041639.html?gatewayAdapt=4itemAdapt), you can support them too by ordering.
 
 :heavy_check_mark: Another popular option is the clone of the [PortaPack H1](https://s.click.aliexpress.com/e/_Dkbqs2X).
 
@@ -48,9 +50,11 @@ To support the people behind the hardware, please buy a genuine [HackRF](https:/
 ## 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).
+<del>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).</del>
 
-Promote your bounty over our Discord by clicking the chat badge on [top](#portapack-mayhem).
+<del>Promote your bounty over our Discord by clicking the chat badge on [top](#portapack-mayhem).</del>
+
+Bountysource has not been reliable lately, so until this changes, please **DO NOT** post a bounty there. Go to our Discord by clicking the chat badge on [top](#portapack-mayhem) and discuss there.
 
 ## What if I need help?
 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).

firmware/CMakeLists.txt

@@ -26,6 +26,7 @@ set(CHIBIOS ${PROJECT_SOURCE_DIR}/chibios)
 set(CHIBIOS_PORTAPACK ${PROJECT_SOURCE_DIR}/chibios-portapack)
 
 set(EXTRACT_CPLD_DATA ${PROJECT_SOURCE_DIR}/tools/extract_cpld_data.py)
+set(EXPORT_EXTERNAL_APP_IMAGES ${PROJECT_SOURCE_DIR}/tools/export_external_apps.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)
@@ -53,10 +54,18 @@ add_custom_target(
 
 add_custom_target(
 	program
+	COMMAND ${PROJECT_SOURCE_DIR}/tools/enter_mode.sh hackrf
 	COMMAND dfu-util --device 1fc9:000c --download ${HACKRF_FIRMWARE_DFU_IMAGE} || (exit 0) # We need to add it for dfu-utils v.011 , (in v.09 it is not necessary)
 	COMMAND sleep 3s
-	COMMAND hackrf_spiflash -w ${FIRMWARE_FILENAME}
-	DEPENDS ${FIRMWARE_FILENAME}
+	COMMAND hackrf_spiflash -i -R -w ${FIRMWARE_FILENAME}
+	DEPENDS firmware ${FIRMWARE_FILENAME}
+)
+
+add_custom_target(
+	program-external-apps
+	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+	COMMAND ${PROJECT_SOURCE_DIR}/tools/copy_external_apps.sh
+	DEPENDS program
 )
 
 # TODO: Bad hack to fix location of LICENSE file for tar.

firmware/application/CMakeLists.txt

@@ -32,7 +32,7 @@ include(CheckCXXCompilerFlag)
 project(application)
 
 # Compiler options here.
-set(USE_OPT "-Os -g --specs=nano.specs")
+set(USE_OPT "-Os -g --specs=nano.specs -specs=nosys.specs")
 
 # C specific options here (added to USE_OPT).
 set(USE_COPT "-std=gnu99")
@@ -44,7 +44,7 @@ if(cpp20_supported)
 else()
 	set(USE_CPPOPT "-std=c++17")
 endif()
-set(USE_CPPOPT "${USE_CPPOPT} -fno-rtti -fno-exceptions -Weffc++ -Wuninitialized -Wno-volatile")
+set(USE_CPPOPT "${USE_CPPOPT} -flto -fno-rtti -fno-exceptions -Weffc++ -Wuninitialized -Wno-volatile")
 
 # Enable this if you want the linker to remove unused code and data
 set(USE_LINK_GC yes)
@@ -97,6 +97,7 @@ include(${CHIBIOS_PORTAPACK}/os/ports/GCC/ARMCMx/LPC43xx_M0/port.cmake)
 include(${CHIBIOS}/os/kernel/kernel.cmake)
 include(${CHIBIOS_PORTAPACK}/os/various/fatfs_bindings/fatfs.cmake)
 include(${CHIBIOS}/test/test.cmake)
+include(external/external.cmake)
 
 # Define linker script file here
 set(LDSCRIPT ${PORTLD}/LPC43xx_M0.ld)
@@ -112,6 +113,17 @@ set(CSRC
 	${BOARDSRC}
 	${FATFSSRC}
 	firmware_info.c
+	usb_serial_cdc.c
+	usb_serial_descriptor.c
+	usb_serial_endpoints.c
+	usb_serial_io.c
+	${HACKRF_PATH}/firmware/common/usb.c
+	${HACKRF_PATH}/firmware/common/usb_queue.c
+	${HACKRF_PATH}/firmware/hackrf_usb/usb_device.c
+	${HACKRF_PATH}/firmware/common/usb_request.c
+	${HACKRF_PATH}/firmware/common/usb_standard_request.c
+	${CHIBIOS}/os/various/shell.c
+	${CHIBIOS}/os/various/chprintf.c
 )
 
 # C++ sources that can be compiled in ARM or THUMB mode depending on the global
@@ -161,6 +173,7 @@ set(CPPSRC
 	${COMMON}/ui_painter.cpp
 	${COMMON}/ui_text.cpp
 	${COMMON}/ui_widget.cpp
+	${COMMON}/ui_language.cpp
 	${COMMON}/utility.cpp
 	${COMMON}/wm8731.cpp
 	${COMMON}/performance_counter.cpp
@@ -182,12 +195,17 @@ set(CPPSRC
 	io_convert.cpp
 	io_file.cpp
 	io_wave.cpp
+	iq_trim.cpp
 	irq_controls.cpp
 	irq_lcd_frame.cpp
 	irq_rtc.cpp
 	log_file.cpp
 	metadata_file.cpp
 	portapack.cpp
+	usb_serial_shell.cpp
+	usb_serial_event.cpp
+	usb_serial_thread.cpp
+	usb_serial.cpp
 	qrcodegen.cpp
 	radio.cpp
 	receiver_model.cpp
@@ -238,76 +256,81 @@ set(CPPSRC
 	ui/ui_textentry.cpp
 	ui/ui_tone_key.cpp
 	ui/ui_transmitter.cpp
+	apps/acars_app.cpp
+	apps/ais_app.cpp
+	apps/analog_audio_app.cpp
+	# apps/analog_tv_app.cpp
+	apps/ble_comm_app.cpp
+	apps/ble_rx_app.cpp
+	apps/ble_tx_app.cpp
+	apps/capture_app.cpp
+	apps/ert_app.cpp
+	apps/gps_sim_app.cpp
+	# apps/lge_app.cpp
+	apps/pocsag_app.cpp
+	# apps/replay_app.cpp
+	apps/soundboard_app.cpp
+	apps/tpms_app.cpp
+	apps/tpms_app.cpp
 	apps/ui_about_simple.cpp
 	apps/ui_adsb_rx.cpp
 	apps/ui_adsb_tx.cpp
-	apps/ui_afsk_rx.cpp
 	apps/ui_aprs_rx.cpp
-	apps/ui_btle_rx.cpp
-	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_btle_rx.cpp
+	# apps/ui_coasterp.cpp
 	apps/ui_debug.cpp
+	apps/ui_dfu_menu.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
-	apps/ui_lcr.cpp
-	apps/lge_app.cpp
+	apps/ui_fsk_rx.cpp
+	apps/ui_iq_trim.cpp
+	# apps/ui_jammer.cpp
+    # apps/ui_keyfob.cpp
+	# apps/ui_lcr.cpp
+	apps/ui_level.cpp  
 	apps/ui_looking_glass_app.cpp
 	apps/ui_mictx.cpp
 	apps/ui_modemsetup.cpp
 	apps/ui_morse.cpp
+	# apps/ui_nrf_rx.cpp
 	# apps/ui_nuoptix.cpp
+	apps/ui_playlist.cpp
 	apps/ui_pocsag_tx.cpp
 	apps/ui_rds.cpp
+	apps/ui_recon_settings.cpp
+	apps/ui_recon.cpp  
 	apps/ui_remote.cpp
 	apps/ui_scanner.cpp
-	apps/ui_search.cpp
+	apps/ui_sd_over_usb.cpp
 	apps/ui_sd_wipe.cpp
+	apps/ui_search.cpp
 	apps/ui_settings.cpp
 	apps/ui_siggen.cpp
 	apps/ui_sonde.cpp
-	apps/ui_sstvtx.cpp
+	apps/ui_spectrum_painter_image.cpp
+	apps/ui_spectrum_painter_text.cpp
+	apps/ui_spectrum_painter.cpp
 	apps/ui_ss_viewer.cpp
+	apps/ui_sstvtx.cpp
+	apps/ui_subghzd.cpp
 	# apps/ui_test.cpp
 	apps/ui_text_editor.cpp
 	apps/ui_tone_search.cpp
 	apps/ui_touch_calibration.cpp
 	apps/ui_touchtunes.cpp
 	apps/ui_view_wav.cpp
+	apps/ui_weatherstation.cpp
 	apps/ui_whipcalc.cpp
-	apps/acars_app.cpp
-	apps/ais_app.cpp
-	apps/analog_audio_app.cpp
-	apps/analog_tv_app.cpp
-	apps/capture_app.cpp
-	apps/ert_app.cpp
-	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
-	apps/ui_spectrum_painter.cpp
-	apps/ui_spectrum_painter_image.cpp
-	apps/ui_spectrum_painter_text.cpp
 	protocols/aprs.cpp
 	protocols/ax25.cpp
 	protocols/bht.cpp
 	protocols/dcs.cpp
 	protocols/encoders.cpp
-	protocols/lcr.cpp
+	# protocols/lcr.cpp
 	protocols/modems.cpp
 	protocols/rds.cpp
 	# ui_handwrite.cpp
@@ -316,9 +339,13 @@ set(CPPSRC
 	# ui_replay_view.cpp
 	# ui_script.cpp
 	ui_sd_card_debug.cpp
+	config_mode.cpp
 	${CPLD_20150901_DATA_CPP}
 	${CPLD_20170522_DATA_CPP}
 	${HACKRF_CPLD_DATA_CPP}
+	ui_external_items_menu_loader.cpp
+
+	${EXTCPPSRC}
 )
 
 # C sources to be compiled in ARM mode regardless of the global setting.
@@ -351,6 +378,9 @@ set(INCDIR ${CMAKE_CURRENT_BINARY_DIR} ${COMMON} ${PORTINC} ${KERNINC} ${TESTINC
 	${HALINC} ${PLATFORMINC} ${BOARDINC}
 	${FATFSINC}
 	${CHIBIOS}/os/various
+	${HACKRF_PATH}/firmware/libopencm3/include
+	${HACKRF_PATH}/firmware/common
+	${HACKRF_PATH}/firmware
 	ui
 	hw
 	apps
@@ -394,7 +424,7 @@ set(CPPWARN "-Wall -Wextra -Wno-psabi")
 # List all default C defines here, like -D_DEBUG=1
 # TODO: Switch -DCRT0_INIT_DATA depending on load from RAM or SPIFI?
 # NOTE: _RANDOM_TCC to kill a GCC 4.9.3 error with std::max argument types
-set(DDEFS "-DLPC43XX -DLPC43XX_M0 -D__NEWLIB__ -DHACKRF_ONE -DTOOLCHAIN_GCC -DTOOLCHAIN_GCC_ARM -D_RANDOM_TCC=0 -D'VERSION_STRING=\"${VERSION}\"'")
+set(DDEFS "-DLPC43XX -DLPC43XX_M0 -D__NEWLIB__ -DHACKRF_ONE -DTOOLCHAIN_GCC -DTOOLCHAIN_GCC_ARM -D_RANDOM_TCC=0 -D'VERSION_STRING=\"${VERSION}\"' -DVERSION_MD5=${VERSION_MD5}")
 
 # List all default ASM defines here, like -D_DEBUG=1
 set(DADEFS)
@@ -463,12 +493,13 @@ set_target_properties(${PROJECT_NAME}.elf PROPERTIES LINK_DEPENDS ${LDSCRIPT})
 add_definitions(${DEFS})
 include_directories(. ${INCDIR})
 link_directories(${LLIBDIR})
-target_link_libraries(${PROJECT_NAME}.elf ${LIBS})
+target_link_libraries(${PROJECT_NAME}.elf ${LIBS} "-L${CMAKE_CURRENT_LIST_DIR}/external")
 target_link_libraries(${PROJECT_NAME}.elf -Wl,-Map=${PROJECT_NAME}.map)
 
 add_custom_command(
 	OUTPUT ${PROJECT_NAME}.bin
-	COMMAND ${CMAKE_OBJCOPY} -O binary ${PROJECT_NAME}.elf ${PROJECT_NAME}.bin
+	COMMAND ${CMAKE_OBJCOPY} -v -O binary ${PROJECT_NAME}.elf ${PROJECT_NAME}.bin --remove-section=.external_app_*
+	COMMAND ${EXPORT_EXTERNAL_APP_IMAGES} ${PROJECT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_OBJCOPY} ${EXTAPPLIST}
 	DEPENDS ${PROJECT_NAME}.elf
 )
 

firmware/application/app_settings.cpp

@@ -2,6 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2022 Arjan Onwezen
+ * Copyright (C) 2023 Kyle Reed
  *
  * This file is part of PortaPack.
  *
@@ -23,7 +24,9 @@
 
 #include "app_settings.hpp"
 
+#include "convert.hpp"
 #include "file.hpp"
+#include "file_reader.hpp"
 #include "portapack.hpp"
 #include "portapack_persistent_memory.hpp"
 #include "utility.hpp"
@@ -34,145 +37,140 @@
 
 namespace fs = std::filesystem;
 using namespace portapack;
-using namespace std::literals;
 
-namespace app_settings {
+namespace {
+fs::path get_settings_path(const std::string& app_name) {
+    return fs::path{u"/SETTINGS"} / app_name + u".ini";
+}
+}  // namespace
 
-template <typename T>
-static void read_setting(
-    std::string_view file_content,
-    std::string_view setting_name,
-    T& value) {
-    auto pos = file_content.find(setting_name);
-
-    if (pos != file_content.npos) {
-        pos += setting_name.length();
-        value = strtoll(&file_content[pos], nullptr, 10);
-    }
+void BoundSetting::parse(std::string_view value) {
+    switch (type_) {
+        case SettingType::I64:
+            parse_int(value, as<int64_t>());
+            break;
+        case SettingType::I32:
+            parse_int(value, as<int32_t>());
+            break;
+        case SettingType::U32:
+            parse_int(value, as<uint32_t>());
+            break;
+        case SettingType::U8:
+            parse_int(value, as<uint8_t>());
+            break;
+        case SettingType::String:
+            as<std::string>() = trim(value);
+            break;
+        case SettingType::Bool: {
+            int parsed = 0;
+            parse_int(value, parsed);
+            as<bool>() = (parsed != 0);
+            break;
+        }
+    };
 }
 
-template <typename T>
-static void write_setting(File& file, std::string_view setting_name, const T& value) {
-    // NB: Not using file.write_line speed this up. This happens on every
+void BoundSetting::write(File& file) const {
+    // NB: Write directly without allocations. This happens on every
     // app exit when enabled so should be fast to keep the UX responsive.
     StringFormatBuffer buffer;
     size_t length = 0;
-    auto value_str = to_string_dec_uint(value, buffer, length);
 
-    file.write(setting_name.data(), setting_name.length());
-    file.write(value_str, length);
+    file.write(name_.data(), name_.length());
+    file.write("=", 1);
+
+    switch (type_) {
+        case SettingType::I64:
+            file.write(to_string_dec_int(as<int64_t>(), buffer, length), length);
+            break;
+        case SettingType::I32:
+            file.write(to_string_dec_int(as<int32_t>(), buffer, length), length);
+            break;
+        case SettingType::U32:
+            file.write(to_string_dec_uint(as<uint32_t>(), buffer, length), length);
+            break;
+        case SettingType::U8:
+            file.write(to_string_dec_uint(as<uint8_t>(), buffer, length), length);
+            break;
+        case SettingType::String: {
+            const auto& str = as<std::string>();
+            file.write(str.data(), str.length());
+            break;
+        }
+        case SettingType::Bool:
+            file.write(as<bool>() ? "1" : "0", 1);
+            break;
+    }
+
     file.write("\r\n", 2);
 }
 
-static fs::path get_settings_path(const std::string& app_name) {
-    return fs::path{u"/SETTINGS"} / app_name + u".ini";
+SettingsStore::SettingsStore(std::string_view store_name, SettingBindings bindings)
+    : store_name_{store_name}, bindings_{bindings} {
+    reload();
 }
 
-namespace setting {
-constexpr std::string_view baseband_bandwidth = "baseband_bandwidth="sv;
-constexpr std::string_view sampling_rate = "sampling_rate="sv;
-constexpr std::string_view lna = "lna="sv;
-constexpr std::string_view vga = "vga="sv;
-constexpr std::string_view rx_amp = "rx_amp="sv;
-constexpr std::string_view tx_amp = "tx_amp="sv;
-constexpr std::string_view tx_gain = "tx_gain="sv;
-constexpr std::string_view channel_bandwidth = "channel_bandwidth="sv;
-constexpr std::string_view rx_frequency = "rx_frequency="sv;
-constexpr std::string_view tx_frequency = "tx_frequency="sv;
-constexpr std::string_view step = "step="sv;
-constexpr std::string_view modulation = "modulation="sv;
-constexpr std::string_view am_config_index = "am_config_index="sv;
-constexpr std::string_view nbfm_config_index = "nbfm_config_index="sv;
-constexpr std::string_view wfm_config_index = "wfm_config_index="sv;
-constexpr std::string_view squelch = "squelch="sv;
-constexpr std::string_view volume = "volume="sv;
-}  // namespace setting
-
-// TODO: Only load/save values that are declared used.
-// This will prevent switching apps from changing setting unnecessarily.
-// TODO: Track which values are actually read.
-// TODO: Maybe just use a dictionary which would allow for custom settings.
-// TODO: Create a control value binding which will allow controls to
-//       be declaratively bound to a setting and persistence will be magic.
-
-ResultCode load_settings(const std::string& app_name, AppSettings& settings) {
-    if (!portapack::persistent_memory::load_app_settings())
-        return ResultCode::SettingsDisabled;
-
-    auto file_path = get_settings_path(app_name);
-    auto data = File::read_file(file_path);
-
-    if (!data)
-        return ResultCode::LoadFailed;
-
-    if (flags_enabled(settings.mode, Mode::TX)) {
-        read_setting(*data, setting::tx_frequency, settings.tx_frequency);
-        read_setting(*data, setting::tx_amp, settings.tx_amp);
-        read_setting(*data, setting::tx_gain, settings.tx_gain);
-        read_setting(*data, setting::channel_bandwidth, settings.channel_bandwidth);
-    }
-
-    if (flags_enabled(settings.mode, Mode::RX)) {
-        read_setting(*data, setting::rx_frequency, settings.rx_frequency);
-        read_setting(*data, setting::lna, settings.lna);
-        read_setting(*data, setting::vga, settings.vga);
-        read_setting(*data, setting::rx_amp, settings.rx_amp);
-        read_setting(*data, setting::modulation, settings.modulation);
-        read_setting(*data, setting::am_config_index, settings.am_config_index);
-        read_setting(*data, setting::nbfm_config_index, settings.nbfm_config_index);
-        read_setting(*data, setting::wfm_config_index, settings.wfm_config_index);
-        read_setting(*data, setting::squelch, settings.squelch);
-    }
-
-    read_setting(*data, setting::baseband_bandwidth, settings.baseband_bandwidth);
-    read_setting(*data, setting::sampling_rate, settings.sampling_rate);
-    read_setting(*data, setting::step, settings.step);
-    read_setting(*data, setting::volume, settings.volume);
-
-    return ResultCode::Ok;
+SettingsStore::~SettingsStore() {
+    save();
 }
 
-ResultCode save_settings(const std::string& app_name, AppSettings& settings) {
-    if (!portapack::persistent_memory::save_app_settings())
-        return ResultCode::SettingsDisabled;
+void SettingsStore::reload() {
+    load_settings(store_name_, bindings_);
+}
 
-    File settings_file;
-    auto file_path = get_settings_path(app_name);
-    ensure_directory(file_path.parent_path());
+void SettingsStore::save() const {
+    save_settings(store_name_, bindings_);
+}
 
-    auto error = settings_file.create(file_path);
+bool load_settings(std::string_view store_name, SettingBindings& bindings) {
+    File f;
+    auto path = get_settings_path(std::string{store_name});
+
+    auto error = f.open(path);
     if (error)
-        return ResultCode::SaveFailed;
+        return false;
 
-    if (flags_enabled(settings.mode, Mode::TX)) {
-        write_setting(settings_file, setting::tx_frequency, settings.tx_frequency);
-        write_setting(settings_file, setting::tx_amp, settings.tx_amp);
-        write_setting(settings_file, setting::tx_gain, settings.tx_gain);
-        write_setting(settings_file, setting::channel_bandwidth, settings.channel_bandwidth);
+    auto reader = FileLineReader(f);
+    for (const auto& line : reader) {
+        auto cols = split_string(line, '=');
+
+        if (cols.size() != 2)
+            continue;
+
+        // Find a binding with the name.
+        auto it = std::find_if(
+            bindings.begin(), bindings.end(),
+            [name = cols[0]](auto& bound_setting) {
+                return name == bound_setting.name();
+            });
+
+        // If found, parse the value.
+        if (it != bindings.end())
+            it->parse(cols[1]);
     }
 
-    if (flags_enabled(settings.mode, Mode::RX)) {
-        write_setting(settings_file, setting::rx_frequency, settings.rx_frequency);
-        write_setting(settings_file, setting::lna, settings.lna);
-        write_setting(settings_file, setting::vga, settings.vga);
-        write_setting(settings_file, setting::rx_amp, settings.rx_amp);
-        write_setting(settings_file, setting::modulation, settings.modulation);
-        write_setting(settings_file, setting::am_config_index, settings.am_config_index);
-        write_setting(settings_file, setting::nbfm_config_index, settings.nbfm_config_index);
-        write_setting(settings_file, setting::wfm_config_index, settings.wfm_config_index);
-        write_setting(settings_file, setting::squelch, settings.squelch);
-    }
-
-    write_setting(settings_file, setting::baseband_bandwidth, settings.baseband_bandwidth);
-    write_setting(settings_file, setting::sampling_rate, settings.sampling_rate);
-    write_setting(settings_file, setting::step, settings.step);
-    write_setting(settings_file, setting::volume, settings.volume);
-
-    return ResultCode::Ok;
+    return true;
 }
 
+bool save_settings(std::string_view store_name, const SettingBindings& bindings) {
+    File f;
+    auto path = get_settings_path(std::string{store_name});
+
+    make_new_directory(SETTINGS_DIR);
+    auto error = f.create(path);
+    if (error)
+        return false;
+
+    for (const auto& bound_setting : bindings)
+        bound_setting.write(f);
+
+    return true;
+}
+
+namespace app_settings {
+
 void copy_to_radio_model(const AppSettings& settings) {
-    // NB: Don't actually adjust the radio here or it will hang.
+    // NB: Don't actually adjust the radio here or it may hang.
     // Specifically 'modulation' which requires a running baseband.
 
     if (flags_enabled(settings.mode, Mode::TX)) {
@@ -230,28 +228,77 @@ void copy_from_radio_model(AppSettings& settings) {
 }
 
 /* SettingsManager *************************************************/
+SettingsManager::SettingsManager(std::string_view app_name, Mode mode, Options options)
+    : SettingsManager{app_name, mode, options, {}} {}
+
 SettingsManager::SettingsManager(
-    std::string app_name,
+    std::string_view app_name,
     Mode mode,
-    Options options)
-    : app_name_{std::move(app_name)},
+    SettingBindings additional_settings)
+    : SettingsManager{app_name, mode, Options::None, std::move(additional_settings)} {}
+
+SettingsManager::SettingsManager(
+    std::string_view app_name,
+    Mode mode,
+    Options options,
+    SettingBindings additional_settings)
+    : app_name_{app_name},
       settings_{},
+      bindings_{},
       loaded_{false} {
     settings_.mode = mode;
     settings_.options = options;
-    auto result = load_settings(app_name_, settings_);
 
-    if (result == ResultCode::Ok) {
-        loaded_ = true;
-        copy_to_radio_model(settings_);
+    // Pre-alloc enough for app settings and additional settings.
+    additional_settings.reserve(COMMON_APP_SETTINGS_COUNT + additional_settings.size());
+    bindings_ = std::move(additional_settings);
+
+    // Settings should always be loaded because apps now rely
+    // on being able to store UI settings, config, etc.
+
+    // Transmitter model settings.
+    if (flags_enabled(mode, Mode::TX)) {
+        bindings_.emplace_back("tx_frequency"sv, &settings_.tx_frequency);
+        bindings_.emplace_back("tx_amp"sv, &settings_.tx_amp);
+        bindings_.emplace_back("tx_gain"sv, &settings_.tx_gain);
+        bindings_.emplace_back("channel_bandwidth"sv, &settings_.channel_bandwidth);
     }
+
+    // Receiver model settings.
+    if (flags_enabled(mode, Mode::RX)) {
+        bindings_.emplace_back("rx_frequency"sv, &settings_.rx_frequency);
+        bindings_.emplace_back("lna"sv, &settings_.lna);
+        bindings_.emplace_back("vga"sv, &settings_.vga);
+        bindings_.emplace_back("rx_amp"sv, &settings_.rx_amp);
+        bindings_.emplace_back("modulation"sv, &settings_.modulation);
+        bindings_.emplace_back("am_config_index"sv, &settings_.am_config_index);
+        bindings_.emplace_back("nbfm_config_index"sv, &settings_.nbfm_config_index);
+        bindings_.emplace_back("wfm_config_index"sv, &settings_.wfm_config_index);
+        bindings_.emplace_back("squelch"sv, &settings_.squelch);
+    }
+
+    // Common model settings.
+    bindings_.emplace_back("baseband_bandwidth"sv, &settings_.baseband_bandwidth);
+    bindings_.emplace_back("sampling_rate"sv, &settings_.sampling_rate);
+    bindings_.emplace_back("step"sv, &settings_.step);
+    bindings_.emplace_back("volume"sv, &settings_.volume);
+
+    // RadioState should have initialized default radio parameters before this function;
+    // copy them to settings_ before checking settings .ini file (in case the file doesn't exist
+    // or doesn't include all parameters). Settings in the file can overwrite all, or a subset of parameters.
+    copy_from_radio_model(settings_);
+
+    loaded_ = load_settings(app_name_, bindings_);
+
+    // Only copy to the radio if load was successful.
+    if (loaded_)
+        copy_to_radio_model(settings_);
 }
 
 SettingsManager::~SettingsManager() {
-    if (portapack::persistent_memory::save_app_settings()) {
-        copy_from_radio_model(settings_);
-        save_settings(app_name_, settings_);
-    }
+    copy_from_radio_model(settings_);
+
+    save_settings(app_name_, bindings_);
 }
 
 }  // namespace app_settings

firmware/application/app_settings.hpp

@@ -2,6 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2022 Arjan Onwezen
+ * Copyright (C) 2023 Kyle Reed
  *
  * This file is part of PortaPack.
  *
@@ -27,21 +28,90 @@
 #include <cstddef>
 #include <cstdint>
 #include <string>
+#include <string_view>
 #include <utility>
+#include <variant>
 
 #include "file.hpp"
 #include "max283x.hpp"
 #include "string_format.hpp"
 
-namespace app_settings {
+// Folder to store app settings, pmem_fileflag, and date_fileflag
+#define SETTINGS_DIR u"/SETTINGS"
 
-enum class ResultCode : uint8_t {
-    Ok,                // settings found
-    LoadFailed,        // settings (file) not found
-    SaveFailed,        // unable to save settings
-    SettingsDisabled,  // load/save disabled in settings
+// Bring in the string_view literal.
+using std::literals::operator""sv;
+
+#define COMMON_APP_SETTINGS_COUNT 19
+
+/* Represents a named setting bound to a variable instance. */
+/* Using void* instead of std::variant, because variant is a pain to dispatch over. */
+class BoundSetting {
+    /* The type of bound setting. */
+    enum class SettingType : uint8_t {
+        I64,
+        I32,
+        U32,
+        U8,
+        String,
+        Bool,
+    };
+
+   public:
+    BoundSetting(std::string_view name, int64_t* target)
+        : name_{name}, target_{target}, type_{SettingType::I64} {}
+
+    BoundSetting(std::string_view name, int32_t* target)
+        : name_{name}, target_{target}, type_{SettingType::I32} {}
+
+    BoundSetting(std::string_view name, uint32_t* target)
+        : name_{name}, target_{target}, type_{SettingType::U32} {}
+
+    BoundSetting(std::string_view name, uint8_t* target)
+        : name_{name}, target_{target}, type_{SettingType::U8} {}
+
+    BoundSetting(std::string_view name, std::string* target)
+        : name_{name}, target_{target}, type_{SettingType::String} {}
+
+    BoundSetting(std::string_view name, bool* target)
+        : name_{name}, target_{target}, type_{SettingType::Bool} {}
+
+    std::string_view name() const { return name_; }
+    void parse(std::string_view value);
+    void write(File& file) const;
+
+   private:
+    template <typename T>
+    constexpr auto& as() const {
+        return *reinterpret_cast<T*>(target_);
+    }
+
+    std::string_view name_;
+    void* target_;
+    SettingType type_;
 };
 
+using SettingBindings = std::vector<BoundSetting>;
+
+/* RAII wrapper for Settings that loads/saves to the SD card. */
+class SettingsStore {
+   public:
+    SettingsStore(std::string_view store_name, SettingBindings bindings);
+    ~SettingsStore();
+
+    void reload();
+    void save() const;
+
+   private:
+    std::string_view store_name_;
+    SettingBindings bindings_;
+};
+
+bool load_settings(std::string_view store_name, SettingBindings& bindings);
+bool save_settings(std::string_view store_name, const SettingBindings& bindings);
+
+namespace app_settings {
+
 enum class Mode : uint8_t {
     RX = 0x01,
     TX = 0x02,
@@ -55,7 +125,6 @@ enum class Options {
     UseGlobalTargetFrequency = 0x0001,
 };
 
-// TODO: separate types for TX/RX or union?
 /* NB: See RX/TX model headers for default values. */
 struct AppSettings {
     Mode mode = Mode::RX;
@@ -76,13 +145,10 @@ struct AppSettings {
     uint8_t nbfm_config_index = 0;
     uint8_t wfm_config_index = 0;
     uint8_t squelch = 80;
-
     uint8_t volume;
+    // NOTE: update COMMON_APP_SETTINGS_COUNT when adding to this
 };
 
-ResultCode load_settings(const std::string& app_name, AppSettings& settings);
-ResultCode save_settings(const std::string& app_name, AppSettings& settings);
-
 /* Copies common values to the receiver/transmitter models. */
 void copy_to_radio_model(const AppSettings& settings);
 
@@ -90,11 +156,15 @@ void copy_to_radio_model(const AppSettings& settings);
 void copy_from_radio_model(AppSettings& settings);
 
 /* RAII wrapper for automatically loading and saving settings for an app.
+ * "Additional" settings are always loaded, but radio settings are conditionally
+ * saved/loaded if the global app settings options are enabled.
  * NB: This should be added to a class before any LNA/VGA controls so that
  * the receiver/transmitter models are set before the control ctors run. */
 class SettingsManager {
    public:
-    SettingsManager(std::string app_name, Mode mode, Options options = Options::None);
+    SettingsManager(std::string_view app_name, Mode mode, Options options = Options::None);
+    SettingsManager(std::string_view app_name, Mode mode, SettingBindings additional_settings);
+    SettingsManager(std::string_view app_name, Mode mode, Options options, SettingBindings additional_settings);
     ~SettingsManager();
 
     SettingsManager(const SettingsManager&) = delete;
@@ -104,13 +174,15 @@ class SettingsManager {
 
     /* True if settings were successfully loaded from file. */
     bool loaded() const { return loaded_; }
+
     Mode mode() const { return settings_.mode; }
 
     AppSettings& raw() { return settings_; }
 
    private:
-    std::string app_name_;
+    std::string_view app_name_;
     AppSettings settings_;
+    SettingBindings bindings_;
     bool loaded_;
 };
 

firmware/application/apps/acars_app.hpp

@@ -60,11 +60,12 @@ class ACARSAppView : public View {
    private:
     NavigationView& nav_;
     RxRadioState radio_state_{
+        131550000 /* frequency */,
         1750000 /* bandwidth */,
         2457600 /* sampling rate */
     };
     app_settings::SettingsManager settings_{
-        "rx_acars.hpp", app_settings::Mode::RX};
+        "rx_acars", app_settings::Mode::RX};
 
     bool logging{false};
     uint32_t packet_counter{0};

firmware/application/apps/ais_app.cpp

@@ -382,9 +382,6 @@ AISAppView::AISAppView(NavigationView& nav)
 
     recent_entry_detail_view.hidden(true);
 
-    if (!settings_.loaded())
-        receiver_model.set_target_frequency(initial_target_frequency);
-
     receiver_model.enable();
 
     options_channel.on_change = [this](size_t, OptionsField::value_t v) {

firmware/application/apps/ais_app.hpp

@@ -162,9 +162,8 @@ class AISAppView : public View {
     std::string title() const override { return "AIS RX"; };
 
    private:
-    static constexpr uint32_t initial_target_frequency = 162025000;
-
     RxRadioState radio_state_{
+        162025000 /* frequency*/,
         1750000 /* bandwidth */,
         2457600 /* sampling rate */
     };

firmware/application/apps/ble_comm_app.cpp

@@ -0,0 +1,331 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * 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 "ble_comm_app.hpp"
+
+#include "ui_modemsetup.hpp"
+
+#include "modems.hpp"
+#include "audio.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "ui_text.hpp"
+
+using namespace portapack;
+using namespace modems;
+
+void BLECommLogger::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+namespace ui {
+static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
+    uint64_t freq_hz;
+
+    switch (channel_number) {
+        case 37:
+            freq_hz = 2'402'000'000ull;
+            break;
+        case 38:
+            freq_hz = 2'426'000'000ull;
+            break;
+        case 39:
+            freq_hz = 2'480'000'000ull;
+            break;
+        case 0 ... 10:
+            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
+            break;
+        case 11 ... 36:
+            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
+            break;
+        default:
+            freq_hz = UINT64_MAX;
+    }
+
+    return freq_hz;
+}
+
+void BLECommView::focus() {
+    options_channel.focus();
+}
+
+BLECommView::BLECommView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &options_channel,
+                  &field_frequency,
+                  &label_send_adv,
+                  &button_send_adv,
+                  &check_log,
+                  &label_packets_sent,
+                  &text_packets_sent,
+                  &console});
+
+    field_frequency.set_step(0);
+
+    button_send_adv.on_select = [this](ImageButton&) {
+        this->toggle();
+    };
+
+    check_log.set_value(logging);
+
+    check_log.on_select = [this](Checkbox&, bool v) {
+        str_log = "";
+        logging = v;
+
+        if (logger && logging)
+            logger->append(LOG_ROOT_DIR "/BLELOG_" + to_string_timestamp(rtc_time::now()) + ".TXT");
+    };
+
+    options_channel.on_change = [this](size_t, int32_t i) {
+        // If we selected Auto don't do anything and Auto will handle changing.
+        if (i == 40) {
+            auto_channel = true;
+            return;
+        } else {
+            auto_channel = false;
+        }
+
+        field_frequency.set_value(get_freq_by_channel_number(i));
+        channel_number_rx = i;
+        channel_number_tx = i;
+    };
+
+    options_channel.set_selected_index(3, true);
+
+    logger = std::make_unique<BLECommLogger>();
+
+    // Generate new random Mac Address upon each new startup.
+    generateRandomMacAddress(randomMac);
+
+    // Setup Initial Advertise Packet.
+    advertisePacket = build_adv_packet();
+}
+
+void BLECommView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    console.set_parent_rect(content_rect);
+}
+
+BLECommView::~BLECommView() {
+    receiver_model.disable();
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+bool BLECommView::in_tx_mode() const {
+    return (bool)is_running_tx;
+}
+
+void BLECommView::toggle() {
+    if (in_tx_mode()) {
+        sendAdvertisement(false);
+    } else {
+        sendAdvertisement(true);
+    }
+}
+
+BLETxPacket BLECommView::build_adv_packet() {
+    BLETxPacket bleTxPacket;
+    memset(&bleTxPacket, 0, sizeof(BLETxPacket));
+
+    std::string dataString = "11094861636b524620506f7274617061636b";
+
+    strncpy(bleTxPacket.macAddress, randomMac, 12);
+    strncpy(bleTxPacket.advertisementData, dataString.c_str(), dataString.length());
+
+    // Duty cycle of 40% per 100ms advertisment periods.
+    strncpy(bleTxPacket.packetCount, "80", 3);
+    bleTxPacket.packet_count = 80;
+
+    bleTxPacket.packetType = PKT_TYPE_DISCOVERY;
+
+    return bleTxPacket;
+}
+
+void BLECommView::sendAdvertisement(bool enable) {
+    if (enable) {
+        startTx(advertisePacket);
+        is_adv = true;
+    } else {
+        is_adv = false;
+        stopTx();
+    }
+}
+
+void BLECommView::startTx(BLETxPacket packetToSend) {
+    int randomChannel = channel_number_tx;
+
+    if (auto_channel) {
+        int min = 37;
+        int max = 39;
+
+        randomChannel = min + std::rand() % (max - min + 1);
+
+        field_frequency.set_value(get_freq_by_channel_number(randomChannel));
+    }
+
+    if (!in_tx_mode()) {
+        switch_rx_tx(false);
+
+        currentPacket = packetToSend;
+        packet_counter = currentPacket.packet_count;
+
+        button_send_adv.set_bitmap(&bitmap_stop);
+        baseband::set_btletx(randomChannel, currentPacket.macAddress, currentPacket.advertisementData, currentPacket.packetType);
+        transmitter_model.set_tx_gain(47);
+        transmitter_model.enable();
+
+        is_running_tx = true;
+    } else {
+        baseband::set_btletx(randomChannel, currentPacket.macAddress, currentPacket.advertisementData, currentPacket.packetType);
+    }
+
+    if ((packet_counter % 10) == 0) {
+        text_packets_sent.set(to_string_dec_uint(packet_counter));
+    }
+
+    is_sending = true;
+
+    packet_counter--;
+}
+
+void BLECommView::stopTx() {
+    button_send_adv.set_bitmap(&bitmap_play);
+    text_packets_sent.set(to_string_dec_uint(packet_counter));
+
+    switch_rx_tx(true);
+
+    baseband::set_btlerx(channel_number_rx);
+    receiver_model.enable();
+
+    is_running_tx = false;
+}
+
+void BLECommView::switch_rx_tx(bool inRxMode) {
+    if (inRxMode) {
+        // Start Rx
+        transmitter_model.disable();
+        baseband::shutdown();
+        baseband::run_image(portapack::spi_flash::image_tag_btle_rx);
+    } else {
+        // Start Tx
+        receiver_model.disable();
+        baseband::shutdown();
+        baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+    }
+}
+
+void BLECommView::on_data(BlePacketData* packet) {
+    parse_received_packet(packet, (ADV_PDU_TYPE)packet->type);
+}
+
+// called each 1/60th of second, so 6 = 100ms
+void BLECommView::on_timer() {
+    // Send advertise burst only once every 100ms
+    if (++timer_counter == timer_period) {
+        timer_counter = 0;
+
+        if (!is_adv) {
+            sendAdvertisement(true);
+        }
+    }
+}
+
+void BLECommView::on_tx_progress(const bool done) {
+    if (done) {
+        if (in_tx_mode()) {
+            is_sending = false;
+
+            if (packet_counter == 0) {
+                if (is_adv) {
+                    sendAdvertisement(false);
+                } else {
+                    stopTx();
+                }
+            } else {
+                startTx(currentPacket);
+            }
+        }
+    }
+}
+
+void BLECommView::parse_received_packet(const BlePacketData* packet, ADV_PDU_TYPE pdu_type) {
+    std::string data_string;
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        data_string += to_string_hex(packet->data[i], 2);
+    }
+
+    receivedPacket.dbValue = packet->max_dB;
+    receivedPacket.timestamp = to_string_timestamp(rtc_time::now());
+    receivedPacket.dataString = data_string;
+
+    receivedPacket.packetData.type = packet->type;
+    receivedPacket.packetData.size = packet->size;
+    receivedPacket.packetData.dataLen = packet->dataLen;
+
+    receivedPacket.packetData.macAddress[0] = packet->macAddress[0];
+    receivedPacket.packetData.macAddress[1] = packet->macAddress[1];
+    receivedPacket.packetData.macAddress[2] = packet->macAddress[2];
+    receivedPacket.packetData.macAddress[3] = packet->macAddress[3];
+    receivedPacket.packetData.macAddress[4] = packet->macAddress[4];
+    receivedPacket.packetData.macAddress[5] = packet->macAddress[5];
+
+    receivedPacket.numHits++;
+
+    for (int i = 0; i < packet->dataLen; i++) {
+        receivedPacket.packetData.data[i] = packet->data[i];
+    }
+
+    if (pdu_type == SCAN_REQ || pdu_type == CONNECT_REQ) {
+        ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)packet->data;
+
+        std::reverse(directed_mac_data->A1, directed_mac_data->A1 + 6);
+        console.clear(true);
+        std::string str_console = "";
+        std::string pduTypeStr = "";
+
+        if (pdu_type == SCAN_REQ) {
+            pduTypeStr += "SCAN_REQ";
+        } else if (pdu_type == CONNECT_REQ) {
+            pduTypeStr += "CONNECT_REQ";
+        }
+
+        str_console += "PACKET TYPE:" + pduTypeStr + "\n";
+        str_console += "MY MAC:" + to_string_formatted_mac_address(randomMac) + "\n";
+        str_console += "SCAN MAC:" + to_string_mac_address(directed_mac_data->A1, 6, false) + "\n";
+        console.write(str_console);
+    }
+}
+
+} /* namespace ui */

firmware/application/apps/ble_comm_app.hpp

@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * 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 __BLE_COMM_APP_H__
+#define __BLE_COMM_APP_H__
+
+#include "ble_rx_app.hpp"
+#include "ble_tx_app.hpp"
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+#include "recent_entries.hpp"
+
+class BLECommLogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+class BLECommView : public View {
+   public:
+    BLECommView(NavigationView& nav);
+    ~BLECommView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    std::string title() const override { return "BLE Comm"; };
+
+   private:
+    BLETxPacket build_adv_packet();
+    void switch_rx_tx(bool inRxMode);
+    void startTx(BLETxPacket packetToSend);
+    void stopTx();
+    void toggle();
+    bool in_tx_mode() const;
+    void on_timer();
+    void on_data(BlePacketData* packetData);
+    void on_tx_progress(const bool done);
+    void parse_received_packet(const BlePacketData* packet, ADV_PDU_TYPE pdu_type);
+    void sendAdvertisement(bool enable);
+
+    NavigationView& nav_;
+
+    RxRadioState radio_state_rx_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */,
+        ReceiverModel::Mode::WidebandFMAudio};
+
+    TxRadioState radio_state_tx_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */
+    };
+
+    app_settings::SettingsManager settings_{
+        "BLE Comm Tx", app_settings::Mode::RX_TX};
+
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+
+    uint8_t channel_number_tx = 37;
+    uint8_t channel_number_rx = 37;
+    bool auto_channel = false;
+
+    char randomMac[13] = "010203040506";
+
+    bool is_running_tx = false;
+    bool is_sending = false;
+    bool is_adv = false;
+
+    int16_t timer_period{6};  // Delay each packet by 16ms.
+    int16_t timer_counter = 0;
+    int16_t timer_rx_counter = 0;
+    int16_t timer_rx_period{12};  // Poll Rx for at least 200ms. (TBD)
+
+    uint32_t packet_counter{0};
+    BLETxPacket advertisePacket{};
+    BLETxPacket currentPacket{};
+    BleRecentEntry receivedPacket{};
+
+    static constexpr auto header_height = 5 * 16;
+
+    OptionsField options_channel{
+        {0 * 8, 0 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39},
+         {"Auto", 40}}};
+
+    RxFrequencyField field_frequency{
+        {6 * 8, 0 * 16},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {16 * 8, 0 * 16}};
+
+    LNAGainField field_lna{
+        {18 * 8, 0 * 16}};
+
+    VGAGainField field_vga{
+        {21 * 8, 0 * 16}};
+
+    RSSI rssi{
+        {24 * 8, 0, 6 * 8, 4}};
+
+    Channel channel{
+        {24 * 8, 5, 6 * 8, 4}};
+
+    Labels label_send_adv{
+        {{0 * 8, 2 * 8}, "Send Advertisement:", Color::light_grey()}};
+
+    ImageButton button_send_adv{
+        {21 * 8, 1 * 16, 10 * 8, 2 * 16},
+        &bitmap_play,
+        Color::green(),
+        Color::black()};
+
+    Checkbox check_log{
+        {24 * 8, 2 * 8},
+        3,
+        "Log",
+        true};
+
+    Labels label_packets_sent{
+        {{0 * 8, 4 * 8}, "Packets Left:", Color::light_grey()}};
+
+    Text text_packets_sent{
+        {13 * 8, 2 * 16, 12 * 8, 16},
+        "-"};
+
+    Console console{
+        {0, 4 * 16, 240, 240}};
+
+    std::string str_log{""};
+    bool logging{false};
+
+    std::unique_ptr<BLECommLogger> logger{};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::BlePacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const BLEPacketMessage*>(p);
+            this->on_data(message->packet);
+        }};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.done);
+        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/

firmware/application/apps/ble_rx_app.cpp

@@ -0,0 +1,936 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * 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 "ble_rx_app.hpp"
+#include "ble_rx_app.hpp"
+#include "ui_modemsetup.hpp"
+
+#include "modems.hpp"
+#include "audio.hpp"
+#include "io_file.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "ui_fileman.hpp"
+#include "ui_textentry.hpp"
+
+using namespace portapack;
+using namespace modems;
+namespace fs = std::filesystem;
+
+void BLELogger::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+std::string pad_string_with_spaces(int snakes) {
+    std::string paddedStr(snakes, ' ');
+    return paddedStr;
+}
+
+uint64_t copy_mac_address_to_uint64(const uint8_t* macAddress) {
+    uint64_t result = 0;
+
+    // Copy each byte of the MAC address to the corresponding byte in the uint64_t.
+    for (int i = 0; i < 6; ++i) {
+        result |= static_cast<uint64_t>(macAddress[i]) << ((5 - i) * 8);
+    }
+
+    return result;
+}
+
+void reverse_byte_array(uint8_t* arr, int length) {
+    int start = 0;
+    int end = length - 1;
+
+    while (start < end) {
+        // Swap elements at start and end
+        uint8_t temp = arr[start];
+        arr[start] = arr[end];
+        arr[end] = temp;
+
+        // Move the indices towards the center
+        start++;
+        end--;
+    }
+}
+
+namespace ui {
+
+std::string pdu_type_to_string(ADV_PDU_TYPE type) {
+    std::string pduTypeStr = "";
+
+    switch (type) {
+        case ADV_IND:
+            pduTypeStr += "ADV_IND";
+            break;
+        case ADV_DIRECT_IND:
+            pduTypeStr += "ADV_DIRECT_IND";
+            break;
+        case ADV_NONCONN_IND:
+            pduTypeStr += "ADV_NONCONN_IND";
+            break;
+        case SCAN_REQ:
+            pduTypeStr += "SCAN_REQ";
+            break;
+        case SCAN_RSP:
+            pduTypeStr += "SCAN_RSP";
+            break;
+        case CONNECT_REQ:
+            pduTypeStr += "CONNECT_REQ";
+            break;
+        case ADV_SCAN_IND:
+            pduTypeStr += "ADV_SCAN_IND";
+            break;
+        case RESERVED0:
+        case RESERVED1:
+        case RESERVED2:
+        case RESERVED3:
+        case RESERVED4:
+        case RESERVED5:
+        case RESERVED6:
+        case RESERVED7:
+        case RESERVED8:
+            pduTypeStr += "RESERVED";
+            break;
+        default:
+            pduTypeStr += "UNKNOWN";
+            break;
+    }
+
+    return pduTypeStr;
+}
+
+template <>
+void RecentEntriesTable<BleRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line{};
+    line.reserve(30);
+
+    if (!entry.nameString.empty() && entry.include_name) {
+        line = entry.nameString;
+
+        if (line.length() < 17) {
+            line += pad_string_with_spaces(17 - line.length());
+        } else {
+            line = truncate(line, 17);
+        }
+    } else {
+        line = to_string_mac_address(entry.packetData.macAddress, 6, false);
+    }
+
+    // Pushing single digit values down right justified.
+    std::string hitsStr = to_string_dec_int(entry.numHits);
+    int hitsDigits = hitsStr.length();
+    uint8_t hits_spacing = 8 - hitsDigits;
+
+    // Pushing single digit values down right justified.
+    std::string dbStr = to_string_dec_int(entry.dbValue);
+    int dbDigits = dbStr.length();
+    uint8_t db_spacing = 5 - dbDigits;
+
+    line += pad_string_with_spaces(hits_spacing) + hitsStr;
+
+    line += pad_string_with_spaces(db_spacing) + dbStr;
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const BleRecentEntry& entry)
+    : nav_{nav},
+      entry_{entry} {
+    add_children({&button_done,
+                  &button_send,
+                  &button_save,
+                  &label_mac_address,
+                  &text_mac_address,
+                  &label_pdu_type,
+                  &text_pdu_type,
+                  &labels});
+
+    text_mac_address.set(to_string_mac_address(entry.packetData.macAddress, 6, false));
+    text_pdu_type.set(pdu_type_to_string(entry.pduType));
+
+    button_done.on_select = [&nav](const ui::Button&) {
+        nav.pop();
+    };
+
+    button_send.on_select = [this, &nav](const ui::Button&) {
+        auto packetToSend = build_packet();
+        nav.set_on_pop([packetToSend, &nav]() {
+            nav.replace<BLETxView>(packetToSend);
+        });
+        nav.pop();
+    };
+
+    button_save.on_select = [this, &nav](const ui::Button&) {
+        auto packetToSave = build_packet();
+
+        packetFileBuffer = "";
+        text_prompt(
+            nav,
+            packetFileBuffer,
+            64,
+            [this, packetToSave](std::string& buffer) {
+                on_save_file(buffer, packetToSave);
+            });
+    };
+}
+
+void BleRecentEntryDetailView::on_save_file(const std::string value, BLETxPacket packetToSave) {
+    ensure_directory(packet_save_path);
+    auto folder = packet_save_path.parent_path();
+    auto ext = packet_save_path.extension();
+    auto new_path = folder / value + ext;
+
+    saveFile(new_path, packetToSave);
+}
+
+bool BleRecentEntryDetailView::saveFile(const std::filesystem::path& path, BLETxPacket packetToSave) {
+    File f;
+    auto error = f.create(path);
+    if (error)
+        return false;
+
+    std::string macAddressStr = packetToSave.macAddress;
+    std::string advertisementDataStr = packetToSave.advertisementData;
+    std::string packetCountStr = packetToSave.packetCount;
+
+    std::string packetString = macAddressStr + ' ' + advertisementDataStr + ' ' + packetCountStr;
+
+    f.write(packetString.c_str(), packetString.length());
+
+    return true;
+}
+
+void BleRecentEntryDetailView::update_data() {
+}
+
+void BleRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+Rect BleRecentEntryDetailView::draw_field(
+    Painter& painter,
+    const Rect& draw_rect,
+    const Style& style,
+    const std::string& label,
+    const std::string& value) {
+    const int label_length_max = 4;
+
+    painter.draw_string(Point{draw_rect.left(), draw_rect.top()}, style, label);
+    painter.draw_string(Point{draw_rect.left() + (label_length_max + 1) * 8, draw_rect.top()}, style, value);
+
+    return {draw_rect.left(), draw_rect.top() + draw_rect.height(), draw_rect.width(), draw_rect.height()};
+}
+
+void BleRecentEntryDetailView::paint(Painter& painter) {
+    View::paint(painter);
+
+    const auto s = style();
+    const auto rect = screen_rect();
+
+    auto field_rect = Rect{rect.left(), rect.top() + 64, rect.width(), 16};
+
+    uint8_t type[total_data_lines];
+    uint8_t length[total_data_lines];
+    uint8_t data[total_data_lines][40];
+
+    int currentByte = 0;
+    int currentPacket = 0;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+
+    switch (entry_.pduType) {
+        case ADV_IND:
+        case ADV_NONCONN_IND:
+        case SCAN_RSP:
+        case ADV_SCAN_IND: {
+            ADV_PDU_PAYLOAD_TYPE_0_2_4_6* advertiseData = (ADV_PDU_PAYLOAD_TYPE_0_2_4_6*)entry_.packetData.data;
+
+            for (currentByte = 0; (currentByte < entry_.packetData.dataLen) && (currentPacket < total_data_lines);) {
+                length[currentPacket] = advertiseData->Data[currentByte++];
+                type[currentPacket] = advertiseData->Data[currentByte++];
+
+                // Subtract 1 because type is part of the length.
+                for (i = 0; i < length[currentPacket] - 1; i++) {
+                    data[currentPacket][i] = advertiseData->Data[currentByte++];
+                }
+
+                currentPacket++;
+            }
+
+            for (i = 0; i < currentPacket; i++) {
+                uint8_t number_data_lines = ceil((float)(length[i] - 1) / 10.0);
+                uint8_t current_line = 0;
+                std::array<std::string, total_data_lines> data_strings{};
+
+                for (j = 0; (j < (number_data_lines * 10)) && (j < length[i] - 1); j++) {
+                    if ((j / 10) != current_line) {
+                        current_line++;
+                    }
+
+                    data_strings[current_line] += to_string_hex(data[i][j], 2);
+                }
+
+                // Read the type back to the total length.
+                field_rect = draw_field(painter, field_rect, s, to_string_hex(length[i]), to_string_hex(type[i]) + pad_string_with_spaces(3) + data_strings[0]);
+
+                if (number_data_lines > 1) {
+                    for (k = 1; k < number_data_lines; k++) {
+                        if (!data_strings[k].empty()) {
+                            field_rect = draw_field(painter, field_rect, s, "", pad_string_with_spaces(5) + data_strings[k]);
+                        }
+                    }
+                }
+            }
+        } break;
+
+        case ADV_DIRECT_IND:
+        case SCAN_REQ: {
+            ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)entry_.packetData.data;
+            uint8_t type = 0xFF;
+            field_rect = draw_field(painter, field_rect, s, to_string_hex(entry_.packetData.dataLen), to_string_hex(type) + pad_string_with_spaces(3) + to_string_mac_address(directed_mac_data->A1, 6, false));
+        } break;
+
+        case CONNECT_REQ:
+        default: {
+            uint8_t type = 0xFF;
+
+            // TODO: Display Connect Request Information. For right now just printing full hex data.
+            // This struct will eventually be used to break apart containing data of Connect Request.
+            // ADV_PDU_PAYLOAD_TYPE_5 * connect_req = (ADV_PDU_PAYLOAD_TYPE_5 *)entry_.packetData.data;
+
+            for (currentByte = 0; (currentByte < entry_.packetData.dataLen); currentByte++) {
+                data[0][currentByte] = entry_.packetData.data[currentByte];
+            }
+
+            uint8_t number_data_lines = ceil((float)entry_.packetData.dataLen / 10.0);
+            uint8_t current_line = 0;
+            std::array<std::string, total_data_lines> data_strings{};
+
+            for (j = 0; (j < (number_data_lines * 10)) && (j < entry_.packetData.dataLen); j++) {
+                if ((j / 10) != current_line) {
+                    current_line++;
+                }
+
+                data_strings[current_line] += to_string_hex(data[0][j], 2);
+            }
+
+            field_rect = draw_field(painter, field_rect, s, to_string_hex(entry_.packetData.dataLen), to_string_hex(type) + pad_string_with_spaces(3) + data_strings[0]);
+
+            if (number_data_lines > 1) {
+                for (k = 1; k < number_data_lines; k++) {
+                    if (!data_strings[k].empty()) {
+                        field_rect = draw_field(painter, field_rect, s, "", pad_string_with_spaces(5) + data_strings[k]);
+                    }
+                }
+            }
+        } break;
+    }
+}
+
+void BleRecentEntryDetailView::set_entry(const BleRecentEntry& entry) {
+    entry_ = entry;
+    set_dirty();
+}
+
+BLETxPacket BleRecentEntryDetailView::build_packet() {
+    BLETxPacket bleTxPacket;
+    memset(&bleTxPacket, 0, sizeof(BLETxPacket));
+
+    std::string macAddressStr = to_string_mac_address(entry_.packetData.macAddress, 6, true);
+
+    strncpy(bleTxPacket.macAddress, macAddressStr.c_str(), 12);
+    strncpy(bleTxPacket.advertisementData, entry_.dataString.c_str(), entry_.packetData.dataLen * 2);
+    strncpy(bleTxPacket.packetCount, "50", 3);
+    bleTxPacket.packet_count = 50;
+
+    return bleTxPacket;
+}
+
+static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
+    uint64_t freq_hz;
+
+    switch (channel_number) {
+        case 37:
+            freq_hz = 2'402'000'000ull;
+            break;
+        case 38:
+            freq_hz = 2'426'000'000ull;
+            break;
+        case 39:
+            freq_hz = 2'480'000'000ull;
+            break;
+        case 0 ... 10:
+            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
+            break;
+        case 11 ... 36:
+            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
+            break;
+        default:
+            freq_hz = UINT64_MAX;
+    }
+
+    return freq_hz;
+}
+
+void BLERxView::focus() {
+    options_channel.focus();
+}
+
+void BLERxView::file_error() {
+    nav_.display_modal("Error", "File read error.");
+}
+
+BLERxView::BLERxView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_btle_rx);
+
+    add_children({&rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &options_channel,
+                  &field_frequency,
+                  &check_log,
+                  &button_find,
+                  &check_name,
+                  &label_sort,
+                  &options_sort,
+                  &label_found,
+                  &text_found_count,
+                  &check_serial_log,
+                  &button_filter,
+                  &button_save_list,
+                  &button_clear_list,
+                  &button_switch,
+                  &recent_entries_view});
+
+    recent_entries_view.on_select = [this](const BleRecentEntry& entry) {
+        nav_.push<BleRecentEntryDetailView>(entry);
+    };
+
+    check_serial_log.on_select = [this](Checkbox&, bool v) {
+        serial_logging = v;
+        if (v) {
+            usb_serial_thread = std::make_unique<UsbSerialThread>();
+        } else {
+            usb_serial_thread.reset();
+        }
+    };
+    check_serial_log.set_value(serial_logging);
+
+    ensure_directory(find_packet_path);
+    ensure_directory(log_packets_path);
+    ensure_directory(packet_save_path);
+
+    filterBuffer = filter;
+
+    button_filter.on_select = [this](Button&) {
+        text_prompt(
+            nav_,
+            filterBuffer,
+            64,
+            [this](std::string& buffer) {
+                on_filter_change(buffer);
+            });
+    };
+
+    logger = std::make_unique<BLELogger>();
+
+    check_log.on_select = [this](Checkbox&, bool v) {
+        str_log = "";
+        logging = v;
+
+        if (logger && logging)
+            logger->append(
+                "BLERX/Logs"
+                "/BLELOG_" +
+                to_string_timestamp(rtc_time::now()) + ".TXT");
+    };
+    check_log.set_value(logging);
+
+    button_save_list.on_select = [this, &nav](const ui::Button&) {
+        listFileBuffer = "";
+        text_prompt(
+            nav,
+            listFileBuffer,
+            64,
+            [this](std::string& buffer) {
+                on_save_file(buffer);
+            });
+    };
+
+    button_clear_list.on_select = [this](Button&) {
+        recent.clear();
+    };
+
+    button_switch.on_select = [&nav](Button&) {
+        nav.replace<BLETxView>();
+    };
+
+    field_frequency.set_step(0);
+
+    check_name.set_value(name_enable);
+
+    check_name.on_select = [this](Checkbox&, bool v) {
+        name_enable = v;
+        setAllMembersToValue(recent, &BleRecentEntry::include_name, v);
+        recent_entries_view.set_dirty();
+    };
+
+    options_channel.on_change = [this](size_t index, int32_t v) {
+        channel_index = (uint8_t)index;
+
+        // If we selected Auto don't do anything and Auto will handle changing.
+        if (v == 40) {
+            auto_channel = true;
+            return;
+        } else {
+            auto_channel = false;
+        }
+
+        field_frequency.set_value(get_freq_by_channel_number(v));
+        channel_number = v;
+
+        baseband::set_btlerx(channel_number);
+    };
+
+    options_sort.on_change = [this](size_t index, int32_t v) {
+        sort_index = (uint8_t)index;
+        handle_entries_sort(v);
+    };
+
+    options_channel.set_selected_index(channel_index, true);
+    options_sort.set_selected_index(sort_index, true);
+
+    button_find.on_select = [this](Button&) {
+        auto open_view = nav_.push<FileLoadView>(".TXT");
+        open_view->on_changed = [this](std::filesystem::path new_file_path) {
+            on_file_changed(new_file_path);
+
+            // nav_.set_on_pop([this]() { button_play.focus(); });
+        };
+    };
+
+    // Auto-configure modem for LCR RX (will be removed later)
+    baseband::set_btlerx(channel_number);
+
+    receiver_model.enable();
+}
+
+std::string BLERxView::build_line_str(BleRecentEntry entry) {
+    std::string macAddressStr = to_string_mac_address(entry.packetData.macAddress, 6, false) + ",";
+    std::string timestameStr = entry.timestamp + ",";
+    std::string nameStr = entry.nameString + ",";
+    std::string pduStr = pdu_type_to_string(entry.pduType) + ",";
+    std::string dataStr = "0x" + entry.dataString + ",";
+    std::string hitsStr = to_string_dec_int(entry.numHits) + ",";
+    std::string dbStr = to_string_dec_int(entry.dbValue) + ",";
+    std::string channelStr = to_string_dec_int(entry.channelNumber) + ",";
+
+    std::string lineStr = timestameStr + macAddressStr + nameStr + pduStr + dataStr + hitsStr + dbStr + channelStr;
+    lineStr += pad_string_with_spaces(maxLineLength - lineStr.length());
+
+    return lineStr;
+}
+
+void BLERxView::on_save_file(const std::string value) {
+    auto folder = packet_save_path.parent_path();
+    auto ext = packet_save_path.extension();
+    auto new_path = folder / value + ext;
+
+    saveFile(new_path);
+}
+
+bool BLERxView::saveFile(const std::filesystem::path& path) {
+    // Check to see if file was previously saved.
+    bool file_existed = file_exists(path);
+
+    // Attempt to open, if it can't be opened. Create new.
+    auto src = std::make_unique<File>();
+    auto error = src->open(path, false, true);
+
+    if (error) {
+        return false;
+    }
+
+    for (const auto& entry : recent) {
+        tempList.emplace_back(entry);
+    }
+
+    if (!file_existed) {
+        src->write_line(headerStr.c_str());
+
+        auto it = tempList.begin();
+
+        while (it != tempList.end()) {
+            BleRecentEntry entry = (BleRecentEntry)*it;
+            src->write_line(build_line_str(entry).c_str());
+            it++;
+        }
+    } else {
+        // Check file for macAddressStr before adding.
+        char currentLine[maxLineLength];
+        uint64_t startPos = headerStr.length();
+        uint64_t bytesRead = 0;
+        uint64_t bytePos = 0;
+
+        File::Size currentSize = src->size();
+
+        auto dst = std::make_unique<File>();
+        const std::filesystem::path tempFilePath = path + "~";
+        auto error = dst->open(tempFilePath, false, true);
+
+        if (error) {
+            return false;
+        }
+
+        dst->write_line(headerStr.c_str());
+
+        src->seek(startPos);
+
+        // Look for ones found and rewrite.
+        do {
+            memset(currentLine, 0, maxLineLength);
+
+            bytesRead = readUntil(*src, currentLine, currentSize, '\n');
+
+            if (!bytesRead) {
+                break;
+            }
+
+            bytePos += bytesRead;
+
+            std::string lineStr = "";
+            std::string macAddressStr = "";
+            BleRecentEntry foundEntry;
+
+            char* token;
+            token = strtok(currentLine, ",");
+
+            while (token != NULL) {
+                auto it = tempList.begin();
+
+                while (it != tempList.end()) {
+                    BleRecentEntry& entry = reinterpret_cast<BleRecentEntry&>(*it);
+
+                    macAddressStr = to_string_mac_address(entry.packetData.macAddress, 6, false);
+
+                    if (strstr(token, macAddressStr.c_str()) != NULL) {
+                        entry.entryFound = true;
+                        foundEntry = entry;
+                        break;
+                    }
+
+                    it++;
+                }
+
+                if (foundEntry.entryFound) {
+                    break;
+                }
+
+                token = strtok(NULL, ",");
+            }
+
+            if (foundEntry.entryFound) {
+                dst->write_line(build_line_str(foundEntry).c_str());
+            }
+
+        } while (bytePos <= currentSize);
+
+        // Write the ones not found.
+        auto it = tempList.begin();
+
+        while (it != tempList.end()) {
+            BleRecentEntry entry = (BleRecentEntry)*it;
+
+            if (!entry.entryFound) {
+                dst->write_line(build_line_str(entry).c_str());
+            }
+
+            it++;
+        }
+
+        // Close files before renaming/deleting.
+        src.reset();
+        dst.reset();
+
+        // Delete original and overwrite with temp file.
+        delete_file(path);
+        rename_file(tempFilePath, path);
+    }
+
+    tempList.clear();
+
+    return true;
+}
+
+void BLERxView::on_data(BlePacketData* packet) {
+    if (!logging) {
+        str_log = "";
+    }
+
+    str_console += pdu_type_to_string((ADV_PDU_TYPE)packet->type);
+    str_console += " Len:";
+    str_console += to_string_dec_uint(packet->size);
+    str_console += " Mac:";
+    str_console += to_string_mac_address(packet->macAddress, 6, false);
+    str_console += " Data:";
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        str_console += to_string_hex(packet->data[i], 2);
+    }
+
+    uint64_t macAddressEncoded = copy_mac_address_to_uint64(packet->macAddress);
+
+    // Start of Packet stuffing.
+    // Masking off the top 2 bytes to avoid invalid keys.
+    auto& entry = ::on_packet(recent, macAddressEncoded & 0xFFFFFFFFFFFF);
+    updateEntry(packet, entry, (ADV_PDU_TYPE)packet->type);
+
+    // Add entries if they meet the criteria.
+    auto value = filter;
+    resetFilteredEntries(recent, [&value](const BleRecentEntry& entry) {
+        return (entry.dataString.find(value) == std::string::npos) && (entry.nameString.find(value) == std::string::npos);
+    });
+
+    handle_entries_sort(options_sort.selected_index());
+
+    // Log at End of Packet.
+    if (logger && logging) {
+        logger->log_raw_data(str_console + "\r\n");
+    }
+
+    if (serial_logging) {
+        usb_serial_thread->serial_str = str_console + "\r\n";
+        usb_serial_thread->str_ready = true;
+    }
+    str_console = "";
+
+    if (!searchList.empty()) {
+        auto it = searchList.begin();
+
+        while (it != searchList.end()) {
+            std::string searchStr = (std::string)*it;
+
+            if (entry.dataString.find(searchStr) != std::string::npos) {
+                searchList.erase(it);
+                found_count++;
+                break;
+            }
+
+            it++;
+        }
+
+        text_found_count.set(to_string_dec_uint(found_count) + "/" + to_string_dec_uint(total_count));
+    }
+}
+
+void BLERxView::on_filter_change(std::string value) {
+    // New filter? Reset list from recent entries.
+    if (filter != value) {
+        resetFilteredEntries(recent, [&value](const BleRecentEntry& entry) {
+            return (entry.dataString.find(value) == std::string::npos) && (entry.nameString.find(value) == std::string::npos);
+        });
+    }
+
+    filter = value;
+}
+
+void BLERxView::on_file_changed(const std::filesystem::path& new_file_path) {
+    file_path = fs::path(u"/") + new_file_path;
+    found_count = 0;
+    total_count = 0;
+    searchList.clear();
+
+    {  // Get the size of the data file.
+        File data_file;
+        auto error = data_file.open(file_path, true, false);
+        if (error) {
+            file_error();
+            file_path = "";
+            return;
+        }
+
+        uint64_t bytesRead = 0;
+        uint64_t bytePos = 0;
+        char currentLine[maxLineLength];
+
+        do {
+            memset(currentLine, 0, maxLineLength);
+
+            bytesRead = readUntil(data_file, currentLine, maxLineLength, '\n');
+
+            // Remove return if found.
+            if (currentLine[strlen(currentLine)] == '\r') {
+                currentLine[strlen(currentLine)] = '\0';
+            }
+
+            if (!bytesRead) {
+                break;
+            }
+
+            searchList.push_back(currentLine);
+            total_count++;
+
+            bytePos += bytesRead;
+
+        } while (bytePos <= data_file.size());
+    }
+}
+
+// called each 1/60th of second, so 6 = 100ms
+void BLERxView::on_timer() {
+    if (++timer_count == timer_period) {
+        timer_count = 0;
+
+        if (auto_channel) {
+            int min = 37;
+            int max = 39;
+
+            int randomChannel = min + std::rand() % (max - min + 1);
+
+            field_frequency.set_value(get_freq_by_channel_number(randomChannel));
+            baseband::set_btlerx(randomChannel);
+        }
+    }
+}
+
+void BLERxView::handle_entries_sort(uint8_t index) {
+    switch (index) {
+        case 0:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
+            break;
+        case 1:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.numHits; }, false);
+            break;
+        case 2:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.dbValue; }, false);
+            break;
+        case 3:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
+            break;
+        case 4:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.nameString; }, true);
+            break;
+        default:
+            break;
+    }
+
+    recent_entries_view.set_dirty();
+}
+
+void BLERxView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
+    recent_entries_view.set_parent_rect(content_rect);
+}
+
+BLERxView::~BLERxView() {
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type) {
+    std::string data_string;
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        data_string += to_string_hex(packet->data[i], 2);
+    }
+
+    entry.dbValue = packet->max_dB;
+    entry.timestamp = to_string_timestamp(rtc_time::now());
+    entry.dataString = data_string;
+
+    entry.packetData.type = packet->type;
+    entry.packetData.size = packet->size;
+    entry.packetData.dataLen = packet->dataLen;
+
+    // Mac Address of sender.
+    entry.packetData.macAddress[0] = packet->macAddress[0];
+    entry.packetData.macAddress[1] = packet->macAddress[1];
+    entry.packetData.macAddress[2] = packet->macAddress[2];
+    entry.packetData.macAddress[3] = packet->macAddress[3];
+    entry.packetData.macAddress[4] = packet->macAddress[4];
+    entry.packetData.macAddress[5] = packet->macAddress[5];
+
+    entry.numHits++;
+    entry.pduType = pdu_type;
+    entry.channelNumber = channel_number;
+
+    // Parse Data Section into buffer to be interpretted later.
+    for (int i = 0; i < packet->dataLen; i++) {
+        entry.packetData.data[i] = packet->data[i];
+    }
+
+    entry.include_name = check_name.value();
+
+    // Only parse name for advertisment packets and empty name entries
+    if ((pdu_type == ADV_IND || pdu_type == ADV_NONCONN_IND || pdu_type == SCAN_RSP || pdu_type == ADV_SCAN_IND) && entry.nameString.empty()) {
+        ADV_PDU_PAYLOAD_TYPE_0_2_4_6* advertiseData = (ADV_PDU_PAYLOAD_TYPE_0_2_4_6*)entry.packetData.data;
+
+        uint8_t currentByte = 0;
+        uint8_t length = 0;
+        uint8_t type = 0;
+
+        std::string decoded_data;
+        for (currentByte = 0; (currentByte < entry.packetData.dataLen);) {
+            length = advertiseData->Data[currentByte++];
+            type = advertiseData->Data[currentByte++];
+
+            // Subtract 1 because type is part of the length.
+            for (int i = 0; i < length - 1; i++) {
+                if (type == 0x08 || type == 0x09) {
+                    decoded_data += (char)advertiseData->Data[currentByte];
+                }
+                currentByte++;
+            }
+            if (!decoded_data.empty()) {
+                entry.nameString = std::move(decoded_data);
+                break;
+            }
+        }
+    } else if (pdu_type == ADV_DIRECT_IND || pdu_type == SCAN_REQ) {
+        ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)entry.packetData.data;
+        reverse_byte_array(directed_mac_data->A1, 6);
+    }
+}
+
+} /* namespace ui */

firmware/application/apps/ble_rx_app.hpp

@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * 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 __BLE_RX_APP_H__
+#define __BLE_RX_APP_H__
+
+#include "ble_tx_app.hpp"
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+#include "usb_serial_thread.hpp"
+
+#include "recent_entries.hpp"
+
+class BLELogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+typedef enum {
+    ADV_IND = 0,
+    ADV_DIRECT_IND = 1,
+    ADV_NONCONN_IND = 2,
+    SCAN_REQ = 3,
+    SCAN_RSP = 4,
+    CONNECT_REQ = 5,
+    ADV_SCAN_IND = 6,
+    RESERVED0 = 7,
+    RESERVED1 = 8,
+    RESERVED2 = 9,
+    RESERVED3 = 10,
+    RESERVED4 = 11,
+    RESERVED5 = 12,
+    RESERVED6 = 13,
+    RESERVED7 = 14,
+    RESERVED8 = 15
+} ADV_PDU_TYPE;
+
+struct BleRecentEntry {
+    using Key = uint64_t;
+
+    static constexpr Key invalid_key = 0xffffffff;
+
+    uint64_t macAddress;
+    int dbValue;
+    BlePacketData packetData;
+    std::string timestamp;
+    std::string dataString;
+    std::string nameString;
+    bool include_name;
+    uint16_t numHits;
+    ADV_PDU_TYPE pduType;
+    uint8_t channelNumber;
+    bool entryFound;
+
+    BleRecentEntry()
+        : BleRecentEntry{0} {
+    }
+
+    BleRecentEntry(
+        const uint64_t macAddress)
+        : macAddress{macAddress},
+          dbValue{},
+          packetData{},
+          timestamp{},
+          dataString{},
+          nameString{},
+          include_name{},
+          numHits{},
+          pduType{},
+          channelNumber{},
+          entryFound{} {
+    }
+
+    Key key() const {
+        return macAddress;
+    }
+};
+
+using BleRecentEntries = RecentEntries<BleRecentEntry>;
+using BleRecentEntriesView = RecentEntriesView<BleRecentEntries>;
+
+class BleRecentEntryDetailView : public View {
+   public:
+    BleRecentEntryDetailView(NavigationView& nav, const BleRecentEntry& entry);
+
+    void set_entry(const BleRecentEntry& new_entry);
+    const BleRecentEntry& entry() const { return entry_; };
+
+    void update_data();
+    void focus() override;
+    void paint(Painter&) override;
+
+   private:
+    NavigationView& nav_;
+    BleRecentEntry entry_{};
+    BLETxPacket build_packet();
+    void on_save_file(const std::string value, BLETxPacket packetToSave);
+    bool saveFile(const std::filesystem::path& path, BLETxPacket packetToSave);
+    std::string packetFileBuffer{};
+    std::filesystem::path packet_save_path{u"BLERX/Lists/????.csv"};
+
+    static constexpr uint8_t total_data_lines{5};
+
+    Labels label_mac_address{
+        {{0 * 8, 0 * 16}, "Mac Address:", Color::light_grey()}};
+
+    Text text_mac_address{
+        {12 * 8, 0 * 16, 17 * 8, 16},
+        "-"};
+
+    Labels label_pdu_type{
+        {{0 * 8, 1 * 16}, "PDU Type:", Color::light_grey()}};
+
+    Text text_pdu_type{
+        {9 * 8, 1 * 16, 17 * 8, 16},
+        "-"};
+
+    Labels labels{
+        {{0 * 8, 3 * 16}, "Len", Color::light_grey()},
+        {{5 * 8, 3 * 16}, "Type", Color::light_grey()},
+        {{10 * 8, 3 * 16}, "Value", Color::light_grey()},
+    };
+
+    Button button_send{
+        {19, 224, 96, 24},
+        "Send"};
+
+    Button button_done{
+        {125, 224, 96, 24},
+        "Done"};
+
+    Button button_save{
+        {72, 264, 96, 24},
+        "Save"};
+
+    bool send_updates{false};
+
+    Rect draw_field(
+        Painter& painter,
+        const Rect& draw_rect,
+        const Style& style,
+        const std::string& label,
+        const std::string& value);
+};
+
+class BLERxView : public View {
+   public:
+    BLERxView(NavigationView& nav);
+    ~BLERxView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    std::string title() const override { return "BLE RX"; };
+
+   private:
+    std::string build_line_str(BleRecentEntry entry);
+    void on_save_file(const std::string value);
+    bool saveFile(const std::filesystem::path& path);
+    std::unique_ptr<UsbSerialThread> usb_serial_thread{};
+    void on_data(BlePacketData* packetData);
+    void on_filter_change(std::string value);
+    void on_file_changed(const std::filesystem::path& new_file_path);
+    void file_error();
+    void on_timer();
+    void handle_entries_sort(uint8_t index);
+    void updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type);
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{
+        2402000000 /* frequency */,
+        4000000 /* bandwidth */,
+        4000000 /* sampling rate */,
+        ReceiverModel::Mode::WidebandFMAudio};
+
+    uint8_t channel_index{0};
+    uint8_t sort_index{0};
+    std::string filter{};
+    bool logging{false};
+    bool serial_logging{false};
+
+    bool name_enable{true};
+    app_settings::SettingsManager settings_{
+        "rx_ble",
+        app_settings::Mode::RX,
+        {
+            {"channel_index"sv, &channel_index},
+            {"sort_index"sv, &sort_index},
+            {"filter"sv, &filter},
+            {"log"sv, &logging},
+            // disabled to always start without USB serial activated until we can make it non blocking if not connected
+            // {"serial_log"sv, &serial_logging},
+            {"name"sv, &name_enable},
+        }};
+
+    std::string str_console = "";
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+    uint8_t channel_number = 37;
+    bool auto_channel = false;
+
+    int16_t timer_count{0};
+    int16_t timer_period{6};  // 100ms
+
+    std::string filterBuffer{};
+    std::string listFileBuffer{};
+    std::string headerStr = "Timestamp, MAC Address, Name, Packet Type, Data, Hits, dB, Channel";
+    uint16_t maxLineLength = 140;
+
+    std::filesystem::path file_path{};
+    uint64_t found_count = 0;
+    uint64_t total_count = 0;
+    std::vector<std::string> searchList{};
+
+    std::filesystem::path find_packet_path{u"BLERX/Find/????.TXT"};
+    std::filesystem::path log_packets_path{u"BLERX/Logs/????.TXT"};
+    std::filesystem::path packet_save_path{u"BLERX/Lists/????.csv"};
+
+    static constexpr auto header_height = 4 * 16;
+    static constexpr auto switch_button_height = 3 * 16;
+
+    OptionsField options_channel{
+        {0 * 8, 0 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39},
+         {"Auto", 40}}};
+
+    RxFrequencyField field_frequency{
+        {6 * 8, 0 * 16},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {16 * 8, 0 * 16}};
+
+    LNAGainField field_lna{
+        {18 * 8, 0 * 16}};
+
+    VGAGainField field_vga{
+        {21 * 8, 0 * 16}};
+
+    RSSI rssi{
+        {24 * 8, 0, 6 * 8, 4}};
+
+    Channel channel{
+        {24 * 8, 5, 6 * 8, 4}};
+
+    Labels label_sort{
+        {{0 * 8, 3 * 8}, "Sort:", Color::light_grey()}};
+
+    OptionsField options_sort{
+        {5 * 8, 3 * 8},
+        4,
+        {{"MAC", 0},
+         {"Hits", 1},
+         {"dB", 2},
+         {"Time", 3},
+         {"Name", 4}}};
+
+    Button button_filter{
+        {11 * 8, 3 * 8, 4 * 8, 16},
+        "Filter"};
+
+    Checkbox check_log{
+        {17 * 8, 3 * 8},
+        3,
+        "Log",
+        true};
+
+    Checkbox check_name{
+        {23 * 8, 3 * 8},
+        3,
+        "Name",
+        true};
+
+    Button button_find{
+        {0 * 8, 6 * 8, 4 * 8, 16},
+        "Find"};
+
+    Labels label_found{
+        {{5 * 8, 6 * 8}, "Found:", Color::light_grey()}};
+
+    Text text_found_count{
+        {11 * 8, 3 * 16, 20 * 8, 16},
+        "0/0"};
+
+    Checkbox check_serial_log{
+        {17 * 8, 3 * 16 - 2},
+        7,
+        "USB Log",
+        true};
+
+    Console console{
+        {0, 4 * 16, 240, 240}};
+
+    Button button_clear_list{
+        {2 * 8, 320 - (16 + 32), 7 * 8, 32},
+        "Clear"};
+
+    Button button_save_list{
+        {11 * 8, 320 - (16 + 32), 11 * 8, 32},
+        "Export CSV"};
+
+    Button button_switch{
+        {240 - 6 * 8, 320 - (16 + 32), 4 * 8, 32},
+        "Tx"};
+
+    std::string str_log{""};
+    std::unique_ptr<BLELogger> logger{};
+
+    BleRecentEntries recent{};
+    BleRecentEntries tempList{};
+
+    const RecentEntriesColumns columns{{
+        {"Mac Address", 17},
+        {"Hits", 7},
+        {"dB", 4},
+    }};
+
+    BleRecentEntriesView recent_entries_view{columns, recent};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::BlePacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const BLEPacketMessage*>(p);
+            this->on_data(message->packet);
+        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/

firmware/application/apps/ble_tx_app.cpp

@@ -0,0 +1,561 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * 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 "ble_tx_app.hpp"
+#include "ble_rx_app.hpp"
+
+#include "ui_fileman.hpp"
+#include "ui_modemsetup.hpp"
+
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "io_file.hpp"
+#include "modems.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "rtc_time.hpp"
+#include "string_format.hpp"
+
+using namespace portapack;
+using namespace modems;
+namespace fs = std::filesystem;
+
+void BLELoggerTx::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+bool hasValidHexPairs(const std::string& str, int totalPairs) {
+    int validPairs = 0;
+
+    for (int i = 0; i < totalPairs * 2; i += 2) {
+        char c1 = str[i];
+        char c2 = str[i + 1];
+
+        if (!(std::isxdigit(c1) && std::isxdigit(c2))) {
+            return false;  // Return false if any pair is invalid.
+        }
+
+        validPairs++;
+    }
+
+    return (validPairs == totalPairs);
+}
+
+std::vector<std::string> splitIntoStrings(const char* input) {
+    std::vector<std::string> result;
+    int length = std::strlen(input);
+    int start = 0;
+
+    while (start < length) {
+        int remaining = length - start;
+        int chunkSize = (remaining > 29) ? 29 : remaining;
+        result.push_back(std::string(input + start, chunkSize));
+        start += chunkSize;
+    }
+
+    return result;
+}
+
+uint32_t stringToUint32(const std::string& str) {
+    size_t pos = 0;
+    uint32_t result = 0;
+
+    while (pos < str.size() && std::isdigit(str[pos])) {
+        int digit = str[pos] - '0';
+
+        // Check for overflow before adding the next digit
+        if (result > (UINT32_MAX - digit) / 10) {
+            return 0;
+        }
+
+        result = result * 10 + digit;
+        pos++;
+    }
+
+    return result;
+}
+
+static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
+    uint64_t freq_hz;
+
+    switch (channel_number) {
+        case 37:
+            freq_hz = 2'402'000'000ull;
+            break;
+        case 38:
+            freq_hz = 2'426'000'000ull;
+            break;
+        case 39:
+            freq_hz = 2'480'000'000ull;
+            break;
+        case 0 ... 10:
+            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
+            break;
+        case 11 ... 36:
+            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
+            break;
+        default:
+            freq_hz = UINT64_MAX;
+    }
+
+    return freq_hz;
+}
+
+namespace ui {
+
+void BLETxView::focus() {
+    button_open.focus();
+}
+
+bool BLETxView::is_active() const {
+    return (bool)is_running;
+}
+
+void BLETxView::file_error() {
+    nav_.display_modal("Error", "File read error.");
+}
+
+bool BLETxView::saveFile(const std::filesystem::path& path) {
+    File f;
+    auto error = f.create(path);
+    if (error)
+        return false;
+
+    for (uint32_t i = 0; i < num_packets; i++) {
+        std::string macAddressStr = packets[i].macAddress;
+        std::string advertisementDataStr = packets[i].advertisementData;
+        std::string packetCountStr = packets[i].packetCount;
+
+        std::string packetString = macAddressStr + ' ' + advertisementDataStr + ' ' + packetCountStr;
+
+        // Are we on the last line?
+        if (i != num_packets - 1) {
+            packetString += '\n';
+        }
+
+        f.write(packetString.c_str(), packetString.length());
+    }
+
+    return true;
+}
+
+void BLETxView::toggle() {
+    if (is_active()) {
+        stop();
+    } else {
+        start();
+    }
+}
+
+void BLETxView::start() {
+    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+    transmitter_model.enable();
+
+    // Generate new random Mac Address.
+    generateRandomMacAddress(randomMac);
+
+    // If this is our first run, check file.
+    if (!is_active()) {
+        File data_file;
+
+        auto error = data_file.open(file_path);
+        if (error && !file_override) {
+            file_error();
+            check_loop.set_value(false);
+            return;
+        }
+
+        button_play.set_bitmap(&bitmap_stop);
+        is_running = true;
+    }
+
+    char advertisementData[63] = {0};
+    strcpy(advertisementData, packets[current_packet].advertisementData);
+
+    // TODO: Make this a checkbox.
+    if (!markedBytes.empty()) {
+        for (size_t i = 0; i < strlen(advertisementData); i++) {
+            bool found = false;
+
+            auto it = std::find(markedBytes.begin(), markedBytes.end(), i);
+
+            if (it != markedBytes.end()) {
+                found = true;
+            }
+
+            if (found) {
+                uint8_t hexDigit;
+                switch (marked_data_sequence.selected_index_value()) {
+                    case 0:
+                        hexDigit = marked_counter++;
+                        break;
+                    case 1:
+                        hexDigit = marked_counter--;
+                        break;
+                    case 2: {
+                        uint8_t min = 0x00;
+                        uint8_t max = 0x0F;
+
+                        hexDigit = min + std::rand() % (max - min + 1);
+                    } break;
+                    default:
+                        hexDigit = 0;
+                        break;
+                }
+
+                advertisementData[i] = uint_to_char(hexDigit, 16);
+
+                // Bounding to Hex.
+                if (marked_counter == 16) {
+                    marked_counter = 0;
+                } else if (marked_counter == 255) {
+                    marked_counter = 15;
+                }
+            }
+        }
+    }
+
+    // Setup next packet configuration.
+    progressbar.set_max(packets[current_packet].packet_count);
+    baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, advertisementData, pduType);
+}
+
+void BLETxView::stop() {
+    transmitter_model.disable();
+    baseband::shutdown();
+
+    progressbar.set_value(0);
+    button_play.set_bitmap(&bitmap_play);
+    check_loop.set_value(false);
+
+    update_current_packet(packets[0], 0);
+
+    is_running = false;
+}
+
+void BLETxView::reset() {
+    transmitter_model.disable();
+    baseband::shutdown();
+
+    start();
+}
+
+// called each 1/60th of second, so 6 = 100ms
+void BLETxView::on_timer() {
+    if (++timer_count == timer_period) {
+        timer_count = 0;
+
+        if (is_active()) {
+            // Reached end of current packet repeats.
+            if (packet_counter == 0) {
+                // Done sending all packets.
+                if (current_packet == (num_packets - 1)) {
+                    current_packet = 0;
+
+                    // If looping, restart from beginning.
+                    if (check_loop.value()) {
+                        update_current_packet(packets[current_packet], current_packet);
+                        reset();
+                    } else {
+                        stop();
+                    }
+                } else {
+                    current_packet++;
+                    update_current_packet(packets[current_packet], current_packet);
+                    reset();
+                }
+            } else {
+                reset();
+            }
+        }
+    }
+
+    if (++auto_channel_counter == auto_channel_period) {
+        auto_channel_counter = 0;
+
+        if (auto_channel) {
+            int min = 37;
+            int max = 39;
+
+            channel_number = min + std::rand() % (max - min + 1);
+
+            field_frequency.set_value(get_freq_by_channel_number(channel_number));
+        }
+    }
+}
+
+void BLETxView::on_tx_progress(const bool done) {
+    if (done) {
+        if (is_active()) {
+            if ((packet_counter % 10) == 0) {
+                text_packets_sent.set(to_string_dec_uint(packet_counter));
+            }
+
+            packet_counter--;
+            progressbar.set_value(packets[current_packet].packet_count - packet_counter);
+        }
+    }
+}
+
+BLETxView::BLETxView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&button_open,
+                  &text_filename,
+                  &progressbar,
+                  &check_rand_mac,
+                  &field_frequency,
+                  &tx_view,  // now it handles previous rfgain, rfamp.
+                  &check_loop,
+                  &button_play,
+                  &label_speed,
+                  &options_speed,
+                  &options_channel,
+                  &options_adv_type,
+                  &label_marked_data,
+                  &marked_data_sequence,
+                  &label_packet_index,
+                  &text_packet_index,
+                  &label_packets_sent,
+                  &text_packets_sent,
+                  &label_mac_address,
+                  &text_mac_address,
+                  &label_data_packet,
+                  &dataEditView,
+                  &button_clear_marked,
+                  &button_save_packet,
+                  &button_switch});
+
+    field_frequency.set_step(0);
+
+    ensure_directory(packet_save_path);
+
+    button_play.on_select = [this](ImageButton&) {
+        this->toggle();
+    };
+
+    options_channel.on_change = [this](size_t, int32_t i) {
+        // If we selected Auto don't do anything and Auto will handle changing.
+        if (i == 40) {
+            auto_channel = true;
+            return;
+        } else {
+            auto_channel = false;
+        }
+
+        field_frequency.set_value(get_freq_by_channel_number(i));
+        channel_number = i;
+    };
+
+    options_speed.on_change = [this](size_t, int32_t i) {
+        timer_period = i;
+        timer_count = 0;
+    };
+
+    options_adv_type.on_change = [this](size_t, int32_t i) {
+        pduType = (PKT_TYPE)i;
+    };
+
+    options_speed.set_selected_index(0);
+    options_channel.set_selected_index(0);
+    options_adv_type.set_selected_index(0);
+
+    check_rand_mac.set_value(false);
+    check_rand_mac.on_select = [this](Checkbox&, bool v) {
+        random_mac = v;
+    };
+
+    button_open.on_select = [this](Button&) {
+        auto open_view = nav_.push<FileLoadView>(".TXT");
+        open_view->on_changed = [this](std::filesystem::path new_file_path) {
+            on_file_changed(new_file_path);
+
+            nav_.set_on_pop([this]() { button_play.focus(); });
+        };
+    };
+
+    button_save_packet.on_select = [this, &nav](Button&) {
+        packetFileBuffer = "";
+        text_prompt(
+            nav,
+            packetFileBuffer,
+            64,
+            [this](std::string& buffer) {
+                on_save_file(buffer);
+            });
+    };
+
+    button_switch.on_select = [&nav](Button&) {
+        nav.replace<BLERxView>();
+    };
+
+    dataEditView.on_select = [this] {
+        // Save last selected cursor.
+        cursor_pos.line = dataEditView.line();
+        cursor_pos.col = dataEditView.col();
+
+        // Reject setting newline at index 29.
+        if (cursor_pos.col != 29) {
+            uint16_t dataBytePos = (cursor_pos.line * 29) + cursor_pos.col;
+
+            auto it = std::find(markedBytes.begin(), markedBytes.end(), dataBytePos);
+
+            if (it != markedBytes.end()) {
+                markedBytes.erase(it);
+            } else {
+                markedBytes.push_back(dataBytePos);
+            }
+
+            dataEditView.cursor_mark_selected();
+        }
+    };
+
+    button_clear_marked.on_select = [this](Button&) {
+        marked_counter = 0;
+        markedBytes.clear();
+        dataEditView.cursor_clear_marked();
+    };
+}
+
+BLETxView::BLETxView(
+    NavigationView& nav,
+    BLETxPacket packet)
+    : BLETxView(nav) {
+    packets[0] = packet;
+
+    update_current_packet(packets[0], 0);
+
+    num_packets = 1;
+    file_override = true;
+}
+
+void BLETxView::on_file_changed(const fs::path& new_file_path) {
+    file_path = fs::path(u"/") + new_file_path;
+    num_packets = 0;
+
+    {  // Get the size of the data file.
+        File data_file;
+        auto error = data_file.open(file_path);
+        if (error) {
+            file_error();
+            file_path = "";
+            return;
+        }
+
+        do {
+            readUntil(data_file, packets[num_packets].macAddress, mac_address_size_str, ' ');
+            readUntil(data_file, packets[num_packets].advertisementData, max_packet_size_str, ' ');
+            readUntil(data_file, packets[num_packets].packetCount, max_packet_repeat_str, '\n');
+
+            uint64_t macAddressSize = strlen(packets[num_packets].macAddress);
+            uint64_t advertisementDataSize = strlen(packets[num_packets].advertisementData);
+            uint64_t packetCountSize = strlen(packets[num_packets].packetCount);
+
+            packets[num_packets].packet_count = stringToUint32(packets[num_packets].packetCount);
+
+            // Verify Data.
+            if ((macAddressSize == mac_address_size_str) && (advertisementDataSize < max_packet_size_str) && (packetCountSize < max_packet_repeat_str) &&
+                hasValidHexPairs(packets[num_packets].macAddress, macAddressSize / 2) && hasValidHexPairs(packets[num_packets].advertisementData, advertisementDataSize / 2) && (packets[num_packets].packet_count >= 1) && (packets[num_packets].packet_count < max_packet_repeat_count)) {
+                text_filename.set(truncate(file_path.filename().string(), 12));
+
+            } else {
+                // Did not find any packets.
+                if (num_packets == 0) {
+                    file_path = "";
+                    return;
+                }
+
+                break;
+            }
+
+            num_packets++;
+
+        } while (num_packets < max_num_packets);
+
+        update_current_packet(packets[0], 0);
+    }
+}
+
+void BLETxView::on_save_file(const std::string value) {
+    auto folder = packet_save_path.parent_path();
+    auto ext = packet_save_path.extension();
+    auto new_path = folder / value + ext;
+
+    saveFile(new_path);
+}
+
+void BLETxView::on_data(uint32_t value, bool is_data) {
+    std::string str_console = "";
+
+    if (is_data) {
+        str_console += (char)(value);
+    }
+}
+
+void BLETxView::update_current_packet(BLETxPacket packet, uint32_t currentIndex) {
+    std::string formattedMacAddress = to_string_formatted_mac_address(packet.macAddress);
+
+    std::vector<std::string> strings = splitIntoStrings(packet.advertisementData);
+
+    text_packet_index.set(to_string_dec_uint(current_packet));
+
+    text_packets_sent.set(to_string_dec_uint(packet.packet_count));
+
+    text_mac_address.set(formattedMacAddress);
+
+    packet_counter = packet.packet_count;
+    current_packet = currentIndex;
+
+    dataFile.create(dataTempFilePath);
+
+    for (const std::string& str : strings) {
+        dataFile.write(str.c_str(), str.size());
+        dataFile.write("\n", 1);
+        ;
+    }
+
+    dataFile.~File();
+
+    auto result = FileWrapper::open(dataTempFilePath);
+
+    if (!result)
+        return;
+
+    dataFileWrapper = *std::move(result);
+
+    dataEditView.set_font_zoom(true);
+    dataEditView.set_file(*dataFileWrapper);
+    dataEditView.redraw(true, true);
+}
+
+void BLETxView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
+    dataEditView.set_parent_rect(content_rect);
+}
+
+BLETxView::~BLETxView() {
+    delete_file(dataTempFilePath);
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+} /* namespace ui */

firmware/application/apps/ble_tx_app.hpp

@@ -0,0 +1,337 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * 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 __BLE_TX_APP_H__
+#define __BLE_TX_APP_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_text_editor.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "replay_thread.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+#include "recent_entries.hpp"
+
+#include <string>
+#include <memory>
+
+class BLELoggerTx {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+
+enum PKT_TYPE {
+    PKT_TYPE_INVALID_TYPE,
+    PKT_TYPE_RAW,
+    PKT_TYPE_DISCOVERY,
+    PKT_TYPE_IBEACON,
+    PKT_TYPE_ADV_IND,
+    PKT_TYPE_ADV_DIRECT_IND,
+    PKT_TYPE_ADV_NONCONN_IND,
+    PKT_TYPE_ADV_SCAN_IND,
+    PKT_TYPE_SCAN_REQ,
+    PKT_TYPE_SCAN_RSP,
+    PKT_TYPE_CONNECT_REQ,
+    PKT_TYPE_LL_DATA,
+    PKT_TYPE_LL_CONNECTION_UPDATE_REQ,
+    PKT_TYPE_LL_CHANNEL_MAP_REQ,
+    PKT_TYPE_LL_TERMINATE_IND,
+    PKT_TYPE_LL_ENC_REQ,
+    PKT_TYPE_LL_ENC_RSP,
+    PKT_TYPE_LL_START_ENC_REQ,
+    PKT_TYPE_LL_START_ENC_RSP,
+    PKT_TYPE_LL_UNKNOWN_RSP,
+    PKT_TYPE_LL_FEATURE_REQ,
+    PKT_TYPE_LL_FEATURE_RSP,
+    PKT_TYPE_LL_PAUSE_ENC_REQ,
+    PKT_TYPE_LL_PAUSE_ENC_RSP,
+    PKT_TYPE_LL_VERSION_IND,
+    PKT_TYPE_LL_REJECT_IND,
+    PKT_TYPE_NUM_PKT_TYPE
+};
+
+struct BLETxPacket {
+    char macAddress[13];
+    char advertisementData[63];
+    char packetCount[11];
+    uint32_t packet_count;
+    PKT_TYPE packetType;
+};
+
+class BLETxView : public View {
+   public:
+    BLETxView(NavigationView& nav);
+    BLETxView(NavigationView& nav, BLETxPacket packet);
+    ~BLETxView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    bool is_active() const;
+    void toggle();
+    void start();
+    void stop();
+    void reset();
+    void handle_replay_thread_done(const uint32_t return_code);
+    void file_error();
+    bool saveFile(const std::filesystem::path& path);
+
+    std::string title() const override { return "BLE TX"; };
+
+   private:
+    void on_timer();
+    void on_data(uint32_t value, bool is_data);
+    void on_file_changed(const std::filesystem::path& new_file_path);
+    void on_save_file(const std::string value);
+    void on_tx_progress(const bool done);
+    void on_random_data_change(std::string value);
+    void update_current_packet(BLETxPacket packet, uint32_t currentIndex);
+
+    NavigationView& nav_;
+    TxRadioState radio_state_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */
+    };
+    app_settings::SettingsManager settings_{
+        "tx_ble", app_settings::Mode::TX};
+
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+
+    std::filesystem::path file_path{};
+    std::filesystem::path packet_save_path{u"BLETX/BLETX_????.TXT"};
+    uint8_t channel_number = 37;
+    bool auto_channel = false;
+
+    char randomMac[13] = "010203040506";
+
+    bool is_running = false;
+
+    int16_t timer_count{0};
+    int16_t timer_period{1};
+    int16_t auto_channel_counter = 0;
+    int16_t auto_channel_period{6};
+
+    bool repeatLoop = false;
+    uint32_t packet_counter{0};
+    uint32_t num_packets{0};
+    uint32_t current_packet{0};
+    bool random_mac = false;
+    bool file_override = false;
+
+    typedef struct {
+        uint16_t line;
+        uint16_t col;
+    } CursorPos;
+
+    std::unique_ptr<FileWrapper> dataFileWrapper{};
+    File dataFile{};
+    std::filesystem::path dataTempFilePath{u"BLETX/dataFileTemp.TXT"};
+    std::vector<uint16_t> markedBytes{};
+    CursorPos cursor_pos{};
+    uint8_t marked_counter = 0;
+
+    static constexpr uint8_t mac_address_size_str{12};
+    static constexpr uint8_t max_packet_size_str{62};
+    static constexpr uint8_t max_packet_repeat_str{10};
+    static constexpr uint32_t max_packet_repeat_count{UINT32_MAX};
+    static constexpr uint32_t max_num_packets{32};
+
+    BLETxPacket packets[max_num_packets];
+
+    PKT_TYPE pduType = {PKT_TYPE_DISCOVERY};
+
+    static constexpr auto header_height = 10 * 16;
+    static constexpr auto switch_button_height = 6 * 16;
+
+    Button button_open{
+        {0 * 8, 0 * 16, 10 * 8, 2 * 16},
+        "Open file"};
+
+    Text text_filename{
+        {11 * 8, 0 * 16, 12 * 8, 16},
+        "-"};
+
+    ProgressBar progressbar{
+        {11 * 8, 1 * 16, 9 * 8, 16}};
+
+    Checkbox check_rand_mac{
+        {21 * 8, 1 * 16},
+        6,
+        "?? Mac",
+        true};
+
+    TxFrequencyField field_frequency{
+        {0 * 8, 2 * 16},
+        nav_};
+
+    TransmitterView2 tx_view{
+        {11 * 8, 2 * 16},
+        /*short_ui*/ true};
+
+    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()};
+
+    Labels label_speed{
+        {{0 * 8, 6 * 8}, "Speed:", Color::light_grey()}};
+
+    OptionsField options_speed{
+        {7 * 8, 6 * 8},
+        3,
+        {{"1 ", 1},     // 16ms
+         {"2 ", 2},     // 32ms
+         {"3 ", 3},     // 48ms
+         {"4 ", 6},     // 100ms
+         {"5 ", 12}}};  // 200ms
+
+    OptionsField options_channel{
+        {11 * 8, 6 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39},
+         {"Auto", 40}}};
+
+    OptionsField options_adv_type{
+        {17 * 8, 6 * 8},
+        14,
+        {{"DISCOVERY ", PKT_TYPE_DISCOVERY},
+         {"ADV_IND", PKT_TYPE_ADV_IND},
+         {"ADV_DIRECT", PKT_TYPE_ADV_DIRECT_IND},
+         {"ADV_NONCONN", PKT_TYPE_ADV_NONCONN_IND},
+         {"ADV_SCAN_IND", PKT_TYPE_ADV_SCAN_IND},
+         {"SCAN_REQ", PKT_TYPE_SCAN_REQ},
+         {"SCAN_RSP", PKT_TYPE_SCAN_RSP},
+         {"CONNECT_REQ", PKT_TYPE_CONNECT_REQ}}};
+
+    Labels label_marked_data{
+        {{0 * 8, 4 * 16}, "Marked Data:", Color::light_grey()}};
+
+    OptionsField marked_data_sequence{
+        {12 * 8, 8 * 8},
+        8,
+        {{"Ascend", 0},
+         {"Descend", 1},
+         {"Random", 2}}};
+
+    Labels label_packet_index{
+        {{0 * 8, 12 * 8}, "Packet Index:", Color::light_grey()}};
+
+    Text text_packet_index{
+        {13 * 8, 6 * 16, 12 * 8, 16},
+        "-"};
+
+    Labels label_packets_sent{
+        {{0 * 8, 14 * 8}, "Repeat Count:", Color::light_grey()}};
+
+    Text text_packets_sent{
+        {13 * 8, 7 * 16, 12 * 8, 16},
+        "-"};
+
+    Labels label_mac_address{
+        {{0 * 8, 16 * 8}, "Mac Address:", Color::light_grey()}};
+
+    Text text_mac_address{
+        {12 * 8, 8 * 16, 20 * 8, 16},
+        "-"};
+
+    Labels label_data_packet{
+        {{0 * 8, 9 * 16}, "Packet Data:", Color::light_grey()}};
+
+    Console console{
+        {0, 9 * 18, 240, 240}};
+
+    TextViewer dataEditView{
+        {0, 9 * 18, 240, 240}};
+
+    Button button_clear_marked{
+        {1 * 8, 14 * 16, 13 * 8, 3 * 8},
+        "Clear Marked"};
+
+    Button button_save_packet{
+        {1 * 8, 16 * 16, 13 * 8, 2 * 16},
+        "Save Packet"};
+
+    Button button_switch{
+        {16 * 8, 16 * 16, 13 * 8, 2 * 16},
+        "Switch to Rx"};
+
+    std::string str_log{""};
+    bool logging{true};
+    bool logging_done{false};
+    std::string packetFileBuffer{};
+
+    std::unique_ptr<BLELoggerTx> logger{};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::AFSKData,
+        [this](Message* const p) {
+            const auto message = static_cast<const AFSKDataMessage*>(p);
+            this->on_data(message->value, message->is_data);
+        }};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.done);
+        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/

firmware/application/apps/capture_app.cpp

@@ -44,6 +44,7 @@ CaptureAppView::CaptureAppView(NavigationView& nav)
         &field_vga,
         &option_bandwidth,
         &option_format,
+        &check_trim,
         &record_view,
         &waterfall,
     });
@@ -59,31 +60,44 @@ CaptureAppView::CaptureAppView(NavigationView& nav)
         record_view.set_file_type((RecordView::FileType)file_type);
     };
 
+    check_trim.on_select = [this](Checkbox&, bool v) {
+        record_view.set_auto_trim(v);
+    };
+
     freqman_set_bandwidth_option(SPEC_MODULATION, option_bandwidth);
-    option_bandwidth.on_change = [this](size_t, uint32_t base_rate) {
-        /* base_rate is used for FFT calculation and display LCD, and also in recording writing SD Card rate. */
+    option_bandwidth.on_change = [this](size_t, uint32_t bandwidth) {
+        /* Nyquist would imply a sample rate of 2x bandwidth, but because the ADC
+         * provides 2 values (I,Q), the sample_rate is equal to bandwidth here. */
+        auto sample_rate = bandwidth;
+
+        /* base_rate (bandwidth) is used for FFT calculation and display LCD, and also in recording writing SD Card rate. */
         /* ex. sampling_rate values, 4Mhz, when recording 500 kHz (BW) and fs 8 Mhz, when selected 1 Mhz BW ... */
-        /* ex. recording 500kHz BW to .C16 file, base_rate clock 500kHz x2(I,Q) x 2 bytes (int signed) =2MB/sec rate SD Card  */
-
-        // For lower bandwidths, (12k5, 16k, 20k), increase the oversample rate to get a higher sample rate.
-        OversampleRate oversample_rate = base_rate >= 25'000 ? OversampleRate::Rate8x : OversampleRate::Rate16x;
-
-        // HackRF suggests a minimum sample rate of 2M.
-        // Oversampling helps get to higher sample rates when recording lower bandwidths.
-        uint32_t sampling_rate = toUType(oversample_rate) * base_rate;
-
-        // Set up proper anti aliasing BPF bandwidth in MAX2837 before ADC sampling according to the new added BW Options.
-        auto anti_alias_baseband_bandwidth_filter = filter_bandwidth_for_sampling_rate(sampling_rate);
+        /* ex. recording 500kHz BW to .C16 file, base_rate clock 500kHz x2(I,Q) x 2 bytes (int signed) =2MB/sec rate SD Card. */
 
         waterfall.stop();
-        record_view.set_sampling_rate(sampling_rate, oversample_rate);  // NB: Actually updates the baseband.
-        receiver_model.set_sampling_rate(sampling_rate);
-        receiver_model.set_baseband_bandwidth(anti_alias_baseband_bandwidth_filter);
+
+        // record_view determines the correct oversampling to apply and returns the actual sample rate.
+        // NB: record_view is what actually updates proc_capture baseband settings.
+        auto actual_sample_rate = record_view.set_sampling_rate(sample_rate);
+
+        // Update the radio model with the actual sampling rate.
+        receiver_model.set_sampling_rate(actual_sample_rate);
+
+        // Get suitable anti-aliasing BPF bandwidth for MAX2837 given the actual sample rate.
+        auto anti_alias_filter_bandwidth = filter_bandwidth_for_sampling_rate(actual_sample_rate);
+        receiver_model.set_baseband_bandwidth(anti_alias_filter_bandwidth);
+
+        // Automatically switch default capture format to C8 when bandwidth setting is increased to >=1.5MHz
+        if ((bandwidth >= 1500000) && (previous_bandwidth < 1500000)) {
+            option_format.set_selected_index(1);
+        }
+        previous_bandwidth = bandwidth;
+
         waterfall.start();
     };
 
     receiver_model.enable();
-    option_bandwidth.set_selected_index(7);  // Preselected default option 500kHz.
+    option_bandwidth.set_by_value(500000);
 
     record_view.on_error = [&nav](std::string message) {
         nav.display_modal("Error", message);

firmware/application/apps/capture_app.hpp

@@ -46,6 +46,7 @@ class CaptureAppView : public View {
 
    private:
     static constexpr ui::Dim header_height = 3 * 16;
+    uint32_t previous_bandwidth{500000};
 
     NavigationView& nav_;
     RxRadioState radio_state_{ReceiverModel::Mode::Capture};
@@ -91,6 +92,12 @@ class CaptureAppView : public View {
         {{"C16", RecordView::FileType::RawS16},
          {"C8", RecordView::FileType::RawS8}}};
 
+    Checkbox check_trim{
+        {23 * 8, 1 * 16},
+        4,
+        "Trim",
+        /*small*/ true};
+
     RecordView record_view{
         {0 * 8, 2 * 16, 30 * 8, 1 * 16},
         u"BBD_????.*",

firmware/application/apps/ert_app.cpp

@@ -65,9 +65,13 @@ std::string commodity_type(CommodityType value) {
 
 } /* namespace ert */
 
-void ERTLogger::on_packet(const ert::Packet& packet) {
+void ERTLogger::on_packet(const ert::Packet& packet, const uint32_t target_frequency) {
     const auto formatted = packet.symbols_formatted();
-    std::string entry = ert::format::type(packet.type()) + " " + formatted.data + "/" + formatted.errors;
+
+    // TODO: function doesn't take uint64_t, so when >= 1<<32, weirdness will ensue!
+    const auto target_frequency_str = to_string_dec_uint(target_frequency, 10);
+
+    std::string entry = target_frequency_str + " " + ert::format::type(packet.type()) + " " + formatted.data + "/" + formatted.errors;
     log_file.write_entry(packet.received_at(), entry);
 }
 
@@ -99,10 +103,12 @@ void RecentEntriesTable<ERTRecentEntries>::draw(
     painter.draw_string(target_rect.location(), style, line);
 }
 
-ERTAppView::ERTAppView(NavigationView&) {
+ERTAppView::ERTAppView(NavigationView& nav)
+    : nav_{nav} {
     baseband::run_image(portapack::spi_flash::image_tag_ert);
 
     add_children({
+        &field_frequency,
         &field_rf_amp,
         &field_lna,
         &field_vga,
@@ -110,8 +116,7 @@ ERTAppView::ERTAppView(NavigationView&) {
         &recent_entries_view,
     });
 
-    if (!settings_.loaded())
-        receiver_model.set_target_frequency(initial_target_frequency);
+    field_frequency.set_step(1000000);
 
     receiver_model.enable();
 
@@ -137,7 +142,7 @@ void ERTAppView::set_parent_rect(const Rect new_parent_rect) {
 
 void ERTAppView::on_packet(const ert::Packet& packet) {
     if (logger) {
-        logger->on_packet(packet);
+        logger->on_packet(packet, receiver_model.target_frequency());
     }
 
     if (packet.crc_ok()) {

firmware/application/apps/ert_app.hpp

@@ -24,6 +24,7 @@
 
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
 #include "ui_rssi.hpp"
 #include "ui_channel.hpp"
 
@@ -95,7 +96,7 @@ class ERTLogger {
         return log_file.append(filename);
     }
 
-    void on_packet(const ert::Packet& packet);
+    void on_packet(const ert::Packet& packet, const uint32_t target_frequency);
 
    private:
     LogFile log_file{};
@@ -123,12 +124,12 @@ class ERTAppView : public View {
     std::string title() const override { return "ERT RX"; };
 
    private:
-    static constexpr uint32_t initial_target_frequency = 911600000;
-
     ERTRecentEntries recent{};
     std::unique_ptr<ERTLogger> logger{};
 
+    NavigationView& nav_;
     RxRadioState radio_state_{
+        911600000 /* frequency */,
         2500000 /* bandwidth */,
         4194304 /* sampling rate */};
     app_settings::SettingsManager settings_{
@@ -144,6 +145,10 @@ class ERTAppView : public View {
 
     static constexpr auto header_height = 1 * 16;
 
+    RxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+
     RFAmpField field_rf_amp{
         {13 * 8, 0 * 16}};
 

firmware/application/apps/gps_sim_app.cpp

@@ -74,7 +74,10 @@ void GpsSimAppView::on_file_changed(const fs::path& new_file_path) {
     auto duration = ms_duration(file_size, transmitter_model.sampling_rate(), 2);
     text_duration.set(to_string_time_ms(duration));
 
-    button_play.focus();
+    // TODO: fix in UI framework with 'try_focus()'?
+    // Hack around focus getting called by ctor before parent is set.
+    if (parent())
+        button_play.focus();
 }
 
 void GpsSimAppView::on_tx_progress(const uint32_t progress) {
@@ -173,11 +176,6 @@ GpsSimAppView::GpsSimAppView(
         &waterfall,
     });
 
-    if (!settings_.loaded()) {
-        field_frequency.set_value(initial_target_frequency);
-        transmitter_model.set_sampling_rate(2600000);
-    }
-
     field_frequency.set_step(5000);
 
     button_play.on_select = [this](ImageButton&) {

firmware/application/apps/gps_sim_app.hpp

@@ -24,9 +24,6 @@
 #ifndef __GPS_SIM_APP_HPP__
 #define __GPS_SIM_APP_HPP__
 
-#define SHORT_UI true
-#define NORMAL_UI false
-
 #include "app_settings.hpp"
 #include "radio_state.hpp"
 #include "ui_widget.hpp"
@@ -54,21 +51,17 @@ class GpsSimAppView : public View {
     std::string title() const override { return "GPS Sim TX"; };
 
    private:
-    static constexpr uint32_t initial_target_frequency = 1575420000;
-
     NavigationView& nav_;
-    RxRadioState radio_state_{
-        3000000 /* bandwidth */,
-        500000 /* sampling rate */
+    TxRadioState radio_state_{
+        1575420000 /* frequency */,
+        15000000 /* bandwidth */,
+        2600000 /* sampling rate */
     };
     app_settings::SettingsManager settings_{
         "tx_gps", app_settings::Mode::TX};
 
     static constexpr ui::Dim header_height = 3 * 16;
 
-    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};
 
@@ -109,10 +102,8 @@ class GpsSimAppView : public View {
         nav_};
 
     TransmitterView2 tx_view{
-        // new handling of NumberField field_rfgain, NumberField field_rfamp
-        74, 1 * 8, SHORT_UI  // x(columns), y (line) position. (Used in Replay / GPS Simul / Playlist App)
-                             //		10*8, 2*8, NORMAL_UI				// x(columns), y (line) position. (Used in Mic App)
-    };
+        {11 * 8, 2 * 16},
+        /*short_ui*/ true};
 
     Checkbox check_loop{
         {21 * 8, 2 * 16},

firmware/application/apps/pocsag_app.cpp

@@ -22,15 +22,15 @@
 
 #include "pocsag_app.hpp"
 
+#include "audio.hpp"
 #include "baseband_api.hpp"
 #include "portapack_persistent_memory.hpp"
+#include "string_format.hpp"
+#include "utility.hpp"
 
 using namespace portapack;
 using namespace pocsag;
-
-#include "string_format.hpp"
-#include "utility.hpp"
-#include "audio.hpp"
+namespace pmem = portapack::persistent_memory;
 
 void POCSAGLogger::log_raw_data(const pocsag::POCSAGPacket& packet, const uint32_t frequency) {
     std::string entry = "Raw: F:" + to_string_dec_uint(frequency) + "Hz " +
@@ -43,52 +43,100 @@ void POCSAGLogger::log_raw_data(const pocsag::POCSAGPacket& packet, const uint32
     log_file.write_entry(packet.timestamp(), entry);
 }
 
-void POCSAGLogger::log_decoded(
-    const pocsag::POCSAGPacket& packet,
-    const std::string text) {
-    log_file.write_entry(packet.timestamp(), text);
+void POCSAGLogger::log_decoded(Timestamp timestamp, const std::string& text) {
+    log_file.write_entry(timestamp, text);
 }
 
 namespace ui {
 
+POCSAGSettingsView::POCSAGSettingsView(
+    NavigationView& nav,
+    POCSAGSettings& settings)
+    : settings_{settings} {
+    add_children(
+        {&labels,
+         &check_log,
+         &check_log_raw,
+         &check_small_font,
+         &check_hide_bad,
+         &check_hide_addr_only,
+         &opt_filter_mode,
+         &field_filter_address,
+         &button_save});
+
+    check_log.set_value(settings_.enable_logging);
+    check_log_raw.set_value(settings_.enable_raw_log);
+    check_small_font.set_value(settings_.enable_small_font);
+    check_hide_bad.set_value(settings_.hide_bad_data);
+    check_hide_addr_only.set_value(settings_.hide_addr_only);
+    opt_filter_mode.set_by_value(settings_.filter_mode);
+    field_filter_address.set_value(settings_.filter_address);
+
+    button_save.on_select = [this, &nav](Button&) {
+        settings_.enable_logging = check_log.value();
+        settings_.enable_raw_log = check_log_raw.value();
+        settings_.enable_small_font = check_small_font.value();
+        settings_.hide_bad_data = check_hide_bad.value();
+        settings_.hide_addr_only = check_hide_addr_only.value();
+        settings_.filter_mode = opt_filter_mode.selected_index_value();
+        settings_.filter_address = field_filter_address.to_integer();
+
+        nav.pop();
+    };
+}
+
 POCSAGAppView::POCSAGAppView(NavigationView& nav)
     : nav_{nav} {
-    baseband::run_image(portapack::spi_flash::image_tag_pocsag);
+    baseband::run_image(portapack::spi_flash::image_tag_pocsag2);
 
-    add_children({&rssi,
-                  &channel,
-                  &audio,
-                  &field_rf_amp,
-                  &field_lna,
-                  &field_vga,
-                  &field_frequency,
-                  &check_log,
-                  &field_volume,
-                  &check_ignore,
-                  &sym_ignore,
-                  &console});
+    add_children(
+        {&rssi,
+         &audio,
+         &field_rf_amp,
+         &field_lna,
+         &field_vga,
+         &field_frequency,
+         &field_squelch,
+         &field_volume,
+         &image_status,
+         &text_packet_count,
+         &widget_baud,
+         &widget_bits,
+         &widget_frames,
+         &button_filter_last,
+         &button_config,
+         &console});
 
-    if (!settings_.loaded())
-        field_frequency.set_value(initial_target_frequency);
-
-    receiver_model.enable();
-
-    // TODO: app setting instead?
-    uint32_t ignore_address;
-    ignore_address = persistent_memory::pocsag_ignore_address();
-
-    // TODO: is this common enough for a helper?
-    for (size_t c = 0; c < 7; c++) {
-        sym_ignore.set_sym(6 - c, ignore_address % 10);
-        ignore_address /= 10;
+    // No app settings, use fallbacks from pmem.
+    if (!app_settings_.loaded()) {
+        settings_.filter_address = pmem::pocsag_ignore_address();
+        settings_.filter_mode = (settings_.filter_address == 0)
+                                    ? FILTER_NONE
+                                    : FILTER_DROP;
     }
 
-    logger = std::make_unique<POCSAGLogger>();
-    if (logger)
-        logger->append(LOG_ROOT_DIR "/POCSAG.TXT");
+    logger.append(LOG_ROOT_DIR "/POCSAG.TXT");
 
+    field_squelch.set_value(receiver_model.squelch_level());
+    field_squelch.on_change = [this](int32_t v) {
+        receiver_model.set_squelch_level(v);
+    };
+
+    button_filter_last.on_select = [this](Button&) {
+        if (settings_.filter_mode == FILTER_NONE)
+            settings_.filter_mode = FILTER_DROP;
+        settings_.filter_address = last_address;
+        refresh_ui();
+    };
+
+    button_config.on_select = [this](Button&) {
+        nav_.push<POCSAGSettingsView>(settings_);
+        nav_.set_on_pop([this]() { refresh_ui(); });
+    };
+
+    refresh_ui();
     audio::output::start();
-
+    receiver_model.enable();
     baseband::set_pocsag();
 }
 
@@ -98,81 +146,206 @@ void POCSAGAppView::focus() {
 
 POCSAGAppView::~POCSAGAppView() {
     audio::output::stop();
-
-    // Save ignored address
-    persistent_memory::set_pocsag_ignore_address(sym_ignore.value_dec_u32());
-
     receiver_model.disable();
     baseband::shutdown();
+
+    // Save pmem settings.
+    pmem::set_pocsag_ignore_address(settings_.filter_address);
+    pmem::set_pocsag_last_address(last_address);  // For POCSAG TX.
+}
+
+void POCSAGAppView::refresh_ui() {
+    // Set console font style.
+    console.set_style(
+        settings_.enable_small_font
+            ? &Styles::white_small
+            : &Styles::white);
+
+    // Update filter button text.
+    std::string btn_text = "Filter Last";
+    switch (settings_.filter_mode) {
+        case FILTER_DROP:
+            btn_text = "Ignore Last";
+            break;
+
+        case FILTER_KEEP:
+            btn_text = "Keep Last";
+            break;
+
+        case FILTER_NONE:
+        default:
+            btn_text = "Filter Last";
+            break;
+    }
+    button_filter_last.set_text(btn_text);
+}
+
+bool POCSAGAppView::ignore_address(uint32_t address) const {
+    switch (settings_.filter_mode) {
+        case FILTER_DROP:
+            return address == settings_.filter_address;
+
+        case FILTER_KEEP:
+            return address != settings_.filter_address;
+
+        case FILTER_NONE:
+        default:
+            return false;
+    }
+}
+
+void POCSAGAppView::handle_decoded(Timestamp timestamp, const std::string& prefix) {
+    bool bad_data = pocsag_state.errors >= 3;
+
+    // Too many errors for reliable decode.
+    if (bad_data && hide_bad_data()) {
+        console.write("\n" STR_COLOR_MAGENTA + prefix + " Too many decode errors.");
+        last_address = 0;
+        return;
+    }
+
+    // Ignore address? TODO: could filter earlier.
+    if (ignore_address(pocsag_state.address)) {
+        console.write("\n" STR_COLOR_CYAN + prefix + " Ignored: " + to_string_dec_uint(pocsag_state.address));
+        last_address = pocsag_state.address;
+        return;
+    }
+
+    // Color indicates the message has a lot of decoding errors.
+    std::string color = bad_data ? STR_COLOR_MAGENTA : STR_COLOR_WHITE;
+
+    std::string console_info = "\n" + color + prefix;
+    console_info += " #" + to_string_dec_uint(pocsag_state.address);
+    console_info += " F" + to_string_dec_uint(pocsag_state.function);
+
+    if (pocsag_state.out_type == ADDRESS) {
+        last_address = pocsag_state.address;
+
+        if (!hide_addr_only()) {
+            console.write(console_info);
+
+            if (logging()) {
+                logger.log_decoded(
+                    timestamp,
+                    to_string_dec_uint(pocsag_state.address) +
+                        " F" + to_string_dec_uint(pocsag_state.function));
+            }
+        }
+
+    } else if (pocsag_state.out_type == MESSAGE) {
+        if (pocsag_state.address != last_address) {
+            // New message
+            last_address = pocsag_state.address;
+            console.writeln(console_info);
+            console.write(color + pocsag_state.output);
+        } else {
+            // Message continues...
+            console.write(color + pocsag_state.output);
+        }
+
+        if (logging()) {
+            logger.log_decoded(
+                timestamp,
+                to_string_dec_uint(pocsag_state.address) +
+                    " F" + to_string_dec_uint(pocsag_state.function) +
+                    " " + pocsag_state.output);
+        }
+    }
+}
+
+static Color get_status_color(const POCSAGState& state) {
+    if (state.out_type == IDLE)
+        return Color::white();
+
+    switch (state.mode) {
+        case STATE_CLEAR:
+            return Color::cyan();
+        case STATE_HAVE_ADDRESS:
+            return Color::yellow();
+        case STATE_GETTING_MSG:
+            return Color::green();
+    }
+
+    // Shouldn't get here...
+    return Color::red();
 }
 
 void POCSAGAppView::on_packet(const POCSAGPacketMessage* message) {
-    std::string alphanum_text = "";
+    const uint32_t roundVal = 50;
+    const uint32_t bitrate_rounded = roundVal * ((message->packet.bitrate() + (roundVal / 2)) / roundVal);
+    auto bitrate = to_string_dec_uint(bitrate_rounded);
+    auto timestamp = to_string_datetime(message->packet.timestamp(), HM);
+    auto prefix = timestamp + " " + bitrate;
 
-    if (message->packet.flag() != NORMAL)
-        console.writeln("\n\x1B\x0CRC ERROR: " + pocsag::flag_str(message->packet.flag()));
-    else {
-        pocsag_decode_batch(message->packet, &pocsag_state);
+    // Display packet count to be able to tell whether baseband sent a packet for a tone.
+    ++packet_count;
+    text_packet_count.set(to_string_dec_uint(packet_count));
 
-        if ((ignore()) && (pocsag_state.address == sym_ignore.value_dec_u32())) {
-            // Ignore (inform, but no log)
-            // console.write("\n\x1B\x03" + to_string_time(message->packet.timestamp()) +
-            //			" Ignored address " + to_string_dec_uint(pocsag_state.address));
-            return;
-        }
-        // Too many errors for reliable decode
-        if ((ignore()) && (pocsag_state.errors >= 3)) {
-            return;
-        }
+    if (logging_raw())
+        logger.log_raw_data(message->packet, receiver_model.target_frequency());
 
-        std::string console_info;
-        const uint32_t roundVal = 50;
-        const uint32_t bitrate = roundVal * ((message->packet.bitrate() + (roundVal / 2)) / roundVal);
-        console_info = "\n" + to_string_datetime(message->packet.timestamp(), HM);
-        console_info += " " + to_string_dec_uint(bitrate);
-        console_info += " ADDR:" + to_string_dec_uint(pocsag_state.address);
-        console_info += " F" + to_string_dec_uint(pocsag_state.function);
+    if (message->packet.flag() != NORMAL) {
+        console.writeln("\n" STR_COLOR_RED + prefix + " CRC ERROR: " + pocsag::flag_str(message->packet.flag()));
+        last_address = 0;
+    } else {
+        // Set color before to be able to see if decode gets stuck.
+        image_status.set_foreground(Color::magenta());
+        pocsag_state.codeword_index = 0;
+        pocsag_state.errors = 0;
 
-        // Store last received address for POCSAG TX
-        persistent_memory::set_pocsag_last_address(pocsag_state.address);
+        // Handle multiple messages (if any).
+        while (pocsag_decode_batch(message->packet, pocsag_state))
+            handle_decoded(message->packet.timestamp(), prefix);
 
-        if (pocsag_state.out_type == ADDRESS) {
-            // Address only
-
-            console.write(console_info);
-
-            if (logger && logging()) {
-                logger->log_decoded(
-                    message->packet, to_string_dec_uint(pocsag_state.address) +
-                                         " F" + to_string_dec_uint(pocsag_state.function) +
-                                         " Address only");
-            }
-
-            last_address = pocsag_state.address;
-        } else if (pocsag_state.out_type == MESSAGE) {
-            if (pocsag_state.address != last_address) {
-                // New message
-                console.writeln(console_info);
-                console.write(pocsag_state.output);
-
-                last_address = pocsag_state.address;
-            } else {
-                // Message continues...
-                console.write(pocsag_state.output);
-            }
-
-            if (logger && logging())
-                logger->log_decoded(
-                    message->packet, to_string_dec_uint(pocsag_state.address) +
-                                         " F" + to_string_dec_uint(pocsag_state.function) +
-                                         " Alpha: " + pocsag_state.output);
-        }
+        // Handle the remainder.
+        handle_decoded(message->packet.timestamp(), prefix);
     }
 
-    // TODO: make setting.
-    // Log raw data whatever it contains
-    /*if (logger && logging())
-        logger->log_raw_data(message->packet, receiver_model.target_frequency());*/
+    // Set status icon color to indicate state machine state.
+    image_status.set_foreground(get_status_color(pocsag_state));
+}
+
+void POCSAGAppView::on_stats(const POCSAGStatsMessage* stats) {
+    widget_baud.set_rate(stats->baud_rate);
+    widget_bits.set_bits(stats->current_bits);
+    widget_frames.set_frames(stats->current_frames);
+    widget_frames.set_sync(stats->has_sync);
+}
+
+void BaudIndicator::paint(Painter& painter) {
+    auto p = screen_pos();
+    char top = '-';
+    char bot = '-';
+
+    if (rate_ > 0) {
+        auto r = rate_ / 100;
+        top = (r / 10) + '0';
+        bot = (r % 10) + '0';
+    }
+
+    painter.draw_char(p, Styles::white_small, top);
+    painter.draw_char({p.x(), p.y() + 8}, Styles::white_small, bot);
+}
+
+void BitsIndicator::paint(Painter&) {
+    auto p = screen_pos();
+    for (size_t i = 0; i < sizeof(bits_) * 8; ++i) {
+        auto is_set = ((bits_ >> i) & 0x1) == 1;
+
+        int x = p.x() + (i / height);
+        int y = p.y() + (i % height);
+        display.draw_pixel({x, y}, is_set ? Color::white() : Color::black());
+    }
+}
+
+void FrameIndicator::paint(Painter& painter) {
+    auto p = screen_pos();
+    painter.draw_rectangle({p, {2, height}}, has_sync_ ? Color::green() : Color::grey());
+
+    for (size_t i = 0; i < height; ++i) {
+        auto p2 = p + Point{2, 15 - (int)i};
+        painter.draw_hline(p2, 2, i < frame_count_ ? Color::white() : Color::black());
+    }
 }
 
 } /* namespace ui */

firmware/application/apps/pocsag_app.hpp

@@ -27,12 +27,15 @@
 #include "ui_freq_field.hpp"
 #include "ui_receiver.hpp"
 #include "ui_rssi.hpp"
+#include "ui_styles.hpp"
 
-#include "log_file.hpp"
 #include "app_settings.hpp"
-#include "radio_state.hpp"
+#include "log_file.hpp"
 #include "pocsag.hpp"
 #include "pocsag_packet.hpp"
+#include "radio_state.hpp"
+
+#include <functional>
 
 class POCSAGLogger {
    public:
@@ -41,7 +44,7 @@ class POCSAGLogger {
     }
 
     void log_raw_data(const pocsag::POCSAGPacket& packet, const uint32_t frequency);
-    void log_decoded(const pocsag::POCSAGPacket& packet, const std::string text);
+    void log_decoded(Timestamp timestamp, const std::string& text);
 
    private:
     LogFile log_file{};
@@ -49,6 +52,142 @@ class POCSAGLogger {
 
 namespace ui {
 
+class BaudIndicator : public Widget {
+   public:
+    BaudIndicator(Point position)
+        : Widget{{position, {5, height}}} {}
+
+    void paint(Painter& painter) override;
+    void set_rate(uint16_t rate) {
+        if (rate != rate_) {
+            rate_ = rate;
+            set_dirty();
+        }
+    }
+
+   private:
+    static constexpr uint8_t height = 16;
+    uint16_t rate_ = 0;
+};
+
+class BitsIndicator : public Widget {
+   public:
+    BitsIndicator(Point position)
+        : Widget{{position, {2, height}}} {}
+
+    void paint(Painter& painter) override;
+    void set_bits(uint32_t bits) {
+        if (bits != bits_) {
+            bits_ = bits;
+            set_dirty();
+        }
+    }
+
+   private:
+    static constexpr uint8_t height = 16;
+    uint32_t bits_ = 0;
+};
+
+class FrameIndicator : public Widget {
+   public:
+    FrameIndicator(Point position)
+        : Widget{{position, {4, height}}} {}
+
+    void paint(Painter& painter) override;
+    void set_frames(uint8_t frame_count) {
+        if (frame_count != frame_count_) {
+            frame_count_ = frame_count;
+            set_dirty();
+        }
+    }
+
+    void set_sync(bool has_sync) {
+        if (has_sync != has_sync_) {
+            has_sync_ = has_sync;
+            set_dirty();
+        }
+    }
+
+   private:
+    static constexpr uint8_t height = 16;
+    uint8_t frame_count_ = 0;
+    bool has_sync_ = false;
+};
+
+enum POCSAGFilter : uint8_t {
+    FILTER_NONE,
+    FILTER_DROP,
+    FILTER_KEEP
+};
+
+struct POCSAGSettings {
+    bool enable_small_font = false;
+    bool enable_logging = false;
+    bool enable_raw_log = false;
+    bool hide_bad_data = false;
+    bool hide_addr_only = false;
+    uint8_t filter_mode = false;
+    uint32_t filter_address = 0;
+};
+
+class POCSAGSettingsView : public View {
+   public:
+    POCSAGSettingsView(NavigationView& nav, POCSAGSettings& settings);
+
+    std::string title() const override { return "POCSAG Config"; };
+    void focus() override { button_save.focus(); }
+
+   private:
+    POCSAGSettings& settings_;
+
+    Labels labels{
+        {{2 * 8, 12 * 16}, "Filter Mode:", Color::light_grey()},
+        {{2 * 8, 13 * 16}, "Filter Addr:", Color::light_grey()},
+    };
+
+    Checkbox check_log{
+        {2 * 8, 2 * 16},
+        10,
+        "Enable Log"};
+
+    Checkbox check_log_raw{
+        {2 * 8, 4 * 16},
+        12,
+        "Log Raw Data"};
+
+    Checkbox check_small_font{
+        {2 * 8, 6 * 16},
+        4,
+        "Use Small Font"};
+
+    Checkbox check_hide_bad{
+        {2 * 8, 8 * 16},
+        22,
+        "Hide Bad Data"};
+
+    Checkbox check_hide_addr_only{
+        {2 * 8, 10 * 16},
+        22,
+        "Hide Addr Only"};
+
+    OptionsField opt_filter_mode{
+        {15 * 8, 12 * 16},
+        4,
+        {{"None", FILTER_NONE},
+         {"Drop", FILTER_DROP},
+         {"Keep", FILTER_KEEP}}};
+
+    SymField field_filter_address{
+        {15 * 8, 13 * 16},
+        7,
+        SymField::Type::Dec,
+        true /*explicit_edit*/};
+
+    Button button_save{
+        {11 * 8, 16 * 16, 10 * 8, 2 * 16},
+        "Save"};
+};
+
 class POCSAGAppView : public View {
    public:
     POCSAGAppView(NavigationView& nav);
@@ -58,60 +197,101 @@ class POCSAGAppView : public View {
     void focus() override;
 
    private:
-    static constexpr uint32_t initial_target_frequency = 466175000;
-    bool logging() const { return check_log.value(); };
-    bool ignore() const { return check_ignore.value(); };
+    bool logging() const { return settings_.enable_logging; };
+    bool logging_raw() const { return settings_.enable_raw_log; };
+    bool hide_bad_data() const { return settings_.hide_bad_data; };
+    bool hide_addr_only() const { return settings_.hide_addr_only; };
 
     NavigationView& nav_;
-    RxRadioState radio_state_{};
-    app_settings::SettingsManager settings_{
-        "rx_pocsag", app_settings::Mode::RX};
+    RxRadioState radio_state_{
+        466175000 /* frequency*/,
+        max283x::filter::bandwidth_minimum /* bandwidth */,
+        3072000 /* sampling rate */
+    };
 
-    uint32_t last_address = 0xFFFFFFFF;
-    pocsag::POCSAGState pocsag_state{};
+    // Settings
+    POCSAGSettings settings_{};
+    app_settings::SettingsManager app_settings_{
+        "rx_pocsag"sv,
+        app_settings::Mode::RX,
+        {
+            {"small_font"sv, &settings_.enable_small_font},
+            {"enable_logging"sv, &settings_.enable_logging},
+            {"enable_raw_log"sv, &settings_.enable_raw_log},
+            {"filter_mode"sv, &settings_.filter_mode},
+            {"filter_address"sv, &settings_.filter_address},
+            {"hide_bad_data"sv, &settings_.hide_bad_data},
+            {"hide_addr_only"sv, &settings_.hide_addr_only},
+        }};
 
-    RFAmpField field_rf_amp{
-        {13 * 8, 0 * 16}};
-    LNAGainField field_lna{
-        {15 * 8, 0 * 16}};
-    VGAGainField field_vga{
-        {18 * 8, 0 * 16}};
-    RSSI rssi{
-        {21 * 8, 0, 6 * 8, 4}};
-    Channel channel{
-        {21 * 8, 5, 6 * 8, 4}};
-    Audio audio{
-        {21 * 8, 10, 6 * 8, 4}};
+    void refresh_ui();
+    bool ignore_address(uint32_t address) const;
+    void handle_decoded(Timestamp timestamp, const std::string& prefix);
+    void on_packet(const POCSAGPacketMessage* message);
+    void on_stats(const POCSAGStatsMessage* stats);
+
+    uint32_t last_address = 0;
+    pocsag::EccContainer ecc{};
+    pocsag::POCSAGState pocsag_state{&ecc};
+    POCSAGLogger logger{};
+    uint16_t packet_count = 0;
 
     RxFrequencyField field_frequency{
         {0 * 8, 0 * 8},
         nav_};
 
+    RFAmpField field_rf_amp{
+        {11 * 8, 0 * 16}};
+    LNAGainField field_lna{
+        {13 * 8, 0 * 16}};
+    VGAGainField field_vga{
+        {16 * 8, 0 * 16}};
+
+    RSSI rssi{
+        {19 * 8 - 4, 3, 6 * 8, 4}};
+    Audio audio{
+        {19 * 8 - 4, 8, 6 * 8, 4}};
+
+    NumberField field_squelch{
+        {25 * 8, 0 * 16},
+        2,
+        {0, 99},
+        1,
+        ' ',
+        true /*wrap*/};
     AudioVolumeField field_volume{
         {28 * 8, 0 * 16}};
 
-    Checkbox check_ignore{
-        {0 * 8, 21},
-        8,
-        "Ign addr",
-        false};
-    SymField sym_ignore{
-        {13 * 8, 25},
-        7,
-        SymField::SYMFIELD_DEC};
+    Image image_status{
+        {0 * 8 + 4, 1 * 16 + 2, 16, 16},
+        &bitmap_icon_pocsag,
+        Color::white(),
+        Color::black()};
 
-    Checkbox check_log{
-        {240 - 8 * 8, 21},
-        3,
-        "Log",
-        false};
+    Text text_packet_count{
+        {3 * 8, 1 * 16 + 2, 5 * 8, 16},
+        "0"};
 
+    BitsIndicator widget_bits{
+        {8 * 8 + 1, 1 * 16 + 2}};
+
+    FrameIndicator widget_frames{
+        {8 * 8 + 4, 1 * 16 + 2}};
+
+    BaudIndicator widget_baud{
+        {8 * 9 + 1, 1 * 16 + 2}};
+
+    Button button_filter_last{
+        {10 * 8, 1 * 16, 12 * 8, 20},
+        "Filter Last"};
+
+    Button button_config{
+        {22 * 8, 1 * 16, 8 * 8, 20},
+        "Config"};
+
+    // 54 == status bar (16) + top controls (2 * 16 + 6).
     Console console{
-        {0, 3 * 16, 240, 256}};
-
-    std::unique_ptr<POCSAGLogger> logger{};
-
-    void on_packet(const POCSAGPacketMessage* message);
+        {0, 2 * 16 + 6, screen_width, screen_height - 54}};
 
     MessageHandlerRegistration message_handler_packet{
         Message::ID::POCSAGPacket,
@@ -119,6 +299,13 @@ class POCSAGAppView : public View {
             const auto message = static_cast<const POCSAGPacketMessage*>(p);
             this->on_packet(message);
         }};
+
+    MessageHandlerRegistration message_handler_stats{
+        Message::ID::POCSAGStats,
+        [this](Message* const p) {
+            const auto stats = static_cast<const POCSAGStatsMessage*>(p);
+            this->on_stats(stats);
+        }};
 };
 
 } /* namespace ui */

firmware/application/apps/replay_app.cpp

@@ -124,7 +124,7 @@ void ReplayAppView::start() {
 
     if (reader) {
         button_play.set_bitmap(&bitmap_stop);
-        baseband::set_sample_rate(sample_rate * 8);
+        baseband::set_sample_rate(sample_rate, OversampleRate::x8);
 
         replay_thread = std::make_unique<ReplayThread>(
             std::move(reader),
@@ -136,7 +136,7 @@ void ReplayAppView::start() {
             });
     }
 
-    transmitter_model.set_sampling_rate(sample_rate * 8);
+    transmitter_model.set_sampling_rate(sample_rate * toUType(OversampleRate::x8));
     transmitter_model.set_baseband_bandwidth(baseband_bandwidth);
     transmitter_model.enable();
 
@@ -203,9 +203,6 @@ ReplayAppView::ReplayAppView(
 
 ReplayAppView::~ReplayAppView() {
     transmitter_model.disable();
-
-    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 )
     baseband::shutdown();
 }
 

firmware/application/apps/replay_app.hpp

@@ -23,9 +23,6 @@
 #ifndef __REPLAY_APP_HPP__
 #define __REPLAY_APP_HPP__
 
-#define SHORT_UI true
-#define NORMAL_UI false
-
 #include "app_settings.hpp"
 #include "radio_state.hpp"
 #include "ui_widget.hpp"
@@ -99,16 +96,13 @@ class ReplayAppView : public View {
     ProgressBar progressbar{
         {18 * 8, 1 * 16, 12 * 8, 16}};
 
-    // TODO: Does this need to be a frequency field at all?
     TxFrequencyField field_frequency{
         {0 * 8, 2 * 16},
         nav_};
 
     TransmitterView2 tx_view{
-        // new handling of NumberField field_rfgain, NumberField field_rfamp
-        74, 1 * 8, SHORT_UI  // x(columns), y (line) position. (Uused in Repay / GPS Simul / Playlist App)
-                             //		10*8, 2*8, NORMAL_UI				// x(columns), y (line) position. (Used in Mic App)
-    };
+        {11 * 8, 2 * 16},
+        /*short_ui*/ true};
 
     Checkbox check_loop{
         {21 * 8, 2 * 16},

firmware/application/apps/soundboard_app.hpp

@@ -50,6 +50,7 @@ class SoundBoardView : public View {
 
    private:
     TxRadioState radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         1536000 /* sampling rate */
     };

firmware/application/apps/tpms_app.cpp

@@ -34,9 +34,6 @@ 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);
 }
@@ -46,11 +43,11 @@ std::string id(TransponderID id) {
 }
 
 std::string pressure(Pressure pressure) {
-    return to_string_dec_int(use_kpa ? pressure.kilopascal() : pressure.psi(), 3);
+    return to_string_dec_int(units_psi ? pressure.psi() : pressure.kilopascal(), 3);
 }
 
 std::string temperature(Temperature temperature) {
-    return to_string_dec_int(use_celsius ? temperature.celsius() : temperature.fahrenheit(), 3);
+    return to_string_dec_int(units_fahr ? temperature.fahrenheit() : temperature.celsius(), 3);
 }
 
 std::string flags(Flags flags) {
@@ -157,9 +154,6 @@ TPMSAppView::TPMSAppView(NavigationView&) {
                   &field_vga,
                   &recent_entries_view});
 
-    if (!settings_.loaded())
-        receiver_model.set_target_frequency(initial_target_frequency);
-
     receiver_model.enable();
 
     options_band.on_change = [this](size_t, OptionsField::value_t v) {
@@ -168,18 +162,16 @@ TPMSAppView::TPMSAppView(NavigationView&) {
     options_band.set_by_value(receiver_model.target_frequency());
 
     options_pressure.on_change = [this](size_t, int32_t i) {
-        tpms::format::use_kpa = !i;
+        tpms::format::units_psi = (bool)i;
         update_view();
     };
-
-    options_pressure.set_selected_index(0, true);
+    options_pressure.set_selected_index(tpms::format::units_psi, true);
 
     options_temperature.on_change = [this](size_t, int32_t i) {
-        tpms::format::use_celsius = !i;
+        tpms::format::units_fahr = (bool)i;
         update_view();
     };
-
-    options_temperature.set_selected_index(0, true);
+    options_temperature.set_selected_index(tpms::format::units_fahr, true);
 
     logger = std::make_unique<TPMSLogger>();
     if (logger) {

firmware/application/apps/tpms_app.hpp

@@ -37,6 +37,17 @@
 
 #include "tpms_packet.hpp"
 
+namespace tpms {
+
+namespace format {
+
+static bool units_psi{false};
+static bool units_fahr{false};
+
+} /* namespace format */
+
+} /* namespace tpms */
+
 namespace std {
 
 } /* namespace std */
@@ -102,13 +113,18 @@ class TPMSAppView : public View {
     std::string title() const override { return "TPMS RX"; };
 
    private:
-    static constexpr uint32_t initial_target_frequency = 315000000;
-
     RxRadioState radio_state_{
+        314950000 /* frequency*/,
         1750000 /* bandwidth */,
         2457600 /* sampling rate */};
+
     app_settings::SettingsManager settings_{
-        "rx_tpms", app_settings::Mode::RX};
+        "rx_tpms",
+        app_settings::Mode::RX,
+        {
+            {"units_psi"sv, &tpms::format::units_psi},
+            {"units_fahr"sv, &tpms::format::units_fahr},
+        }};
 
     MessageHandlerRegistration message_handler_packet{
         Message::ID::TPMSPacket,
@@ -130,12 +146,13 @@ class TPMSAppView : public View {
         {21 * 8, 5, 6 * 8, 4},
     };
 
+    // "315 MHz" TPMS sensors transmit at either 314.9 or 315 MHz but we should pick up either
     OptionsField options_band{
         {0 * 8, 0 * 16},
         3,
         {
-            {"315", 315000000},
-            {"433", 433920000},
+            {"315", 314950000},
+            {"434", 433920000},
         }};
 
     OptionsField options_pressure{
@@ -146,9 +163,9 @@ class TPMSAppView : public View {
 
     OptionsField options_temperature{
         {9 * 8, 0 * 16},
-        1,
-        {{"C", 0},
-         {"F", 1}}};
+        2,
+        {{STR_DEGREES_C, 0},
+         {STR_DEGREES_F, 1}}};
 
     RFAmpField field_rf_amp{
         {13 * 8, 0 * 16}};

firmware/application/apps/ui_about_simple.cpp

@@ -8,7 +8,7 @@ AboutView::AboutView(NavigationView& nav) {
         nav.pop();
     };
 
-    console.writeln("\x1B\x07List of contributors:\x1B\x10");
+    console.writeln(STR_COLOR_LIGHT_GREY "List of contributors:");
     console.writeln("");
 }
 
@@ -20,7 +20,7 @@ void AboutView::update() {
             case 1:
                 // TODO: Generate this automatically from github
                 // https://github.com/eried/portapack-mayhem/graphs/contributors?to=2022-01-01&from=2020-04-12&type=c
-                console.writeln("\x1B\x06Mayhem:\x1B\x10");
+                console.writeln(STR_COLOR_DARK_YELLOW "Mayhem:");
                 console.writeln("eried,euquiq,gregoryfenton");
                 console.writeln("johnelder,jwetzell,nnemanjan00");
                 console.writeln("N0vaPixel,klockee,GullCode");
@@ -34,13 +34,16 @@ void AboutView::update() {
                 console.writeln("notpike,jLynx,zigad");
                 console.writeln("MichalLeonBorsuk,jimilinuxguy");
                 console.writeln("kallanreed,bernd-herzog");
+                break;
+            case 2:
                 console.writeln("NotherNgineer,zxkmm,u-foka");
+                console.writeln("Netro,HTotoo");
                 console.writeln("");
                 break;
 
-            case 2:
+            case 3:
                 // 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(STR_COLOR_DARK_YELLOW "Havoc:");
                 console.writeln("furrtek,mrmookie,NotPike");
                 console.writeln("mjwaxios,ImDroided,Giorgiofox");
                 console.writeln("F4GEV,z4ziggy,xmycroftx");
@@ -51,16 +54,16 @@ void AboutView::update() {
                 console.writeln("");
                 break;
 
-            case 3:
+            case 4:
                 // https://github.com/eried/portapack-mayhem/graphs/contributors?from=2014-07-05&to=2015-07-31&type=c
-                console.writeln("\x1B\x06PortaPack:\x1B\x10");
+                console.writeln(STR_COLOR_DARK_YELLOW "PortaPack:");
                 console.writeln("jboone,argilo");
                 console.writeln("");
                 break;
 
-            case 4:
+            case 5:
                 // https://github.com/mossmann/hackrf/graphs/contributors
-                console.writeln("\x1B\x06HackRF:\x1B\x10");
+                console.writeln(STR_COLOR_DARK_YELLOW "HackRF:");
                 console.writeln("mossmann,dominicgs,bvernoux");
                 console.writeln("bgamari,schneider42,miek");
                 console.writeln("willcode,hessu,Sec42");

firmware/application/apps/ui_adsb_rx.cpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 Kyle Reed
  *
  * This file is part of PortaPack.
  *
@@ -20,46 +21,50 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <strings.h>
+#include <algorithm>
 
 #include "ui_adsb_rx.hpp"
 #include "ui_alphanum.hpp"
 
-#include "rtc_time.hpp"
-#include "string_format.hpp"
 #include "baseband_api.hpp"
 #include "portapack_persistent_memory.hpp"
+#include "rtc_time.hpp"
+#include "string_format.hpp"
 
 using namespace portapack;
 
 namespace ui {
 
+static std::string get_map_tag(const AircraftRecentEntry& entry) {
+    return trimr(entry.callsign.empty() ? entry.icao_str : entry.callsign);
+}
+
 template <>
 void RecentEntriesTable<AircraftRecentEntries>::draw(
     const Entry& entry,
     const Rect& target_rect,
     Painter& painter,
     const Style& style) {
-    char aged_color;
     Color target_color;
-    auto entry_age = entry.age;
+    std::string entry_string;
 
-    // Color decay for flights not being updated anymore
-    if (entry_age < ADSB_CURRENT) {
-        aged_color = 0x10;
-        target_color = Color::green();
-    } else if (entry_age < ADSB_RECENT) {
-        aged_color = 0x07;
-        target_color = Color::light_grey();
-    } else {
-        aged_color = 0x08;
-        target_color = Color::grey();
-    }
+    switch (entry.state) {
+        case ADSBAgeState::Invalid:
+        case ADSBAgeState::Current:
+            entry_string = "";
+            target_color = Color::green();
+            break;
+        case ADSBAgeState::Recent:
+            entry_string = STR_COLOR_LIGHT_GREY;
+            target_color = Color::light_grey();
+            break;
+        default:
+            entry_string = STR_COLOR_DARK_GREY;
+            target_color = Color::grey();
+    };
 
-    std::string entry_string = "\x1B";
-    entry_string += aged_color;
     entry_string +=
-        (entry.callsign[0] != ' ' ? entry.callsign + " " : entry.icaoStr + "   ") +
+        (entry.callsign.empty() ? entry.icao_str + "   " : entry.callsign + " ") +
         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) + " " +
@@ -72,47 +77,59 @@ void RecentEntriesTable<AircraftRecentEntries>::draw(
         entry_string);
 
     if (entry.pos.valid)
-        painter.draw_bitmap(target_rect.location() + Point(8 * 8, 0), bitmap_target, target_color, style.background);
+        painter.draw_bitmap(target_rect.location() + Point(8 * 8, 0),
+                            bitmap_target, target_color, style.background);
 }
 
-void ADSBLogger::log_str(std::string& logline) {
-    log_file.write_entry(logline);
+/* ADSBLogger ********************************************/
+
+void ADSBLogger::log(const ADSBLogEntry& log_entry) {
+    std::string log_line;
+    log_line.reserve(100);
+
+    log_line = log_entry.raw_data;
+    log_line += "ICAO:" + log_entry.icao;
+
+    if (!log_entry.callsign.empty())
+        log_line += " " + log_entry.callsign;
+
+    if (log_entry.pos.valid)
+        log_line += " Alt:" + to_string_dec_int(log_entry.pos.altitude) +
+                    " Lat:" + to_string_decimal(log_entry.pos.latitude, 7) +
+                    " Lon:" + to_string_decimal(log_entry.pos.longitude, 7);
+
+    if (log_entry.vel.valid)
+        log_line += " Type:" + to_string_dec_uint(log_entry.vel_type) +
+                    " Hdg:" + to_string_dec_uint(log_entry.vel.heading) +
+                    " Spd: " + to_string_dec_int(log_entry.vel.speed);
+
+    log_file.write_entry(log_line);
 }
 
-// Aircraft Details
-void ADSBRxAircraftDetailsView::focus() {
-    button_close.focus();
-}
-
-ADSBRxAircraftDetailsView::~ADSBRxAircraftDetailsView() {
-    on_close_();
-}
+/* ADSBRxAircraftDetailsView *****************************/
 
 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});
+    const AircraftRecentEntry& entry) {
+    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));
+    text_icao_address.set(entry.icao_str);
 
     // Try getting the aircraft information from icao24.db
-    return_code = db.retrieve_aircraft_record(&aircraft_record, icao_code);
+    std::database db{};
+    std::database::AircraftDBRecord aircraft_record;
+    auto return_code = db.retrieve_aircraft_record(&aircraft_record, entry.icao_str);
     switch (return_code) {
         case DATABASE_RECORD_FOUND:
             text_registration.set(aircraft_record.aircraft_registration);
@@ -120,6 +137,7 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
             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]) {
@@ -142,7 +160,8 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
                         text_type.set("Tilt-wing aircraft");
                         break;
                 }
-                text_number_of_engines.set(std::string(1, aircraft_record.icao_type[1]));
+
+                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");
@@ -157,8 +176,8 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
                         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)
@@ -179,75 +198,49 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
                     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();
 }
 
-void ADSBRxDetailsView::update(const AircraftRecentEntry& entry) {
-    entry_copy = entry;
-    uint32_t age = entry_copy.age;
-
-    if (age < 60)
-        text_last_seen.set(to_string_dec_uint(age) + " seconds ago");
-    else
-        text_last_seen.set(to_string_dec_uint(age / 60) + " minutes ago");
-
-    text_infos.set(entry_copy.info_string);
-    if (entry_copy.velo.heading < 360 && entry_copy.velo.speed >= 0) {  // I don't like this but...
-        text_info2.set("Hdg:" + to_string_dec_uint(entry_copy.velo.heading) + " Spd:" + to_string_dec_int(entry_copy.velo.speed));
-    } else {
-        text_info2.set("");
-    }
-    text_frame_pos_even.set(to_string_hex_array(entry_copy.frame_pos_even.get_raw_data(), 14));
-    text_frame_pos_odd.set(to_string_hex_array(entry_copy.frame_pos_odd.get_raw_data(), 14));
-
-    if (send_updates) {
-        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);
-    }
+void ADSBRxAircraftDetailsView::focus() {
+    button_close.focus();
 }
 
-ADSBRxDetailsView::~ADSBRxDetailsView() {
-    on_close_();
-}
+/* ADSBRxDetailsView *************************************/
 
 ADSBRxDetailsView::ADSBRxDetailsView(
     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_callsign,
-                  &text_last_seen,
-                  &text_airline,
-                  &text_country,
-                  &text_infos,
-                  &text_info2,
-                  &text_frame_pos_even,
-                  &text_frame_pos_odd,
-                  &button_aircraft_details,
-                  &button_see_map});
+    const AircraftRecentEntry& entry)
+    : entry_(entry) {
+    add_children(
+        {&labels,
+         &text_icao_address,
+         &text_callsign,
+         &text_last_seen,
+         &text_airline,
+         &text_country,
+         &text_infos,
+         &text_info2,
+         &text_frame_pos_even,
+         &text_frame_pos_odd,
+         &button_aircraft_details,
+         &button_see_map});
 
-    std::unique_ptr<ADSBLogger> logger{};
-    update(entry_copy);
+    // The following won't change for a given airborne aircraft.
+    // Try getting the airline's name from airlines.db.
+    // NB: Only works once callsign has been read and won't be updated.
+    std::database db;
+    std::database::AirlinesDBRecord airline_record;
+    std::string airline_code = entry_.callsign.substr(0, 3);
+    auto return_code = db.retrieve_airline_record(&airline_record, airline_code);
 
-    // The following won't (shouldn't !) change for a given airborne aircraft
-    // Try getting the airline's name from airlines.db
-    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);
@@ -258,33 +251,125 @@ ADSBRxDetailsView::ADSBRxDetailsView(
             break;
     }
 
-    text_callsign.set(entry_copy.callsign);
-    text_icao_address.set(to_string_hex(entry_copy.ICAO_address, 6));
+    text_icao_address.set(entry_.icao_str);
 
     button_aircraft_details.on_select = [this, &nav](Button&) {
-        aircraft_details_view = nav.push<ADSBRxAircraftDetailsView>(entry_copy, [this]() { send_updates = false; });
-        send_updates = false;
+        aircraft_details_view_ = nav.push<ADSBRxAircraftDetailsView>(entry_);
+        nav.set_on_pop([this]() {
+            aircraft_details_view_ = nullptr;
+            refresh_ui();
+        });
     };
 
     button_see_map.on_select = [this, &nav](Button&) {
-        if (!send_updates) {  // Prevent recursively launching the map
-            geomap_view = nav.push<GeoMapView>(
-                trimr(entry_copy.callsign[0] != ' ' ? entry_copy.callsign : entry_copy.icaoStr),
-                entry_copy.pos.altitude,
-                GeoPos::alt_unit::FEET,
-                entry_copy.pos.latitude,
-                entry_copy.pos.longitude,
-                entry_copy.velo.heading,
-                [this]() {
-                    send_updates = false;
-                });
-            send_updates = true;
-        }
+        geomap_view_ = nav.push<GeoMapView>(
+            get_map_tag(entry_),
+            entry_.pos.altitude,
+            GeoPos::alt_unit::FEET,
+            entry_.pos.latitude,
+            entry_.pos.longitude,
+            entry_.velo.heading);
+        nav.set_on_pop([this]() {
+            geomap_view_ = nullptr;
+            refresh_ui();
+        });
     };
+
+    refresh_ui();
 };
 
-void ADSBRxView::focus() {
-    field_vga.focus();
+void ADSBRxDetailsView::focus() {
+    button_see_map.focus();
+}
+
+void ADSBRxDetailsView::update(const AircraftRecentEntry& entry) {
+    entry_ = entry;
+
+    if (aircraft_details_view_) {
+        // AC Details view is showing, nothing to update.
+    } else if (geomap_view_) {
+        // Map is showing, update the current item.
+        geomap_view_->update_tag(get_map_tag(entry_));
+        geomap_view_->update_position(entry.pos.latitude, entry.pos.longitude, entry.velo.heading, entry.pos.altitude);
+    } else {
+        // Details is showing, update details.
+        refresh_ui();
+    }
+}
+
+void ADSBRxDetailsView::clear_map_markers() {
+    if (geomap_view_)
+        geomap_view_->clear_markers();
+}
+
+bool ADSBRxDetailsView::add_map_marker(const AircraftRecentEntry& entry) {
+    // Map not shown, can't add markers.
+    if (!geomap_view_)
+        return false;
+
+    GeoMarker marker{};
+    marker.lon = entry.pos.longitude;
+    marker.lat = entry.pos.latitude;
+    marker.angle = entry.velo.heading;
+    marker.tag = get_map_tag(entry);
+
+    auto markerStored = geomap_view_->store_marker(marker);
+    return markerStored == MARKER_STORED;
+}
+
+void ADSBRxDetailsView::refresh_ui() {
+    auto age = entry_.age;
+    if (age < 60)
+        text_last_seen.set(to_string_dec_uint(age) + " seconds ago");
+    else
+        text_last_seen.set(to_string_dec_uint(age / 60) + " minutes ago");
+
+    text_callsign.set(entry_.callsign);
+    text_infos.set(entry_.info_string);
+    if (entry_.velo.heading < 360 && entry_.velo.speed >= 0)
+        text_info2.set("Hdg:" + to_string_dec_uint(entry_.velo.heading) +
+                       " Spd:" + to_string_dec_int(entry_.velo.speed));
+    else
+        text_info2.set("");
+
+    text_frame_pos_even.set(to_string_hex_array(entry_.frame_pos_even.get_raw_data(), 14));
+    text_frame_pos_odd.set(to_string_hex_array(entry_.frame_pos_odd.get_raw_data(), 14));
+}
+
+/* ADSBRxView ********************************************/
+
+ADSBRxView::ADSBRxView(NavigationView& nav) {
+    baseband::run_image(portapack::spi_flash::image_tag_adsb_rx);
+    add_children(
+        {&labels,
+         &field_lna,
+         &field_vga,
+         &field_rf_amp,
+         &rssi,
+         &recent_entries_view,
+         &status_frame,
+         &status_good_frame});
+
+    recent_entries_view.set_parent_rect({0, 16, 240, 272});
+    recent_entries_view.on_select = [this, &nav](const AircraftRecentEntry& entry) {
+        detail_key = entry.key();
+        details_view = nav.push<ADSBRxDetailsView>(entry);
+
+        nav.set_on_pop([this]() {
+            detail_key = AircraftRecentEntry::invalid_key;
+            details_view = nullptr;
+        });
+    };
+
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        on_tick_second();
+    };
+
+    logger = std::make_unique<ADSBLogger>();
+    logger->append(LOG_ROOT_DIR "/ADSB.TXT");
+
+    receiver_model.enable();
+    baseband::set_adsb();
 }
 
 ADSBRxView::~ADSBRxView() {
@@ -293,228 +378,185 @@ ADSBRxView::~ADSBRxView() {
     baseband::shutdown();
 }
 
-AircraftRecentEntry ADSBRxView::find_or_create_entry(uint32_t ICAO_address) {
-    auto it = find(recent, ICAO_address);
-
-    // If not found
-    if (it == std::end(recent)) {
-        recent.emplace_front(ICAO_address);  // Add it
-        it = find(recent, ICAO_address);     // Find it again
-    }
-    return *it;
-}
-
-void ADSBRxView::replace_entry(AircraftRecentEntry& entry) {
-    uint32_t ICAO_address = entry.ICAO_address;
-
-    std::replace_if(
-        recent.begin(), recent.end(),
-        [ICAO_address](const AircraftRecentEntry& compEntry) { return ICAO_address == compEntry.ICAO_address; },
-        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
-    recent.sort([](const AircraftRecentEntry& left, const AircraftRecentEntry& right) { return (left.age_state < right.age_state); });
+void ADSBRxView::focus() {
+    field_vga.focus();
 }
 
 void ADSBRxView::on_frame(const ADSBFrameMessage* message) {
-    logger = std::make_unique<ADSBLogger>();
-    rtc::RTC datetime;
-    std::string callsign;
-    std::string str_info;
-    std::string logentry;
-
     auto frame = message->frame;
     uint32_t ICAO_address = frame.get_ICAO_address();
+    status_frame.toggle();
 
-    if (frame.check_CRC() && ICAO_address) {
-        rtcGetTime(&RTCD1, &datetime);
-        auto entry = find_or_create_entry(ICAO_address);
-        frame.set_rx_timestamp(datetime.minute() * 60 + datetime.second());
-        entry.reset_age();
-        if (entry.hits == 0) {
-            entry.amp = message->amp;  // Store amplitude on first hit
-        } else {
-            entry.amp = ((entry.amp * 15) + message->amp) >> 4;  // Update smoothed amplitude on updates
+    // Bad frame, skip it.
+    if (!frame.check_CRC() || ICAO_address == 0)
+        return;
+
+    ADSBLogEntry log_entry;
+    status_good_frame.toggle();
+
+    rtc::RTC datetime;
+    rtcGetTime(&RTCD1, &datetime);
+    frame.set_rx_timestamp(datetime.minute() * 60 + datetime.second());
+
+    // NB: Reference to update entry in-place.
+    auto& entry = find_or_create_entry(ICAO_address);
+    entry.inc_hit();
+    entry.reset_age();
+
+    // Store smoothed amplitude on updates.
+    entry.amp = entry.hits == 0
+                    ? message->amp
+                    : ((entry.amp * 15) + message->amp) >> 4;
+
+    log_entry.raw_data = to_string_hex_array(frame.get_raw_data(), 14);
+    log_entry.icao = entry.icao_str;
+
+    if (frame.get_DF() == DF_ADSB) {
+        uint8_t msg_type = frame.get_msg_type();
+        uint8_t msg_sub = frame.get_msg_sub();
+        uint8_t* raw_data = frame.get_raw_data();
+
+        // 4: // surveillance, altitude reply
+        if ((msg_type >= AIRCRAFT_ID_L) && (msg_type <= AIRCRAFT_ID_H)) {
+            entry.set_callsign(decode_frame_id(frame));
+            log_entry.callsign = entry.callsign;
         }
 
-        entry.inc_hit();
-        if (logger) {
-            logentry += to_string_hex_array(frame.get_raw_data(), 14) + " ";
-            logentry += "ICAO:" + entry.icaoStr + " ";
-        }
+        // 9:
+        // 18: // Extended squitter/non-transponder
+        // 21: // Comm-B, identity reply
+        // 20: // Comm-B, altitude reply
+        else if (((msg_type >= AIRBORNE_POS_BARO_L) && (msg_type <= AIRBORNE_POS_BARO_H)) ||
+                 ((msg_type >= AIRBORNE_POS_GPS_L) && (msg_type <= AIRBORNE_POS_GPS_H))) {
+            entry.set_frame_pos(frame, raw_data[6] & 4);
+            log_entry.pos = entry.pos;
 
-        if (frame.get_DF() == DF_ADSB) {
-            uint8_t msg_type = frame.get_msg_type();
-            uint8_t msg_sub = frame.get_msg_sub();
-            uint8_t* raw_data = frame.get_raw_data();
+            if (entry.pos.valid) {
+                std::string str_info =
+                    "Alt:" + to_string_dec_int(entry.pos.altitude) +
+                    " Lat:" + to_string_decimal(entry.pos.latitude, 2) +
+                    " Lon:" + to_string_decimal(entry.pos.longitude, 2);
 
-            // 4: // surveillance, altitude reply
-            if ((msg_type >= AIRCRAFT_ID_L) && (msg_type <= AIRCRAFT_ID_H)) {
-                callsign = decode_frame_id(frame);
-                entry.set_callsign(callsign);
-                if (logger) {
-                    logentry += callsign + " ";
-                }
+                entry.set_info_string(std::move(str_info));
             }
-            // 9:
-            // 18: { // Extended squitter/non-transponder
-            // 21: // Comm-B, identity reply
-            // 20: // Comm-B, altitude reply
-            else if (((msg_type >= AIRBORNE_POS_BARO_L) && (msg_type <= AIRBORNE_POS_BARO_H)) ||
-                     ((msg_type >= AIRBORNE_POS_GPS_L) && (msg_type <= AIRBORNE_POS_GPS_H))) {
-                entry.set_frame_pos(frame, raw_data[6] & 4);
 
-                if (entry.pos.valid) {
-                    str_info = "Alt:" + to_string_dec_int(entry.pos.altitude) +
-                               " Lat:" + to_string_decimal(entry.pos.latitude, 2) +
-                               " Lon:" + to_string_decimal(entry.pos.longitude, 2);
-
-                    entry.set_info_string(str_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);
-                if (logger) {
-                    logger->append(LOG_ROOT_DIR "/ADSB.TXT");
-                    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
-
-        if (logger) {
-            logger->append(LOG_ROOT_DIR "/ADSB.TXT");
-            // will log each frame in format:
-            // 20171103100227 8DADBEEFDEADBEEFDEADBEEFDEADBEEF ICAO:nnnnnn callsign Alt:nnnnnn Latnnn.nn Lonnnn.nn
-            logger->log_str(logentry);
+        } else if (msg_type == AIRBORNE_VEL && msg_sub >= VEL_GND_SUBSONIC && msg_sub <= VEL_AIR_SUPERSONIC) {
+            entry.set_frame_velo(frame);
+            log_entry.vel = entry.velo;
+            log_entry.vel_type = msg_sub;
         }
     }
+
+    logger->log(log_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();
+    status_frame.reset();
+    status_good_frame.reset();
+
+    ++tick_count;
+    ++ticks_since_marker_refresh;
+
+    // Small list, update all at once.
+    if (recent.size() <= max_update_entries) {
+        update_recent_entries(/*age_delta*/ 1);
+        refresh_ui();
+        return;
     }
+
+    // Too many items, split update work into two phases:
+    // Entry maintenance and UI update.
+    if ((tick_count & 1) == 0)
+        update_recent_entries(/*age_delta*/ 2);
+    else
+        refresh_ui();
 }
 
-void ADSBRxView::updateDetailsAndMap(int ageStep) {
-    ui::GeoMarker marker;
-    bool storeNewMarkers = false;
+void ADSBRxView::refresh_ui() {
+    // There's only one ticks handler, but 3 UIs that need to be updated.
+    // This code will dispatch updates to the currently active view.
 
-    // Sort and truncate the entries, grouped, newest group first
-    sort_entries_by_state();
-    truncate_entries(recent);
-    remove_old_entries();
+    if (details_view) {
+        // The details view is showing, forward updates to that UI.
+        bool current_updated = false;
+        bool map_needs_update = false;
 
-    // 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;
+        if (details_view->map_active()) {
+            // Is it time to clear and refresh the map's markers?
+            if (ticks_since_marker_refresh >= MARKER_UPDATE_SECONDS) {
+                map_needs_update = true;
+                ticks_since_marker_refresh = 0;
+                details_view->clear_map_markers();
+            }
+        } else {
+            // Refresh map immediately once active.
+            ticks_since_marker_refresh = MARKER_UPDATE_SECONDS;
+        }
+
+        // Process the entries list.
+        for (const auto& entry : recent) {
+            // Found the entry being shown in details view. Update it.
+            if (entry.key() == detail_key) {
+                details_view->update(entry);
+                current_updated = true;
+            }
+
+            // NB: current entry also gets a marker so it shows up if map is panned.
+            if (map_needs_update && entry.pos.valid && entry.state <= ADSBAgeState::Recent) {
+                map_needs_update = details_view->add_map_marker(entry);
+            }
+
+            // Any work left to do?
+            if (current_updated && !map_needs_update)
+                break;
         }
     } else {
-        ticksSinceMarkerRefresh = MARKER_UPDATE_SECONDS;  // Send the markers as soon as the geoview exists
-    }
-
-    // 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
-            // Note -- Storing the selected entry too, in case map panning occurs
-            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) {
+        // Main page is the top view. Redraw the entries view.
         recent_entries_view.set_dirty();
     }
 }
 
-ADSBRxView::ADSBRxView(NavigationView& nav) {
-    baseband::run_image(portapack::spi_flash::image_tag_adsb_rx);
-    add_children({&labels,
-                  &field_lna,
-                  &field_vga,
-                  &field_rf_amp,
-                  &rssi,
-                  &recent_entries_view});
+void ADSBRxView::update_recent_entries(int age_delta) {
+    for (auto& entry : recent)
+        entry.inc_age(age_delta);
 
-    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();
-        details_view = nav.push<ADSBRxDetailsView>(
-            entry,
-            [this]() {
-                send_updates = false;
-            });
-        send_updates = true;
-    };
+    // Sort and truncate the entries, grouped by state, newest first.
+    sort_entries_by_state();
+    truncate_entries(recent);
+    remove_expired_entries();
+}
 
-    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
-        on_tick_second();
-    };
+AircraftRecentEntry& ADSBRxView::find_or_create_entry(uint32_t ICAO_address) {
+    // Find ...
+    auto it = find(recent, ICAO_address);
+    if (it != recent.end())
+        return *it;
 
-    baseband::set_adsb();
+    // ... or Create.
+    return recent.emplace_front(ICAO_address);
+}
 
-    receiver_model.set_target_frequency(1'090'000'000);
-    receiver_model.enable();
+void ADSBRxView::sort_entries_by_state() {
+    recent.sort([](const auto& left, const auto& right) {
+        return (left.state < right.state);
+    });
+}
+
+void ADSBRxView::remove_expired_entries() {
+    // NB: Assumes entried are sorted with oldest last.
+    auto it = recent.rbegin();
+    auto end = recent.rend();
+
+    // Find the first !expired entry from the back.
+    while (it != end) {
+        if (it->state != ADSBAgeState::Expired)
+            break;
+
+        std::advance(it, 1);
+    }
+
+    // Remove the range of expired items.
+    recent.erase(it.base(), recent.end());
 }
 
 } /* namespace ui */

firmware/application/apps/ui_adsb_rx.hpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 Kyle Reed
  *
  * This file is part of PortaPack.
  *
@@ -21,29 +22,23 @@
  */
 
 #include "ui.hpp"
-
 #include "ui_receiver.hpp"
 #include "ui_geomap.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 "radio_state.hpp"
 #include "crc.hpp"
+#include "database.hpp"
+#include "file.hpp"
+#include "log_file.hpp"
+#include "message.hpp"
+#include "radio_state.hpp"
+#include "recent_entries.hpp"
+#include "string_format.hpp"
 
 using namespace adsb;
 
 namespace ui {
-
-#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)
 
@@ -66,8 +61,26 @@ namespace ui {
 #define VEL_AIR_SUBSONIC 3
 #define VEL_AIR_SUPERSONIC 4
 
-#define O_E_FRAME_TIMEOUT 20  // timeout between odd and even frames
+#define O_E_FRAME_TIMEOUT 20     // timeout between odd and even frames
+#define MARKER_UPDATE_SECONDS 5  // "other" map marker redraw interval
 
+/* Thresholds (in seconds) that define the transition between ages. */
+struct ADSBAgeLimit {
+    static constexpr int Current = 10;
+    static constexpr int Recent = 30;
+    static constexpr int Expired = 300;
+};
+
+/* Age states used for sorting and drawing recent entries. */
+enum class ADSBAgeState : uint8_t {
+    Invalid,
+    Current,
+    Recent,
+    Old,
+    Expired,
+};
+
+/* Data extracted from ADSB frames. */
 struct AircraftRecentEntry {
     using Key = uint32_t;
 
@@ -76,30 +89,30 @@ struct AircraftRecentEntry {
     uint32_t ICAO_address{};
     uint16_t hits{0};
 
-    uint16_t age_state{1};
-    uint32_t age{0};
+    ADSBAgeState state{ADSBAgeState::Invalid};
+    uint32_t age{0};  // In seconds
     uint32_t amp{0};
     adsb_pos pos{false, 0, 0, 0};
     adsb_vel velo{false, 0, 999, 0};
     ADSBFrame frame_pos_even{};
     ADSBFrame frame_pos_odd{};
 
-    std::string icaoStr{"      "};
-    std::string callsign{"        "};
-    std::string info_string{""};
+    std::string icao_str{};
+    std::string callsign{};
+    std::string info_string{};
 
-    AircraftRecentEntry(
-        const uint32_t ICAO_address)
+    AircraftRecentEntry(const uint32_t ICAO_address)
         : ICAO_address{ICAO_address} {
-        this->icaoStr = to_string_hex(ICAO_address, 6);
+        this->icao_str = to_string_hex(ICAO_address, 6);
     }
 
+    /* RecentEntries helpers expect a "key" on every item. */
     Key key() const {
         return ICAO_address;
     }
 
-    void set_callsign(std::string& new_callsign) {
-        callsign = new_callsign;
+    void set_callsign(std::string new_callsign) {
+        callsign = std::move(new_callsign);
     }
 
     void inc_hit() {
@@ -122,8 +135,8 @@ struct AircraftRecentEntry {
         velo = decode_frame_velo(frame);
     }
 
-    void set_info_string(std::string& new_info_string) {
-        info_string = new_info_string;
+    void set_info_string(std::string new_info_string) {
+        info_string = std::move(new_info_string);
     }
 
     void reset_age() {
@@ -132,59 +145,59 @@ struct AircraftRecentEntry {
 
     void inc_age(int delta) {
         age += delta;
-        if (age < ADSB_CURRENT) {
-            age_state = pos.valid ? 0 : 1;
-        } else if (age < ADSB_RECENT) {
-            age_state = 2;
-        } else if (age < ADSB_REMOVE) {
-            age_state = 3;
-        } else {
-            age_state = 4;
-        }
+
+        if (age < ADSBAgeLimit::Current)
+            state = pos.valid ? ADSBAgeState::Invalid
+                              : ADSBAgeState::Current;
+
+        else if (age < ADSBAgeLimit::Recent)
+            state = ADSBAgeState::Recent;
+
+        else if (age < ADSBAgeLimit::Expired)
+            state = ADSBAgeState::Old;
+
+        else
+            state = ADSBAgeState::Expired;
     }
 };
 
+// NB: uses std::list underneath so assuming refs are NOT invalidated.
 using AircraftRecentEntries = RecentEntries<AircraftRecentEntry>;
 
+/* Holds data for logging. */
+struct ADSBLogEntry {
+    std::string raw_data{};
+    std::string icao{};
+    std::string callsign{};
+    adsb_pos pos{};
+    adsb_vel vel{};
+    uint8_t vel_type{};
+};
+
+// TODO: Make logging optional.
+/* Logs entries to a log file. */
 class ADSBLogger {
    public:
     Optional<File::Error> append(const std::filesystem::path& filename) {
         return log_file.append(filename);
     }
-    void log_str(std::string& logline);
+    void log(const ADSBLogEntry& log_entry);
 
    private:
     LogFile log_file{};
 };
 
+/* Shows detailed information about an aircraft. */
 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;
+    ADSBRxAircraftDetailsView(
+        NavigationView&,
+        const AircraftRecentEntry& entry);
 
     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 = {};
+    std::string title() const override { return "AC Details"; }
 
    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()},
@@ -237,36 +250,34 @@ class ADSBRxAircraftDetailsView : public View {
         "Back"};
 };
 
+/* Shows detailed information about an aircraft's flight. */
 class ADSBRxDetailsView : public View {
    public:
-    ADSBRxDetailsView(NavigationView&, const AircraftRecentEntry& entry, const std::function<void(void)> on_close);
-    ~ADSBRxDetailsView();
+    ADSBRxDetailsView(NavigationView&, const AircraftRecentEntry& entry);
 
     ADSBRxDetailsView(const ADSBRxDetailsView&) = delete;
-    ADSBRxDetailsView(ADSBRxDetailsView&&) = delete;
     ADSBRxDetailsView& operator=(const ADSBRxDetailsView&) = delete;
-    ADSBRxDetailsView& operator=(ADSBRxDetailsView&&) = delete;
 
     void focus() override;
-
     void update(const AircraftRecentEntry& entry);
 
-    std::string title() const override { return "Details"; };
+    /* Calls forwarded to map view if shown. */
+    bool map_active() const { return geomap_view_; }
+    void clear_map_markers();
+    /* Adds a marker for the entry to the map. Returns true on success. */
+    bool add_map_marker(const AircraftRecentEntry& entry);
 
-    AircraftRecentEntry get_current_entry() { return entry_copy; }
-
-    std::database::AirlinesDBRecord airline_record = {};
-
-    GeoMapView* geomap_view{nullptr};
+    std::string title() const override { return "Details"; }
 
    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;
+    void refresh_ui();
+
+    GeoMapView* geomap_view_{nullptr};
+    ADSBRxAircraftDetailsView* aircraft_details_view_{nullptr};
+
+    // NB: Keeping a copy so that it doesn't end up dangling
+    // if removed from the recent entries list.
+    AircraftRecentEntry entry_{AircraftRecentEntry::invalid_key};
 
     Labels labels{
         {{0 * 8, 1 * 16}, "ICAO:", Color::light_grey()},
@@ -321,6 +332,7 @@ class ADSBRxDetailsView : public View {
         "See on map"};
 };
 
+/* Main ADSB application view and message dispatch. */
 class ADSBRxView : public View {
    public:
     ADSBRxView(NavigationView& nav);
@@ -332,45 +344,52 @@ class ADSBRxView : public View {
     ADSBRxView& operator=(ADSBRxView&&) = delete;
 
     void focus() override;
-
     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:
     RxRadioState radio_state_{
-        2500000 /* bandwidth */,
-        2000000 /* sampling rate */,
+        1'090'000'000 /* frequency */,
+        2'500'000 /* bandwidth */,
+        2'000'000 /* sampling rate */,
         ReceiverModel::Mode::SpectrumAnalysis};
     app_settings::SettingsManager settings_{
         "rx_adsb", app_settings::Mode::RX};
 
     std::unique_ptr<ADSBLogger> logger{};
+
+    /* Event Handlers */
     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};
-
-    const RecentEntriesColumns columns{{{"ICAO/Call", 9},
-                                        {"Lvl", 3},
-                                        {"Spd", 3},
-                                        {"Amp", 3},
-                                        {"Hit", 3},
-                                        {"Age", 4}}};
-    AircraftRecentEntries recent{};
-    RecentEntriesView<RecentEntries<AircraftRecentEntry>> recent_entries_view{columns, recent};
+    void refresh_ui();
 
     SignalToken signal_token_tick_second{};
+    uint8_t tick_count = 0;
+    uint16_t ticks_since_marker_refresh{MARKER_UPDATE_SECONDS};
+
+    /* Max number of entries that can be updated in a single pass.
+     * 16 is one screen of recent entries. */
+    static constexpr uint8_t max_update_entries = 16;
+
+    /* Recent Entries */
+    const RecentEntriesColumns columns{
+        {{"ICAO/Call", 9},
+         {"Lvl", 3},
+         {"Spd", 3},
+         {"Amp", 3},
+         {"Hit", 3},
+         {"Age", 4}}};
+    AircraftRecentEntries recent{};
+    RecentEntriesView<AircraftRecentEntries> recent_entries_view{columns, recent};
+
+    /* Entry Management */
+    void update_recent_entries(int age_delta);
+    AircraftRecentEntry& find_or_create_entry(uint32_t ICAO_address);
+    void sort_entries_by_state();
+    void remove_expired_entries();
+
+    /* The key of the entry in the details view if shown. */
+    AircraftRecentEntry::Key detail_key{AircraftRecentEntry::invalid_key};
     ADSBRxDetailsView* details_view{nullptr};
-    uint32_t detailed_entry_key{0};
-    bool send_updates{false};
 
     Labels labels{
         {{0 * 8, 0 * 8}, "LNA:   VGA:   AMP:", Color::light_grey()}};
@@ -385,7 +404,17 @@ class ADSBRxView : public View {
         {18 * 8, 0 * 16}};
 
     RSSI rssi{
-        {20 * 8, 4, 10 * 8, 8},
+        {20 * 8, 4, 10 * 7, 8},
+    };
+
+    ActivityDot status_frame{
+        {screen_width - 3, 5, 2, 2},
+        Color::white(),
+    };
+
+    ActivityDot status_good_frame{
+        {screen_width - 3, 9, 2, 2},
+        Color::green(),
     };
 
     MessageHandlerRegistration message_handler_frame{

firmware/application/apps/ui_adsb_tx.cpp

@@ -186,13 +186,12 @@ ADSBSquawkView::ADSBSquawkView(
                   &field_squawk});
 }
 
-void ADSBSquawkView::collect_frames(const uint32_t ICAO_address, std::vector<ADSBFrame>& frame_list) {
+void ADSBSquawkView::collect_frames(const uint32_t /*ICAO_address*/, std::vector<ADSBFrame>& frame_list) {
     if (!enabled) return;
 
     ADSBFrame temp_frame;
-    (void)ICAO_address;
 
-    encode_frame_squawk(temp_frame, field_squawk.concatenate_4_octal_u16());
+    encode_frame_squawk(temp_frame, field_squawk.to_integer());
 
     frame_list.emplace_back(temp_frame);
 }
@@ -277,7 +276,7 @@ ADSBTxView::~ADSBTxView() {
 }
 
 void ADSBTxView::generate_frames() {
-    const uint32_t ICAO_address = sym_icao.value_hex_u64();
+    const uint32_t ICAO_address = sym_icao.to_integer();
 
     frames.clear();
 
@@ -297,6 +296,9 @@ void ADSBTxView::generate_frames() {
 void ADSBTxView::start_tx() {
     generate_frames();
 
+    /* Already tested , with SDR Angel + another Hackrf RX  and dump1090 + SDR RLT. Final conclusion is TX LPF 6 Mhz is
+     * the best settings to fulfill ADSB transponder spectrum mask requirements (<=-20 dB's at +-7Mhz , <=-40 dB's at +-23Mhz )
+     * and not showing any ADSB data decoding degradation.*/
     transmitter_model.enable();
 
     baseband::set_adsb();

firmware/application/apps/ui_adsb_tx.hpp

@@ -135,7 +135,7 @@ class ADSBSquawkView : public OptionTabView {
     SymField field_squawk{
         {10 * 8, 2 * 16},
         4,
-        SymField::SYMFIELD_OCT};
+        SymField::Type::Oct};
 };
 
 class ADSBTXThread {
@@ -203,7 +203,8 @@ class ADSBTxView : public View {
         };*/
 
     TxRadioState radio_state_{
-        10000000 /* bandwidth */,
+        1090000000 /* frequency */,
+        6000000 /* bandwidth */,
         4000000 /* sampling rate */
     };
     app_settings::SettingsManager settings_{
@@ -235,7 +236,7 @@ class ADSBTxView : public View {
     SymField sym_icao{
         {10 * 8, 4 * 8},
         6,
-        SymField::SYMFIELD_HEX};
+        SymField::Type::Hex};
 
     Text text_frame{
         {1 * 8, 29 * 8, 14 * 8, 16},

firmware/application/apps/ui_aprs_rx.cpp

@@ -42,15 +42,12 @@ void RecentEntriesTable<APRSRecentEntries>::draw(
     const Rect& target_rect,
     Painter& painter,
     const Style& style) {
-    char aged_color;
     Color target_color;
     // auto entry_age = entry.age;
 
     target_color = Color::green();
 
-    aged_color = 0x10;
-    std::string entry_string = "\x1B";
-    entry_string += aged_color;
+    std::string entry_string = "";
 
     entry_string += entry.source_formatted;
     entry_string.append(10 - entry.source_formatted.size(), ' ');

firmware/application/apps/ui_aprs_rx.hpp

@@ -190,7 +190,11 @@ class APRSRxView : public View {
     bool reset_console = false;
 
     NavigationView& nav_;
-    RxRadioState radio_state_{};
+    RxRadioState radio_state_{
+        144390000 /* frequency */,
+        1750000 /* bandwidth */,
+        3072000 /* sampling rate */
+    };
     app_settings::SettingsManager settings_{
         "rx_aprs", app_settings::Mode::RX};
 

firmware/application/apps/ui_aprs_tx.cpp

@@ -48,9 +48,10 @@ APRSTXView::~APRSTXView() {
 }
 
 void APRSTXView::start_tx() {
+    // TODO: Clean up this API to take string_views to avoid allocations.
     make_aprs_frame(
-        sym_source.value_string().c_str(), num_ssid_source.value(),
-        sym_dest.value_string().c_str(), num_ssid_dest.value(),
+        sym_source.to_string().c_str(), num_ssid_source.value(),
+        sym_dest.to_string().c_str(), num_ssid_dest.value(),
         payload);
 
     // uint8_t * bb_data_ptr = shared_memory.bb_data.data;

firmware/application/apps/ui_aprs_tx.hpp

@@ -46,6 +46,7 @@ class APRSTXView : public View {
 
    private:
     TxRadioState radio_state_{
+        144390000 /* frequency */,
         1750000 /* bandwidth */,
         AFSK_TX_SAMPLERATE /* sampling rate */
     };
@@ -68,7 +69,8 @@ class APRSTXView : public View {
     SymField sym_source{
         {7 * 8, 1 * 16},
         6,
-        SymField::SYMFIELD_ALPHANUM};
+        SymField::Type::Alpha};
+
     NumberField num_ssid_source{
         {19 * 8, 1 * 16},
         2,
@@ -79,7 +81,7 @@ class APRSTXView : public View {
     SymField sym_dest{
         {7 * 8, 2 * 16},
         6,
-        SymField::SYMFIELD_ALPHANUM};
+        SymField::Type::Alpha};
 
     NumberField num_ssid_dest{
         {19 * 8, 2 * 16},

firmware/application/apps/ui_btle_rx.cpp

@@ -54,7 +54,6 @@ BTLERxView::BTLERxView(NavigationView& nav)
                   &console});
 
     // Auto-configure modem for LCR RX (TODO: remove later)
-    field_frequency.set_value(2426000000);
     auto def_bell202 = &modem_defs[0];
     persistent_memory::set_modem_baudrate(def_bell202->baudrate);
     serial_format_t serial_format;
@@ -71,7 +70,7 @@ BTLERxView::BTLERxView(NavigationView& nav)
     };
 
     // Auto-configure modem for LCR RX (will be removed later)
-    baseband::set_btle(persistent_memory::modem_baudrate(), 8, 0, false);
+    baseband::set_btlerx(channel_number);
 
     audio::set_rate(audio::Rate::Hz_24000);
     audio::output::start();

firmware/application/apps/ui_btle_rx.hpp

@@ -50,6 +50,7 @@ class BTLERxView : public View {
 
     NavigationView& nav_;
     RxRadioState radio_state_{
+        2426000000 /* frequency */,
         4000000 /* bandwidth */,
         4000000 /* sampling rate */,
         ReceiverModel::Mode::WidebandFMAudio};
@@ -59,6 +60,8 @@ class BTLERxView : public View {
     uint8_t console_color{0};
     uint32_t prev_value{0};
 
+    static constexpr uint8_t channel_number = 37;
+
     RFAmpField field_rf_amp{
         {13 * 8, 0 * 16}};
     LNAGainField field_lna{

firmware/application/apps/ui_debug.cpp

@@ -20,6 +20,7 @@
  */
 
 #include "ui_debug.hpp"
+#include "debug.hpp"
 
 #include "ch.h"
 
@@ -33,6 +34,7 @@
 #include "ui_font_fixed_8x16.hpp"
 #include "ui_styles.hpp"
 #include "ui_painter.hpp"
+#include "ui_external_items_menu_loader.hpp"
 
 #include "portapack.hpp"
 #include "portapack_persistent_memory.hpp"
@@ -122,12 +124,12 @@ void TemperatureWidget::paint(Painter& painter) {
 }
 
 TemperatureWidget::temperature_t TemperatureWidget::temperature(const sample_t sensor_value) const {
-    /*It seems to be a temperature difference of 25C*/
-    return -40 + (sensor_value * 4.31) + 25;  // max2837 datasheet temp 25ºC has sensor value: 15
+    // Scaling is different for MAX2837 vs MAX2839 so it's now done in the respective chip-specific module
+    return sensor_value;
 }
 
 std::string TemperatureWidget::temperature_str(const temperature_t temperature) const {
-    return to_string_dec_int(temperature, temp_len - 1) + "C";
+    return to_string_dec_int(temperature, temp_len - 2) + STR_DEGREES_C;
 }
 
 Coord TemperatureWidget::screen_y(
@@ -157,11 +159,8 @@ void TemperatureView::focus() {
 /* RegistersWidget *******************************************************/
 
 RegistersWidget::RegistersWidget(
-    RegistersWidgetConfig&& config,
-    std::function<uint32_t(const size_t register_number)>&& reader)
-    : Widget{},
-      config(std::move(config)),
-      reader(std::move(reader)) {
+    RegistersWidgetConfig&& config)
+    : Widget{}, config(std::move(config)), page_number(0) {
 }
 
 void RegistersWidget::update() {
@@ -177,12 +176,15 @@ void RegistersWidget::paint(Painter& painter) {
 
 void RegistersWidget::draw_legend(const Coord left, Painter& painter) {
     const auto pos = screen_pos();
+    const std::string spaces(config.legend_length(), ' ');
+
+    for (uint32_t i = 0; i < config.registers_per_page; i += config.registers_per_row()) {
+        uint32_t r = page_number * config.registers_per_page + i;
 
-    for (size_t i = 0; i < config.registers_count; i += config.registers_per_row()) {
         const Point offset{
             left, static_cast<int>((i / config.registers_per_row()) * row_height)};
 
-        const auto text = to_string_hex(i, config.legend_length());
+        const auto text = (r >= config.registers_count) ? spaces : to_string_hex(r, config.legend_length());
         painter.draw_string(
             pos + offset,
             style().invert(),
@@ -194,15 +196,16 @@ void RegistersWidget::draw_values(
     const Coord left,
     Painter& painter) {
     const auto pos = screen_pos();
+    const std::string spaces(config.value_length(), ' ');
+
+    for (uint32_t i = 0; i < config.registers_per_page; i++) {
+        uint32_t r = page_number * config.registers_per_page + i;
 
-    for (size_t i = 0; i < config.registers_count; i++) {
         const Point offset = {
             static_cast<int>(left + config.legend_width() + 8 + (i % config.registers_per_row()) * (config.value_width() + 8)),
             static_cast<int>((i / config.registers_per_row()) * row_height)};
 
-        const auto value = reader(i);
-
-        const auto text = to_string_hex(value, config.value_length());
+        const auto text = (r >= config.registers_count) ? spaces : to_string_hex(reg_read(r), config.value_length());
         painter.draw_string(
             pos + offset,
             style(),
@@ -210,19 +213,61 @@ void RegistersWidget::draw_values(
     }
 }
 
+uint32_t RegistersWidget::reg_read(const uint32_t register_number) {
+    if (register_number < config.registers_count) {
+        switch (config.chip_type) {
+            case CT_PMEM:
+                return portapack::persistent_memory::pmem_data_word(register_number / 4) >> (register_number % 4 * 8);
+            case CT_RFFC5072:
+                return radio::debug::first_if::register_read(register_number);
+            case CT_MAX283X:
+                return radio::debug::second_if::register_read(register_number);
+            case CT_SI5351:
+                return portapack::clock_generator.read_register(register_number);
+            case CT_AUDIO:
+                return audio::debug::reg_read(register_number);
+        }
+    }
+    return 0xFFFF;
+}
+
+void RegistersWidget::reg_write(const uint32_t register_number, const uint32_t value) {
+    if (register_number < config.registers_count) {
+        switch (config.chip_type) {
+            case CT_PMEM:
+                break;
+            case CT_RFFC5072:
+                radio::debug::first_if::register_write(register_number, value);
+                break;
+            case CT_MAX283X:
+                radio::debug::second_if::register_write(register_number, value);
+                break;
+            case CT_SI5351:
+                portapack::clock_generator.write_register(register_number, value);
+                break;
+            case CT_AUDIO:
+                audio::debug::reg_write(register_number, value);
+                break;
+        }
+    }
+}
+
 /* RegistersView *********************************************************/
 
 RegistersView::RegistersView(
     NavigationView& nav,
     const std::string& title,
-    RegistersWidgetConfig&& config,
-    std::function<uint32_t(const size_t register_number)>&& reader)
-    : registers_widget{std::move(config), std::move(reader)} {
+    RegistersWidgetConfig&& config)
+    : registers_widget{std::move(config)} {
     add_children({
         &text_title,
         &registers_widget,
         &button_update,
         &button_done,
+        &labels,
+        &field_write_reg_num,
+        &field_write_data_val,
+        &button_write,
     });
 
     button_update.on_select = [this](Button&) {
@@ -231,16 +276,38 @@ RegistersView::RegistersView(
     button_done.on_select = [&nav](Button&) { nav.pop(); };
 
     registers_widget.set_parent_rect({0, 48, 240, 192});
+    registers_widget.set_page(0);
 
     text_title.set_parent_rect({(240 - static_cast<int>(title.size()) * 8) / 2, 16,
                                 static_cast<int>(title.size()) * 8, 16});
     text_title.set(title);
+
+    field_write_reg_num.on_change = [this](SymField&) {
+        field_write_data_val.set_value(this->registers_widget.reg_read(field_write_reg_num.to_integer()));
+        field_write_data_val.set_dirty();
+    };
+
+    const auto value = registers_widget.reg_read(0);
+    field_write_data_val.set_value(value);
+
+    button_write.set_style(&Styles::red);
+    button_write.on_select = [this](Button&) {
+        this->registers_widget.reg_write(field_write_reg_num.to_integer(), field_write_data_val.to_integer());
+        this->registers_widget.update();
+    };
 }
 
 void RegistersView::focus() {
     button_done.focus();
 }
 
+bool RegistersView::on_encoder(const EncoderEvent delta) {
+    registers_widget.set_page(std::max(0ul, std::min(registers_widget.page_count() - 1, registers_widget.page() + delta)));
+    registers_widget.update();
+
+    return true;
+}
+
 /* ControlsSwitchesWidget ************************************************/
 
 void ControlsSwitchesWidget::on_show() {
@@ -374,18 +441,10 @@ 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); }); }},
-        {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); }); }},
-        {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>(
-                                                                                                              audio::debug::codec_name(), RegistersWidgetConfig{audio::debug::reg_count(), audio::debug::reg_bits()},
-                                                                                                              [](const size_t register_number) { return audio::debug::reg_read(register_number); }); }},
+        {"RFFC5072", ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>("RFFC5072", RegistersWidgetConfig{CT_RFFC5072, 31, 31, 16}); }},
+        {max283x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, max283x]() { nav.push<RegistersView>(max283x, RegistersWidgetConfig{CT_MAX283X, 32, 32, 10}); }},
+        {si5351x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, si5351x]() { nav.push<RegistersView>(si5351x, RegistersWidgetConfig{CT_SI5351, 188, 96, 8}); }},
+        {audio::debug::codec_name(), ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>(audio::debug::codec_name(), RegistersWidgetConfig{CT_AUDIO, audio::debug::reg_count(), audio::debug::reg_count(), audio::debug::reg_bits()}); }},
     });
     set_max_rows(2);  // allow wider buttons
 }
@@ -397,44 +456,73 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
         add_items({{"..", ui::Color::light_grey(), &bitmap_icon_previous, [&nav]() { nav.pop(); }}});
     }
     add_items({
-        {"Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryView>(); }},
+        {"Buttons Test", ui::Color::dark_cyan(), &bitmap_icon_controls, [&nav]() { nav.push<DebugControlsView>(); }},
+        {"Debug Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { portapack::persistent_memory::debug_dump(); }},
+        {"M0 Stack Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { stack_dump(); }},
+        {"Memory Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryDumpView>(); }},
+        {"Memory Usage", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryView>(); }},
+        {"Peripherals", ui::Color::dark_cyan(), &bitmap_icon_peripherals, [&nav]() { nav.push<DebugPeripheralsMenuView>(); }},
+        {"Pers. Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugPmemView>(); }},
         //{ "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>(); }},
         {"Touch Test", ui::Color::dark_cyan(), &bitmap_icon_notepad, [&nav]() { nav.push<DebugScreenTest>(); }},
-        {"P.Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugPmemView>(); }},
-        {"Debug Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { portapack::persistent_memory::debug_dump(); }},
-        {"Fonts Viewer", ui::Color::dark_cyan(), &bitmap_icon_notepad, [&nav]() { nav.push<DebugFontsView>(); }},
     });
+
+    for (auto const& gridItem : ExternalItemsMenuLoader::load_external_items(app_location_t::DEBUG, nav)) {
+        add_item(gridItem);
+    };
+
     set_max_rows(2);  // allow wider buttons
 }
 
+/* DebugMemoryDumpView *********************************************************/
+
+DebugMemoryDumpView::DebugMemoryDumpView(NavigationView& nav) {
+    add_children({
+        &button_dump,
+        &button_read,
+        &button_write,
+        &button_done,
+        &labels,
+        &field_starting_address,
+        &field_byte_count,
+        &field_rw_address,
+        &field_data_value,
+    });
+
+    button_done.on_select = [&nav](Button&) { nav.pop(); };
+
+    button_dump.on_select = [this](Button&) {
+        if (field_byte_count.to_integer() != 0)
+            memory_dump((uint32_t*)field_starting_address.to_integer(), ((uint32_t)field_byte_count.to_integer() + 3) / 4, false);
+    };
+
+    button_read.on_select = [this](Button&) {
+        field_data_value.set_value(*(uint32_t*)field_rw_address.to_integer());
+        field_data_value.set_dirty();
+    };
+
+    button_write.set_style(&Styles::red);
+    button_write.on_select = [this](Button&) {
+        *(uint32_t*)field_rw_address.to_integer() = (uint32_t)field_data_value.to_integer();
+    };
+}
+
+void DebugMemoryDumpView::focus() {
+    button_done.focus();
+}
+
 /* DebugPmemView *********************************************************/
 
-uint32_t pmem_checksum(volatile const uint32_t data[63]) {
-    CRC<32> crc{0x04c11db7, 0xffffffff, 0xffffffff};
-    for (size_t i = 0; i < 63; i++) {
-        const auto word = data[i];
-        crc.process_byte((word >> 0) & 0xff);
-        crc.process_byte((word >> 8) & 0xff);
-        crc.process_byte((word >> 16) & 0xff);
-        crc.process_byte((word >> 24) & 0xff);
-    }
-    return crc.checksum();
-}
-
 DebugPmemView::DebugPmemView(NavigationView& nav)
-    : data{*reinterpret_cast<pmem_data*>(memory::map::backup_ram.base())}, registers_widget(RegistersWidgetConfig{page_size, 8}, std::bind(&DebugPmemView::registers_widget_feed, this, std::placeholders::_1)) {
-    static_assert(sizeof(pmem_data) == memory::map::backup_ram.size());
-
-    add_children({&text_page, &registers_widget, &text_checksum, &text_checksum2, &button_ok});
+    : registers_widget(RegistersWidgetConfig{CT_PMEM, PMEM_SIZE_BYTES, page_size, 8}) {
+    add_children({&registers_widget, &text_checksum, &text_checksum2, &button_ok});
 
     registers_widget.set_parent_rect({0, 32, 240, 192});
 
-    text_checksum.set("Size: " + to_string_dec_uint(portapack::persistent_memory::data_size(), 3) + "  CRC: " + to_string_hex(data.check_value, 8));
-    text_checksum2.set("Calculated CRC: " + to_string_hex(pmem_checksum(data.regfile), 8));
+    text_checksum.set("Size: " + to_string_dec_uint(portapack::persistent_memory::data_size(), 3) + "  CRC: " + to_string_hex(portapack::persistent_memory::pmem_stored_checksum(), 8));
+    text_checksum2.set("Calculated CRC: " + to_string_hex(portapack::persistent_memory::pmem_calculated_checksum(), 8));
 
     button_ok.on_select = [&nav](Button&) {
         nav.pop();
@@ -444,7 +532,7 @@ DebugPmemView::DebugPmemView(NavigationView& nav)
 }
 
 bool DebugPmemView::on_encoder(const EncoderEvent delta) {
-    page = std::max(0l, std::min((int32_t)page_max, page + delta));
+    registers_widget.set_page(std::max(0ul, std::min((uint32_t)page_count - 1, registers_widget.page() + delta)));
 
     update();
 
@@ -456,52 +544,9 @@ void DebugPmemView::focus() {
 }
 
 void DebugPmemView::update() {
-    text_page.set(to_string_hex(page_size * page, 2) + "+");
     registers_widget.update();
 }
 
-uint32_t DebugPmemView::registers_widget_feed(const size_t register_number) {
-    if (page_size * page + register_number >= memory::map::backup_ram.size()) {
-        return 0xff;
-    }
-    return data.regfile[(page_size * page + register_number) / 4] >> (register_number % 4 * 8);
-}
-
-/* DebugFontsView *******************************************************/
-
-uint16_t DebugFontsView::display_font(Painter& painter, uint16_t y_offset, const Style* font_style, std::string_view font_name) {
-    auto char_width{font_style->font.char_width()};
-    auto char_height{font_style->font.line_height()};
-    auto cpl{((screen_width / char_width) - 6) & 0xF8};  // Display a multiple of 8 characters per line
-    uint16_t line_pos{y_offset};
-
-    painter.draw_string({0, y_offset}, *font_style, font_name);
-
-    // Displaying ASCII+extended characters from 0x20 to 0xFF
-    for (uint8_t c = 0; c <= 0xDF; c++) {
-        line_pos = y_offset + ((c / cpl) + 2) * char_height;
-
-        if ((c % cpl) == 0)
-            painter.draw_string({0, line_pos}, *font_style, "Ox" + to_string_hex(c + 0x20, 2));
-
-        painter.draw_char({((c % cpl) + 5) * char_width, line_pos}, *font_style, (char)(c + 0x20));
-    }
-
-    return line_pos + char_height;
-}
-
-void DebugFontsView::paint(Painter& painter) {
-    int16_t line_pos;
-
-    line_pos = display_font(painter, 32, &Styles::white, "Fixed 8x16");
-    display_font(painter, line_pos + 16, &Styles::white_small, "Fixed 5x8");
-}
-
-DebugFontsView::DebugFontsView(NavigationView& nav)
-    : nav_{nav} {
-    set_focusable(true);
-}
-
 /* DebugScreenTest ****************************************************/
 
 DebugScreenTest::DebugScreenTest(NavigationView& nav)

firmware/application/apps/ui_debug.hpp

@@ -48,8 +48,8 @@ class DebugMemoryView : public View {
 
    private:
     Text text_title{
-        {96, 96, 48, 16},
-        "Memory",
+        {72, 96, 96, 16},
+        "Memory Usage",
     };
 
     Text text_label_m0_core_free{
@@ -105,7 +105,7 @@ class TemperatureWidget : public Widget {
     static constexpr temperature_t display_temp_min = -10;  // Accomodate negative values, present in cold startup cases
     static constexpr temperature_t display_temp_scale = 3;
     static constexpr int bar_width = 1;
-    static constexpr int temp_len = 4;  // Now scale shows up to 4 chars ("-10C")
+    static constexpr int temp_len = 5;  // Now scale shows up to 5 chars ("-10ºC")
 };
 
 class TemperatureView : public View {
@@ -131,9 +131,19 @@ class TemperatureView : public View {
         "Done"};
 };
 
+typedef enum {
+    CT_PMEM,
+    CT_RFFC5072,
+    CT_MAX283X,
+    CT_SI5351,
+    CT_AUDIO,
+} chip_type_t;
+
 struct RegistersWidgetConfig {
-    size_t registers_count;
-    size_t register_bits;
+    chip_type_t chip_type;
+    uint32_t registers_count;
+    uint32_t registers_per_page;
+    uint32_t register_bits;
 
     constexpr size_t legend_length() const {
         return (registers_count >= 0x10) ? 2 : 1;
@@ -174,17 +184,22 @@ struct RegistersWidgetConfig {
 
 class RegistersWidget : public Widget {
    public:
-    RegistersWidget(
-        RegistersWidgetConfig&& config,
-        std::function<uint32_t(const size_t register_number)>&& reader);
+    RegistersWidget(RegistersWidgetConfig&& config);
 
     void update();
 
     void paint(Painter& painter) override;
 
+    uint32_t reg_read(const uint32_t register_number);
+    void reg_write(const uint32_t register_number, const uint32_t value);
+
+    void set_page(int32_t value) { page_number = value; }
+    uint32_t page(void) { return page_number; }
+    uint32_t page_count(void) { return (config.registers_count + config.registers_per_page - 1) / config.registers_per_page; }
+
    private:
     const RegistersWidgetConfig config;
-    const std::function<uint32_t(const size_t register_number)> reader;
+    uint32_t page_number;
 
     static constexpr size_t row_height = 16;
 
@@ -194,13 +209,9 @@ class RegistersWidget : public Widget {
 
 class RegistersView : public View {
    public:
-    RegistersView(
-        NavigationView& nav,
-        const std::string& title,
-        RegistersWidgetConfig&& config,
-        std::function<uint32_t(const size_t register_number)>&& reader);
-
-    void focus();
+    RegistersView(NavigationView& nav, const std::string& title, RegistersWidgetConfig&& config);
+    void focus() override;
+    bool on_encoder(const EncoderEvent delta) override;
 
    private:
     Text text_title{};
@@ -208,12 +219,30 @@ class RegistersView : public View {
     RegistersWidget registers_widget;
 
     Button button_update{
-        {16, 256, 96, 24},
+        {16, 280, 96, 24},
         "Update"};
 
     Button button_done{
-        {128, 256, 96, 24},
+        {128, 280, 96, 24},
         "Done"};
+
+    Button button_write{
+        {144, 248, 80, 20},
+        "Write"};
+
+    Labels labels{
+        {{1 * 8, 248}, "Reg:", Color::light_grey()},
+        {{8 * 8, 248}, "Data:", Color::light_grey()}};
+
+    SymField field_write_reg_num{
+        {5 * 8, 248},
+        2,
+        SymField::Type::Hex};
+
+    SymField field_write_data_val{
+        {13 * 8, 248},
+        4,
+        SymField::Type::Hex};
 };
 
 class ControlsSwitchesWidget : public Widget {
@@ -274,6 +303,58 @@ class DebugControlsView : public View {
         "Done"};
 };
 
+class DebugMemoryDumpView : public View {
+   public:
+    DebugMemoryDumpView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "Memory Dump"; };
+
+   private:
+    Button button_dump{
+        {72, 4 * 16, 96, 24},
+        "Dump"};
+
+    Button button_read{
+        {16, 11 * 16, 96, 24},
+        "Read"};
+
+    Button button_write{
+        {128, 11 * 16, 96, 24},
+        "Write"};
+
+    Button button_done{
+        {128, 240, 96, 24},
+        "Done"};
+
+    Labels labels{
+        {{5 * 8, 1 * 16}, "Dump Range to File", Color::yellow()},
+        {{0 * 8, 2 * 16}, "Starting Address: 0x", Color::light_grey()},
+        {{0 * 8, 3 * 16}, "Byte Count:       0x", Color::light_grey()},
+        {{3 * 8, 8 * 16}, "Read/Write Single Word", Color::yellow()},
+        {{0 * 8, 9 * 16}, "Memory Address:   0x", Color::light_grey()},
+        {{0 * 8, 10 * 16}, "Data Value:       0x", Color::light_grey()}};
+
+    SymField field_starting_address{
+        {20 * 8, 2 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_byte_count{
+        {20 * 8, 3 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_rw_address{
+        {20 * 8, 9 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_data_value{
+        {20 * 8, 10 * 16},
+        8,
+        SymField::Type::Hex};
+};
+
 class DebugPmemView : public View {
    public:
     DebugPmemView(NavigationView& nav);
@@ -282,19 +363,8 @@ class DebugPmemView : public View {
     std::string title() const override { return "P.Mem Debug"; }
 
    private:
-    struct pmem_data {
-        uint32_t regfile[63];
-        uint32_t check_value;
-    };
-
     static constexpr uint8_t page_size{96};  // Must be multiply of 4 otherwise bit shifting for register view wont work properly
-    static constexpr uint8_t page_max{(portapack::memory::map::backup_ram.size() + page_size - 1) / page_size - 1};
-
-    int32_t page{0};
-
-    volatile const pmem_data& data;
-
-    Text text_page{{16, 16, 208, 16}};
+    static constexpr uint8_t page_count{(portapack::memory::map::backup_ram.size() + page_size - 1) / page_size};
 
     RegistersWidget registers_widget;
 
@@ -307,18 +377,6 @@ class DebugPmemView : public View {
     };
 
     void update();
-    uint32_t registers_widget_feed(const size_t register_number);
-};
-
-class DebugFontsView : public View {
-   public:
-    DebugFontsView(NavigationView& nav);
-    void paint(Painter& painter) override;
-    std::string title() const override { return "Fonts"; };
-
-   private:
-    uint16_t display_font(Painter& painter, uint16_t y_offset, const Style* font_style, std::string_view font_name);
-    NavigationView& nav_;
 };
 
 class DebugScreenTest : public View {

firmware/application/apps/ui_dfu_menu.cpp

@@ -92,7 +92,9 @@ DfuMenu2::DfuMenu2(NavigationView& nav)
                   &text_info_line_5,
                   &text_info_line_6,
                   &text_info_line_7,
-                  &text_info_line_8});
+                  &text_info_line_8,
+                  &text_info_line_9,
+                  &text_info_line_10});
 }
 
 void DfuMenu2::paint(Painter& painter) {
@@ -103,10 +105,12 @@ void DfuMenu2::paint(Painter& painter) {
     text_info_line_5.set(to_string_dec_uint(portapack::receiver_model.am_configuration(), 10));
     text_info_line_6.set(to_string_dec_uint(portapack::receiver_model.nbfm_configuration(), 10));
     text_info_line_7.set(to_string_dec_uint(portapack::receiver_model.wfm_configuration(), 10));
-    text_info_line_8.set("");
+    text_info_line_8.set(to_string_dec_uint(portapack::transmitter_model.target_frequency(), 10));
+    text_info_line_9.set(to_string_dec_uint(portapack::transmitter_model.baseband_bandwidth(), 10));
+    text_info_line_10.set(to_string_dec_uint(portapack::transmitter_model.sampling_rate(), 10));
 
     constexpr auto margin = 5;
-    constexpr auto lines = 8 + 2;
+    constexpr auto lines = 10 + 2;
 
     painter.fill_rectangle(
         {{5 * CHARACTER_WIDTH - margin, 3 * LINE_HEIGHT - margin},

firmware/application/apps/ui_dfu_menu.hpp

@@ -57,14 +57,14 @@ class DfuMenu : public View {
         {{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}, ""};
+    Text text_info_line_1{{15 * CHARACTER_WIDTH, 5 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_2{{15 * CHARACTER_WIDTH, 6 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_3{{15 * CHARACTER_WIDTH, 7 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_4{{15 * CHARACTER_WIDTH, 8 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_5{{15 * CHARACTER_WIDTH, 9 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_6{{15 * CHARACTER_WIDTH, 10 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_7{{15 * CHARACTER_WIDTH, 11 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_8{{15 * CHARACTER_WIDTH, 12 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
 };
 
 class DfuMenu2 : public View {
@@ -77,17 +77,19 @@ class DfuMenu2 : public View {
    private:
     NavigationView& nav_;
 
-    Text text_head{{6 * CHARACTER_WIDTH, 3 * LINE_HEIGHT, 8 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, "Receiver"};
+    Text text_head{{6 * CHARACTER_WIDTH, 3 * LINE_HEIGHT, 14 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, "Radio Settings"};
 
     Labels labels{
-        {{5 * CHARACTER_WIDTH, 5 * LINE_HEIGHT}, "Tgt freq:", Color::dark_cyan()},
-        {{5 * CHARACTER_WIDTH, 6 * LINE_HEIGHT}, "Bandwidt:", Color::dark_cyan()},
-        {{5 * CHARACTER_WIDTH, 7 * LINE_HEIGHT}, "Sampl Rt:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 5 * LINE_HEIGHT}, "RX Freq:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 6 * LINE_HEIGHT}, "RX BW:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 7 * LINE_HEIGHT}, "RX SampR:", Color::dark_cyan()},
         {{5 * CHARACTER_WIDTH, 8 * LINE_HEIGHT}, "Modulatn:", Color::dark_cyan()},
         {{5 * CHARACTER_WIDTH, 9 * LINE_HEIGHT}, "AM cfg:", Color::dark_cyan()},
         {{5 * CHARACTER_WIDTH, 10 * LINE_HEIGHT}, "NBFM cfg:", Color::dark_cyan()},
         {{5 * CHARACTER_WIDTH, 11 * LINE_HEIGHT}, "WFM cfg:", Color::dark_cyan()},
-        {{5 * CHARACTER_WIDTH, 12 * LINE_HEIGHT}, "", Color::dark_cyan()}};
+        {{5 * CHARACTER_WIDTH, 12 * LINE_HEIGHT}, "TX Freq:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 13 * LINE_HEIGHT}, "TX BW:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 14 * LINE_HEIGHT}, "TX SampR:", Color::dark_cyan()}};
 
     Text text_info_line_1{{14 * CHARACTER_WIDTH, 5 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
     Text text_info_line_2{{14 * CHARACTER_WIDTH, 6 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
@@ -97,6 +99,8 @@ class DfuMenu2 : public View {
     Text text_info_line_6{{14 * CHARACTER_WIDTH, 10 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
     Text text_info_line_7{{14 * CHARACTER_WIDTH, 11 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
     Text text_info_line_8{{14 * CHARACTER_WIDTH, 12 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_9{{14 * CHARACTER_WIDTH, 13 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_10{{14 * CHARACTER_WIDTH, 14 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
 };
 
 } /* namespace ui */

firmware/application/apps/ui_encoders.cpp

@@ -49,7 +49,6 @@ EncodersConfigView::EncodersConfigView(
                   &field_clk_step,
                   &field_frameduration,
                   &field_frameduration_step,
-                  &symfield_word,
                   &text_format,
                   &waveform});
 
@@ -64,10 +63,6 @@ EncodersConfigView::EncodersConfigView(
     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
@@ -98,33 +93,46 @@ void EncodersConfigView::focus() {
 }
 
 void EncodersConfigView::on_type_change(size_t index) {
-    std::string format_string = "";
-    size_t word_length;
-    char symbol_type;
+    // Remove existing SymField controls.
+    for (auto& symfield : symfields_word)
+        remove_child(symfield.get());
+    symfields_word.clear();
 
     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);
-    size_t n = 0, i = 0;
-    while (n < word_length) {
-        symbol_type = encoder_def->word_format[i++];
-        if (symbol_type == 'A') {
-            symfield_word.set_symbol_list(n++, encoder_def->address_symbols);
-            format_string += 'A';
-        } else if (symbol_type == 'D') {
-            symfield_word.set_symbol_list(n++, encoder_def->data_symbols);
-            format_string += 'D';
+    // Add new SymFields.
+    Point pos{2 * 8, 9 * 8};
+    std::string format_string;
+    uint8_t word_length = encoder_def->word_length;
+    auto on_change_handler = [this](SymField&) {
+        generate_frame();
+    };
+
+    for (uint8_t i = 0; i < word_length; i++) {
+        auto symbol_type = encoder_def->word_format[i];
+        symfields_word.push_back(std::make_unique<SymField>(pos, 1));
+        auto& symfield = symfields_word.back();
+        symfield->on_change = on_change_handler;
+
+        switch (symbol_type) {
+            case 'A':
+                symfield->set_symbol_list(encoder_def->address_symbols);
+                format_string += 'A';
+                break;
+            case 'D':
+                symfield->set_symbol_list(encoder_def->data_symbols);
+                format_string += 'D';
+                break;
         }
+
+        add_child(symfield.get());
+        pos += Point{8, 0};
     }
 
     // Ugly :( Pad to erase
     format_string.append(24 - format_string.size(), ' ');
-
     text_format.set(format_string);
 
     generate_frame();
@@ -146,17 +154,18 @@ void EncodersConfigView::draw_waveform() {
 }
 
 void EncodersConfigView::generate_frame() {
-    size_t i = 0;
-
     frame_fragments.clear();
 
+    size_t i = 0;
     for (auto c : encoder_def->word_format) {
         if (c == 'S')
             frame_fragments += encoder_def->sync;
-        else if (!c)
+        else if (c == '\0')
             break;
-        else
-            frame_fragments += encoder_def->bit_format[symfield_word.get_sym(i++)];
+        else {
+            auto offset = symfields_word[i++]->get_offset(0);
+            frame_fragments += encoder_def->bit_format[offset];
+        }
     }
 
     draw_waveform();
@@ -260,6 +269,9 @@ void EncodersView::start_tx(const bool scan) {
     repeat_index = 1;
     update_progress();
 
+    /* Setting TX LPF 1M75 in this TX OOK App  , We got same results as fw 1.7.4
+     * Looking max BW of this app, we tested , Selecting OOK type 145026 with CLK 455K and max DEV. 150k,
+     * and we got BW +-2Mhz , with that TX LPF 1M75, it is fine.*/
     transmitter_model.enable();
 
     baseband::set_ook_data(

firmware/application/apps/ui_encoders.hpp

@@ -29,6 +29,9 @@
 #include "app_settings.hpp"
 #include "radio_state.hpp"
 
+#include <memory>
+#include <vector>
+
 using namespace encoders;
 
 namespace ui {
@@ -113,10 +116,7 @@ class EncodersConfigView : public View {
          {"100", 100},
          {"1000", 1000}}};
 
-    SymField symfield_word{
-        {2 * 8, 9 * 8},
-        20,
-        SymField::SYMFIELD_DEF};
+    std::vector<std::unique_ptr<SymField>> symfields_word{};
 
     Text text_format{
         {2 * 8, 11 * 8, 24 * 8, 16},
@@ -185,6 +185,7 @@ class EncodersView : public View {
     };
 
     TxRadioState radio_state_{
+        433920000 /* frequency */,
         1750000 /* bandwidth */,
         OOK_SAMPLERATE /* sampling rate */
     };

firmware/application/apps/ui_fileman.cpp

@@ -27,8 +27,10 @@
 #include <algorithm>
 #include "ui_fileman.hpp"
 #include "ui_playlist.hpp"
+#include "ui_remote.hpp"
 #include "ui_ss_viewer.hpp"
 #include "ui_text_editor.hpp"
+#include "ui_iq_trim.hpp"
 #include "string_format.hpp"
 #include "portapack.hpp"
 #include "event_m0.hpp"
@@ -44,6 +46,7 @@ static const fs::path c16_ext{u".C16"};
 static const fs::path cxx_ext{u".C*"};
 static const fs::path png_ext{u".PNG"};
 static const fs::path bmp_ext{u".BMP"};
+static const fs::path rem_ext{u".REM"};
 }  // namespace ui
 
 namespace {
@@ -106,14 +109,17 @@ bool partner_file_prompt(
     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);
-        });
+    // Display the continuation UI once the current has been popped.
+    nav.set_on_pop([&nav, partner, action_name, on_partner_action] {
+        nav.display_modal(
+            "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;
 }
@@ -150,7 +156,7 @@ void FileManBaseView::load_directory_contents(const fs::path& dir_path) {
 
     for (const auto& entry : fs::directory_iterator(dir_path, u"*")) {
         // Hide files starting with '.' (hidden / tmp).
-        if (is_hidden_file(entry.path()))
+        if (!show_hidden_files && is_hidden_file(entry.path()))
             continue;
 
         if (fs::is_regular_file(entry.status())) {
@@ -185,11 +191,10 @@ FileManBaseView::FileManBaseView(
       extension_filter{filter} {
     add_children({&labels,
                   &text_current,
-                  &text_info,
                   &button_exit});
 
-    button_exit.on_select = [this, &nav](Button&) {
-        nav.pop();
+    button_exit.on_select = [this](Button&) {
+        nav_.pop();
     };
 
     if (!sdcIsCardInserted(&SDCD1)) {
@@ -250,8 +255,13 @@ void FileManBaseView::refresh_list() {
         auto entry_name = truncate(entry.path, 20);
 
         if (entry.is_directory) {
+            auto size_str =
+                (entry.path == parent_dir_path)
+                    ? ""
+                    : to_string_dec_uint(file_count(current_path / entry.path));
+
             menu_view.add_item(
-                {entry_name,
+                {entry_name + std::string(21 - entry_name.length(), ' ') + size_str,
                  ui::Color::yellow(),
                  &bitmap_icon_dir,
                  [this](KeyEvent key) {
@@ -278,7 +288,6 @@ void FileManBaseView::refresh_list() {
             break;
     }
 
-    text_info.set(menu_view.item_count() >= max_items_shown ? "Too many files!" : "");
     menu_view.set_highlighted(prev_highlight);
 }
 
@@ -320,9 +329,9 @@ FileLoadView::FileLoadView(
         if (get_selected_entry().is_directory) {
             push_dir(get_selected_entry().path);
         } else {
-            nav_.pop();
             if (on_changed)
                 on_changed(get_selected_full_path());
+            nav_.pop();
         }
     };
 }
@@ -342,7 +351,6 @@ FileSaveView::FileSaveView(
         file_{ file }
 {
         add_children({
-                &labels,
                 &text_path,
                 &button_edit_path,
                 &text_name,
@@ -523,6 +531,9 @@ bool FileManagerView::handle_file_open() {
         nav_.push<SplashViewer>(path);
         reload_current();
         return true;
+    } else if (path_iequal(rem_ext, ext)) {
+        nav_.push<RemoteView>(path);
+        return true;
     }
 
     return false;
@@ -546,7 +557,6 @@ FileManagerView::FileManagerView(
 
     add_children({
         &menu_view,
-        &labels,
         &text_date,
         &button_rename,
         &button_delete,
@@ -557,13 +567,21 @@ FileManagerView::FileManagerView(
         &button_new_file,
         &button_open_notepad,
         &button_rename_timestamp,
+        &button_open_iq_trim,
+        &button_show_hidden_files,
     });
 
     menu_view.on_highlight = [this]() {
-        if (selected_is_valid())
-            text_date.set(to_string_FAT_timestamp(file_created_date(get_selected_full_path())));
-        else
-            text_date.set("");
+        if (menu_view.highlighted_index() >= max_items_shown - 1) {
+            text_date.set_style(&Styles::red);
+            text_date.set("Too many files!");
+        } else {
+            text_date.set_style(&Styles::grey);
+            if (selected_is_valid())
+                text_date.set((is_directory(get_selected_full_path()) ? "Created " : "Modified ") + to_string_FAT_timestamp(file_created_date(get_selected_full_path())));
+            else
+                text_date.set("");
+        }
     };
 
     refresh_list();
@@ -622,7 +640,7 @@ FileManagerView::FileManagerView(
     button_open_notepad.on_select = [this]() {
         if (selected_is_valid() && !get_selected_entry().is_directory) {
             auto path = get_selected_full_path();
-            nav_.replace<TextEditorView>(path);
+            nav_.push<TextEditorView>(path);
         } else
             nav_.display_modal("Open in Notepad", "Can't open that in Notepad.");
     };
@@ -633,6 +651,20 @@ FileManagerView::FileManagerView(
         } else
             nav_.display_modal("Timestamp Rename", "Can't rename that.");
     };
+
+    button_open_iq_trim.on_select = [this]() {
+        auto path = get_selected_full_path();
+        if (selected_is_valid() && !get_selected_entry().is_directory && is_cxx_capture_file(path)) {
+            nav_.push<IQTrimView>(path);
+        } else
+            nav_.display_modal("IQ Trim", "Not a capture file.");
+    };
+
+    button_show_hidden_files.on_select = [this]() {
+        show_hidden_files = !show_hidden_files;
+        button_show_hidden_files.set_color(show_hidden_files ? Color::green() : Color::dark_grey());
+        reload_current();
+    };
 }
 
 }  // namespace ui

firmware/application/apps/ui_fileman.hpp

@@ -77,7 +77,8 @@ class FileManBaseView : public View {
         {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".PPL", &bitmap_icon_file_iq, ui::Color::white()},  // PPL is the file extension for playlist app
+        {u".PPL", &bitmap_icon_file_iq, ui::Color::white()},  // Playlist/Replay
+        {u".REM", &bitmap_icon_remote, ui::Color::orange()},  // Remote
         {u"", &bitmap_icon_file, ui::Color::light_grey()}     // NB: Must be last.
     };
 
@@ -103,6 +104,8 @@ class FileManBaseView : public View {
     std::vector<fileman_entry> entry_list{};
     std::vector<uint32_t> saved_index_stack{};
 
+    bool show_hidden_files{false};
+
     Labels labels{
         {{0, 0}, "Path:", Color::light_grey()}};
 
@@ -115,11 +118,6 @@ class FileManBaseView : public View {
         {0, 2 * 8, 240, 26 * 8},
         true};
 
-    // HACK: for item count limit.
-    Text text_info{
-        {1 * 8, 35 * 8, 15 * 8, 16},
-        ""};
-
     Button button_exit{
         {22 * 8, 34 * 8, 8 * 8, 32},
         "Exit"};
@@ -218,11 +216,8 @@ class FileManagerView : public FileManBaseView {
     // True if the selected entry is a real file item.
     bool selected_is_valid() const;
 
-    Labels labels{
-        {{0, 26 * 8}, "Created ", Color::light_grey()}};
-
     Text text_date{
-        {8 * 8, 26 * 8, 19 * 8, 16},
+        {0 * 8, 26 * 8, 28 * 8, 16},
         ""};
 
     NewButton button_rename{
@@ -277,7 +272,20 @@ class FileManagerView : public FileManBaseView {
         {4 * 8, 34 * 8, 4 * 8, 32},
         {},
         &bitmap_icon_options_datetime,
+        Color::orange(),
+        /*vcenter*/ true};
+
+    NewButton button_open_iq_trim{
+        {9 * 8, 34 * 8, 4 * 8, 32},
+        {},
+        &bitmap_icon_trim,
         Color::orange()};
+
+    NewButton button_show_hidden_files{
+        {13 * 8, 34 * 8, 4 * 8, 32},
+        {},
+        &bitmap_icon_hide,
+        Color::dark_grey()};
 };
 
 } /* namespace ui */

firmware/application/apps/ui_freqman.cpp

@@ -23,6 +23,7 @@
 
 #include "ui_freqman.hpp"
 
+#include "binder.hpp"
 #include "event_m0.hpp"
 #include "portapack.hpp"
 #include "rtc_time.hpp"
@@ -92,9 +93,9 @@ void FreqManBaseView::focus() {
 
     // TODO: Shouldn't be on focus.
     if (error_ == ERROR_ACCESS) {
-        nav_.display_modal("Error", "File access error", ABORT, nullptr);
+        nav_.display_modal("Error", "File access error", ABORT);
     } else if (error_ == ERROR_NOFILES) {
-        nav_.display_modal("Error", "No database files\nin /FREQMAN", ABORT, nullptr);
+        nav_.display_modal("Error", "No database files\nin /FREQMAN", ABORT);
     } else {
         options_category.focus();
     }
@@ -152,28 +153,14 @@ FrequencySaveView::FrequencySaveView(
     add_children(
         {&labels,
          &big_display,
-         &button_clear,
-         &button_edit,
          &button_save,
-         &text_description});
+         &field_description});
 
     entry_.type = freqman_type::Single;
     entry_.frequency_a = value;
     entry_.description = to_string_timestamp(rtc_time::now());
-    refresh_ui();
 
-    button_clear.on_select = [this, &nav](Button&) {
-        entry_.description = "";
-        refresh_ui();
-    };
-
-    button_edit.on_select = [this, &nav](Button&) {
-        temp_buffer_ = entry_.description;
-        text_prompt(nav_, temp_buffer_, desc_edit_max, [this](std::string& new_desc) {
-            entry_.description = new_desc;
-            refresh_ui();
-        });
-    };
+    bind(field_description, entry_.description, nav);
 
     button_save.on_select = [this, &nav](Button&) {
         db_.insert_entry(db_.entry_count(), entry_);
@@ -181,9 +168,13 @@ FrequencySaveView::FrequencySaveView(
     };
 }
 
+void FrequencySaveView::focus() {
+    refresh_ui();
+    FreqManBaseView::focus();
+}
+
 void FrequencySaveView::refresh_ui() {
     big_display.set(entry_.frequency_a);
-    text_description.set(entry_.description);
 }
 
 /* FrequencyLoadView *************************************/
@@ -376,69 +367,26 @@ FrequencyEditView::FrequencyEditView(
     field_step.options().insert(
         field_step.options().begin(), {"None", -1});
 
-    field_type.set_by_value((int32_t)entry_.type);
-    field_type.on_change = [this](size_t, auto value) {
-        entry_.type = static_cast<freqman_type>(value);
+    bind(field_type, entry_.type, [this](auto) {
         refresh_ui();
-    };
+    });
 
-    // TODO: this pattern should be able to be wrapped up.
-    field_freq_a.set_value(entry_.frequency_a);
-    field_freq_a.on_change = [this](rf::Frequency f) {
-        entry_.frequency_a = f;
+    bind(field_freq_a, entry_.frequency_a, nav, [this](auto) {
         refresh_ui();
-    };
-    field_freq_a.on_edit = [this]() {
-        auto freq_view = nav_.push<FrequencyKeypadView>(field_freq_a.value());
-        freq_view->on_changed = [this](rf::Frequency f) {
-            field_freq_a.set_value(f);
-        };
-    };
+    });
 
-    field_freq_b.set_value(entry_.frequency_b);
-    field_freq_b.on_change = [this](rf::Frequency f) {
-        entry_.frequency_b = f;
+    bind(field_freq_b, entry_.frequency_b, nav, [this](auto) {
         refresh_ui();
-    };
-    field_freq_b.on_edit = [this]() {
-        auto freq_view = nav_.push<FrequencyKeypadView>(field_freq_b.value());
-        freq_view->on_changed = [this](rf::Frequency f) {
-            field_freq_b.set_value(f);
-        };
-    };
+    });
 
-    field_modulation.set_by_value((int32_t)entry_.modulation);
-    field_modulation.on_change = [this](size_t, auto value) {
-        entry_.modulation = static_cast<freqman_index_t>(value);
+    bind(field_modulation, entry_.modulation, [this](auto) {
         populate_bandwidth_options();
-    };
+    });
 
-    field_bandwidth.set_by_value((int32_t)entry_.bandwidth);
-    field_bandwidth.on_change = [this](size_t, auto value) {
-        entry_.bandwidth = static_cast<freqman_index_t>(value);
-    };
-
-    field_step.set_by_value((int32_t)entry_.step);
-    field_step.on_change = [this](size_t, auto value) {
-        entry_.step = static_cast<freqman_index_t>(value);
-    };
-
-    field_tone.set_by_value((int32_t)entry_.tone);
-    field_tone.on_change = [this](size_t, auto value) {
-        entry_.tone = static_cast<freqman_index_t>(value);
-    };
-
-    field_description.set_text(entry_.description);
-    field_description.on_change = [this](TextField& tf) {
-        entry_.description = tf.get_text();
-    };
-    field_description.on_select = [this](TextField& tf) {
-        temp_buffer_ = tf.get_text();
-        text_prompt(nav_, temp_buffer_, FreqManBaseView::desc_edit_max,
-                    [this, &tf](std::string& new_desc) {
-                        tf.set_text(new_desc);
-                    });
-    };
+    bind(field_bandwidth, entry_.bandwidth);
+    bind(field_step, entry_.step);
+    bind(field_tone, entry_.tone);
+    bind(field_description, entry_.description, nav_);
 
     button_save.on_select = [this](Button&) {
         if (on_save)
@@ -464,7 +412,8 @@ void FrequencyEditView::refresh_ui() {
 
     auto is_range = entry_.type == freqman_type::Range;
     auto is_ham = entry_.type == freqman_type::HamRadio;
-    auto has_freq_b = is_range || is_ham;
+    auto is_repeater = entry_.type == freqman_type::Repeater;
+    auto has_freq_b = is_range || is_ham || is_repeater;
 
     field_freq_b.set_style(has_freq_b ? &Styles::white : &Styles::grey);
     field_step.set_style(is_range ? &Styles::white : &Styles::grey);

firmware/application/apps/ui_freqman.hpp

@@ -87,9 +87,9 @@ class FrequencySaveView : public FreqManBaseView {
    public:
     FrequencySaveView(NavigationView& nav, const rf::Frequency value);
     std::string title() const override { return "Save freq"; }
+    void focus() override;
 
    private:
-    std::string temp_buffer_{};
     freqman_entry entry_{};
 
     void refresh_ui();
@@ -101,15 +101,9 @@ class FrequencySaveView : public FreqManBaseView {
     Labels labels{
         {{0 * 8, 6 * 16}, "Description:", Color::white()}};
 
-    Text text_description{{0 * 8, 7 * 16, 30 * 8, 1 * 16}};
-
-    Button button_clear{
-        {4 * 8, 10 * 16, 10 * 8, 2 * 16},
-        "Clear"};
-
-    Button button_edit{
-        {16 * 8, 10 * 16, 10 * 8, 2 * 16},
-        "Edit"};
+    TextField field_description{
+        {0 * 8, 7 * 16, 30 * 8, 1 * 16},
+        ""};
 
     Button button_save{
         {0 * 8, 17 * 16, 15 * 8, 2 * 16},
@@ -226,7 +220,8 @@ class FrequencyEditView : public View {
             {"Single", 0},
             {"Range", 1},
             {"HamRadio", 2},
-            {"Raw", 3},
+            {"Repeater", 3},
+            {"Raw", 4},
         }};
 
     FrequencyField field_freq_a{{13 * 8, 4 * 16}};

firmware/application/apps/ui_fsk_rx.cpp

@@ -0,0 +1,197 @@
+/*
+ * 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_fsk_rx.hpp"
+
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "string_format.hpp"
+#include "utility.hpp"
+
+#include "ui_freqman.hpp"
+
+using namespace portapack;
+namespace pmem = portapack::persistent_memory;
+
+void FskRxLogger::log_raw_data(const std::string& data, const uint32_t frequency) {
+    std::string entry = "Raw: F:" + to_string_dec_uint(frequency) + "Hz";
+
+    // // Raw hex dump of all the codewords
+    // for (size_t c = 0; c < 16; c++)
+    //     entry += to_string_hex(packet[c], 8) + " ";
+
+    log_file.write_entry(data + entry);
+}
+
+void FskRxLogger::log_decoded(Timestamp timestamp, const std::string& text) {
+    log_file.write_entry(timestamp, text);
+}
+
+namespace ui {
+//---------------------------------------------------------------------------------------------------------------
+//  Console View
+//---------------------------------------------------------------------------------------------------------------
+FskRxAppConsoleView::FskRxAppConsoleView(NavigationView& nav, Rect parent_rect)
+    : View(parent_rect), nav_{nav} {
+    add_child(&console);
+};
+
+void FskRxAppConsoleView::on_packet(uint32_t value, bool is_data) {
+    if (is_data) {
+        console.write(to_string_dec_uint(value) + " ");
+    }
+}
+
+void FskRxAppConsoleView::on_show() {
+    hidden(false);
+}
+
+void FskRxAppConsoleView::on_hide() {
+    hidden(true);
+}
+
+FskRxAppConsoleView::~FskRxAppConsoleView() {
+}
+
+//---------------------------------------------------------------------------------------------------------------
+//  Spectrum View
+//---------------------------------------------------------------------------------------------------------------
+FskRxAppView::FskRxAppView(NavigationView& nav, Rect parent_rect)
+    : View(parent_rect), nav_{nav} {
+    add_child(&waterfall);
+    hidden(true);
+}
+
+FskRxAppView::~FskRxAppView() {
+}
+
+void FskRxAppView::focus() {
+}
+
+void FskRxAppView::on_show() {
+    hidden(false);
+    waterfall.start();
+}
+
+void FskRxAppView::on_hide() {
+    hidden(true);
+    waterfall.stop();
+}
+
+//---------------------------------------------------------------------------------------------------------------
+//  Base View
+//---------------------------------------------------------------------------------------------------------------
+FskxRxMainView::FskxRxMainView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&tab_view,
+                  &view_data,
+                  &view_stream,
+                  &labels,
+                  &rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_frequency,
+                  &deviation_frequency,
+                  &record_view});
+
+    baseband::run_image(portapack::spi_flash::image_tag_fskrx);
+
+    // DEBUG
+    record_view.on_error = [&nav](std::string message) {
+        nav.display_modal("Error", message);
+    };
+
+    deviation_frequency.on_change = [this](rf::Frequency f) {
+        refresh_ui(f);
+    };
+
+    // Set initial sampling rate
+    /* Bandwidth of 2FSK is 2 * Deviation */
+    record_view.set_sampling_rate(initial_deviation * 2);
+
+    field_frequency.set_value(initial_target_frequency);
+    deviation_frequency.set_value(initial_deviation);
+
+    logger.append(LOG_ROOT_DIR "/FSKRX.TXT");
+
+    baseband::set_fsk(initial_deviation);
+
+    audio::output::start();
+    receiver_model.enable();
+}
+
+void FskxRxMainView::handle_decoded(Timestamp timestamp, const std::string& prefix) {
+    if (logging()) {
+        logger.log_decoded(timestamp, prefix);
+    }
+}
+
+void FskxRxMainView::refresh_ui(rf::Frequency deviationHz) {
+    /* Nyquist would imply a sample rate of 2x bandwidth, but because the ADC
+     * provides 2 values (I,Q), the sample_rate is equal to bandwidth here. */
+    /* Bandwidth of 2FSK is 2 * Deviation */
+    auto sample_rate = deviationHz * 2;
+
+    /* base_rate (bandwidth) is used for FFT calculation and display LCD, and also in recording writing SD Card rate. */
+    /* ex. sampling_rate values, 4Mhz, when recording 500 kHz (BW) and fs 8 Mhz, when selected 1 Mhz BW ... */
+    /* ex. recording 500kHz BW to .C16 file, base_rate clock 500kHz x2(I,Q) x 2 bytes (int signed) =2MB/sec rate SD Card. */
+
+    if (!view_stream.hidden()) {
+        view_stream.waterfall.stop();
+    }
+
+    // record_view determines the correct oversampling to apply and returns the actual sample rate.
+    // NB: record_view is what actually updates proc_capture baseband settings.
+    auto actual_sample_rate = record_view.set_sampling_rate(sample_rate);
+
+    // Update the radio model with the actual sampling rate.
+    receiver_model.set_sampling_rate(actual_sample_rate);
+
+    // Get suitable anti-aliasing BPF bandwidth for MAX2837 given the actual sample rate.
+    auto anti_alias_filter_bandwidth = filter_bandwidth_for_sampling_rate(actual_sample_rate);
+    receiver_model.set_baseband_bandwidth(anti_alias_filter_bandwidth);
+
+    if (!view_stream.hidden()) {
+        view_stream.waterfall.start();
+    }
+}
+
+void FskxRxMainView::focus() {
+    field_frequency.focus();
+}
+
+void FskxRxMainView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+
+    ui::Rect waterfall_rect{0, 0, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    view_stream.waterfall.set_parent_rect(waterfall_rect);
+}
+
+FskxRxMainView::~FskxRxMainView() {
+    audio::output::stop();
+    receiver_model.disable();
+    baseband::shutdown();
+}
+} /* namespace ui */

firmware/application/apps/ui_fsk_rx.hpp

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2018 Furrtek
+ * 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.
+ */
+
+#ifndef __UI_FSK_RX_H__
+#define __UI_FSK_RX_H__
+
+#include "ui_widget.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_receiver.hpp"
+#include "ui_record_view.hpp"
+#include "ui_rssi.hpp"
+#include "ui_spectrum.hpp"
+#include "ui_styles.hpp"
+#include "ui_tabview.hpp"
+
+#include "app_settings.hpp"
+#include "log_file.hpp"
+#include "radio_state.hpp"
+#include "pocsag_app.hpp"
+
+#include <functional>
+
+class FskRxLogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data, const uint32_t frequency);
+    void log_decoded(Timestamp timestamp, const std::string& text);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+class FskRxAppConsoleView : public View {
+   public:
+    FskRxAppConsoleView(NavigationView& nav, Rect parent_rec);
+    ~FskRxAppConsoleView();
+
+    std::string title() const override { return "FSK RX Data"; };
+
+    void on_packet(uint32_t value, bool is_data);
+
+    void on_show() override;
+    void on_hide() override;
+
+   private:
+    NavigationView& nav_;
+
+    Console console{
+        {0, 0, 240, 224}};
+};
+
+class FskRxAppView : public View {
+   public:
+    FskRxAppView(NavigationView& nav, Rect parent_rect);
+    ~FskRxAppView();
+
+    void focus() override;
+    void on_show() override;
+    void on_hide() override;
+
+    spectrum::WaterfallView waterfall{};
+
+    std::string title() const override { return "FSK RX Stream"; };
+
+   private:
+    NavigationView& nav_;
+    RxRadioState radio_state_{};
+};
+
+class FskxRxMainView : public View {
+   public:
+    FskxRxMainView(NavigationView& nav);
+    ~FskxRxMainView();
+
+    void focus() override;
+    void set_parent_rect(const Rect new_parent_rect) override;
+
+    std::string title() const override { return "FSK RX"; };
+
+   private:
+    static constexpr uint32_t initial_target_frequency = 902'075'000;
+    static constexpr ui::Dim header_height = (5 * 16);
+
+    uint32_t initial_deviation{3750};
+
+    bool logging() const { return false; };
+    bool logging_raw() const { return false; };
+
+    NavigationView& nav_;
+    Rect view_rect = {0, header_height, 240, 224};
+
+    FskRxAppView view_stream{nav_, view_rect};
+    FskRxAppConsoleView view_data{nav_, view_rect};
+
+    TabView tab_view{
+        {"Data", Color::yellow(), &view_data},
+        {"Stream", Color::cyan(), &view_stream}};
+
+    void refresh_ui(rf::Frequency f);
+    void on_packet(uint32_t value, bool is_data);
+    void handle_decoded(Timestamp timestamp, const std::string& prefix);
+
+    uint32_t last_address = 0;
+    FskRxLogger logger{};
+    uint16_t packet_count = 0;
+
+    RxFrequencyField field_frequency{
+        {0 * 8, 4 * 8},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {11 * 8, 2 * 16}};
+
+    LNAGainField field_lna{
+        {13 * 8, 2 * 16}};
+
+    VGAGainField field_vga{
+        {16 * 8, 2 * 16}};
+
+    RSSI rssi{
+        {19 * 8 - 4, 35, 6 * 8, 4}};
+
+    Channel channel{
+        {19 * 8 - 4, 40, 6 * 8, 4}};
+
+    Labels labels{
+        {{0 * 8, 3 * 16}, "Deviation:", Color::light_grey()},
+    };
+
+    FrequencyField deviation_frequency{
+        {10 * 8, 3 * 16},
+        {3750, 500000},
+    };
+
+    // DEBUG
+    RecordView record_view{
+        {0 * 8, 4 * 16, 30 * 8, 1 * 16},
+        u"FSKRX_????.C16",
+        u"FSKRX",
+        RecordView::FileType::RawS16,
+        16384,
+        3};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::AFSKData,
+        [this](Message* const p) {
+            const auto message = static_cast<const AFSKDataMessage*>(p);
+            this->view_data.on_packet(message->value, message->is_data);
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__POCSAG_APP_H__*/

firmware/application/apps/ui_iq_trim.cpp

@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2023 Kyle Reed
+ *
+ * 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_iq_trim.hpp"
+
+#include "complex.hpp"
+#include "portapack.hpp"
+#include "ui_fileman.hpp"
+
+using namespace portapack;
+namespace fs = std::filesystem;
+
+namespace ui {
+
+IQTrimView::IQTrimView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({
+        &labels,
+        &field_path,
+        &field_start,
+        &field_end,
+        &text_samples,
+        &text_max,
+        &field_cutoff,
+        &field_amplify,
+        &button_trim,
+    });
+
+    field_path.on_select = [this](TextField&) {
+        auto open_view = nav_.push<FileLoadView>(".C*");
+        open_view->push_dir(u"CAPTURES");
+        open_view->on_changed = [this](fs::path path) {
+            open_file(path);
+        };
+    };
+
+    text_samples.set_style(&Styles::light_grey);
+    text_max.set_style(&Styles::light_grey);
+
+    field_start.on_change = [this](int32_t v) {
+        if (field_end.value() < v)
+            field_end.set_value(v, false);
+        set_dirty();
+    };
+
+    field_end.on_change = [this](int32_t v) {
+        if (field_start.value() > v)
+            field_start.set_value(v, false);
+        set_dirty();
+    };
+
+    field_cutoff.set_value(7);  // 7% of max is a good default.
+    field_cutoff.on_change = [this](int32_t) {
+        compute_range();
+        refresh_ui();
+    };
+
+    field_amplify.set_value(1);  // 1X is default (no amplification)
+    field_amplify.on_change = [this](int32_t) {
+        refresh_ui();
+    };
+
+    button_trim.on_select = [this](Button&) {
+        if (trim_capture()) {
+            profile_capture();
+            compute_range();
+            refresh_ui();
+        }
+    };
+}
+
+IQTrimView::IQTrimView(NavigationView& nav, const fs::path& path)
+    : IQTrimView(nav) {
+    open_file(path);
+}
+
+void IQTrimView::open_file(const std::filesystem::path& path) {
+    path_ = std::move(path);
+    profile_capture();
+    compute_range();
+    refresh_ui();
+}
+
+void IQTrimView::paint(Painter& painter) {
+    if (info_) {
+        uint32_t power_cutoff = field_cutoff.value() * static_cast<uint64_t>(info_->max_power) / 100;
+
+        // Draw power buckets.
+        for (size_t i = 0; i < power_buckets_.size(); ++i) {
+            auto power = power_buckets_[i].power;
+            uint8_t amp = 0;
+
+            if (power > power_cutoff && info_->max_power > 0)
+                amp = (255ULL * power) / info_->max_power;
+
+            painter.draw_vline(
+                pos_lines + Point{(int)i, 0},
+                height_lines,
+                Color(amp, amp, amp));
+        }
+
+        // Draw trim range edges.
+        int start_x = screen_width * field_start.value() / info_->sample_count;
+        int end_x = screen_width * field_end.value() / info_->sample_count;
+
+        painter.draw_vline(
+            pos_lines + Point{start_x, 0},
+            height_lines,
+            Color::dark_green());
+        painter.draw_vline(
+            pos_lines + Point{end_x, 0},
+            height_lines,
+            Color::dark_red());
+    }
+}
+
+void IQTrimView::focus() {
+    field_path.focus();
+}
+
+void IQTrimView::refresh_ui() {
+    field_path.set_text(path_.filename().string());
+    text_samples.set(to_string_dec_uint(info_->sample_count));
+
+    // show max power after amplification applied
+    uint64_t power_amp = field_amplify.value() * field_amplify.value() * field_amplify.value() * field_amplify.value();
+    text_max.set(to_string_dec_uint(info_->max_power * power_amp));
+
+    // show max power in red if amplification is too high, causing clipping
+    uint32_t clipping_limit = (fs::capture_file_sample_size(path_) == sizeof(complex8_t)) ? 0x80 : 0x8000;
+    if ((field_amplify.value() * info_->max_iq) > clipping_limit)
+        text_max.set_style(&Styles::red);
+    else
+        text_max.set_style(&Styles::light_grey);
+
+    set_dirty();
+}
+
+void IQTrimView::update_range_controls(iq::TrimRange trim_range) {
+    auto max_range = info_ ? info_->sample_count : 0;
+    auto step = info_ ? info_->sample_count / screen_width : 0;
+
+    field_start.set_range(0, max_range);
+    field_start.set_step(step);
+    field_end.set_range(0, max_range);
+    field_end.set_step(step);
+
+    field_start.set_value(trim_range.start_sample, false);
+    field_end.set_value(trim_range.end_sample, false);
+}
+
+void IQTrimView::profile_capture() {
+    power_buckets_ = {};
+    iq::PowerBuckets buckets{
+        .p = power_buckets_.data(),
+        .size = power_buckets_.size()};
+
+    progress_ui.show_reading();
+    info_ = iq::profile_capture(path_, buckets);
+    progress_ui.clear();
+}
+
+void IQTrimView::compute_range() {
+    if (!info_)
+        return;
+
+    iq::PowerBuckets buckets{
+        .p = power_buckets_.data(),
+        .size = power_buckets_.size()};
+    auto trim_range = iq::compute_trim_range(*info_, buckets, field_cutoff.value());
+
+    update_range_controls(trim_range);
+}
+
+bool IQTrimView::trim_capture() {
+    if (!info_) {
+        nav_.display_modal("Error", "Open a file first.");
+        return false;
+    }
+
+    bool trimmed = false;
+    iq::TrimRange trim_range{
+        static_cast<uint32_t>(field_start.value()),
+        static_cast<uint32_t>(field_end.value()),
+        info_->sample_size};
+
+    if (trim_range.start_sample >= trim_range.end_sample) {
+        nav_.display_modal("Error", "Invalid trimming range.");
+        return false;
+    }
+
+    progress_ui.show_trimming();
+    trimmed = iq::trim_capture_with_range(path_, trim_range, progress_ui.get_callback(), field_amplify.value());
+    progress_ui.clear();
+
+    if (!trimmed)
+        nav_.display_modal("Error", "Trimming failed.");
+
+    return trimmed;
+}
+
+}  // namespace ui

firmware/application/apps/ui_iq_trim.hpp

@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2023 Kyle Reed
+ *
+ * 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_IQ_TRIM_H__
+#define __UI_IQ_TRIM_H__
+
+#include "file.hpp"
+#include "iq_trim.hpp"
+#include "optional.hpp"
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_styles.hpp"
+#include "ui_widget.hpp"
+
+#include <array>
+
+namespace ui {
+
+/* Helper for drawing progress related to IQ trimming. */
+/* TODO: Ideally this would all be done on second thread. */
+class TrimProgressUI {
+   public:
+    void show_reading() {
+        clear();
+        p.draw_string({6 * 8, 5 * 16}, Styles::yellow, "Reading Capture...");
+    }
+
+    void show_trimming() {
+        clear();
+        p.draw_string({5 * 8, 5 * 16}, Styles::yellow, "Trimming Capture...");
+    }
+
+    void show_progress(uint8_t percent) {
+        auto width = percent * screen_width / 100;
+        p.draw_hline({0, 6 * 16 + 2}, width, Color::yellow());
+    }
+
+    void clear() {
+        p.fill_rectangle({0 * 8, 4 * 16, screen_width, 3 * 16}, Color::black());
+    }
+
+    auto get_callback() {
+        return [this](uint8_t percent) { show_progress(percent); };
+    }
+
+   private:
+    Painter p{};
+};
+
+class IQTrimView : public View {
+   public:
+    IQTrimView(NavigationView& nav);
+    IQTrimView(NavigationView& nav, const std::filesystem::path& path);
+
+    std::string title() const override { return "IQ Trim"; }
+    void paint(Painter& painter) override;
+    void focus() override;
+
+   private:
+    void open_file(const std::filesystem::path& path);
+
+    /* Update controls with latest values. */
+    void refresh_ui();
+
+    /* Update the start/end controls with trim range info. */
+    void update_range_controls(iq::TrimRange trim_range);
+
+    /* Collect capture info and samples to draw the UI. */
+    void profile_capture();
+
+    /* Determine the start and end buckets based on the cutoff. */
+    void compute_range();
+
+    /* Trims the capture file based on the settings. */
+    bool trim_capture();
+
+    NavigationView& nav_;
+
+    std::filesystem::path path_{};
+    Optional<iq::CaptureInfo> info_{};
+    std::array<iq::PowerBuckets::Bucket, screen_width> power_buckets_{};
+    TrimProgressUI progress_ui{};
+
+    Labels labels{
+        {{0 * 8, 0 * 16}, "Capture File:", Color::light_grey()},
+        {{0 * 8, 6 * 16}, "Start  :", Color::light_grey()},
+        {{0 * 8, 7 * 16}, "End    :", Color::light_grey()},
+        {{0 * 8, 8 * 16}, "Samples:", Color::light_grey()},
+        {{0 * 8, 9 * 16}, "Max Pwr:", Color::light_grey()},
+        {{0 * 8, 10 * 16}, "Cutoff :", Color::light_grey()},
+        {{12 * 8, 10 * 16}, "%", Color::light_grey()},
+        {{0 * 8, 12 * 16}, "Amplify:", Color::light_grey()},
+        {{10 * 8, 12 * 16}, "x", Color::light_grey()},
+    };
+
+    TextField field_path{
+        {0 * 8, 1 * 16, 30 * 8, 1 * 16},
+        "Open File..."};
+
+    Point pos_lines{0 * 8, 4 * 16};
+    Dim height_lines{2 * 16};
+
+    NumberField field_start{
+        {9 * 8, 6 * 16},
+        10,
+        {0, 0},
+        1,
+        ' '};
+
+    NumberField field_end{
+        {9 * 8, 7 * 16},
+        10,
+        {0, 0},
+        1,
+        ' '};
+
+    Text text_samples{
+        {9 * 8, 8 * 16, 10 * 8, 1 * 16},
+        "0"};
+
+    Text text_max{
+        {9 * 8, 9 * 16, 20 * 8, 1 * 16},
+        "0"};
+
+    NumberField field_cutoff{
+        {9 * 8, 10 * 16},
+        3,
+        {1, 100},
+        1,
+        ' '};
+
+    NumberField field_amplify{
+        {9 * 8, 12 * 16},
+        1,
+        {1, 9},
+        1,
+        ' '};
+
+    Button button_trim{
+        {20 * 8, 16 * 16, 8 * 8, 2 * 16},
+        "Trim"};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_IQ_TRIM_H__*/

firmware/application/apps/ui_keyfob.cpp

@@ -97,12 +97,12 @@ size_t KeyfobView::generate_frame() {
     uint64_t payload;
 
     // Symfield word to frame
-    payload = field_payload_a.value_hex_u64();
+    payload = field_payload_a.to_integer();
     for (size_t i = 0; i < 5; i++) {
         frame[4 - i] = payload & 0xFF;
         payload >>= 8;
     }
-    payload = field_payload_b.value_hex_u64();
+    payload = field_payload_b.to_integer();
     for (size_t i = 0; i < 5; i++) {
         frame[9 - i] = payload & 0xFF;
         payload >>= 8;
@@ -136,9 +136,6 @@ void KeyfobView::focus() {
 }
 
 KeyfobView::~KeyfobView() {
-    // save app settings
-    settings.save("tx_keyfob", &app_settings);
-
     transmitter_model.disable();
     baseband::shutdown();
 }
@@ -167,12 +164,12 @@ void KeyfobView::on_make_change(size_t index) {
 // DEBUG
 void KeyfobView::update_symfields() {
     for (size_t i = 0; i < 5; i++) {
-        field_payload_a.set_sym(i << 1, frame[i] >> 4);
-        field_payload_a.set_sym((i << 1) + 1, frame[i] & 0x0F);
+        field_payload_a.set_offset(i << 1, frame[i] >> 4);
+        field_payload_a.set_offset((i << 1) + 1, frame[i] & 0x0F);
     }
     for (size_t i = 0; i < 5; i++) {
-        field_payload_b.set_sym(i << 1, frame[5 + i] >> 4);
-        field_payload_b.set_sym((i << 1) + 1, frame[5 + i] & 0x0F);
+        field_payload_b.set_offset(i << 1, frame[5 + i] >> 4);
+        field_payload_b.set_offset((i << 1) + 1, frame[5 + i] & 0x0F);
     }
 }
 
@@ -212,13 +209,6 @@ KeyfobView::KeyfobView(
                   &progressbar,
                   &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();
 
@@ -232,8 +222,6 @@ KeyfobView::KeyfobView(
 
     options_make.set_selected_index(0);
 
-    transmitter_model.set_target_frequency(433920000);  // Fixed 433.92MHz
-
     tx_view.on_edit_frequency = [this, &nav]() {
         auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.target_frequency());
         new_view->on_changed = [this](rf::Frequency f) {

firmware/application/apps/ui_keyfob.hpp

@@ -44,11 +44,12 @@ class KeyfobView : public View {
     NavigationView& nav_;
 
     TxRadioState radio_state_{
+        433920000 /* frequency */,
         1750000 /* bandwidth */,
         OOK_SAMPLERATE /* sampling rate */
     };
     app_settings::SettingsManager settings_{
-        "tx_keyfob", , app_settings::Mode::TX};
+        "tx_keyfob", app_settings::Mode::TX};
 
     // 1013210ns / bit
     static constexpr uint32_t subaru_samples_per_bit = (OOK_SAMPLERATE * 0.00101321);
@@ -98,11 +99,11 @@ class KeyfobView : public View {
     SymField field_payload_a{
         {2 * 8, 5 * 16},
         10,
-        SymField::SYMFIELD_HEX};
+        SymField::Type::Hex};
     SymField field_payload_b{
         {13 * 8, 5 * 16},
         10,
-        SymField::SYMFIELD_HEX};
+        SymField::Type::Hex};
 
     Text text_status{
         {2 * 8, 13 * 16, 128, 16},

firmware/application/apps/ui_level.cpp

@@ -24,7 +24,9 @@
 #include "ui_level.hpp"
 #include "ui_fileman.hpp"
 #include "ui_freqman.hpp"
+#include "baseband_api.hpp"
 #include "file.hpp"
+#include "oversample.hpp"
 
 using namespace portapack;
 using namespace tonekey;
@@ -140,31 +142,24 @@ LevelView::LevelView(NavigationView& nav)
 }
 
 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;
+    static int16_t last_max_db = -1000;
+    static int16_t last_min_rssi = -1000;
+    static int16_t last_avg_rssi = -1000;
+    static int16_t 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;
-
+    // refresh db
     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()));
+    // refresh rssi
+    if (last_min_rssi != rssi_graph.get_graph_min() || last_avg_rssi != rssi_graph.get_graph_avg() || last_max_rssi != rssi_graph.get_graph_max()) {
+        last_min_rssi = rssi_graph.get_graph_min();
+        last_avg_rssi = rssi_graph.get_graph_avg();
+        last_max_rssi = rssi_graph.get_graph_max();
+        freq_stats_rssi.set("RSSI: " + to_string_dec_int(last_min_rssi) + "/" + to_string_dec_int(last_avg_rssi) + "/" + to_string_dec_int(last_max_rssi) + ",dt: " + to_string_dec_int(rssi_graph.get_graph_delta()));
     }
 } /* on_statistic_updates */
 
@@ -174,48 +169,52 @@ size_t LevelView::change_mode(freqman_index_t new_mod) {
     switch (new_mod) {
         case AM_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
-            // bw DSB (0) default
-            field_bw.set_by_value(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_value());
             field_bw.on_change = [this](size_t, OptionsField::value_t n) { receiver_model.set_am_configuration(n); };
+            // bw DSB (0) default
+            field_bw.set_by_value(0);
             text_ctcss.set("             ");
             break;
         case NFM_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
-            // bw 16k (2) default
-            field_bw.set_by_value(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_value());
             field_bw.on_change = [this](size_t, OptionsField::value_t n) { receiver_model.set_nbfm_configuration(n); };
+            // bw 16k (2) default
+            field_bw.set_by_value(2);
             break;
         case WFM_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
-            // bw 200k (0) only/default
-            field_bw.set_by_value(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_value());
             field_bw.on_change = [this](size_t, OptionsField::value_t n) { receiver_model.set_wfm_configuration(n); };
+            // bw 200k (0) only/default
+            field_bw.set_by_value(0);
             text_ctcss.set("             ");
             break;
         case SPEC_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
             baseband::run_image(portapack::spi_flash::image_tag_capture);
             receiver_model.set_modulation(ReceiverModel::Mode::Capture);
-            field_bw.set_by_value(0);
             field_bw.on_change = [this](size_t, OptionsField::value_t sampling_rate) {
-                auto anti_alias_baseband_bandwidth_filter = filter_bandwidth_for_sampling_rate(sampling_rate);
-                receiver_model.set_sampling_rate(sampling_rate);
-                receiver_model.set_baseband_bandwidth(anti_alias_baseband_bandwidth_filter);
+                // Baseband needs to know the desired sampling and oversampling rates.
+                baseband::set_sample_rate(sampling_rate, get_oversample_rate(sampling_rate));
+
+                // The radio needs to know the effective sampling rate.
+                auto actual_sampling_rate = get_actual_sample_rate(sampling_rate);
+                receiver_model.set_sampling_rate(actual_sampling_rate);
+                receiver_model.set_baseband_bandwidth(filter_bandwidth_for_sampling_rate(actual_sampling_rate));
             };
+            field_bw.set_by_value(0);
         default:
             break;
     }
     if (new_mod != SPEC_MODULATION) {
-        // reset receiver model to fix bug when going from SPEC to audio, the sound is distorded
+        // Reset receiver model to fix bug when going from SPEC to audio, the sound is distorted.
         receiver_model.set_sampling_rate(3072000);
         receiver_model.set_baseband_bandwidth(1750000);
     }

firmware/application/apps/ui_level.hpp

@@ -64,7 +64,6 @@ class LevelView : public View {
 
     // TODO: needed?
     int32_t db{0};
-    long long int MAX_UFREQ = {7200000000};  // maximum usable freq
     rf::Frequency freq_ = {0};
 
     Labels labels{

firmware/application/apps/ui_looking_glass_app.cpp

@@ -74,8 +74,8 @@ rf::Frequency GlassView::get_freq_from_bin_pos(uint8_t pos) {
 
 void GlassView::on_marker_change() {
     marker = get_freq_from_bin_pos(marker_pixel_index);
-    button_marker.set_text(to_string_short_freq(marker));
-    PlotMarker(marker_pixel_index);  // Refresh marker on screen
+    field_marker.set_text(to_string_short_freq(marker));
+    plot_marker(marker_pixel_index);  // Refresh marker on screen
 }
 
 void GlassView::retune() {
@@ -87,23 +87,13 @@ void GlassView::retune() {
     baseband::spectrum_streaming_start();  // Do the RX
 }
 
-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::reset_live_view(bool clear_screen) {
+void GlassView::reset_live_view() {
     max_freq_hold = 0;
     max_freq_power = -1000;
-    if (clear_screen) {
-        // only clear screen in peak mode
-        if (live_frequency_view == 2) {
-            display.fill_rectangle({{0, 108 + 16}, {SCREEN_W, 320 - (108 + 16)}}, {0, 0, 0});
-        }
-    }
+
+    // Clear screen in peak mode.
+    if (live_frequency_view == 2)
+        display.fill_rectangle({{0, 108 + 16}, {SCREEN_W, SCREEN_H - (108 + 16)}}, {0, 0, 0});
 }
 
 void GlassView::add_spectrum_pixel(uint8_t power) {
@@ -134,15 +124,15 @@ void GlassView::add_spectrum_pixel(uint8_t power) {
                 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, 108 + 16}, {1, SCREEN_H - point}}, {0, 0, 0});
                 }
-                display.fill_rectangle({{xpos, 320 - point}, {1, point}}, {color_gradient, 0, uint8_t(255 - color_gradient)});
+                display.fill_rectangle({{xpos, SCREEN_H - 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_pixel_index);
+            plot_marker(marker_pixel_index);
         } else {
             display.draw_pixels({{0, display.scroll(1)}, {SCREEN_W, 1}}, spectrum_row);  // new line at top, one less var, speedier
         }
@@ -151,8 +141,8 @@ void GlassView::add_spectrum_pixel(uint8_t power) {
 }
 
 bool GlassView::process_bins(uint8_t* powerlevel) {
-    bins_Hz_size += each_bin_size;          // add pixel to fulfilled bag of Hz
-    if (bins_Hz_size >= marker_pixel_step)  // new pixel fullfilled
+    bins_hz_size += each_bin_size;          // add pixel to fulfilled bag of Hz
+    if (bins_hz_size >= marker_pixel_step)  // new pixel fullfilled
     {
         if (*powerlevel > min_color_power)
             add_spectrum_pixel(*powerlevel);  // Pixel will represent max_power
@@ -162,7 +152,7 @@ bool GlassView::process_bins(uint8_t* powerlevel) {
 
         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"
+            bins_hz_size = 0;  // Since this is an entire pixel line, we don't carry "Pixels into next bin"
             if (mode != LOOKING_GLASS_SINGLEPASS) {
                 f_center = f_center_ini;
                 retune();
@@ -170,18 +160,18 @@ bool GlassView::process_bins(uint8_t* powerlevel) {
                 baseband::spectrum_streaming_start();
             return true;  // signal a new line
         }
-        bins_Hz_size -= marker_pixel_step;  // reset bins size, but carrying the eventual excess Hz into next pixel
+        bins_hz_size -= marker_pixel_step;  // reset bins size, but carrying the eventual excess Hz into next pixel
     }
     return false;
 }
 
 // Apparently, the spectrum object returns an array of SPEC_NB_BINS (256) bins
-// Each having the radio signal power for it's corresponding frequency slot
+// Each having the radio signal power for its 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
     // we actually need SCREEN_W (240) of those bins
-    for (bin = 0; bin < bin_length; bin++) {
+    for (uint8_t bin = 0; bin < bin_length; bin++) {
         get_max_power(spectrum, bin, max_power);
         // process dc spike if enable
         if (bin == 119) {
@@ -215,7 +205,7 @@ void GlassView::on_show() {
 }
 
 void GlassView::on_range_changed() {
-    reset_live_view(true);
+    reset_live_view();
     f_min = field_frequency_min.value();
     f_max = field_frequency_max.value();
     f_min = f_min * MHZ_DIV;  // Transpose into full frequency realm
@@ -231,8 +221,7 @@ void GlassView::on_range_changed() {
         looking_glass_sampling_rate = looking_glass_bandwidth;
         each_bin_size = looking_glass_bandwidth / SCREEN_W;
         looking_glass_step = looking_glass_bandwidth;
-        f_center_ini = f_min + (looking_glass_bandwidth / 2);                            // Initial center frequency for sweep
-        portapack::display.fill_rectangle({17 * 8, 4 * 16, 2 * 8, 16}, Color::black());  // Clear old marker and whole marker rectangle btw
+        f_center_ini = f_min + (looking_glass_bandwidth / 2);  // Initial center frequency for sweep
     } else {
         // view is made in multiple pass, use original bin picking
         mode = scan_type.selected_index_value();
@@ -253,19 +242,13 @@ void GlassView::on_range_changed() {
     }
     search_span = looking_glass_range / MHZ_DIV;
     marker_pixel_step = looking_glass_range / SCREEN_W;  // Each pixel value in Hz
-                                                         //
-    button_range.set_text("      ");                     // clear up to 6 chars
-    if (locked_range) {
-        button_range.set_text(">" + to_string_dec_uint(search_span) + "<");
-    } else {
-        button_range.set_text(" " + to_string_dec_uint(search_span) + " ");
-    }
 
-    pixel_index = 0;   // reset pixel counter
-    max_power = 0;     // reset save max power level
-    bins_Hz_size = 0;  // reset amount of Hz filled up by pixels
-                       //
+    pixel_index = 0;
+    max_power = 0;
+    bins_hz_size = 0;
+
     on_marker_change();
+    update_range_field();
 
     // set the sample rate and bandwidth
     receiver_model.set_sampling_rate(looking_glass_sampling_rate);
@@ -273,11 +256,11 @@ void GlassView::on_range_changed() {
 
     receiver_model.set_squelch_level(0);
     f_center = f_center_ini;  // Reset sweep into first slice
-    baseband::set_spectrum(looking_glass_bandwidth, field_trigger.value());
+    baseband::set_spectrum(looking_glass_bandwidth, trigger);
     receiver_model.set_target_frequency(f_center);  // tune rx for this slice
 }
 
-void GlassView::PlotMarker(uint8_t pos) {
+void GlassView::plot_marker(uint8_t pos) {
     uint8_t shift_y = 0;
     if (live_frequency_view > 0)  // plot one line down when in live view
     {
@@ -289,7 +272,7 @@ void GlassView::PlotMarker(uint8_t pos) {
     portapack::display.fill_rectangle({pos, 106 + shift_y, 1, 2}, Color::red());         // Red marker bottom
 }
 
-void GlassView::clip_min(int32_t v) {
+void GlassView::update_min(int32_t v) {
     int32_t min_size = steps;
     if (locked_range)
         min_size = search_span;
@@ -299,15 +282,14 @@ void GlassView::clip_min(int32_t v) {
         v = 7200 - min_size;
     }
     if (v > (field_frequency_max.value() - min_size))
-        field_frequency_max.set_value(v + min_size);
+        field_frequency_max.set_value(v + min_size, false);
     if (locked_range)
-        field_frequency_max.set_value(v + min_size);
+        field_frequency_max.set_value(v + min_size, false);
     else
-        field_frequency_min.set_value(v);
-    on_range_changed();
+        field_frequency_min.set_value(v, false);
 }
 
-void GlassView::clip_max(int32_t v) {
+void GlassView::update_max(int32_t v) {
     int32_t min_size = steps;
     if (locked_range)
         min_size = search_span;
@@ -317,12 +299,21 @@ void GlassView::clip_max(int32_t v) {
         v = min_size;
     }
     if (v < (field_frequency_min.value() + min_size))
-        field_frequency_min.set_value(v - min_size);
+        field_frequency_min.set_value(v - min_size, false);
     if (locked_range)
-        field_frequency_min.set_value(v - min_size);
+        field_frequency_min.set_value(v - min_size, false);
     else
-        field_frequency_max.set_value(v);
-    on_range_changed();
+        field_frequency_max.set_value(v, false);
+}
+
+void GlassView::update_range_field() {
+    if (!locked_range) {
+        field_range.set_style(&Styles::white);
+        field_range.set_text(" " + to_string_dec_uint(search_span) + " ");
+    } else {
+        field_range.set_style(&Styles::red);
+        field_range.set_text(">" + to_string_dec_uint(search_span) + "<");
+    }
 }
 
 GlassView::GlassView(
@@ -335,7 +326,7 @@ GlassView::GlassView(
                   &field_frequency_max,
                   &field_lna,
                   &field_vga,
-                  &button_range,
+                  &field_range,
                   &steps_config,
                   &scan_type,
                   &view_config,
@@ -343,175 +334,156 @@ GlassView::GlassView(
                   &filter_config,
                   &field_rf_amp,
                   &range_presets,
-                  &button_marker,
+                  &field_marker,
                   &field_trigger,
                   &button_jump,
                   &button_rst,
                   &freq_stats});
 
-    load_Presets();  // Load available presets from TXT files (or default)
+    load_presets();  // Load available presets from TXT files (or default).
+    preset_index = clip<uint8_t>(preset_index, 0, presets_db.size());
 
+    field_frequency_min.set_value(f_min / MHZ_DIV);
     field_frequency_min.on_change = [this](int32_t v) {
-        clip_min(v);
+        range_presets.set_selected_index(0);  // Manual
+        update_min(v);
+        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() * MHZ_DIV);
         new_view->on_changed = [this, &field](rf::Frequency f) {
-            clip_min(f / MHZ_DIV);
+            field_frequency_min.set_value(f / MHZ_DIV);
         };
     };
 
+    field_frequency_max.set_value(f_max / MHZ_DIV);
     field_frequency_max.on_change = [this](int32_t v) {
-        clip_max(v);
+        range_presets.set_selected_index(0);  // Manual
+        update_max(v);
+        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() * MHZ_DIV);
         new_view->on_changed = [this, &field](rf::Frequency f) {
-            clip_max(f / MHZ_DIV);
+            field_frequency_max.set_value(f / MHZ_DIV);
         };
     };
 
-    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;
+    steps_config.on_change = [this](size_t, OptionsField::value_t v) {
         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
+    steps_config.set_selected_index(0);  // 1 Mhz step.
 
-    scan_type.on_change = [this](size_t n, OptionsField::value_t v) {
-        (void)n;
+    scan_type.on_change = [this](size_t, OptionsField::value_t v) {
         mode = v;
         on_range_changed();
     };
-    scan_type.set_selected_index(0);  // default legacy fast scan
+    scan_type.set_selected_index(mode);
 
-    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}, {SCREEN_W, 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}, {SCREEN_W, 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);
+    view_config.on_change = [this](size_t, OptionsField::value_t v) {
+        reset_live_view();  // Clear between changes.
+        live_frequency_view = v;
+
+        switch (v) {
+            case 0:  // SPEC
+                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.
+                break;
+
+            case 1:  // LEVEL
+                display.fill_rectangle({{0, 108}, {SCREEN_W, 24}}, {0, 0, 0});
+                display.scroll_disable();
+                level_integration.hidden(false);
+                freq_stats.hidden(false);
+                button_jump.hidden(false);
+                button_rst.hidden(false);
+                break;
+
+            case 2:  // PEAK
+            default:
+                display.fill_rectangle({{0, 108}, {SCREEN_W, 24}}, {0, 0, 0});
+                display.scroll_disable();
+                level_integration.hidden(false);
+                freq_stats.hidden(false);
+                button_jump.hidden(false);
+                button_rst.hidden(false);
+                break;
         }
+
         set_dirty();
     };
-    view_config.set_selected_index(0);  // default spectrum
+    view_config.set_selected_index(live_frequency_view);
 
-    level_integration.on_change = [this](size_t n, OptionsField::value_t v) {
-        (void)n;
-        reset_live_view(true);
+    level_integration.on_change = [this](size_t, OptionsField::value_t v) {
+        reset_live_view();
         live_frequency_integrate = v;
     };
-    level_integration.set_selected_index(3);  // default integration of ( 3 * old value + new_value ) / 4
+    level_integration.set_selected_index(live_frequency_integrate);
 
-    filter_config.on_change = [this](size_t n, OptionsField::value_t v) {
-        (void)n;
-        reset_live_view(true);
+    filter_config.on_change = [this](size_t ix, OptionsField::value_t v) {
+        reset_live_view();
         min_color_power = v;
+        filter_index = ix;
     };
-    filter_config.set_selected_index(0);
+    filter_config.set_selected_index(filter_index);
 
-    range_presets.on_change = [this](size_t n, OptionsField::value_t v) {
-        (void)n;
+    range_presets.on_change = [this](size_t ix, OptionsField::value_t v) {
+        preset_index = ix;
+        if (ix == 0) return;  // Don't update range for "Manual".
+
+        // NB: Don't trigger updates, presets directly set the range
+        // values without applying step or range lock.
         field_frequency_min.set_value(presets_db[v].min, false);
         field_frequency_max.set_value(presets_db[v].max, false);
         on_range_changed();
     };
+    range_presets.set_selected_index(preset_index);
 
-    button_marker.on_change = [this]() {
-        if (((int)marker_pixel_index + button_marker.get_encoder_delta()) < 0) {
-            marker_pixel_index = 0;
-        } else if (((int)marker_pixel_index + button_marker.get_encoder_delta()) > SCREEN_W) {
-            marker_pixel_index = SCREEN_W;
-        } else {
-            marker_pixel_index = marker_pixel_index + button_marker.get_encoder_delta();
-        }
+    field_marker.on_encoder_change = [this](TextField&, EncoderEvent delta) {
+        marker_pixel_index = clip<uint8_t>(marker_pixel_index + delta, 0, SCREEN_W);
         on_marker_change();
-        button_marker.set_encoder_delta(0);
     };
 
-    button_marker.on_select = [this](ButtonWithEncoder&) {
-        receiver_model.set_target_frequency(marker);  // Center tune rx in marker freq.
-        auto settings = receiver_model.settings();
-        settings.frequency_step = MHZ_DIV;        // Preset a 1 MHz frequency step into RX -> AUDIO
-        nav_.replace<AnalogAudioView>(settings);  // Jump into audio view
+    field_marker.on_select = [this](TextField&) {
+        // Launch Audio with marker frequency.
+        launch_audio(marker);
     };
 
     field_trigger.on_change = [this](int32_t v) {
-        baseband::set_spectrum(looking_glass_bandwidth, v);
+        trigger = v;
+        baseband::set_spectrum(looking_glass_bandwidth, trigger);
     };
-    field_trigger.set_value(32);  // Defaults to 32, as normal triggering resolution
+    field_trigger.set_value(trigger);
 
-    button_range.on_select = [this](Button&) {
-        if (locked_range) {
-            locked_range = false;
-            button_range.set_style(&Styles::white);
-            button_range.set_text(" " + to_string_dec_uint(search_span) + " ");
-        } else {
-            locked_range = true;
-            button_range.set_style(&Styles::red);
-            button_range.set_text(">" + to_string_dec_uint(search_span) + "<");
-        }
+    field_range.on_select = [this](TextField&) {
+        locked_range = !locked_range;
+        update_range_field();
     };
 
     button_jump.on_select = [this](Button&) {
-        receiver_model.set_target_frequency(max_freq_hold);  // Center tune rx in marker freq.
-        auto settings = receiver_model.settings();
-        settings.frequency_step = MHZ_DIV;        // Preset a 1 MHz frequency step into RX -> AUDIO
-        nav_.replace<AnalogAudioView>(settings);  // Jump into audio view
+        // Launch Audio with peak frequency.
+        launch_audio(max_freq_hold);
     };
 
     button_rst.on_select = [this](Button&) {
-        reset_live_view(true);
+        reset_live_view();
     };
 
     display.scroll_set_area(109, 319);
-    baseband::set_spectrum(looking_glass_bandwidth, 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
 
-    marker_pixel_index = 120;
-    on_range_changed();
+    // 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
+    baseband::set_spectrum(looking_glass_bandwidth, trigger);
+
+    marker_pixel_index = SCREEN_W / 2;
+    on_range_changed();  // Force a UI update.
 
     receiver_model.set_sampling_rate(looking_glass_sampling_rate);   // 20mhz
     receiver_model.set_baseband_bandwidth(looking_glass_bandwidth);  // possible values: 1.75/2.5/3.5/5/5.5/6/7/8/9/10/12/14/15/20/24/28MHz
@@ -519,11 +491,14 @@ GlassView::GlassView(
     receiver_model.enable();
 }
 
-void GlassView::load_Presets() {
+void GlassView::load_presets() {
     File presets_file;
     auto error = presets_file.open("LOOKINGGLASS/PRESETS.TXT");
     presets_db.clear();
 
+    // Add the "Manual" entry.
+    presets_db.push_back({0, 0, "Manual"});
+
     if (!error) {
         auto reader = FileLineReader(presets_file);
         for (const auto& line : reader) {
@@ -546,14 +521,10 @@ void GlassView::load_Presets() {
         }
     }
 
-    // Couldn't load any from the file, load a default instead.
-    if (presets_db.empty())
-        presets_Default();
-
-    populate_Presets();
+    populate_presets();
 }
 
-void GlassView::populate_Presets() {
+void GlassView::populate_presets() {
     using option_t = std::pair<std::string, int32_t>;
     using options_t = std::vector<option_t>;
     options_t entries;
@@ -561,12 +532,14 @@ void GlassView::populate_Presets() {
     for (const auto& preset : presets_db)
         entries.emplace_back(preset.label, entries.size());
 
-    range_presets.set_options(entries);
+    range_presets.set_options(std::move(entries));
 }
 
-void GlassView::presets_Default() {
-    presets_db.clear();
-    presets_db.push_back({2320, 2560, "DEFAULT WIFI 2.4GHz"});
+void GlassView::launch_audio(rf::Frequency center_freq) {
+    receiver_model.set_target_frequency(center_freq);
+    auto settings = receiver_model.settings();
+    settings.frequency_step = MHZ_DIV;        // Preset a 1 MHz frequency step into RX -> AUDIO
+    nav_.replace<AnalogAudioView>(settings);  // Jump into audio view
 }
 
 }  // namespace ui

firmware/application/apps/ui_looking_glass_app.hpp

@@ -72,8 +72,28 @@ class GlassView : public View {
    private:
     NavigationView& nav_;
     RxRadioState radio_state_{ReceiverModel::Mode::SpectrumAnalysis};
+    // Settings
+    rf::Frequency f_min = 260 * MHZ_DIV;  // Default to 315/433 remote range.
+    rf::Frequency f_max = 500 * MHZ_DIV;
+    uint8_t preset_index = 0;  // Manual
+    uint8_t filter_index = 0;  // OFF
+    uint8_t trigger = 32;
+    uint8_t mode = LOOKING_GLASS_FASTSCAN;
+    uint8_t live_frequency_view = 0;       // Spectrum
+    uint8_t live_frequency_integrate = 3;  // Default (3 * old value + new_value) / 4
     app_settings::SettingsManager settings_{
-        "rx_glass", app_settings::Mode::RX};
+        "rx_glass"sv,
+        app_settings::Mode::RX,
+        {
+            {"min"sv, &f_min},
+            {"max"sv, &f_max},
+            {"preset"sv, &preset_index},
+            {"filter"sv, &filter_index},
+            {"trigger"sv, &trigger},
+            {"scan_mode"sv, &mode},
+            {"freq_view"sv, &live_frequency_view},
+            {"freq_integrate"sv, &live_frequency_integrate},
+        }};
 
     struct preset_entry {
         rf::Frequency min{};
@@ -82,8 +102,9 @@ class GlassView : public View {
     };
 
     std::vector<preset_entry> presets_db{};
-    void clip_min(int32_t v);
-    void clip_max(int32_t v);
+    void update_min(int32_t v);
+    void update_max(int32_t v);
+    void update_range_field();
     void get_max_power(const ChannelSpectrum& spectrum, uint8_t bin, uint8_t& max_power);
     rf::Frequency get_freq_from_bin_pos(uint8_t pos);
     void on_marker_change();
@@ -94,57 +115,52 @@ class GlassView : public View {
     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);
     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 reset_live_view();
     void add_spectrum_pixel(uint8_t power);
-    void PlotMarker(uint8_t pos);
-    void load_Presets();
-    void txtline_process(std::string& line);
-    void populate_Presets();
-    void presets_Default();
+    void plot_marker(uint8_t pos);
+    void load_presets();
+    void populate_presets();
+    void launch_audio(rf::Frequency center_freq);
 
-    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};
     uint8_t marker_pixel_index{0};
     rf::Frequency marker_pixel_step{0};
-    // size of one spectrum bin in Hz
+
+    // Size of one spectrum bin in Hz.
     rf::Frequency each_bin_size{0};
-    // consumed number of Hz, used to know if we have filled a 'bag' , a corresponding pixel length on screen
-    rf::Frequency bins_Hz_size{0};
+    // Bandwidth of a single spectrum bin.
+    rf::Frequency bins_hz_size{0};
     rf::Frequency looking_glass_sampling_rate{0};
     rf::Frequency looking_glass_bandwidth{0};
     rf::Frequency looking_glass_range{0};
     rf::Frequency looking_glass_step{0};
-    uint8_t min_color_power{0};
+    uint8_t min_color_power{0};  // Filter cutoff level.
     uint32_t pixel_index{0};
-    std::array<Color, SCREEN_W> spectrum_row = {0};
-    std::array<uint8_t, SCREEN_W> 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;
+
+    std::array<Color, SCREEN_W> spectrum_row{};
+    std::array<uint8_t, SCREEN_W> spectrum_data{};
+    ChannelSpectrumFIFO* fifo{};
+
+    int32_t steps = 1;
     bool locked_range = false;
+
+    uint8_t max_power = 0;
+    rf::Frequency max_freq_hold = 0;
+    rf::Frequency last_max_freq = 0;
+    int16_t max_freq_power = -1000;
     uint8_t bin_length = SCREEN_W;
-    uint8_t real_bin_length = SCREEN_W;
     uint8_t offset = 0;
-    uint8_t tune_offset = 0;
-    uint8_t bin = 0;
-    int64_t last_max_freq = 0;
-    uint8_t mode = LOOKING_GLASS_FASTSCAN;
     uint8_t ignore_dc = 0;
 
     Labels labels{
-        {{0, 0}, "MIN:     MAX:     LNA   VGA  ", Color::light_grey()},
-        {{0, 1 * 16}, "RANGE:       FILTER:      AMP:", Color::light_grey()},
+        {{0, 0 * 16}, "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, 3 * 16}, "MARKER:          MHz", Color::light_grey()},
         {{0, 4 * 16}, "RES:    STEP:", Color::light_grey()}};
 
     NumberField field_frequency_min{
@@ -167,8 +183,8 @@ class GlassView : public View {
     VGAGainField field_vga{
         {27 * 8, 0 * 16}};
 
-    Button button_range{
-        {7 * 8, 1 * 16, 4 * 8, 16},
+    TextField field_range{
+        {6 * 8, 1 * 16, 6 * 8, 16},
         ""};
 
     OptionsField filter_config{
@@ -176,23 +192,21 @@ class GlassView : public View {
         4,
         {
             {"OFF ", 0},
-            {"MID ", 118},  // 85 +25 (110) + a bit more to kill all blue
+            {"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}};
+        {28 * 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},
-        " "};
+    TextField field_marker{
+        {7 * 8, 3 * 16, 9 * 8, 16},
+        ""};
 
     NumberField field_trigger{
         {4 * 8, 4 * 16},

firmware/application/apps/ui_mictx.cpp

@@ -51,7 +51,7 @@ void MicTXView::focus() {
             field_rxfrequency.focus();
             break;
         default:
-            field_va.focus();
+            check_va.focus();
             break;
     }
 }
@@ -60,24 +60,56 @@ void MicTXView::update_vumeter() {
     vumeter.set_value(audio_level);
 }
 
+void MicTXView::update_tx_icon() {
+    tx_icon.set_foreground(transmitting ? Color::red() : Color::black());
+    tx_icon.set_background(transmitting ? Color::yellow() : Color::black());
+}
+
 void MicTXView::on_tx_progress(const bool done) {
     // Roger beep played, stop transmitting
     if (done)
         set_tx(false);
 }
 
+uint8_t MicTXView::shift_bits(void) {
+    uint8_t shift_bits_s16{4};  // shift bits factor to the captured ADC S16 audio sample.
+
+    if (audio::debug::codec_name() == "WM8731") {
+        switch (ak4951_alc_and_wm8731_boost_GUI) {
+            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.
+        }
+    } 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)
+    }
+    return shift_bits_s16;
+}
+
 void MicTXView::configure_baseband() {
     // TODO: Can this use the transmitter model instead?
     baseband::set_audiotx_config(
         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
+        mic_gain_x10 / 10.0,
+        shift_bits(),  // to be used in dsp_modulate
         TONES_F2D(tone_key_frequency(tone_key_index), sampling_rate),
-        enable_am,
-        enable_dsb,
-        enable_usb,
-        enable_lsb);
+        (mic_mod_index == MIC_MOD_AM),
+        (mic_mod_index == MIC_MOD_DSB),
+        (mic_mod_index == MIC_MOD_USB),
+        (mic_mod_index == MIC_MOD_LSB));
 }
 
 void MicTXView::set_tx(bool enable) {
@@ -87,6 +119,10 @@ void MicTXView::set_tx(bool enable) {
         transmitting = true;
         configure_baseband();
         transmitter_model.set_target_frequency(tx_frequency);  // Now, no need: transmitter_model.set_tx_gain(tx_gain), nor (rf_amp);
+
+        /* The max. Power Spectrum Densitiy in WFM with High tone mod level (80%) and high 32kHZ subtone as fmod.  with max fdeviation 150k ,
+         BW aprox = 2 *(150K + 32K) = 364khz, then we just select the minimum TX  LPF 1M75. */
+        transmitter_model.set_baseband_bandwidth(1'750'000);
         transmitter_model.enable();
         portapack::pin_i2s0_rx_sda.mode(3);  // This is already done in audio::init but gets changed by the CPLD overlay reprogramming
     } else {
@@ -97,12 +133,24 @@ void MicTXView::set_tx(bool enable) {
             transmitting = false;
             configure_baseband();
             transmitter_model.disable();
-            if (rx_enabled)     // If audio RX is enabled and we've been transmitting
+
+            if (rx_enabled) {
                 rxaudio(true);  // Turn back on audio RX
+
+                // TODO FIXME: this isn't working: vu meter isn't going to 0:
+                vumeter.set_value(0);  // Reset  vumeter
+                vumeter.dirty();       // Force to refresh vumeter.
+            }
         }
     }
+    update_tx_icon();
 }
 
+bool MicTXView::tx_button_held() {
+    const auto switches_state = get_switches_state();
+    return switches_state[(size_t)ui::KeyEvent::Select];
+};
+
 void MicTXView::do_timing() {
     if (va_enabled) {
         if (!transmitting) {
@@ -124,7 +172,8 @@ void MicTXView::do_timing() {
                 if ((decay_timer >> 8) >= decay_ms) {
                     decay_timer = 0;
                     attack_timer = 0;
-                    set_tx(false);
+                    if (!button_touch && !tx_button_held())
+                        set_tx(false);
                 } else {
                     decay_timer += lcd_frame_duration;
                 }
@@ -134,42 +183,39 @@ void MicTXView::do_timing() {
         }
     } else {
         // Check for PTT release
-        const auto switches_state = get_switches_state();
-        if (!switches_state[4] && transmitting && !button_touch)  // Select button
+        if (transmitting && !button_touch && !tx_button_held())
             set_tx(false);
     }
 }
 
-void MicTXView::rxaudio(bool is_on) {
-    if (is_on) {
+void MicTXView::rxaudio(bool enable) {
+    if (enable) {
         audio::input::stop();
         baseband::shutdown();
 
-        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);                 // 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 {                                                                         // 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, or the two new addional BW filters (180k, 40k)
+        switch (mic_mod_index) {
+            case MIC_MOD_NFM:  // 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 user's selection (8k5, 11k, 16k).
+                break;
+            case MIC_MOD_WFM:  // WFM, BW 200Khz aprox, or the two new addional BW filters (180k, 40k)
                 baseband::run_image(portapack::spi_flash::image_tag_wfm_audio);
                 receiver_model.set_modulation(ReceiverModel::Mode::WidebandFMAudio);
-                // receiver_model.set_wfm_configuration(n);  // it is called above, depending user's selection (200k, 180k, 0k).
-            } 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 user's selection (8k5, 11k, 16k).
-            }
+                // receiver_model.set_wfm_configuration(n); is called above, depending user's selection (200k, 180k, 0k).
+                break;
+            case MIC_MOD_AM:
+            case MIC_MOD_DSB:
+            case MIC_MOD_USB:
+            case MIC_MOD_LSB:
+                baseband::run_image(portapack::spi_flash::image_tag_am_audio);
+                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),
+                break;
         }
 
-        if (bool_same_F_tx_rx_enabled)                          // when stop TX, define to which freq RX we return
-            receiver_model.set_target_frequency(tx_frequency);  // Update freq also for RX = TX
-        else
-            receiver_model.set_target_frequency(rx_frequency);  // Now with separate freq controls!
-        receiver_model.set_lna(rx_lna);
-        receiver_model.set_vga(rx_vga);
-        receiver_model.set_rf_amp(rx_amp);
+        receiver_model.set_target_frequency(bool_same_F_tx_rx_enabled ? tx_frequency : rx_frequency);
         receiver_model.enable();
         audio::output::start();
     } else {                                                                    // These incredibly convoluted steps are required for the vumeter to reappear when stopping RX.
@@ -179,14 +225,82 @@ void MicTXView::rxaudio(bool is_on) {
 
         baseband::run_image(portapack::spi_flash::image_tag_mic_tx);
         audio::output::stop();
-        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.
+        audio::input::start(ak4951_alc_and_wm8731_boost_GUI, mic_to_HP_enabled);  // set up ALC mode (AK4951) or set up mic_boost ON/OFF (WM8731). and the check box "Hear Mic"
         portapack::pin_i2s0_rx_sda.mode(3);
         configure_baseband();
     }
 }
 
-void MicTXView::set_ptt_visibility(bool v) {
-    tx_button.hidden(!v);
+void MicTXView::set_rxbw_options(void) {
+    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 (mic_mod_index) {
+        case MIC_MOD_NFM:
+            freqman_set_bandwidth_option(NFM_MODULATION, field_rxbw);  // restore dynamic field_rxbw value with NFM options from freqman_db.cpp
+            field_rxbw.set_by_value(receiver_model.nbfm_configuration());
+            break;
+        case MIC_MOD_WFM:
+            freqman_set_bandwidth_option(WFM_MODULATION, field_rxbw);  // restore dynamic field_rxbw value with WFM options from freqman_db.cpp
+            field_rxbw.set_by_value(receiver_model.wfm_configuration());
+            break;
+        case MIC_MOD_AM:
+            rxbw.emplace_back("DSB 9k", 0);  // we offer in AM DSB two audio BW 9k / 6k.
+            rxbw.emplace_back("DSB 6k", 1);
+            field_rxbw.set_options(rxbw);  // store that aux GUI option to the field_rxbw.
+            break;
+        case MIC_MOD_DSB:
+            rxbw.emplace_back("USB+3k", 0);  // added dynamically two options (index 0,1) to that DSB-SC case to the field_rxbw value.
+            rxbw.emplace_back("LSB-3k", 1);
+            field_rxbw.set_options(rxbw);  // store that aux GUI option to the field_rxbw.
+            break;
+        case MIC_MOD_USB:
+            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.
+            break;
+        case MIC_MOD_LSB:
+            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.
+            break;
+    }
+}
+
+void MicTXView::set_rxbw_defaults(bool use_app_settings) {
+    if (use_app_settings) {
+        field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);
+        field_rxbw.set_by_value(rxbw_index);
+    } else if (mic_mod_index == MIC_MOD_NFM) {
+        field_bw.set_value(10);  // NFM TX bw 10k, RX bw 16k (2) default
+        field_rxbw.set_by_value(2);
+    } else if (mic_mod_index == MIC_MOD_WFM) {
+        field_bw.set_value(75);  // WFM TX bw 75K, RX bw 200k (0) default
+        field_rxbw.set_by_value(0);
+    }
+    // field_bw is hidden in other modulation cases
+}
+
+void MicTXView::update_receiver_rxbw(void) {
+    // 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)
+    // 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)
+    // In DSB-SC 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)
+    switch (mic_mod_index) {
+        case MIC_MOD_NFM:
+            receiver_model.set_nbfm_configuration(rxbw_index);  // 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)
+            break;
+        case MIC_MOD_WFM:
+            receiver_model.set_wfm_configuration(rxbw_index);  // we are in WFM case, we need to select proper WFB RX BW filter, WFM BW 200K(0), WFM BW 180K(1), WFM BW 40K(2)
+            break;
+        case MIC_MOD_AM:
+            receiver_model.set_am_configuration(rxbw_index);  // 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),
+            break;
+        case MIC_MOD_USB:
+        case MIC_MOD_LSB:
+            break;  // change can't happen in these modes because there's only one BW choice
+        case MIC_MOD_DSB:
+            receiver_model.set_am_configuration(rxbw_index + 2);  // we are in DSB-SC TX mode, we need to select proper SSB filter. 0+2 =>usb(2), 1+2=3 =>lsb(3),
+            break;
+    }
 }
 
 MicTXView::MicTXView(
@@ -195,400 +309,260 @@ MicTXView::MicTXView(
 
     baseband::run_image(portapack::spi_flash::image_tag_mic_tx);
 
-    if (audio::debug::codec_name() == "WM8731") {
-        add_children({&labels_WM8731,  // we have audio codec WM8731, same MIC menu as original.
-                      &vumeter,
-                      &options_gain,  // MIC GAIN float factor on the GUI.
-                      &options_wm8731_boost_mode,
-                      //		&check_va,
-                      &field_va,
-                      &field_va_level,
-                      &field_va_attack,
-                      &field_va_decay,
-                      &field_bw,
-                      &tx_view,  // it already integrates previous rfgain, 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});
+    bool wm = (audio::debug::codec_name() == "WM8731");
+    add_children({&labels_both,
+                  wm ? &labels_WM8731 : &labels_AK4951,  // enable ALC if AK4951
+                  &vumeter,
+                  &options_gain,  // MIC GAIN float factor on the GUI.
+                  wm ? &options_wm8731_boost_mode : &options_ak4951_alc_mode,
+                  &check_va,
+                  &field_va_level,
+                  &field_va_attack,
+                  &field_va_decay,
+                  &field_bw,
+                  &tx_view,  // it already integrates previous rfgain, rfamp.
+                  &options_mode,
+                  &field_frequency,
+                  &options_tone_key,
+                  &check_rogerbeep,
+                  &check_mic_to_HP,          // check box to activate "hear mic"
+                  &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,
+                  &tx_icon});
 
-    } 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,
-                      &tx_view,  // it already integrates previous rfgain, 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});
-    }
+    set_rxbw_options();
+    set_rxbw_defaults(settings_.loaded());
 
     tone_keys_populate(options_tone_key);
+    options_tone_key.set_selected_index(tone_key_index);
     options_tone_key.on_change = [this](size_t i, int32_t) {
         tone_key_index = i;
     };
-    options_tone_key.set_selected_index(0);
+
+    check_rogerbeep.set_value(rogerbeep_enabled);
+    check_rogerbeep.on_select = [this](Checkbox&, bool v) {
+        rogerbeep_enabled = v;
+    };
+
+    field_rxlna.set_value(receiver_model.lna());
+    field_rxlna.on_change = [this](int32_t v) {
+        receiver_model.set_lna(v);
+    };
+
+    field_rxvga.set_value(receiver_model.vga());
+    field_rxvga.on_change = [this](int32_t v) {
+        receiver_model.set_vga(v);
+    };
+
+    field_rxamp.set_value(receiver_model.rf_amp());
+    field_rxamp.on_change = [this](int32_t v) {
+        receiver_model.set_rf_amp(v);
+    };
 
     options_gain.on_change = [this](size_t, int32_t v) {
-        mic_gain = v / 10.0;
+        mic_gain_x10 = v;
         configure_baseband();
     };
-    options_gain.set_selected_index(1);  // x1.0 preselected default.
+    options_gain.set_by_value(mic_gain_x10);  // x1.0 preselected default.
+
+    field_rxbw.on_change = [this](size_t, int32_t v) {
+        rxbw_index = v;
+        update_receiver_rxbw();
+    };
+    field_rxbw.set_by_value(rxbw_index);
+
+    field_squelch.set_value(receiver_model.squelch_level());
+    field_squelch.on_change = [this](int32_t v) {
+        receiver_model.set_squelch_level(v);
+    };
 
     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_off
-            configure_baseband();                                  // to update in real time, sending msg, var-parameters >>shift_bits FM msg, to audio_tx from M0 to M4 Proc -
+            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, mic_to_HP_enabled);  // Detected (WM8731), set up the proper wm_boost on/off, 0..4 (0,1) boost_on, (2,3,4) boost_off,and the check box "Hear Mic"
+            configure_baseband();                                                     // to update in real time, 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.
+        if (!settings_.loaded()) {
+            ak4951_alc_and_wm8731_boost_GUI = 3;  // preset GUI index 3 as default WM -> -02 dB's
+        }
+        options_wm8731_boost_mode.set_selected_index(ak4951_alc_and_wm8731_boost_GUI);
     } 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.
+            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, mic_to_HP_enabled);  // Detected (AK4951) ==> Set up proper ALC mode from 0..11 options, and the check box "Hear Mic"
+            configure_baseband();                                                     // sending fixed >>8_FM, var-parameters msg, to audiotx from this M0 to M4 process.
         };
+        if (!settings_.loaded())
+            ak4951_alc_and_wm8731_boost_GUI = 0;
+        options_ak4951_alc_mode.set_selected_index(ak4951_alc_and_wm8731_boost_GUI);
     }
 
-    // options_ak4951_alc_mode.set_selected_index(0);
-
+    // WARNING: transmitter_model.set_target_frequency() and receiver_model.set_target_frequency() both update the same tuning freq, but one has an offset!
     tx_frequency = transmitter_model.target_frequency();
-    field_frequency.set_value(transmitter_model.target_frequency());
-    field_frequency.set_step(receiver_model.frequency_step());
     field_frequency.on_change = [this](rf::Frequency f) {
         tx_frequency = f;
-        if (!rx_enabled) {  // not activated receiver. just update freq TX
+        if (!rx_enabled)
             transmitter_model.set_target_frequency(f);
-        } else {                                         // activated receiver.
-            if (bool_same_F_tx_rx_enabled)               // user selected common freq- TX = RX
-                receiver_model.set_target_frequency(f);  // Update common freq also for RX
-        }
+        else if (bool_same_F_tx_rx_enabled)
+            receiver_model.set_target_frequency(f);
+        // else tuning freq will be updated when rx is enabled, transmitting starts, or when rx_frequency is changed (if rx_enabled)
     };
     field_frequency.on_edit = [this, &nav]() {
         focused_ui = 0;
         // TODO: Provide separate modal method/scheme?
         auto new_view = nav.push<FrequencyKeypadView>(tx_frequency);
         new_view->on_changed = [this](rf::Frequency f) {
-            tx_frequency = f;
-            if (!rx_enabled) {
-                transmitter_model.set_target_frequency(f);
-            } else {
-                if (bool_same_F_tx_rx_enabled)
-                    receiver_model.set_target_frequency(f);  // Update freq also for RX
-            }
             this->field_frequency.set_value(f);
-            set_dirty();
         };
     };
+    field_frequency.set_value(tx_frequency);
 
-    field_bw.on_change = [this](uint32_t v) {
-        transmitter_model.set_channel_bandwidth(v * 1000);
-    };
-    field_bw.set_value(10);  // pre-default first time, TX deviation FM for NFM / FM
+    // TODO: would be nice if frequency step was configurable in this app
+    field_frequency.set_step(receiver_model.frequency_step());
 
-    // now, no need direct update, field_rfgain, field_rfamp (it is done in ui_transmitter.cpp)
-
-    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:  //{ "FM", 0 }
-                enable_am = false;
-                enable_usb = false;
-                enable_lsb = false;
-                enable_dsb = false;
-                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
-                options_tone_key.hidden(0);  // we are in FM mode, we should have active the Key-tones & CTCSS option.
-
-                freqman_set_bandwidth_option(NFM_MODULATION, field_rxbw);  // restore dynamic field_rxbw value with NFM options from freqman_db.cpp
-                field_rxbw.set_by_value(2);                                // // bw 16k (2) default
-                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:  //{ "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.
-
-                freqman_set_bandwidth_option(WFM_MODULATION, field_rxbw);  // restore dynamic field_rxbw value with WFM options from freqman_db.cpp
-                field_rxbw.set_by_value(0);                                // bw 200k (0) default
-                field_rxbw.hidden(0);                                      // we are in WFM mode, we need to show to the user the selected BW WFM filter.
-                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
-                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("DSB 9k", 0);  // we offer in AM DSB two audio BW 9k / 6k.
-                rxbw.emplace_back("DSB 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 3:  //{ "USB", 3 }
-                enable_usb = true;
-                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 4:  //{ "LSB", 4 }
-                enable_lsb = true;
-                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 5:  //{ "DSB-SC", 5 }
-                enable_dsb = true;
-                rxaudio(rx_enabled);        // Update now if we have RX audio on
-                check_rogerbeep.hidden(0);  // make visible again the "rogerbeep" selection.
-
-                rxbw.emplace_back("USB+3k", 0);  // added dynamically two options (index 0,1) to that DSB-SC case to the field_rxbw value.
-                rxbw.emplace_back("LSB-3k", 1);
-
-                field_rxbw.set_options(rxbw);  // store that aux GUI option to the field_rxbw.
-
-                break;
-        }
-        // configure_baseband();
-    };
-
-    /*
-        check_va.on_select = [this](Checkbox&, bool v) {
-                va_enabled = v;
-                text_ptt.hidden(v);			//hide / show PTT text
-                check_rxactive.hidden(v); 	//hide / show the RX AUDIO
-                set_dirty();				//Refresh display
-        };
-        */
-    field_va.set_selected_index(1);
-    field_va.on_change = [this](size_t, int32_t v) {
-        switch (v) {
-            case 0:
-                va_enabled = 0;
-                this->set_ptt_visibility(0);
-                check_rxactive.hidden(0);
-                ptt_enabled = 0;
-                break;
-            case 1:
-                va_enabled = 0;
-                this->set_ptt_visibility(1);
-                check_rxactive.hidden(0);
-                ptt_enabled = 1;
-                break;
-            case 2:
-                if (!rx_enabled) {
-                    va_enabled = 1;
-                    this->set_ptt_visibility(0);
-                    check_rxactive.hidden(1);
-                    ptt_enabled = 0;
-                } else {
-                    field_va.set_selected_index(1);
-                }
-                break;
-        }
-        set_dirty();
-    };
-
-    check_rogerbeep.on_select = [this](Checkbox&, bool v) {
-        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_target_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);
-    };
-    field_va_level.set_value(40);
-
-    field_va_attack.on_change = [this](int32_t v) {
-        attack_ms = v;
-    };
-    field_va_attack.set_value(500);
-
-    field_va_decay.on_change = [this](int32_t v) {
-        decay_ms = v;
-    };
-    field_va_decay.set_value(1000);
-
-    check_rxactive.on_select = [this](Checkbox&, bool v) {
-        //		vumeter.set_value(0);	//Start with a clean vumeter
-        rx_enabled = v;
-        //		check_va.hidden(v); 	//Hide or show voice activation
-        rxaudio(v);   // Activate-Deactivate audio rx accordingly
-        set_dirty();  // Refresh interface
-    };
-
-    field_rxbw.on_change = [this](size_t, int32_t v) {
-        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),
-            }
-            if (enable_wfm) {
-                receiver_model.set_wfm_configuration(v);  // we are in WFM case, we need to select proper WFB RX BW filter, WFM BW 200K(0), WFM BW 180K(1), WFM BW 40K(2)
-            }
-        }
-    };
-
-    field_squelch.on_change = [this](int32_t v) {
-        receiver_model.set_squelch_level(100 - v);
-    };
-    field_squelch.set_value(0);
-    receiver_model.set_squelch_level(0);
-
-    rx_frequency = receiver_model.target_frequency();
+    // WARNING: transmitter_model.set_target_frequency() and receiver_model.set_target_frequency() both update the same tuning freq, but one has an offset!
     field_rxfrequency.set_value(rx_frequency);
-    field_rxfrequency.set_step(receiver_model.frequency_step());
     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_target_frequency(f);
+            receiver_model.set_target_frequency(rx_frequency);
     };
     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);
         new_view->on_changed = [this](rf::Frequency f) {
-            rx_frequency = f;
-            if (rx_enabled)
-                receiver_model.set_target_frequency(f);
             this->field_rxfrequency.set_value(f);
-            set_dirty();
         };
     };
 
-    rx_lna = receiver_model.lna();
-    field_rxlna.on_change = [this](int32_t v) {
-        rx_lna = v;
-        if (rx_enabled)
-            receiver_model.set_lna(v);
-    };
-    field_rxlna.set_value(rx_lna);
+    // TODO: would be nice if frequency step was configurable in this app
+    field_rxfrequency.set_step(receiver_model.frequency_step());
 
-    rx_vga = receiver_model.vga();
-    field_rxvga.on_change = [this](int32_t v) {
-        rx_vga = v;
-        if (rx_enabled)
-            receiver_model.set_vga(v);
+    check_common_freq_tx_rx.on_select = [this](Checkbox&, bool v) {
+        bool_same_F_tx_rx_enabled = v;
+        field_rxfrequency.hidden(v);
+        set_dirty();
+        receiver_model.set_target_frequency(bool_same_F_tx_rx_enabled ? tx_frequency : rx_frequency);  // To go to the proper tuned freq. when toggling it
     };
-    field_rxvga.set_value(rx_vga);
+    check_common_freq_tx_rx.set_value(bool_same_F_tx_rx_enabled);
 
-    rx_amp = receiver_model.rf_amp();
-    field_rxamp.on_change = [this](int32_t v) {
-        rx_amp = v;
-        if (rx_enabled)
-            receiver_model.set_rf_amp(rx_amp);
+    field_bw.on_change = [this](uint32_t v) {
+        transmitter_model.set_channel_bandwidth(v * 1000);
     };
-    field_rxamp.set_value(rx_amp);
+    field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);  // pre-default first time, TX deviation FM for NFM / FM
+
+    // now, no need direct update, field_rfgain, field_rfamp (it is done in ui_transmitter.cpp)
+
+    options_mode.on_change = [this](size_t, int32_t v) {
+        mic_mod_index = v;
+
+        // update bw & tone key visibility - only visible in NFM/WFM modes
+        if ((mic_mod_index == MIC_MOD_NFM) || (mic_mod_index == MIC_MOD_WFM)) {
+            field_bw.hidden(false);
+            options_tone_key.hidden(false);
+        } else {
+            field_bw.hidden(true);
+            options_tone_key.set_selected_index(0);
+            options_tone_key.hidden(true);
+        }
+
+        // update rogerbeep visibility - disable in USB/LSB modes
+        if ((mic_mod_index == MIC_MOD_USB) || (mic_mod_index == MIC_MOD_LSB)) {
+            check_rogerbeep.set_value(false);
+            check_rogerbeep.hidden(true);
+        } else {
+            check_rogerbeep.hidden(false);
+        }
+
+        // update squelch visibility - only visible in NFM mode
+        field_squelch.hidden(mic_mod_index != MIC_MOD_NFM);
+
+        // update bandwidth
+        set_rxbw_options();
+        set_rxbw_defaults(false);
+        field_rxbw.hidden(false);
+        set_dirty();  // Refresh display
+
+        rxaudio(rx_enabled);  // Update now if we have RX audio on
+        // configure_baseband();
+    };
+    options_mode.set_selected_index(mic_mod_index);
+
+    check_mic_to_HP.on_select = [this](Checkbox&, bool v) {
+        mic_to_HP_enabled = v;
+        if (mic_to_HP_enabled) {  // When user click to "hear mic to HP", we will select the higher acoustic sound Option MODE  ALC or BOOST-
+            audio::input::loopback_mic_to_hp_enable();
+            if (audio::debug::codec_name() == "WM8731") {
+                options_wm8731_boost_mode.set_selected_index(0);  // In WM we always go to Boost +12 dB’s respect reference level
+            } else if (ak4951_alc_and_wm8731_boost_GUI == 0)      // In AK we are changing only that ALC index =0, because in that option, there is no sound.
+                options_ak4951_alc_mode.set_selected_index(1);    // alc_mode =0 , means no ALC,no DIGITAL filter block (by passed), and that mode has no loopback mode.
+        } else {
+            audio::input::loopback_mic_to_hp_disable();
+        }
+    };
+    check_mic_to_HP.set_value(mic_to_HP_enabled);
+
+    check_rxactive.on_select = [this](Checkbox&, bool v) {
+        //		vumeter.set_value(0);	//Start with a clean vumeter
+        rx_enabled = v;
+        check_mic_to_HP.hidden(rx_enabled);  // Toggle Hide / show "Hear Mic" checkbox depending if we activate or not the receiver. (if RX on => no visible "Mic Hear" option)
+        if ((rx_enabled) && (transmitting))
+            check_mic_to_HP.set_value(transmitting);  // Once we activate the "Rx audio" in reception time we disable "Hear Mic", but we allow it again in TX time.
+
+        if (rx_enabled)
+            check_va.set_value(false);  // Disallow voice activation during RX audio (for now) - Future TODO: Should allow VOX during RX audio
+
+        rxaudio(v);   // Activate-Deactivate audio RX (receiver) accordingly
+        set_dirty();  // Refresh interface
+    };
+    check_rxactive.set_value(rx_enabled);
 
     tx_button.on_select = [this](Button&) {
-        if (ptt_enabled && !transmitting) {
+        if (!transmitting) {
             set_tx(true);
         }
     };
 
     tx_button.on_touch_release = [this](Button&) {
-        if (button_touch) {
-            button_touch = false;
-            set_tx(false);
-        }
+        button_touch = false;
     };
 
     tx_button.on_touch_press = [this](Button&) {
-        if (!transmitting) {
-            button_touch = true;
-        }
+        button_touch = true;
     };
 
+    field_va_level.on_change = [this](int32_t v) {
+        va_level = v;
+        vumeter.set_mark(v);
+    };
+    field_va_level.set_value(va_level);
+
+    field_va_attack.set_value(attack_ms);
+    field_va_attack.on_change = [this](int32_t v) {
+        attack_ms = v;
+    };
+
+    field_va_decay.set_value(decay_ms);
+    field_va_decay.on_change = [this](int32_t v) {
+        decay_ms = v;
+    };
+
+    check_va.on_select = [this](Checkbox&, bool v) {
+        va_enabled = v;
+        if (va_enabled)
+            check_rxactive.set_value(false);  // Disallow RX-audio in VOX mode (for now) - Future TODO: Should allow VOX during RX audio
+    };
+    check_va.set_value(va_enabled);
+
     // These shouldn't be necessary, but because
     // this app uses both transmitter_model and directly
     // configures the baseband, these end up being required.
@@ -598,7 +572,12 @@ MicTXView::MicTXView(
     set_tx(false);
 
     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.
+    audio::input::start(ak4951_alc_and_wm8731_boost_GUI, mic_to_HP_enabled);  // set up ALC mode (AK4951) or set up mic_boost ON/OFF (WM8731). and the check box "Hear Mic"
+
+    // Workaround for bad RX reception when app first started -- shouldn't be necessary:
+    // Trigger receiver to update modulation.
+    if (rx_enabled)
+        receiver_model.set_squelch_level(receiver_model.squelch_level());
 }
 
 MicTXView::MicTXView(
@@ -607,16 +586,15 @@ MicTXView::MicTXView(
     : MicTXView(nav) {
     // Try to use the modulation/bandwidth from RX settings.
     // TODO: These concepts should be merged so there's only one.
-    // TODO: enums/constants for these indexes.
     switch (override.mode) {
         case ReceiverModel::Mode::AMAudio:
-            options_mode.set_selected_index(2);
+            options_mode.set_selected_index(MIC_MOD_AM);
             break;
         case ReceiverModel::Mode::NarrowbandFMAudio:
-            options_mode.set_selected_index(0);
+            options_mode.set_selected_index(MIC_MOD_NFM);
             break;
         case ReceiverModel::Mode::WidebandFMAudio:
-            options_mode.set_selected_index(1);
+            options_mode.set_selected_index(MIC_MOD_WFM);
             break;
 
         // Unsupported modulations.
@@ -626,6 +604,8 @@ MicTXView::MicTXView(
             break;
     }
 
+    check_common_freq_tx_rx.set_value(true);  // freq passed from other app is in tx_frequency, so set rx_frequency=tx_frequency
+
     // TODO: bandwidth selection is tied too tightly to the UI
     // controls. It's not possible to set the bandwidth here without
     // refactoring. Also options_mode seems to have a category error.
@@ -633,10 +613,12 @@ MicTXView::MicTXView(
 
 MicTXView::~MicTXView() {
     audio::input::stop();
-    transmitter_model.set_target_frequency(tx_frequency);  // Save Tx frequency instead of Rx. Or maybe we need some "System Wide" changes to seperate Tx and Rx frequency.
-    transmitter_model.disable();
-    if (rx_enabled)  // Also turn off audio rx if enabled
+    if (rx_enabled) {  // Also turn off both (audio rx if enabled, and disable  mic_loop to HP)
         rxaudio(false);
+        audio::input::loopback_mic_to_hp_disable();  // Leave Mic audio off in the main menu (as original audio path, otherwise we had No audio in next "Audio App")
+    }
+    transmitter_model.set_target_frequency(tx_frequency);  // Set tx_frequency here to be saved in app_settings (might not match rx_frequency)
+    transmitter_model.disable();
     baseband::shutdown();
 }
 

firmware/application/apps/ui_mictx.hpp

@@ -25,9 +25,6 @@
 #ifndef __UI_MICTX_H__
 #define __UI_MICTX_H__
 
-#define SHORT_UI true
-#define NORMAL_UI false
-
 #include "app_settings.hpp"
 #include "radio_state.hpp"
 #include "ui.hpp"
@@ -73,66 +70,85 @@ class MicTXView : public View {
     static constexpr uint32_t lcd_frame_duration = (256 * 1000UL) / 60;  // 1 frame @ 60fps in ms .8 fixed point  /60
 
     void update_vumeter();
+    bool tx_button_held();
     void do_timing();
     void set_tx(bool enable);
-    //	void on_target_frequency_changed(rf::Frequency f);
     void on_tx_progress(const bool done);
+    void update_tx_icon();
+    uint8_t shift_bits(void);
     void configure_baseband();
-
+    void set_rxbw_options(void);
+    void set_rxbw_defaults(bool use_app_settings);
+    void update_receiver_rxbw(void);
     void rxaudio(bool is_on);
 
-    void set_ptt_visibility(bool v);
-
     RxRadioState rx_radio_state_{};
     TxRadioState tx_radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         sampling_rate /* sampling rate */
     };
-    app_settings::SettingsManager settings_{
-        "tx_mic", app_settings::Mode::RX_TX,
-        app_settings::Options::UseGlobalTargetFrequency};
 
-    bool transmitting{false};
+    enum Mic_Modulation : uint32_t {
+        MIC_MOD_NFM = 0,
+        MIC_MOD_WFM = 1,
+        MIC_MOD_AM = 2,
+        MIC_MOD_USB = 3,
+        MIC_MOD_LSB = 4,
+        MIC_MOD_DSB = 5,
+    };
+
+    // Settings
+    uint32_t mic_mod_index{0};
+    uint32_t rxbw_index{0};
     bool va_enabled{false};
-    bool ptt_enabled{true};
     bool rogerbeep_enabled{false};
+    bool mic_to_HP_enabled{false};
     bool bool_same_F_tx_rx_enabled{false};
+    rf::Frequency rx_frequency{0};
     bool rx_enabled{false};
-    uint32_t tone_key_index{};
-    float mic_gain{1.0};
+    uint32_t tone_key_index{0};
+    uint32_t mic_gain_x10{1};
     uint8_t ak4951_alc_and_wm8731_boost_GUI{0};
+    uint32_t va_level{40};
+    uint32_t attack_ms{500};
+    uint32_t decay_ms{1000};
+    app_settings::SettingsManager settings_{
+        "tx_mic",
+        app_settings::Mode::RX_TX,
+        app_settings::Options::UseGlobalTargetFrequency,
+        {
+            {"mic_mod_index"sv, &mic_mod_index},
+            {"rxbw_index"sv, &rxbw_index},
+            {"same_F_tx_rx"sv, &bool_same_F_tx_rx_enabled},
+            {"mic_rx_frequency"sv, &rx_frequency},
+            {"rx_enabled"sv, &rx_enabled},
+            {"mic_gain_x10"sv, &mic_gain_x10},
+            {"mic_to_HP"sv, &mic_to_HP_enabled},
+            {"alc_and_boost"sv, &ak4951_alc_and_wm8731_boost_GUI},
+            {"va_level"sv, &va_level},
+            {"attack_ms"sv, &attack_ms},
+            {"decay_ms"sv, &decay_ms},
+            {"vox"sv, &va_enabled},
+            {"rogerbeep"sv, &rogerbeep_enabled},
+            {"tone_key_index"sv, &tone_key_index},
+        }};
+
+    rf::Frequency tx_frequency{0};
+    bool transmitting{false};
     uint32_t audio_level{0};
-    uint32_t va_level{};
-    uint32_t attack_ms{};
-    uint32_t decay_ms{};
     uint32_t attack_timer{0};
     uint32_t decay_timer{0};
     int32_t tx_gain{47};
     bool rf_amp{false};
-    int32_t rx_lna{32};
-    int32_t rx_vga{32};
-    bool rx_amp{false};
-    rf::Frequency tx_frequency{0};
-    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
-    // TODO: Some of this stuff is mutually exclusive. Need a better representation.
-    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_WM8731{
+    Labels labels_both{
         {{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}, "FM TXBW:    kHz", Color::light_grey()},  // to be more symetric and consistent to the below FM RXBW
         {{18 * 8, (5 * 8)}, "Mode:", Color::light_grey()},          // now, no need to handle GAIN, Amp here It is handled by ui_transmitter.cpp
-        {{3 * 8, 8 * 8}, "TX Activation:", Color::light_grey()},    // we delete  { { 3 * 8, 5 * 8 }, "GAIN:", Color::light_grey() },
         {{4 * 8, 10 * 8}, "LVL:", Color::light_grey()},             // we delete  { {11 * 8, 5 * 8 }, "Amp:", Color::light_grey() },
         {{12 * 8, 10 * 8}, "ATT:", Color::light_grey()},
         {{20 * 8, 10 * 8}, "DEC:", Color::light_grey()},
@@ -145,25 +161,10 @@ class MicTXView : public View {
         {{5 * 8, (27 * 8) + 2}, "LNA:", Color::light_grey()},
         {{12 * 8, (27 * 8) + 2}, "VGA:", Color::light_grey()},
         {{19 * 8, (27 * 8) + 2}, "AMP:", Color::light_grey()}};
+    Labels labels_WM8731{
+        {{17 * 8, 1 * 8}, "Boost", 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()},
-        {{18 * 8, (5 * 8)}, "Mode:", Color::light_grey()},        // now, no need to handle GAIN, Amp here It is handled by ui_transmitter.cpp
-        {{3 * 8, 8 * 8}, "TX Activation:", Color::light_grey()},  // we delete  { { 3 * 8, 5 * 8 }, "GAIN:", Color::light_grey() },
-        {{4 * 8, 10 * 8}, "LVL:", Color::light_grey()},           // we delete  { {11 * 8, 5 * 8 }, "Amp:", Color::light_grey() },
-        {{12 * 8, 10 * 8}, "ATT:", Color::light_grey()},
-        {{20 * 8, 10 * 8}, "DEC:", Color::light_grey()},
-        {{3 * 8, (13 * 8) - 5}, "TONE KEY:", Color::light_grey()},
-        {{3 * 8, (18 * 8) - 1}, "======== Receiver ========", Color::green()},
-        {{(5 * 8), (23 * 8) + 2}, "VOL:", Color::light_grey()},
-        {{14 * 8, (23 * 8) + 2}, "RXBW:", Color::light_grey()},  // we remove the label "FM" because we will display all MOD types RX_BW.
-        {{20 * 8, (25 * 8) + 2}, "SQ:", Color::light_grey()},
-        {{5 * 8, (25 * 8) + 2}, "F_RX:", Color::light_grey()},
-        {{5 * 8, (27 * 8) + 2}, "LNA:", Color::light_grey()},
-        {{12 * 8, (27 * 8) + 2}, "VGA:", Color::light_grey()},
-        {{19 * 8, (27 * 8) + 2}, "AMP:", Color::light_grey()}};
+        {{17 * 8, 1 * 8}, "ALC", Color::light_grey()}};
 
     VuMeter vumeter{
         {0 * 8, 1 * 8, 2 * 8, 33 * 8},
@@ -219,37 +220,26 @@ class MicTXView : public View {
         ' '};
 
     TransmitterView2 tx_view{
-        // new handling of NumberField field_rfgain, NumberField field_rfamp
-        //	3*8, 2*8, SHORT_UI					// x(columns), y (line) position. (used in Replay / GPS Simul / Playlist App's)
-        3 * 8, 2 * 8, NORMAL_UI  // x(columns), y (line) position. (used in Mic App)
-    };
+        {3 * 8, 5 * 8},
+        /*short_ui*/ false};
 
     OptionsField options_mode{
         {24 * 8, 5 * 8},
         6,
         {
-            {"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).
+            {"NFM/FM", MIC_MOD_NFM},
+            {" WFM  ", MIC_MOD_WFM},
+            {"  AM  ", MIC_MOD_AM},  // in fact that TX mode = AM -DSB with carrier.
+            {" USB  ", MIC_MOD_USB},
+            {" LSB  ", MIC_MOD_LSB},
+            {"DSB-SC", MIC_MOD_DSB}  // We are TX Double Side AM Band with suppressed carrier, and allowing in RX both indep SSB lateral band (USB/LSB).
         }};
-    /*
-        Checkbox check_va {
-                { 3 * 8, (10 * 8) - 4 },
-                7,
-                "Voice activation",
-                false
-        };
-        */
 
-    OptionsField field_va{
-        {17 * 8, 8 * 8},
-        4,
-        {{" OFF", 0},
-         {" PTT", 1},
-         {"AUTO", 2}}};
+    Checkbox check_va{
+        {3 * 8, 8 * 7},
+        10,
+        "VOX enable",
+        false};
 
     NumberField field_va_level{
         {8 * 8, 10 * 8},
@@ -281,6 +271,12 @@ class MicTXView : public View {
         "Roger beep",
         false};
 
+    Checkbox check_mic_to_HP{
+        {18 * 8, (14 * 8) + 4},
+        10,
+        "Hear Mic",
+        false};
+
     Checkbox check_rxactive{
         {3 * 8, (21 * 8) - 7},
         8,  // it was 18, but if it is string size should be 8
@@ -290,7 +286,7 @@ class MicTXView : public View {
     Checkbox check_common_freq_tx_rx{
         {18 * 8, (21 * 8) - 7},
         8,
-        "F  TX=RX",
+        "F  RX=TX",
         false};
 
     AudioVolumeField field_volume{
@@ -344,9 +340,15 @@ class MicTXView : public View {
 
     Button tx_button{
         {10 * 8, 30 * 8, 10 * 8, 5 * 8},
-        "TX",
+        "PTT TX",
         true};
 
+    Image tx_icon{
+        {6 * 8, 31 * 8 + 4, 16, 16},
+        &bitmap_icon_microphone,
+        Color::black(),
+        Color::black()};
+
     MessageHandlerRegistration message_handler_lcd_sync{
         Message::ID::DisplayFrameSync,
         [this](const Message* const) {

firmware/application/apps/ui_modemsetup.cpp

@@ -23,7 +23,6 @@
 #include "ui_modemsetup.hpp"
 
 #include "portapack.hpp"
-
 #include "portapack_persistent_memory.hpp"
 
 using namespace portapack;
@@ -41,15 +40,20 @@ ModemSetupView::ModemSetupView(
     using options_t = std::vector<option_t>;
     options_t modem_options;
 
-    add_children({&labels,
-                  &field_baudrate,
-                  &field_mark,
-                  &field_space,
-                  &field_repeat,
-                  &options_modem,
-                  &button_set_modem,
-                  &sym_format,
-                  &button_save});
+    add_children({
+        &labels,
+        &field_baudrate,
+        &field_mark,
+        &field_space,
+        &field_repeat,
+        &options_modem,
+        &button_set_modem,
+        &sym_format_data,
+        &sym_format_parity,
+        &sym_format_stop,
+        &sym_format_msb,
+        &button_save,
+    });
 
     // Only list AFSK modems for now
     for (size_t i = 0; i < MODEM_DEF_COUNT; i++) {
@@ -59,15 +63,10 @@ ModemSetupView::ModemSetupView(
     options_modem.set_options(modem_options);
     options_modem.set_selected_index(0);
 
-    sym_format.set_symbol_list(0, "6789");  // Data bits
-    sym_format.set_symbol_list(1, "NEo");   // Parity
-    sym_format.set_symbol_list(2, "012");   // Stop bits
-    sym_format.set_symbol_list(3, "ML");    // MSB/LSB first
-
-    sym_format.set_sym(0, persistent_memory::serial_format().data_bits - 6);
-    sym_format.set_sym(1, persistent_memory::serial_format().parity);
-    sym_format.set_sym(2, persistent_memory::serial_format().stop_bits);
-    sym_format.set_sym(3, persistent_memory::serial_format().bit_order);
+    sym_format_data.set_offset(0, persistent_memory::serial_format().data_bits - 6);
+    sym_format_parity.set_offset(0, persistent_memory::serial_format().parity);
+    sym_format_stop.set_offset(0, persistent_memory::serial_format().stop_bits);
+    sym_format_msb.set_offset(0, persistent_memory::serial_format().bit_order);
 
     field_mark.set_value(persistent_memory::afsk_mark_freq());
     field_space.set_value(persistent_memory::afsk_space_freq());
@@ -84,18 +83,17 @@ ModemSetupView::ModemSetupView(
     };
 
     button_save.on_select = [this, &nav](Button&) {
-        serial_format_t serial_format;
-
         persistent_memory::set_afsk_mark(field_mark.value());
         persistent_memory::set_afsk_space(field_space.value());
 
         persistent_memory::set_modem_baudrate(field_baudrate.value());
         persistent_memory::set_modem_repeat(field_repeat.value());
 
-        serial_format.data_bits = sym_format.get_sym(0) + 6;
-        serial_format.parity = (parity_enum)sym_format.get_sym(1);
-        serial_format.stop_bits = sym_format.get_sym(2);
-        serial_format.bit_order = (order_enum)sym_format.get_sym(3);
+        serial_format_t serial_format{};
+        serial_format.data_bits = sym_format_data.get_offset(0) + 6;
+        serial_format.parity = (parity_enum)sym_format_parity.get_offset(0);
+        serial_format.stop_bits = sym_format_stop.get_offset(0);
+        serial_format.bit_order = (order_enum)sym_format_msb.get_offset(0);
 
         persistent_memory::set_serial_format(serial_format);
 

firmware/application/apps/ui_modemsetup.hpp

@@ -79,10 +79,25 @@ class ModemSetupView : public View {
         7,
         {}};
 
-    SymField sym_format{
+    SymField sym_format_data{
         {16 * 8, 22 * 8},
-        4,
-        SymField::SYMFIELD_DEF};
+        1,
+        "6789"};
+
+    SymField sym_format_parity{
+        {17 * 8, 22 * 8},
+        1,
+        "NEo"};
+
+    SymField sym_format_stop{
+        {18 * 8, 22 * 8},
+        1,
+        "012"};
+
+    SymField sym_format_msb{
+        {19 * 8, 22 * 8},
+        1,
+        "ML"};
 
     Button button_set_modem{
         {23 * 8, 6 * 8 - 4, 6 * 8, 24},

firmware/application/apps/ui_morse.cpp

@@ -56,13 +56,23 @@ 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_og_tx.write(v);
+        if (hackrf_r9) {           // r9 has a common PIN 54 for MODE CONTROL TX / RX,  <=r6 has two independent MODE CONTROL pins (TX and RX)
+            gpio_r9_rx.write(!v);  // in hackrf r9 opposite logic "0" means tx , "1" rx = no tx)
+        } else {
+            gpio_og_tx.write(v);  // in hackrf <=r6, "1" means tx , "0" no tx.
+        }
+
         arg_c->on_tx_progress(i, false);
 
         chThdSleepMilliseconds(delay * arg_c->time_unit_ms);
     }
 
-    gpio_og_tx.write(0);  // Ensure TX is off
+    if (hackrf_r9) {          // r9 has a common PIN 54 for MODE CONTROL TX / RX,  <=r6 has two independent MODE CONTROL pins (TX and RX)
+        gpio_r9_rx.write(1);  // Hackrf_r9 , common pin,  rx="1" (we ensure TX is off)  / tx="0"
+    } else {
+        gpio_og_tx.write(0);  // Hackrf <=r6 independent TX / RX  pins ,now touching the tx pin ==> Ensure TX is off
+    }
+
     arg_c->on_tx_progress(0, true);
     chThdExit(0);
 
@@ -117,12 +127,14 @@ bool MorseView::start_tx() {
     }
 
     progressbar.set_max(symbol_count);
+    // By experimental spectrum measurment, we left exactly same TX LPF settings as previous fw 1.7.4,  TX LPF= 1M75 (min).
+    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF .already tested in FM morse max tone 9,999k , max dev 150khz
     transmitter_model.enable();
 
-    if (modulation == CW) {
+    baseband::set_tones_config(transmitter_model.channel_bandwidth(), 0, symbol_count, false, false);
+
+    if (mode_cw) {
         ookthread = chThdCreateStatic(ookthread_wa, sizeof(ookthread_wa), NORMALPRIO + 10, ookthread_fn, this);
-    } else if (modulation == FM) {
-        baseband::set_tones_config(transmitter_model.channel_bandwidth(), 0, symbol_count, false, false);
     }
 
     return true;
@@ -131,8 +143,8 @@ bool MorseView::start_tx() {
 void MorseView::update_tx_duration() {
     uint32_t duration_ms;
 
-    time_unit_ms = 1200 / field_speed.value();
-    symbol_count = morse_encode(message, time_unit_ms, field_tone.value(), &time_units);
+    time_unit_ms = 1200 / speed;
+    symbol_count = morse_encode(message, time_unit_ms, tone, &time_units);
 
     if (symbol_count) {
         duration_ms = time_units * time_unit_ms;
@@ -173,7 +185,7 @@ void MorseView::on_loop_progress(const uint32_t progress, const bool done) {
 }
 
 void MorseView::set_foxhunt(size_t i) {
-    message = foxhunt_codes[i];
+    message = foxhunt_codes[i - 1];
     buffer = message.c_str();
     text_message.set(message);
     update_tx_duration();
@@ -186,7 +198,7 @@ MorseView::MorseView(
 
     add_children({&labels,
                   &checkbox_foxhunt,
-                  &options_foxhunt,
+                  &field_foxhunt,
                   &field_speed,
                   &field_tone,
                   &options_modulation,
@@ -198,36 +210,46 @@ MorseView::MorseView(
                   &tx_view});
 
     // Default settings
-    field_speed.set_value(15);                 // 15wps
-    field_tone.set_value(700);                 // 700Hz FM tone
-    options_modulation.set_selected_index(0);  // CW mode
-    options_loop.set_selected_index(0);        // Off
+    field_speed.set_value(speed);
+    field_tone.set_value(tone);
+    options_modulation.set_by_value(mode_cw);
+    options_loop.set_by_value(loop);
+    checkbox_foxhunt.set_value(foxhunt_mode);
+    field_foxhunt.set_value(foxhunt_code);
 
     checkbox_foxhunt.on_select = [this](Checkbox&, bool value) {
         foxhunt_mode = value;
 
         if (foxhunt_mode)
-            set_foxhunt(options_foxhunt.selected_index_value());
+            set_foxhunt(foxhunt_code);
     };
 
-    options_foxhunt.on_change = [this](size_t i, int32_t) {
+    field_foxhunt.on_change = [this](int32_t value) {
+        foxhunt_code = value;
+
         if (foxhunt_mode)
-            set_foxhunt(i);
+            set_foxhunt(foxhunt_code);
     };
 
-    options_modulation.on_change = [this](size_t i, int32_t) {
-        modulation = (modulation_t)i;
-    };
-
-    options_loop.on_change = [this](size_t i, uint32_t n) {
+    options_modulation.on_change = [this](size_t i, int32_t value) {
         (void)i;  // avoid unused warning
-        loop = n;
+        mode_cw = (bool)value;
     };
 
-    field_speed.on_change = [this](int32_t) {
+    options_loop.on_change = [this](size_t i, uint32_t value) {
+        (void)i;  // avoid unused warning
+        loop = value;
+    };
+
+    field_speed.on_change = [this](int32_t value) {
+        speed = value;
         update_tx_duration();
     };
 
+    field_tone.on_change = [this](int32_t value) {
+        tone = value;
+    };
+
     button_message.on_select = [this, &nav](Button&) {
         this->on_set_text(nav);
     };

firmware/application/apps/ui_morse.hpp

@@ -65,22 +65,33 @@ class MorseView : public View {
 
    private:
     NavigationView& nav_;
-    std::string buffer{"PORTAPACK"};
     std::string message{};
     uint32_t time_units{0};
 
     TxRadioState radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         1536000 /* sampling rate */
     };
-    app_settings::SettingsManager settings_{
-        "tx_morse", app_settings::Mode::TX};
 
-    enum modulation_t {
-        CW = 0,
-        FM = 1
-    };
-    modulation_t modulation{CW};
+    std::string buffer{"PORTAPACK"};
+    bool mode_cw{true};
+    bool foxhunt_mode{false};
+    uint32_t foxhunt_code{1};
+    uint32_t speed{15};
+    uint32_t tone{700};
+    app_settings::SettingsManager settings_{
+        "tx_morse",
+        app_settings::Mode::TX,
+        {
+            {"message"sv, &buffer},
+            {"foxhunt"sv, &foxhunt_mode},
+            {"foxhunt_code"sv, &foxhunt_code},
+            {"speed"sv, &speed},
+            {"tone"sv, &tone},
+            {"mode_cw"sv, &mode_cw},
+            {"loop"sv, &loop},
+        }};
 
     bool start_tx();
     void update_tx_duration();
@@ -89,7 +100,6 @@ class MorseView : public View {
 
     Thread* ookthread{nullptr};
     Thread* loopthread{nullptr};
-    bool foxhunt_mode{false};
     bool run{false};
 
     Labels labels{
@@ -103,20 +113,12 @@ class MorseView : public View {
         {4 * 8, 16},
         8,
         "Foxhunt:"};
-    OptionsField options_foxhunt{
+    NumberField field_foxhunt{
         {17 * 8, 16 + 4},
-        7,
-        {{"1 (MOE)", 0},
-         {"2 (MOI)", 1},
-         {"3 (MOS)", 2},
-         {"4 (MOH)", 3},
-         {"5 (MO5)", 4},
-         {"6 (MON)", 5},
-         {"7 (MOD)", 6},
-         {"8 (MOB)", 7},
-         {"9 (MO6)", 8},
-         {"X (MO) ", 9},
-         {"T (S) ", 10}}};
+        2,
+        {1, 11},
+        1,
+        ' '};
 
     NumberField field_speed{
         {10 * 8, 6 * 8},
@@ -135,8 +137,8 @@ class MorseView : public View {
     OptionsField options_modulation{
         {15 * 8, 10 * 8},
         2,
-        {{"CW", 0},
-         {"FM", 1}}};
+        {{"CW", true},
+         {"FM", false}}};
 
     OptionsField options_loop{
         {9 * 8, 12 * 8},

firmware/application/apps/ui_numbers.cpp

@@ -21,6 +21,7 @@
  */
 
 #include "ui_numbers.hpp"
+#include "ui_styles.hpp"
 #include "string_format.hpp"
 
 #include "portapack.hpp"
@@ -38,7 +39,7 @@ namespace ui {
 
 void NumbersStationView::focus() {
     if (file_error)
-        nav_.display_modal("No voices", "No valid voices found in\nthe /numbers directory.", ABORT, nullptr);
+        nav_.display_modal("No voices", "No valid voices found in\nthe /numbers directory.", ABORT);
     else
         button_exit.focus();
 }
@@ -75,7 +76,7 @@ void NumbersStationView::prepare_audio() {
                 return;
             }
 
-            code = symfield_code.get_sym(code_index);
+            code = symfield_code.get_offset(code_index);
 
             if (code >= 10) {
                 memset(audio_buffer, 0, 1024);
@@ -144,7 +145,7 @@ void NumbersStationView::on_tick_second() {
     armed_blink = not armed_blink;
 
     if (armed_blink)
-        check_armed.set_style(&style_red);
+        check_armed.set_style(&Styles::red);
     else
         check_armed.set_style(&style());
 
@@ -152,14 +153,12 @@ void NumbersStationView::on_tick_second() {
 }
 
 void NumbersStationView::on_voice_changed(size_t index) {
-    std::string code_list = "";
+    std::string code_list;
 
     for (const auto& wavs : voices[index].available_wavs)
         code_list += wavs.code;
 
-    for (uint32_t c = 0; c < 25; c++)
-        symfield_code.set_symbol_list(c, code_list);
-
+    symfield_code.set_symbol_list(code_list);
     current_voice = &voices[index];
 }
 
@@ -265,17 +264,17 @@ NumbersStationView::NumbersStationView(
     };
 
     // DEBUG
-    symfield_code.set_sym(0, 10);
-    symfield_code.set_sym(1, 3);
-    symfield_code.set_sym(2, 4);
-    symfield_code.set_sym(3, 11);
-    symfield_code.set_sym(4, 6);
-    symfield_code.set_sym(5, 1);
-    symfield_code.set_sym(6, 9);
-    symfield_code.set_sym(7, 7);
-    symfield_code.set_sym(8, 8);
-    symfield_code.set_sym(9, 0);
-    symfield_code.set_sym(10, 12);  // End
+    symfield_code.set_offset(0, 10);
+    symfield_code.set_offset(1, 3);
+    symfield_code.set_offset(2, 4);
+    symfield_code.set_offset(3, 11);
+    symfield_code.set_offset(4, 6);
+    symfield_code.set_offset(5, 1);
+    symfield_code.set_offset(6, 9);
+    symfield_code.set_offset(7, 7);
+    symfield_code.set_offset(8, 8);
+    symfield_code.set_offset(9, 0);
+    symfield_code.set_offset(10, 12);  // End
 
     /*
         rtc::RTC datetime;

firmware/application/apps/ui_numbers.hpp

@@ -56,6 +56,7 @@ class NumbersStationView : public View {
     NavigationView& nav_;
 
     TxRadioState radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         1536000 /* sampling rate */
     };
@@ -142,16 +143,19 @@ class NumbersStationView : public View {
     SymField symfield_code{
         {1 * 8, 10 * 8},
         25,
-        SymField::SYMFIELD_DEF};
+        SymField::Type::Custom};
 
     Checkbox check_armed{
         {2 * 8, 13 * 16},
         5,
         "Armed"};
-    /*Button button_tx_now {
-                { 18 * 8, 13 * 16, 10 * 8, 32 },
-                "TX now"
-        };*/
+
+    /*
+    Button button_tx_now {
+        { 18 * 8, 13 * 16, 10 * 8, 32 },
+        "TX now"};
+    */
+
     Button button_exit{
         {21 * 8, 16 * 16, 64, 32},
         "Exit"};

firmware/application/apps/ui_nuoptix.hpp

@@ -56,6 +56,7 @@ class NuoptixView : public View {
     };
 
     TxRadioState radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         1536000 /* sampling rate */
     };

firmware/application/apps/ui_playlist.cpp

@@ -24,18 +24,18 @@
 
 #include "ui_playlist.hpp"
 
+#include "baseband_api.hpp"
 #include "convert.hpp"
 #include "file_reader.hpp"
 #include "io_file.hpp"
 #include "io_convert.hpp"
-
+#include "oversample.hpp"
+#include "portapack.hpp"
+#include "portapack_persistent_memory.hpp"
 #include "string_format.hpp"
 #include "ui_fileman.hpp"
 #include "utility.hpp"
 
-#include "baseband_api.hpp"
-#include "portapack.hpp"
-#include "portapack_persistent_memory.hpp"
 #include <unistd.h>
 #include <fstream>
 
@@ -266,16 +266,15 @@ void PlaylistView::send_current_track() {
         return;
     }
 
-    // ReplayThread starts immediately on construction so
-    // these need to be set before creating the ReplayThread.
-    transmitter_model.set_target_frequency(current()->metadata.center_frequency);
-    transmitter_model.set_sampling_rate(current()->metadata.sample_rate * 8);
-    transmitter_model.set_baseband_bandwidth(baseband_bandwidth);
-    transmitter_model.enable();
+    // Update the sample rate in proc_replay baseband.
+    baseband::set_sample_rate(current()->metadata.sample_rate,
+                              get_oversample_rate(current()->metadata.sample_rate));
 
-    // Set baseband sample rate too for waterfall to be correct.
-    // TODO: Why doesn't the transmitter_model just handle this?
-    baseband::set_sample_rate(transmitter_model.sampling_rate());
+    // ReplayThread starts immediately on construction; must be set before creating.
+    transmitter_model.set_target_frequency(current()->metadata.center_frequency);
+    transmitter_model.set_sampling_rate(get_actual_sample_rate(current()->metadata.sample_rate));
+    transmitter_model.set_baseband_bandwidth(current()->metadata.sample_rate <= 500'000 ? 1'750'000 : 2'500'000);  // TX LPF min 1M75 for SR <=500K, and  2M5 (by experimental test) for SR >500K
+    transmitter_model.enable();
 
     // Reset the transmit progress bar.
     progressbar_transmit.set_value(0);
@@ -387,6 +386,7 @@ PlaylistView::PlaylistView(
         &waterfall,
     });
 
+    ensure_directory(u"PLAYLIST");
     waterfall.show_audio_spectrum_view(false);
 
     field_frequency.set_value(100'000'000);

firmware/application/apps/ui_playlist.hpp

@@ -21,9 +21,6 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#define SHORT_UI true
-#define NORMAL_UI false
-
 #include "app_settings.hpp"
 #include "bitmap.hpp"
 #include "file.hpp"
@@ -63,7 +60,6 @@ class PlaylistView : public View {
 
     // More header == less spectrum view.
     static constexpr ui::Dim header_height = 6 * 16;
-    static constexpr uint32_t baseband_bandwidth = 2500000;
 
     struct playlist_entry {
         std::filesystem::path path{};
@@ -118,14 +114,11 @@ class PlaylistView : public View {
     Text text_sample_rate{
         {10 * 8, 1 * 16, 7 * 8, 16}};
 
-    /*v making there's 1px line (instead of two) between two progress bars,
-     * by letting 1px overlapped.
-     * So, since they overlapped 1px, they are visually same, and looks better.
-     */
-
     ProgressBar progressbar_track{
         {18 * 8, 1 * 16, 12 * 8, 8 + 1}};
 
+    // (-1) to overlap with progressbar_track so there's
+    // only 1 pixel between them instead of 2.
     ProgressBar progressbar_transmit{
         {18 * 8, 3 * 8 - 1, 12 * 8, 8}};
 
@@ -135,7 +128,8 @@ class PlaylistView : public View {
     // TODO: delay duration field.
 
     TransmitterView2 tx_view{
-        9 * 8, 1 * 8, SHORT_UI};
+        {11 * 8, 2 * 16},
+        /*short_ui*/ true};
 
     Checkbox check_loop{
         {21 * 8, 2 * 16},

firmware/application/apps/ui_pocsag_tx.cpp

@@ -56,7 +56,7 @@ bool POCSAGTXView::start_tx() {
     pocsag::BitRate bitrate;
     std::vector<uint32_t> codewords;
 
-    address = field_address.value_dec_u32();
+    address = field_address.to_integer();
     if (address > 0x1FFFFFU) {
         nav_.display_modal("Bad address", "Address must be less\nthan 2097152.");
         return false;
@@ -81,6 +81,8 @@ bool POCSAGTXView::start_tx() {
 
     transmitter_model.set_rf_amp(true);
     transmitter_model.set_tx_gain(40);
+    // We left exactly same TX LPF settings as previous fw 1.7.4,  TX LPF= 1M75 (min). It is fine even in max FM dev. 150khz and 2400 bauds.
+    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF . Pocsag is NBFM , using BW channel 25khz or 12khz
     transmitter_model.enable();
 
     uint8_t* data_ptr = shared_memory.bb_data.data;
@@ -137,12 +139,7 @@ POCSAGTXView::POCSAGTXView(
     options_bitrate.set_selected_index(1);  // 1200bps
     options_type.set_selected_index(0);     // Address only
 
-    // TODO: set_value for whole symfield
-    uint32_t reload_address = persistent_memory::pocsag_last_address();
-    for (uint32_t c = 0; c < 7; c++) {
-        field_address.set_sym(6 - c, reload_address % 10);
-        reload_address /= 10;
-    }
+    field_address.set_value(persistent_memory::pocsag_last_address());
 
     options_type.on_change = [this](size_t, int32_t i) {
         if (i == 2)

firmware/application/apps/ui_pocsag_tx.hpp

@@ -60,6 +60,7 @@ class POCSAGTXView : public View {
     NavigationView& nav_;
 
     TxRadioState radio_state_{
+        466175000 /* frequency */,
         1750000 /* bandwidth */,
         2280000 /* sampling rate */
     };
@@ -94,8 +95,7 @@ class POCSAGTXView : public View {
 
     SymField field_address{
         {11 * 8, 6 * 8},
-        7,
-        SymField::SYMFIELD_DEC};
+        7};
 
     OptionsField options_type{
         {11 * 8, 8 * 8},

firmware/application/apps/ui_rds.cpp

@@ -164,7 +164,7 @@ RDSView::~RDSView() {
 }
 
 void RDSView::start_tx() {
-    rds_flags.PI_code = sym_pi_code.value_hex_u64();
+    rds_flags.PI_code = sym_pi_code.to_integer();
     rds_flags.PTY = options_pty.selected_index_value();
     rds_flags.DI = view_PSN.mono_stereo ? 1 : 0;
     rds_flags.TP = check_TP.value();
@@ -212,12 +212,9 @@ RDSView::RDSView(
 
     check_TP.set_value(true);
 
-    sym_pi_code.set_sym(0, 0xF);
-    sym_pi_code.set_sym(1, 0x3);
-    sym_pi_code.set_sym(2, 0xE);
-    sym_pi_code.set_sym(3, 0x0);
-    sym_pi_code.on_change = [this]() {
-        rds_flags.PI_code = sym_pi_code.value_hex_u64();
+    sym_pi_code.set_value(0xF3E0);
+    sym_pi_code.on_change = [this](SymField&) {
+        rds_flags.PI_code = sym_pi_code.to_integer();
     };
 
     options_pty.set_selected_index(0);  // None

firmware/application/apps/ui_rds.hpp

@@ -142,6 +142,7 @@ class RDSView : public View {
     RDS_flags rds_flags{};
 
     TxRadioState radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         2280000 /* sampling rate */
     };
@@ -287,7 +288,7 @@ class RDSView : public View {
     SymField sym_pi_code{
         {13 * 8, 28 + 16},
         4,
-        SymField::SYMFIELD_HEX};
+        SymField::Type::Hex};
 
     /*OptionsField options_coverage {
                 { 17 * 8, 32 + 8 },

firmware/application/apps/ui_recon.cpp

@@ -22,13 +22,24 @@
  */
 
 #include "ui_recon.hpp"
-#include "ui_fileman.hpp"
 #include "ui_freqman.hpp"
 #include "capture_app.hpp"
 #include "convert.hpp"
 #include "file.hpp"
 #include "file_reader.hpp"
 #include "tone_key.hpp"
+#include "replay_app.hpp"
+#include "string_format.hpp"
+#include "ui_fileman.hpp"
+#include "io_file.hpp"
+#include "io_convert.hpp"
+#include "oversample.hpp"
+#include "baseband_api.hpp"
+#include "metadata_file.hpp"
+#include "portapack.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "utility.hpp"
+#include "replay_thread.hpp"
 
 using namespace portapack;
 using namespace tonekey;
@@ -37,6 +48,46 @@ namespace fs = std::filesystem;
 
 namespace ui {
 
+void ReconView::reload_restart_recon() {
+    frequency_file_load();
+    if (frequency_list.size() > 0) {
+        if (fwd) {
+            button_dir.set_text("FW>");
+        } else {
+            button_dir.set_text("<RW");
+        }
+        recon_resume();
+    }
+    if (scanner_mode) {
+        file_name.set_style(&Styles::red);
+        button_scanner_mode.set_style(&Styles::red);
+        button_scanner_mode.set_text("SCAN");
+    } else {
+        file_name.set_style(&Styles::blue);
+        button_scanner_mode.set_style(&Styles::blue);
+        button_scanner_mode.set_text("RECON");
+    }
+    if (frequency_list.size() > FREQMAN_MAX_PER_FILE) {
+        file_name.set_style(&Styles::yellow);
+    }
+}
+
+void ReconView::check_update_ranges_from_current() {
+    if (frequency_list.size() && current_is_valid() && current_entry().type == freqman_type::Range) {
+        if (update_ranges && !manual_mode) {
+            button_manual_start.set_text(to_string_short_freq(current_entry().frequency_a));
+            frequency_range.min = current_entry().frequency_a;
+            if (current_entry().frequency_b != 0) {
+                button_manual_end.set_text(to_string_short_freq(current_entry().frequency_b));
+                frequency_range.max = current_entry().frequency_b;
+            } else {
+                button_manual_end.set_text(to_string_short_freq(current_entry().frequency_a));
+                frequency_range.max = current_entry().frequency_a;
+            }
+        }
+    }
+}
+
 bool ReconView::current_is_valid() {
     return (unsigned)current_index < frequency_list.size();
 }
@@ -59,8 +110,12 @@ void ReconView::recon_stop_recording() {
             button_audio_app.set_text("AUDIO");
         button_audio_app.set_style(&Styles::white);
         record_view->stop();
-        button_config.set_style(&Styles::white);  // disable config while recording as it's causing an IO error pop up at exit
+        button_config.set_style(&Styles::white);
         is_recording = false;
+        // repeater mode
+        if (persistent_memory::recon_repeat_recorded()) {
+            start_repeat();
+        }
     }
 }
 
@@ -87,7 +142,6 @@ void ReconView::reset_indexes() {
 void ReconView::update_description() {
     if (frequency_list.empty() || current_entry().description.empty()) {
         description = "...no description...";
-        return;
     } else {
         switch (current_entry().type) {
             case freqman_type::Range:
@@ -96,12 +150,14 @@ void ReconView::update_description() {
             case freqman_type::HamRadio:
                 description = "H: ";
                 break;
+            case freqman_type::Repeater:
+                description = "L: ";
+                break;
             default:
                 description = "S: ";
         }
         description += current_entry().description;
     }
-
     desc_cycle.set(description);
 }
 
@@ -160,67 +216,17 @@ bool ReconView::recon_save_freq(const fs::path& path, size_t freq_index, bool wa
     return true;
 }
 
-bool ReconView::recon_load_config_from_sd() {
-    make_new_directory(u"SETTINGS");
-
-    File settings_file;
-    auto error = settings_file.open(RECON_CFG_FILE);
-    if (error)
-        return false;
-
-    auto complete = false;
-    auto line_nb = 0;
-    auto reader = FileLineReader(settings_file);
-    for (const auto& line : reader) {
-        switch (line_nb) {
-            case 0:
-                input_file = trim(line);
-                break;
-            case 1:
-                output_file = trim(line);
-                break;
-            case 2:
-                parse_int(line, recon_lock_duration);
-                break;
-            case 3:
-                parse_int(line, recon_lock_nb_match);
-                break;
-            case 4:
-                parse_int(line, squelch);
-                break;
-            case 5:
-                parse_int(line, recon_match_mode);
-                break;
-            case 6:
-                parse_int(line, wait);
-                complete = true;  // NB: Last entry.
-                break;
-        }
-
-        if (complete) break;
-
-        line_nb++;
-    }
-
-    return complete;
-}
-
-bool ReconView::recon_save_config_to_sd() {
-    File settings_file;
-
-    make_new_directory(u"SETTINGS");
-
-    auto error = settings_file.create(RECON_CFG_FILE);
-    if (error)
-        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(squelch));
-    settings_file.write_line(to_string_dec_uint(recon_match_mode));
-    settings_file.write_line(to_string_dec_int(wait));
-    return true;
+void ReconView::load_persisted_settings() {
+    autostart = persistent_memory::recon_autostart_recon();
+    autosave = persistent_memory::recon_autosave_freqs();
+    continuous = persistent_memory::recon_continuous();
+    filedelete = persistent_memory::recon_clear_output();
+    load_freqs = persistent_memory::recon_load_freqs();
+    load_ranges = persistent_memory::recon_load_ranges();
+    load_hamradios = persistent_memory::recon_load_hamradios();
+    load_repeaters = persistent_memory::recon_load_repeaters();
+    update_ranges = persistent_memory::recon_update_ranges_when_recon();
+    auto_record_locked = persistent_memory::recon_auto_record_locked();
 }
 
 void ReconView::audio_output_start() {
@@ -290,19 +296,7 @@ void ReconView::handle_retune() {
         }
         if (last_index != current_index) {
             last_index = current_index;
-            if (frequency_list.size() && current_is_valid() && current_entry().type == freqman_type::Range) {
-                if (update_ranges && !manual_mode) {
-                    button_manual_start.set_text(to_string_short_freq(current_entry().frequency_a));
-                    frequency_range.min = current_entry().frequency_a;
-                    if (current_entry().frequency_b != 0) {
-                        button_manual_end.set_text(to_string_short_freq(current_entry().frequency_b));
-                        frequency_range.max = current_entry().frequency_b;
-                    } else {
-                        button_manual_end.set_text(to_string_short_freq(current_entry().frequency_a));
-                        frequency_range.max = current_entry().frequency_a;
-                    }
-                }
-            }
+            check_update_ranges_from_current();
             text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
             update_description();
         }
@@ -315,7 +309,6 @@ void ReconView::focus() {
 
 ReconView::~ReconView() {
     recon_stop_recording();
-    recon_save_config_to_sd();
     if (field_mode.selected_index_value() != SPEC_MODULATION)
         audio::output::stop();
     receiver_model.disable();
@@ -325,9 +318,20 @@ ReconView::~ReconView() {
 ReconView::ReconView(NavigationView& nav)
     : nav_{nav} {
     chrono_start = chTimeNow();
+
+    tx_view.hidden(true);
+
+    // set record View
     record_view = std::make_unique<RecordView>(Rect{0, 0, 30 * 8, 1 * 16},
-                                               u"AUTO_AUDIO_", u"AUDIO",
+                                               u"AUTO_AUDIO", u"AUDIO",
                                                RecordView::FileType::WAV, 4096, 4);
+    record_view->set_filename_date_frequency(true);
+    record_view->set_auto_trim(false);
+    record_view->hidden(true);
+    record_view->on_error = [&nav](std::string message) {
+        nav.display_modal("Error", message);
+    };
+
     add_children({&labels,
                   &field_lna,
                   &field_vga,
@@ -364,38 +368,22 @@ ReconView::ReconView(NavigationView& nav)
                   &button_restart,
                   &button_mic_app,
                   &button_remove,
-                  record_view.get()});
-
-    record_view->hidden(true);
-    record_view->set_filename_date_frequency(true);
-    record_view->on_error = [&nav](std::string message) {
-        nav.display_modal("Error", message);
-    };
+                  record_view.get(),
+                  &progressbar,
+                  &tx_view});
 
     def_step = 0;
-    // HELPER: Pre-setting a manual range, based on stored frequency
-    rf::Frequency stored_freq = receiver_model.target_frequency();
-    if (stored_freq - OneMHz > 0)
-        frequency_range.min = stored_freq - OneMHz;
-    else
-        frequency_range.min = 0;
-    button_manual_start.set_text(to_string_short_freq(frequency_range.min));
-    if (stored_freq + OneMHz < MAX_UFREQ)
-        frequency_range.max = stored_freq + OneMHz;
-    else
-        frequency_range.max = MAX_UFREQ;
-    button_manual_end.set_text(to_string_short_freq(frequency_range.max));
+    load_persisted_settings();
 
-    // Loading settings
-    autostart = persistent_memory::recon_autostart_recon();
-    autosave = persistent_memory::recon_autosave_freqs();
-    continuous = persistent_memory::recon_continuous();
-    filedelete = persistent_memory::recon_clear_output();
-    load_freqs = persistent_memory::recon_load_freqs();
-    load_ranges = persistent_memory::recon_load_ranges();
-    load_hamradios = persistent_memory::recon_load_hamradios();
-    update_ranges = persistent_memory::recon_update_ranges_when_recon();
-    auto_record_locked = persistent_memory::recon_auto_record_locked();
+    // When update_ranges is set or range invalid, use the rx model frequency instead of the saved values.
+    if (update_ranges || frequency_range.max == 0) {
+        rf::Frequency stored_freq = receiver_model.target_frequency();
+        frequency_range.min = clip<rf::Frequency>(stored_freq - OneMHz, 0, MAX_UFREQ);
+        frequency_range.max = clip<rf::Frequency>(stored_freq + OneMHz, 0, MAX_UFREQ);
+    }
+
+    button_manual_start.set_text(to_string_short_freq(frequency_range.min));
+    button_manual_end.set_text(to_string_short_freq(frequency_range.max));
 
     button_manual_start.on_select = [this, &nav](ButtonWithEncoder& button) {
         clear_freqlist_for_ui_action();
@@ -519,8 +507,7 @@ ReconView::ReconView(NavigationView& nav)
     rssi.set_focusable(true);
     rssi.set_peak(true, 500);
     rssi.on_select = [this](RSSI&) {
-        nav_.pop();
-        nav_.push<LevelView>();
+        nav_.replace<LevelView>();
     };
 
     // TODO: *BUG* Both transmitter_model and receiver_model share the same pmem setting for target_frequency.
@@ -544,10 +531,9 @@ ReconView::ReconView(NavigationView& nav)
 
     button_remove.on_select = [this](ButtonWithEncoder&) {
         handle_remove_current_item();
-
-        // TODO: refresh UI.
         timer = 0;
         freq_lock = 0;
+        recon_redraw();
     };
 
     button_remove.on_change = [this]() {
@@ -557,14 +543,20 @@ ReconView::ReconView(NavigationView& nav)
 
     button_manual_recon.on_select = [this](Button&) {
         button_remove.set_text("DELETE");
+        button_add.hidden(false);
         scanner_mode = false;
         manual_mode = true;
         recon_pause();
         if (!frequency_range.min || !frequency_range.max) {
             nav_.display_modal("Error", "Both START and END freqs\nneed a value");
-        } else if (frequency_range.min > frequency_range.max) {
-            nav_.display_modal("Error", "END freq\nis lower than START");
         } else {
+            if (frequency_range.min > frequency_range.max) {
+                std::swap(frequency_range.min, frequency_range.max);
+                button_manual_start.set_text(to_string_short_freq(frequency_range.min));
+                button_manual_end.set_text(to_string_short_freq(frequency_range.max));
+            }
+
+            // no need to stop audio in SPEC
             if (field_mode.selected_index_value() != SPEC_MODULATION)
                 audio::output::stop();
 
@@ -595,7 +587,7 @@ ReconView::ReconView(NavigationView& nav)
             button_scanner_mode.set_style(&Styles::white);
             button_scanner_mode.set_text("MANUAL");
             file_name.set_style(&Styles::white);
-            file_name.set("MANUAL RANGE RECON");
+            file_name.set("MANUAL => " + output_file);
             desc_cycle.set_style(&Styles::white);
 
             last_entry.modulation = freqman_invalid_index;
@@ -624,27 +616,7 @@ ReconView::ReconView(NavigationView& nav)
     };
 
     button_restart.on_select = [this](Button&) {
-        frequency_file_load(true);
-        if (frequency_list.size() > 0) {
-            if (fwd) {
-                button_dir.set_text("FW>");
-            } else {
-                button_dir.set_text("<RW");
-            }
-            recon_resume();
-        }
-        if (scanner_mode) {
-            file_name.set_style(&Styles::red);
-            button_scanner_mode.set_style(&Styles::red);
-            button_scanner_mode.set_text("SCAN");
-        } else {
-            file_name.set_style(&Styles::blue);
-            button_scanner_mode.set_style(&Styles::blue);
-            button_scanner_mode.set_text("RECON");
-        }
-        if (frequency_list.size() > FREQMAN_MAX_PER_FILE) {
-            file_name.set_style(&Styles::yellow);
-        }
+        reload_restart_recon();
     };
 
     button_add.on_select = [this](ButtonWithEncoder&) {
@@ -664,25 +636,30 @@ ReconView::ReconView(NavigationView& nav)
             scanner_mode = false;
             button_scanner_mode.set_style(&Styles::blue);
             button_scanner_mode.set_text("RECON");
-            button_remove.set_text("DELETE");
+            button_remove.set_text("REMOVE");
         } else {
             scanner_mode = true;
             button_scanner_mode.set_style(&Styles::red);
             button_scanner_mode.set_text("SCAN");
-            button_scanner_mode.set_text("REMOVE");
+            button_remove.set_text("DELETE");
         }
-        frequency_file_load(true);
+        frequency_file_load();
         if (autostart) {
             recon_resume();
         } else {
             recon_pause();
         }
+        button_add.hidden(scanner_mode);
+        if (scanner_mode)  // only needed when hiding, UI mayhem
+            set_dirty();
     };
 
     button_config.on_select = [this, &nav](Button&) {
         if (is_recording)  // disabling config while recording
             return;
+
         clear_freqlist_for_ui_action();
+
         freq_lock = 0;
         timer = 0;
         auto open_view = nav.push<ReconSetupView>(input_file, output_file);
@@ -690,18 +667,11 @@ ReconView::ReconView(NavigationView& nav)
             input_file = result[0];
             output_file = result[1];
             freq_file_path = get_freqman_path(output_file).string();
-            recon_save_config_to_sd();
 
-            autosave = persistent_memory::recon_autosave_freqs();
-            autostart = persistent_memory::recon_autostart_recon();
-            filedelete = persistent_memory::recon_clear_output();
-            load_freqs = persistent_memory::recon_load_freqs();
-            load_ranges = persistent_memory::recon_load_ranges();
-            load_hamradios = persistent_memory::recon_load_hamradios();
-            update_ranges = persistent_memory::recon_update_ranges_when_recon();
-            auto_record_locked = persistent_memory::recon_auto_record_locked();
+            load_persisted_settings();
+            ui_settings.save();
 
-            frequency_file_load(false);
+            frequency_file_load();
             freqlist_cleared_for_ui_action = false;
 
             if (autostart) {
@@ -747,7 +717,6 @@ ReconView::ReconView(NavigationView& nav)
     file_name.set("=>");
 
     // Loading input and output file from settings
-    recon_load_config_from_sd();
     freq_file_path = get_freqman_path(output_file).string();
 
     field_recon_match_mode.set_selected_index(recon_match_mode);
@@ -765,11 +734,14 @@ ReconView::ReconView(NavigationView& nav)
     change_mode(AM_MODULATION);              // start on AM.
     field_mode.set_by_value(AM_MODULATION);  // reflect the mode into the manual selector
 
+    // tx progress bar
+    progressbar.hidden(true);
+
     if (filedelete) {
         delete_file(freq_file_path);
     }
 
-    frequency_file_load(false); /* do not stop all at start */
+    frequency_file_load(); /* do not stop all at start */
     if (autostart) {
         recon_resume();
     } else {
@@ -778,7 +750,7 @@ ReconView::ReconView(NavigationView& nav)
     recon_redraw();
 }
 
-void ReconView::frequency_file_load(bool) {
+void ReconView::frequency_file_load() {
     if (field_mode.selected_index_value() != SPEC_MODULATION)
         audio::output::stop();
 
@@ -797,30 +769,23 @@ void ReconView::frequency_file_load(bool) {
         button_scanner_mode.set_text("RECON");
     }
 
+    file_name.set(file_input + "=>" + output_file);
+
     freqman_load_options options{
         .load_freqs = load_freqs,
         .load_ranges = load_ranges,
-        .load_hamradios = load_hamradios};
-    if (!load_freqman_file(file_input, frequency_list, options)) {
+        .load_hamradios = load_hamradios,
+        .load_repeaters = load_repeaters};
+    if (!load_freqman_file(file_input, frequency_list, options) || frequency_list.empty()) {
         file_name.set_style(&Styles::red);
-        desc_cycle.set(" NO " + file_input + ".TXT FILE ...");
-        file_name.set("=> NO DATA");
-    } else {
-        file_name.set(file_input + "=>" + output_file);
-        if (frequency_list.size() == 0) {
-            file_name.set_style(&Styles::red);
-            desc_cycle.set("/0 no entries in list");
-            file_name.set("BadOrEmpty " + file_input);
-        } else {
-            if (frequency_list.size() > FREQMAN_MAX_PER_FILE) {
-                file_name.set_style(&Styles::yellow);
-            }
-        }
+        desc_cycle.set("...empty file...");
+        frequency_list.clear();
+        text_cycle.set_text(" ");
+        return;
     }
 
-    if (frequency_list.empty()) {
-        text_cycle.set_text(" ");
-        return;  // Can't really do much.
+    if (frequency_list.size() > FREQMAN_MAX_PER_FILE) {
+        file_name.set_style(&Styles::yellow);
     }
 
     reset_indexes();
@@ -839,45 +804,26 @@ void ReconView::frequency_file_load(bool) {
     receiver_model.enable();
     receiver_model.set_squelch_level(0);
     text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
-    if (update_ranges && !manual_mode) {
-        button_manual_start.set_text(to_string_short_freq(current_entry().frequency_a));
-        frequency_range.min = current_entry().frequency_a;
-        if (current_entry().frequency_b != 0) {
-            button_manual_end.set_text(to_string_short_freq(current_entry().frequency_b));
-            frequency_range.max = current_entry().frequency_b;
-        } else {
-            button_manual_end.set_text(to_string_short_freq(current_entry().frequency_a));
-            frequency_range.max = current_entry().frequency_a;
-        }
-    }
+    check_update_ranges_from_current();
     update_description();
     handle_retune();
 }
 
 void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
-    systime_t time_interval = 100;
-    uint32_t local_recon_lock_duration = recon_lock_duration;
+    if (recon_tx)
+        return;
+
+    if (is_repeat_active())
+        return;
 
     chrono_end = chTimeNow();
-    if (field_mode.selected_index_value() == SPEC_MODULATION) {
-        time_interval = chrono_end - chrono_start;
-        // capping here to avoid double check a frequency because time_interval is more than exactly 100 by a few units
-        // this is because we are making a measurement and not using a fixed value
-        if (time_interval > 100)
-            time_interval = 100;
-        if (field_lock_wait.value() == 0) {
-            if (time_interval <= 1)             // capping here to avoid freeze because too quick
-                local_recon_lock_duration = 2;  // minimum working tested value
-            else
-                local_recon_lock_duration = time_interval;
-        }
-    }
+    systime_t time_interval = chrono_end - chrono_start;
     chrono_start = chrono_end;
 
     // hack to reload the list if it was cleared by going into CONFIG
     if (freqlist_cleared_for_ui_action) {
         if (!manual_mode) {
-            frequency_file_load(false);
+            frequency_file_load();
         }
         if (autostart && !user_pause) {
             recon_resume();
@@ -891,8 +837,7 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
         if (!timer) {
             status = 0;
             freq_lock = 0;
-            timer = local_recon_lock_duration;
-            big_display.set_style(&Styles::white);
+            timer = recon_lock_duration;
         }
         if (freq_lock < recon_lock_nb_match)  // LOCKING
         {
@@ -930,9 +875,9 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
                     // contents of a possible recon_start_recording(), but not yet since it's only called once
                     if (auto_record_locked && !is_recording) {
                         button_audio_app.set_style(&Styles::red);
-                        if (field_mode.selected_index_value() == SPEC_MODULATION)
+                        if (field_mode.selected_index_value() == SPEC_MODULATION) {
                             button_audio_app.set_text("RAW REC");
-                        else
+                        } else
                             button_audio_app.set_text("WAV REC");
                         record_view->start();
                         button_config.set_style(&Styles::light_grey);  // disable config while recording as it's causing an IO error pop up at exit
@@ -1051,6 +996,26 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
                                     }
                                 }
                             }
+                        } else if (current_entry().type == freqman_type::Repeater) {
+                            // repeater is like single, we only listen on frequency_a and then jump to next entry
+                            if ((fwd && stepper == 0) || stepper > 0) {  // forward
+                                current_index++;
+                                entry_has_changed = true;
+                                // looping
+                                if ((uint32_t)current_index >= frequency_list.size()) {
+                                    has_looped = true;
+                                    current_index = 0;
+                                }
+                            } else if ((!fwd && stepper == 0) || stepper < 0) {
+                                // reverse
+                                current_index--;
+                                entry_has_changed = true;
+                                // if previous if under the list => go back from end
+                                if (current_index < 0) {
+                                    has_looped = true;
+                                    current_index = frequency_list.size() - 1;
+                                }
+                            }
                         }
                         // set index to boundary if !continuous
                         if (has_looped && !continuous) {
@@ -1079,6 +1044,7 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
                     if (entry_has_changed) {
                         timer = 0;
                         switch (current_entry().type) {
+                            case freqman_type::Repeater:
                             case freqman_type::Single:
                                 freq = current_entry().frequency_a;
                                 break;
@@ -1112,7 +1078,7 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
                     if (stepper > 0) stepper--;
                 }  // if( recon || stepper != 0 || index_stepper != 0 )
             }      // if (frequency_list.size() > 0 )
-        }          /* on_statistic_updates */
+        }          /* on_statistics_updates */
     }
     handle_retune();
     recon_redraw();
@@ -1175,75 +1141,87 @@ void ReconView::on_stepper_delta(int32_t v) {
 }
 
 size_t ReconView::change_mode(freqman_index_t new_mod) {
+    if (recon_tx || is_repeat_active())
+        return 0;
     field_mode.on_change = [this](size_t, OptionsField::value_t) {};
     field_bw.on_change = [this](size_t, OptionsField::value_t) {};
     recon_stop_recording();
-    remove_child(record_view.get());
-    record_view.reset();
-    if (new_mod == SPEC_MODULATION) {
+    if (record_view != nullptr) {
+        remove_child(record_view.get());
+        record_view.reset();
+    }
+    if (persistent_memory::recon_repeat_recorded()) {
+        record_view = std::make_unique<RecordView>(Rect{0, 0, 30 * 8, 1 * 16},
+                                                   u"RECON_REPEAT.C16", u"CAPTURES",
+                                                   RecordView::FileType::RawS16, 16384, 3);
+        record_view->set_filename_as_is(true);
+    } else if (new_mod == SPEC_MODULATION) {
         audio::output::stop();
         record_view = std::make_unique<RecordView>(Rect{0, 0, 30 * 8, 1 * 16},
-                                                   u"AUTO_RAW_", u"CAPTURES",
+                                                   u"AUTO_RAW", u"CAPTURES",
                                                    RecordView::FileType::RawS16, 16384, 3);
     } else {
         record_view = std::make_unique<RecordView>(Rect{0, 0, 30 * 8, 1 * 16},
-                                                   u"AUTO_AUDIO_", u"AUDIO",
+                                                   u"AUTO_AUDIO", u"AUDIO",
                                                    RecordView::FileType::WAV, 4096, 4);
+        record_view->set_filename_date_frequency(true);
     }
+    record_view->set_auto_trim(false);
     add_child(record_view.get());
     record_view->hidden(true);
-    record_view->set_filename_date_frequency(true);
     record_view->on_error = [this](std::string message) {
         nav_.display_modal("Error", message);
     };
     receiver_model.disable();
+    transmitter_model.disable();
     baseband::shutdown();
     size_t recording_sampling_rate = 0;
     switch (new_mod) {
         case AM_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
-            // bw DSB (0) default
-            field_bw.set_by_value(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_value());
             field_bw.on_change = [this](size_t, OptionsField::value_t n) { receiver_model.set_am_configuration(n); };
+            // bw DSB (0) default
+            field_bw.set_by_value(0);
             text_ctcss.set("        ");
             recording_sampling_rate = 12000;
             break;
         case NFM_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
-            // bw 16k (2) default
-            field_bw.set_by_value(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_value());
             field_bw.on_change = [this](size_t, OptionsField::value_t n) { receiver_model.set_nbfm_configuration(n); };
+            // bw 16k (2) default
+            field_bw.set_by_value(2);
             recording_sampling_rate = 24000;
             break;
         case WFM_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
-            // bw 200k (0) default
-            field_bw.set_by_value(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_value());
             field_bw.on_change = [this](size_t, OptionsField::value_t n) { receiver_model.set_wfm_configuration(n); };
+            // bw 200k (0) default
+            field_bw.set_by_value(0);
             text_ctcss.set("        ");
             recording_sampling_rate = 48000;
             break;
         case SPEC_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
-            // bw 200k (0) default
             baseband::run_image(portapack::spi_flash::image_tag_capture);
             receiver_model.set_modulation(ReceiverModel::Mode::Capture);
-            field_bw.set_by_value(0);
             field_bw.on_change = [this](size_t, OptionsField::value_t sampling_rate) {
-                auto anti_alias_baseband_bandwidth_filter = filter_bandwidth_for_sampling_rate(sampling_rate);
-                record_view->set_sampling_rate(sampling_rate);
-                receiver_model.set_sampling_rate(sampling_rate);
-                receiver_model.set_baseband_bandwidth(anti_alias_baseband_bandwidth_filter);
+                // record_view determines the correct oversampling to apply and returns the actual sample rate.
+                auto actual_sampling_rate = record_view->set_sampling_rate(sampling_rate);
+                // The radio needs to know the effective sampling rate.
+                receiver_model.set_sampling_rate(actual_sampling_rate);
+                receiver_model.set_baseband_bandwidth(filter_bandwidth_for_sampling_rate(actual_sampling_rate));
             };
+            // bw 12k5 (0) default
+            field_bw.set_by_value(0);
             text_ctcss.set("        ");
             break;
         default:
@@ -1251,7 +1229,6 @@ size_t ReconView::change_mode(freqman_index_t new_mod) {
     }
     if (new_mod != SPEC_MODULATION) {
         button_audio_app.set_text("AUDIO");
-        // TODO: Oversampling.
         record_view->set_sampling_rate(recording_sampling_rate);
         // reset receiver model to fix bug when going from SPEC to audio, the sound is distorted
         receiver_model.set_sampling_rate(3072000);
@@ -1292,14 +1269,6 @@ void ReconView::handle_remove_current_item() {
         if (current_is_valid()) {
             frequency_list.erase(frequency_list.begin() + current_index);
         }
-
-        if (frequency_list.size() > 0) {
-            current_index = clip<int32_t>(current_index, 0u, frequency_list.size() - 1);
-            text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
-            update_description();
-        } else {
-            current_index = 0;
-        }
     }
 
     // In Scanner or Manual mode, remove the entry from the output file.
@@ -1310,6 +1279,146 @@ void ReconView::handle_remove_current_item() {
 
         freq_db.delete_entry(entry);
     }
+
+    // Clip
+    if (frequency_list.size() > 0) {
+        current_index = clip<int32_t>(current_index, 0u, frequency_list.size() - 1);
+        text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
+        entry = current_entry();
+        freq = entry.frequency_a;
+    } else {
+        current_index = 0;
+        text_cycle.set_text(" ");
+    }
+    update_description();
+}
+
+void ReconView::on_repeat_tx_progress(const uint32_t progress) {
+    progressbar.set_value(progress);
+}
+
+void ReconView::repeat_file_error(const std::filesystem::path& path, const std::string& message) {
+    nav_.display_modal("Error", "Error opening file \n" + path.string() + "\n" + message);
+}
+
+bool ReconView::is_repeat_active() const {
+    return replay_thread != nullptr;
+}
+
+void ReconView::start_repeat() {
+    // Prepare to send a file.
+    std::filesystem::path rawfile = u"/" + repeat_rec_path + u"/" + repeat_rec_file;
+    std::filesystem::path rawmeta = u"/" + repeat_rec_path + u"/" + repeat_rec_meta;
+
+    if (recon_tx == false) {
+        recon_tx = true;
+
+        if (record_view != nullptr) {
+            record_view->stop();
+            remove_child(record_view.get());
+            record_view.reset();
+        }
+
+        receiver_model.disable();
+        transmitter_model.disable();
+        baseband::shutdown();
+
+        baseband::run_image(portapack::spi_flash::image_tag_replay);
+
+        size_t rawsize = 0;
+        {
+            File capture_file;
+            auto error = capture_file.open(rawfile);
+            if (error) {
+                repeat_file_error(rawfile, "Can't open file to send for size");
+                return;
+            }
+            rawsize = capture_file.size();
+        }
+
+        // Reset the transmit progress bar.
+        uint8_t sample_size = std::filesystem::capture_file_sample_size(rawfile);
+        progressbar.set_value(0);
+        progressbar.set_max(rawsize * sizeof(complex16_t) / sample_size);
+        progressbar.hidden(false);
+
+        auto metadata = read_metadata_file(rawmeta);
+        // If no metadata found, fallback to the TX frequency.
+        if (!metadata) {
+            metadata = {freq, 500'000};
+            repeat_file_error(rawmeta, "Can't open file to read meta, using default rx_freq,500'000");
+        }
+
+        // Update the sample rate in proc_replay baseband.
+        baseband::set_sample_rate(metadata->sample_rate,
+                                  get_oversample_rate(metadata->sample_rate));
+
+        transmitter_model.set_sampling_rate(get_actual_sample_rate(metadata->sample_rate));
+        transmitter_model.set_baseband_bandwidth(metadata->sample_rate <= 500'000 ? 1'750'000 : 2'500'000);  // TX LPF min 1M75 for SR <=500K, and  2M5 (by experimental test) for SR >500K
+
+        // set TX to repeater TX freq if entry is Repeater and have a valid freq, else use recorded one
+        if (current_entry().type == freqman_type::Repeater && current_entry().frequency_b != 0) {
+            transmitter_model.set_target_frequency(current_entry().frequency_b);
+        } else {
+            transmitter_model.set_target_frequency(metadata->center_frequency);
+        }
+
+        // set TX powers and enable transmitter
+        transmitter_model.set_tx_gain(persistent_memory::recon_repeat_gain());
+        transmitter_model.set_rf_amp(persistent_memory::recon_repeat_amp());
+        transmitter_model.enable();
+    }
+
+    // clear replay thread and set reader
+    replay_thread.reset();
+    auto reader = std::make_unique<FileConvertReader>();
+    auto error = reader->open(rawfile);
+    if (error) {
+        repeat_file_error(rawfile, "Can't open file to send to thread");
+        return;
+    }
+    repeat_ready_signal = true;
+    repeat_cur_rep++;
+
+    // ReplayThread starts immediately on construction; must be set before creating.
+    replay_thread = std::make_unique<ReplayThread>(
+        std::move(reader),
+        /* read_size */ repeat_read_size,
+        /* buffer_count */ repeat_buffer_count,
+        &repeat_ready_signal,
+        [](uint32_t return_code) {
+            ReplayThreadDoneMessage message{return_code};
+            EventDispatcher::send_message(message);
+        });
+}
+
+void ReconView::stop_repeat(const bool do_loop) {
+    repeat_ready_signal = false;
+
+    if (is_repeat_active()) {
+        replay_thread.reset();
+        transmitter_model.disable();
+    }
+
+    // repeat transmit if current number of repetitions (repeat_cur_rep) is < recon configured number of repetitions (recon_repeat_nb)
+    if (do_loop && repeat_cur_rep < persistent_memory::recon_repeat_nb()) {
+        start_repeat();
+    } else {
+        repeat_cur_rep = 0;
+        recon_tx = false;
+        reload_restart_recon();
+        progressbar.hidden(true);
+        set_dirty();  // fix progressbar no hiding
+    }
+}
+
+void ReconView::handle_repeat_thread_done(const uint32_t return_code) {
+    if (return_code == ReplayThread::END_OF_FILE) {
+        stop_repeat(true);
+    } else if (return_code == ReplayThread::READ_ERROR) {
+        stop_repeat(false);
+        repeat_file_error(u"/" + repeat_rec_path + u"/" + repeat_rec_file, "Can't open file to send.");
+    }
 }
 
 } /* namespace ui */

firmware/application/apps/ui_recon.hpp

@@ -41,10 +41,20 @@
 #include "app_settings.hpp"
 #include "radio_state.hpp"
 #include "ui_recon_settings.hpp"
+#include "ui_transmitter.hpp"
+#include "replay_thread.hpp"
+#include "metadata_file.hpp"
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_spectrum.hpp"
+
+#include <string>
+#include <memory>
 
 namespace ui {
 
-#define RECON_CFG_FILE "SETTINGS/recon.cfg"
+#define RECON_CFG_FILE u"SETTINGS/recon.cfg"
 
 enum class recon_mode : uint8_t {
     Recon,
@@ -66,10 +76,18 @@ class ReconView : public View {
    private:
     NavigationView& nav_;
 
-    RxRadioState radio_state_{};
+    RxRadioState rx_radio_state_{};
+    TxRadioState tx_radio_state_{
+        0 /* frequency */,
+        1750000 /* bandwidth */,
+        500000 /* sampling rate */
+    };
     app_settings::SettingsManager settings_{
-        "rx_recon", app_settings::Mode::RX};
+        "rx_tx_recon"sv, app_settings::Mode::RX_TX};
+    ;
 
+    void reload_restart_recon();
+    void check_update_ranges_from_current();
     void set_loop_config(bool v);
     void clear_freqlist_for_ui_action();
     void reset_indexes();
@@ -80,7 +98,7 @@ class ReconView : public View {
     void show_max(bool refresh_display = false);
     void recon_pause();
     void recon_resume();
-    void frequency_file_load(bool stop_all_before = false);
+    void frequency_file_load();
     void on_statistics_update(const ChannelStatistics& statistics);
     void on_index_delta(int32_t v);
     void on_stepper_delta(int32_t v);
@@ -89,8 +107,7 @@ class ReconView : public View {
     void handle_retune();
     void handle_coded_squelch(const uint32_t value);
     void handle_remove_current_item();
-    bool recon_load_config_from_sd();
-    bool recon_save_config_to_sd();
+    void load_persisted_settings();
     bool recon_save_freq(const std::filesystem::path& path, size_t index, bool warn_if_exists);
     // placeholder for possible void recon_start_recording();
     void recon_stop_recording();
@@ -125,6 +142,7 @@ class ReconView : public View {
     bool load_freqs{true};
     bool load_ranges{true};
     bool load_hamradios{true};
+    bool load_repeaters{true};
     bool update_ranges{true};
     bool fwd{true};
     bool recon{true};
@@ -154,8 +172,8 @@ class ReconView : public View {
     uint16_t last_nb_match{999};
     uint16_t last_freq_lock{999};
     size_t last_list_size{0};
-    int8_t last_rssi_min{-127};
-    int8_t last_rssi_med{-127};
+    int8_t last_rssi_min{127};
+    int8_t last_rssi_med{0};
     int8_t last_rssi_max{-127};
     int32_t last_index{-1};
     int64_t last_freq{0};
@@ -163,6 +181,40 @@ class ReconView : public View {
     systime_t chrono_start{};
     systime_t chrono_end{};
 
+    const std::filesystem::path repeat_rec_file = u"RECON_REPEAT.C16";
+    const std::filesystem::path repeat_rec_meta = u"RECON_REPEAT.TXT";
+    const std::filesystem::path repeat_rec_path = u"CAPTURES";
+    const size_t repeat_read_size{16384};
+    const size_t repeat_buffer_count{3};
+    int8_t repeat_cur_rep = 0;
+    int64_t repeat_sample_rate = 0;
+    static constexpr uint32_t repeat_bandwidth = 2500000;
+    void on_repeat_tx_progress(const uint32_t progress);
+    void start_repeat();
+    void stop_repeat(const bool do_loop);
+    bool is_repeat_active() const;
+    void handle_repeat_thread_done(const uint32_t return_code);
+    void repeat_file_error(const std::filesystem::path& path, const std::string& message);
+    std::filesystem::path repeat_file_path{};
+    std::unique_ptr<ReplayThread> replay_thread{};
+    bool repeat_ready_signal{false};
+    bool recon_tx{false};
+
+    // Persisted settings.
+    SettingsStore ui_settings{
+        "recon"sv,
+        {
+            {"input_file"sv, &input_file},
+            {"output_file"sv, &output_file},
+            {"lock_duration"sv, &recon_lock_duration},
+            {"lock_nb_match"sv, &recon_lock_nb_match},
+            {"squelch_level"sv, &squelch},
+            {"match_mode"sv, &recon_match_mode},
+            {"match_wait"sv, &wait},
+            {"range_min"sv, &frequency_range.min},
+            {"range_max"sv, &frequency_range.max},
+        }};
+
     std::unique_ptr<RecordView> record_view{};
 
     Labels labels{
@@ -288,7 +340,7 @@ class ReconView : public View {
     NumberField field_lock_wait{
         {25 * 8, 24 * 8 + 4},
         4,
-        {0, RECON_MAX_LOCK_DURATION},
+        {STATS_UPDATE_INTERVAL, RECON_MAX_LOCK_DURATION},
         STATS_UPDATE_INTERVAL,
         ' ',
     };
@@ -339,17 +391,47 @@ class ReconView : public View {
         {168, (35 * 8) - 4, 72, 28},
         "<REMOVE>"};
 
+    ProgressBar progressbar{
+        {0 * 8, SCREEN_H / 2 - 16, SCREEN_W, 32}};
+
+    TransmitterView2 tx_view{
+        {11 * 8, 2 * 16},
+        /*short_ui*/ true};
+
     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);
+            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);
+            on_statistics_update(static_cast<const ChannelStatisticsMessage*>(p)->statistics);
+        }};
+
+    MessageHandlerRegistration message_handler_replay_thread_error{
+        Message::ID::ReplayThreadDone,
+        [this](const Message* p) {
+            auto message = *reinterpret_cast<const ReplayThreadDoneMessage*>(p);
+            handle_repeat_thread_done(message.return_code);
+        }};
+
+    MessageHandlerRegistration message_handler_fifo_signal{
+        Message::ID::RequestSignal,
+        [this](const Message* p) {
+            auto message = static_cast<const RequestSignalMessage*>(p);
+            if (message->signal == RequestSignalMessage::Signal::FillRequest) {
+                repeat_ready_signal = true;
+            }
+        }};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* p) {
+            auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            on_repeat_tx_progress(message.progress);
         }};
 };
 

firmware/application/apps/ui_recon_settings.cpp

@@ -39,10 +39,10 @@ namespace ui {
 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,
+    add_children({&button_input_file,
                   &text_input_file,
-                  &button_save_freqs,
-                  &button_output_file,
+                  &button_choose_output_file,
+                  &button_choose_output_name,
                   &checkbox_autosave_freqs,
                   &checkbox_autostart_recon,
                   &checkbox_clear_output});
@@ -52,9 +52,9 @@ ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, st
     checkbox_clear_output.set_value(persistent_memory::recon_clear_output());
 
     text_input_file.set(_input_file);
-    button_output_file.set_text(_output_file);
+    button_choose_output_name.set_text(_output_file);
 
-    button_load_freqs.on_select = [this, &nav](Button&) {
+    button_input_file.on_select = [this, &nav](Button&) {
         auto open_view = nav.push<FileLoadView>(".TXT");
         open_view->push_dir(freqman_dir);
         open_view->on_changed = [this, &nav](std::filesystem::path new_file_path) {
@@ -67,25 +67,24 @@ ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, st
         };
     };
 
-    button_save_freqs.on_select = [this, &nav](Button&) {
+    button_choose_output_file.on_select = [this, &nav](Button&) {
         auto open_view = nav.push<FileLoadView>(".TXT");
         open_view->push_dir(freqman_dir);
         open_view->on_changed = [this, &nav](std::filesystem::path new_file_path) {
             if (new_file_path.native().find(freqman_dir.native()) == 0) {
                 _output_file = new_file_path.stem().string();
-                button_output_file.set_text(_output_file);
+                button_choose_output_name.set_text(_output_file);
             } else {
-                nav.display_modal("LOAD ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
+                nav.display_modal("SAVE 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 = std::move(buffer);
-                        button_output_file.set_text(_output_file);
-                    });
+    button_choose_output_name.on_select = [this, &nav](Button&) {
+        text_prompt(nav, _output_file, 28, [this](std::string& buffer) {
+            _output_file = buffer;
+            button_choose_output_name.set_text(_output_file);
+        });
     };
 };
 
@@ -100,12 +99,17 @@ void ReconSetupViewMore::save() {
     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_load_repeaters(checkbox_load_repeaters.value());
     persistent_memory::set_recon_update_ranges_when_recon(checkbox_update_ranges_when_recon.value());
     persistent_memory::set_recon_auto_record_locked(checkbox_auto_record_locked.value());
+    persistent_memory::set_recon_repeat_recorded(checkbox_repeat_recorded.value());
+    persistent_memory::set_recon_repeat_nb(field_repeat_nb.value());
+    persistent_memory::set_recon_repeat_amp(checkbox_repeat_amp.value());
+    persistent_memory::set_recon_repeat_gain(field_repeat_gain.value());
 };
 
 void ReconSetupViewMain::focus() {
-    button_load_freqs.focus();
+    button_input_file.focus();
 }
 
 ReconSetupViewMore::ReconSetupViewMore(NavigationView& nav, Rect parent_rect)
@@ -114,16 +118,50 @@ ReconSetupViewMore::ReconSetupViewMore(NavigationView& nav, Rect parent_rect)
     hidden(true);
 
     add_children({&checkbox_load_freqs,
+                  &checkbox_load_repeaters,
                   &checkbox_load_ranges,
                   &checkbox_load_hamradios,
                   &checkbox_update_ranges_when_recon,
-                  &checkbox_auto_record_locked});
+                  &checkbox_auto_record_locked,
+                  &checkbox_repeat_recorded,
+                  &text_repeat_nb,
+                  &field_repeat_nb,
+                  &checkbox_repeat_amp,
+                  &text_repeat_gain,
+                  &field_repeat_gain});
+
+    // tx options have to be in yellow to inform the users that activating them will make the device transmit
+    checkbox_repeat_recorded.set_style(&Styles::yellow);
+    text_repeat_nb.set_style(&Styles::yellow);
+    field_repeat_nb.set_style(&Styles::yellow);
+    checkbox_repeat_amp.set_style(&Styles::yellow);
+    text_repeat_gain.set_style(&Styles::yellow);
+    field_repeat_gain.set_style(&Styles::yellow);
 
     checkbox_load_freqs.set_value(persistent_memory::recon_load_freqs());
+    checkbox_load_repeaters.set_value(persistent_memory::recon_load_repeaters());
     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());
     checkbox_auto_record_locked.set_value(persistent_memory::recon_auto_record_locked());
+    checkbox_repeat_recorded.set_value(persistent_memory::recon_repeat_recorded());
+    checkbox_repeat_amp.set_value(persistent_memory::recon_repeat_amp());
+    field_repeat_nb.set_value(persistent_memory::recon_repeat_nb());
+    field_repeat_gain.set_value(persistent_memory::recon_repeat_gain());
+
+    // tx warning modal
+    checkbox_repeat_recorded.on_select = [this, &nav](Checkbox&, bool v) {
+        if (v) {
+            nav.display_modal(
+                "TX WARNING",
+                "This activate TX ability\nin Recon !",
+                YESNO,
+                [this, &nav](bool choice) {
+                    if (!choice)
+                        checkbox_repeat_recorded.set_value(choice);
+                });
+        }
+    };
 };
 
 void ReconSetupViewMore::focus() {

firmware/application/apps/ui_recon_settings.hpp

@@ -30,9 +30,7 @@
 #include "ui_tabview.hpp"
 #include "ui_navigation.hpp"
 #include "string_format.hpp"
-
-// maximum usable freq
-#define MAX_UFREQ 7200000000
+#include "ui_styles.hpp"
 
 // 1Mhz helper
 #ifdef OneMHz
@@ -76,17 +74,18 @@ class ReconSetupViewMain : public View {
     std::string _input_file{"RECON"};
     std::string _output_file{"RECON_RESULTS"};
 
-    Button button_load_freqs{
+    Button button_input_file{
         {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{
+    Button button_choose_output_file{
         {1 * 8, 4 * 16 - 8, 18 * 8, 22},
         "select output file"};
-    Button button_output_file{
+
+    Button button_choose_output_name{
         {1 * 8, 5 * 16 - 2, 18 * 8, 22},
         "RECON_RESULTS"};
 
@@ -118,26 +117,70 @@ class ReconSetupViewMore : public View {
     Checkbox checkbox_load_freqs{
         {1 * 8, 12},
         3,
-        "input: load freqs"};
+        "load freq",
+        true};
+
+    Checkbox checkbox_load_repeaters{
+        {14 * 8, 12},
+        3,
+        "load repeater",
+        true};
 
     Checkbox checkbox_load_ranges{
         {1 * 8, 42},
         3,
-        "input: load ranges"};
+        "load range",
+        true};
 
     Checkbox checkbox_load_hamradios{
         {1 * 8, 72},
         3,
-        "input: load hamradios"};
+        "load hamradio",
+        true};
 
     Checkbox checkbox_update_ranges_when_recon{
         {1 * 8, 102},
         3,
         "auto update m-ranges"};
+
     Checkbox checkbox_auto_record_locked{
         {1 * 8, 132},
         3,
         "record locked periods"};
+
+    Checkbox checkbox_repeat_recorded{
+        {1 * 8, 162},
+        3,
+        "repeater,"};
+
+    Text text_repeat_nb{
+        {14 * 8, 165, 3 * 8, 22},
+        "nb:"};
+
+    NumberField field_repeat_nb{
+        {18 * 8, 165},
+        2,
+        {1, 99},
+        1,
+        ' ',
+    };
+
+    Checkbox checkbox_repeat_amp{
+        {1 * 8, 192},
+        3,
+        "AMP,"};
+
+    Text text_repeat_gain{
+        {10 * 8, 196, 5 * 8, 22},
+        "GAIN:"};
+
+    NumberField field_repeat_gain{
+        {16 * 8, 196},
+        2,
+        {0, 47},
+        1,
+        ' ',
+    };
 };
 
 class ReconSetupView : public View {

firmware/application/apps/ui_remote.cpp

@@ -1,6 +1,5 @@
 /*
- * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
- * Copyright (C) 2018 Furrtek
+ * Copyright (C) 2023 Kyle Reed
  *
  * This file is part of PortaPack.
  *
@@ -22,30 +21,591 @@
 
 #include "ui_remote.hpp"
 
-#include "baseband_api.hpp"
+#include "binder.hpp"
+#include "convert.hpp"
+#include "file_reader.hpp"
+#include "io_convert.hpp"
+#include "irq_controls.hpp"
+#include "oversample.hpp"
 #include "string_format.hpp"
+#include "ui_fileman.hpp"
+#include "ui_receiver.hpp"
+#include "ui_textentry.hpp"
+#include "utility.hpp"
 
 using namespace portapack;
+namespace fs = std::filesystem;
 
 namespace ui {
 
-void RemoteView::focus() {
-    button.focus();
+static constexpr uint8_t text_edit_max = 30;
+
+/* RemoteEntryModel **************************************/
+
+std::string RemoteEntryModel::to_string() const {
+    return join(',', {path.string(),
+                      name,
+                      to_string_dec_uint(icon),
+                      to_string_dec_uint(bg_color),
+                      to_string_dec_uint(fg_color),
+                      to_string_dec_uint(metadata.center_frequency),
+                      to_string_dec_uint(metadata.sample_rate)});
 }
 
-RemoteView::~RemoteView() {
-    // transmitter_model.disable();
-    // baseband::shutdown();
+Optional<RemoteEntryModel> RemoteEntryModel::parse(std::string_view line) {
+    auto cols = split_string(line, ',');
+
+    if (cols.size() < 7)
+        return {};
+
+    RemoteEntryModel entry{};
+
+    entry.path = cols[0];
+    entry.name = std::string{cols[1]};
+    parse_int(cols[2], entry.icon);
+    parse_int(cols[3], entry.bg_color);
+    parse_int(cols[4], entry.fg_color);
+    parse_int(cols[5], entry.metadata.center_frequency);
+    parse_int(cols[6], entry.metadata.sample_rate);
+
+    return entry;
 }
 
-RemoteView::RemoteView(
-    NavigationView& nav) {
-    add_children({&labels,
-                  &button});
+/* RemoteModel *******************************************/
 
-    button.on_select = [this, &nav](Button&) {
-        nav.pop();
+bool RemoteModel::delete_entry(const RemoteEntryModel* entry) {
+    // NB: expecting 'entry' to be a pointer to an entry in vector.
+    auto it = std::find_if(
+        entries.begin(), entries.end(),
+        [entry](auto& item) { return entry == &item; });
+    if (it == entries.end())
+        return false;
+
+    entries.erase(it);
+    return true;
+}
+
+bool RemoteModel::load(const std::filesystem::path& path) {
+    File f;
+    auto error = f.open(path);
+    if (error)
+        return false;
+
+    entries.clear();
+
+    bool first = true;
+    auto reader = FileLineReader(f);
+    for (const auto& line : reader) {
+        if (line.length() == 0 || line[0] == '#')
+            continue;  // Empty or comment line.
+
+        // First line is the "name" field.
+        if (first) {
+            name = trim(line);
+            first = false;
+            continue;
+        }
+
+        // All the other lines are button entries.
+        auto entry = RemoteEntryModel::parse(line);
+        if (entry)
+            entries.push_back(*std::move(entry));
+    }
+
+    return true;
+}
+
+bool RemoteModel::save(const std::filesystem::path& path) {
+    File f;
+    auto error = f.create(path);
+    if (error)
+        return false;
+
+    f.write_line(name);
+    for (auto& entry : entries)
+        f.write_line(entry.to_string());
+
+    return true;
+}
+
+/* RemoteButton ******************************************/
+
+RemoteButton::RemoteButton(Rect parent_rect, RemoteEntryModel* entry)
+    : NewButton{parent_rect, {}, nullptr},
+      entry_{nullptr} {
+    set_entry(entry);
+    // Forward to on_select2 -- this isn't ideal, but works for now.
+    on_select = [this]() {
+        if (on_select2)
+            on_select2(*this);
     };
 }
 
+void RemoteButton::on_focus() {
+    // Enable long press on "Select".
+    SwitchesState config;
+    config[toUType(Switch::Sel)] = true;
+    set_switches_long_press_config(config);
+}
+
+void RemoteButton::on_blur() {
+    // Reset long press.
+    SwitchesState config{};
+    set_switches_long_press_config(config);
+}
+
+bool RemoteButton::on_key(KeyEvent key) {
+    if (key == KeyEvent::Select) {
+        if (key_is_long_pressed(key) && on_long_select) {
+            on_long_select(*this);
+            return true;
+        }
+
+        if (on_select2) {
+            on_select2(*this);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void RemoteButton::paint(Painter& painter) {
+    NewButton::paint(painter);
+
+    // Add a border on the highlighted button.
+    if (has_focus() || highlighted()) {
+        auto r = screen_rect();
+        painter.draw_rectangle(r, Color::white());
+
+        auto p = r.location() + Point{1, 1};
+        auto s = Size{r.size().width() - 2, r.size().height() - 2};
+        painter.draw_rectangle({p, s}, Color::light_grey());
+    }
+};
+
+RemoteEntryModel* RemoteButton::entry() {
+    return entry_;
+}
+
+void RemoteButton::set_entry(RemoteEntryModel* entry) {
+    entry_ = entry;
+    set_focusable(entry_ != nullptr);
+    hidden(entry_ == nullptr);
+
+    if (entry_) {
+        set_text(entry_->name);
+        set_bitmap(RemoteIcons::get(entry_->icon));
+    }
+
+    set_dirty();
+}
+
+Style RemoteButton::paint_style() {
+    if (!entry_)
+        return style();
+
+    MutableStyle s{style()};
+    s.foreground = RemoteColors::get(entry_->fg_color);
+    s.background = RemoteColors::get(entry_->bg_color);
+
+    if (has_focus() || highlighted())
+        s.invert();
+
+    // It's kind of a hack to set 'color_' here, but the base
+    // class' paint logic is kind of convoluted but isn't worth
+    // the extra bytes to copy and paste a paint override.
+    color_ = s.foreground;
+
+    return s;
+}
+
+/* RemoteEntryEditView ***********************************/
+
+RemoteEntryEditView::RemoteEntryEditView(
+    NavigationView& nav,
+    RemoteEntryModel& entry)
+    : entry_{entry} {
+    add_children({
+        &labels,
+        &field_name,
+        &field_path,
+        &field_freq,
+        &text_rate,
+        &field_icon_index,
+        &field_fg_color_index,
+        &field_bg_color_index,
+        &button_preview,
+        &button_delete,
+        &button_done,
+    });
+
+    bind(field_name, entry_.name, nav, [this](auto& v) {
+        button_preview.set_text(v);
+    });
+
+    field_path.on_select = [this, &nav](TextField&) {
+        auto open_view = nav.push<FileLoadView>(".C*");
+        open_view->push_dir(u"CAPTURES");
+        open_view->on_changed = [this](fs::path path) {
+            load_path(std::move(path));
+            refresh_ui();
+        };
+    };
+
+    bind(field_freq, entry_.metadata.center_frequency, nav);
+    bind(field_icon_index, entry_.icon, [this](auto v) {
+        button_preview.set_bitmap(RemoteIcons::get(v));
+    });
+    bind(field_fg_color_index, entry_.fg_color, [this](auto v) {
+        button_preview.set_color(RemoteColors::get(v));
+    });
+    bind(field_bg_color_index, entry_.bg_color, [this](auto) {
+        button_preview.set_dirty();
+    });
+
+    button_delete.on_select = [this, &nav]() {
+        nav.display_modal(
+            "Delete?", "    Delete this button?", YESNO,
+            [this, &nav](bool choice) {
+                if (choice) {
+                    if (on_delete)
+                        on_delete(entry_);
+
+                    // Exit the edit view upon delete.
+                    nav.set_on_pop([&nav]() { nav.pop(); });
+                }
+            });
+    };
+
+    button_done.on_select = [&nav](Button&) {
+        nav.pop();
+    };
+
+    refresh_ui();
+}
+
+void RemoteEntryEditView::focus() {
+    button_done.focus();
+}
+
+void RemoteEntryEditView::refresh_ui() {
+    field_path.set_text(entry_.path.filename().string());
+    field_freq.set_value(entry_.metadata.center_frequency);
+    text_rate.set(unit_auto_scale(entry_.metadata.sample_rate, 3, 0) + "Hz");
+}
+
+void RemoteEntryEditView::load_path(std::filesystem::path&& path) {
+    // Read metafile if it exists.
+    auto metadata_path = get_metadata_path(path);
+    auto metadata = read_metadata_file(metadata_path);
+    entry_.path = std::move(path);
+
+    // Use metadata if found, otherwise fallback to the TX frequency.
+    if (metadata)
+        entry_.metadata = *metadata;
+    else
+        entry_.metadata = {transmitter_model.target_frequency(), 500'000};
+}
+
+/* RemoteView ********************************************/
+
+RemoteView::RemoteView(
+    NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_replay);
+
+    add_children({
+        &field_title,
+        &tx_view,
+        &check_loop,
+        &field_filename,
+        &button_add,
+        &button_new,
+        &button_open,
+        &waterfall,
+    });
+
+    create_buttons();
+
+    field_title.on_select = [this, &nav](TextField&) {
+        temp_buffer_ = model_.name;
+        text_prompt(nav_, temp_buffer_, text_edit_max, [this](std::string& new_name) {
+            model_.name = new_name;
+            refresh_ui();
+            set_needs_save();
+        });
+    };
+
+    field_filename.on_select = [this, &nav](TextField&) {
+        temp_buffer_ = remote_path_.stem().string();
+        text_prompt(nav_, temp_buffer_, text_edit_max, [this](std::string& new_name) {
+            rename_remote(new_name);
+            refresh_ui();
+        });
+    };
+
+    button_add.on_select = [this]() { add_button(); };
+    button_new.on_select = [this]() { new_remote(); };
+    button_open.on_select = [this]() { open_remote(); };
+
+    // Fill in the area between the remote buttons and bottom UI with waterfall.
+    Dim waterfall_top = buttons_top_.y() + button_area_height;
+    Dim waterfall_bottom = button_add.parent_rect().top();
+    Dim waterfall_height = waterfall_bottom - waterfall_top;
+    waterfall.set_parent_rect({0, waterfall_top, screen_width, waterfall_height});
+
+    ensure_directory(u"REMOTES");
+
+    // Load the previously loaded remote if exists.
+    if (!load_remote(settings_.remote_path))
+        init_remote();
+
+    refresh_ui();
+}
+
+RemoteView::RemoteView(NavigationView& nav, fs::path path)
+    : RemoteView(nav) {
+    load_remote(std::move(path));
+    refresh_ui();
+}
+
+RemoteView::~RemoteView() {
+    stop();
+    baseband::shutdown();
+
+    save_remote(/*show_error*/ false);
+}
+
+void RemoteView::focus() {
+    if (model_.entries.empty())
+        button_add.focus();
+    else
+        buttons_[0]->focus();
+}
+
+void RemoteView::create_buttons() {
+    // Handler callbacks.
+    auto handle_send = [this](RemoteButton& btn) {
+        if (btn.entry()->path.empty())
+            // No path set? Go to edit mode instead.
+            edit_button(btn);
+        else if (is_sending() && &btn == current_btn_)
+            // Pressed the same button again? Stop.
+            stop();
+        else
+            // Start sending.
+            send_button(btn);
+    };
+
+    auto handle_edit = [this](RemoteButton& btn) {
+        edit_button(btn);
+    };
+
+    // Create and add RemoteButtons for the whole grid.
+    for (size_t i = 0; i < max_buttons; ++i) {
+        Coord x = i % button_cols;
+        Coord y = i / button_cols;
+        Point pos = Point{x * button_width, y * button_height} + buttons_top_;
+
+        auto btn = std::make_unique<RemoteButton>(
+            Rect{pos, {button_width, button_height}},
+            nullptr);
+        btn->on_select2 = handle_send;
+        btn->on_long_select = handle_edit;
+
+        add_child(btn.get());
+        buttons_.push_back(std::move(btn));
+    }
+}
+
+void RemoteView::reset_buttons() {
+    // Whever the model's entries instance is invalidated,
+    // all the pointers in the buttons will end up dangling.
+    // TODO: This is pretty lame. Could maybe static alloc?
+    for (auto& btn : buttons_)
+        btn->set_entry(nullptr);
+}
+
+void RemoteView::refresh_ui() {
+    field_title.set_text(model_.name);
+    field_filename.set_text(remote_path_.stem().string());
+
+    // Update buttons from the model.
+    for (size_t i = 0; i < buttons_.size(); ++i) {
+        if (i < model_.entries.size())
+            buttons_[i]->set_entry(&model_.entries[i]);
+        else
+            buttons_[i]->set_entry(nullptr);
+    }
+}
+
+void RemoteView::add_button() {
+    if (model_.entries.size() >= max_buttons)
+        return;
+
+    // Don't let replay thread read the model while editing.
+    stop();
+
+    model_.entries.push_back({{}, "<EMPTY>", 0, 3, 1});
+    reset_buttons();
+    refresh_ui();
+    set_needs_save();
+}
+
+void RemoteView::edit_button(RemoteButton& btn) {
+    // Don't let replay thread read the model while editing.
+    stop();
+
+    auto edit_view = nav_.push<RemoteEntryEditView>(*btn.entry());
+    nav_.set_on_pop([this]() {
+        refresh_ui();
+        set_needs_save();
+        focus();  // Need to refocus after refreshing the buttons.
+    });
+
+    edit_view->on_delete = [this](RemoteEntryModel& to_delete) {
+        model_.delete_entry(&to_delete);
+        reset_buttons();
+    };
+}
+
+void RemoteView::send_button(RemoteButton& btn) {
+    // TODO: If this is called while is_sending() == true,
+    // it just stops and doesn't start the new button?
+
+    // Reset everything to prepare to send a file.
+    stop();
+    current_btn_ = &btn;  // Stash for looping.
+
+    // Open the sample file to send.
+    auto reader = std::make_unique<FileConvertReader>();
+    auto error = reader->open(btn.entry()->path);
+    if (error) {
+        show_error("Can't open file:\n" + btn.entry()->path.stem().string());
+        return;
+    }
+
+    // Update the sample rate in proc_replay baseband.
+    baseband::set_sample_rate(
+        btn.entry()->metadata.sample_rate,
+        get_oversample_rate(btn.entry()->metadata.sample_rate));
+
+    // ReplayThread starts immediately on construction; must be set before creating.
+    transmitter_model.set_target_frequency(btn.entry()->metadata.center_frequency);
+    transmitter_model.set_sampling_rate(get_actual_sample_rate(btn.entry()->metadata.sample_rate));
+    transmitter_model.set_baseband_bandwidth(baseband_bandwidth);
+    transmitter_model.enable();
+
+    // ReplayThread reads the file and sends to the baseband.
+    replay_thread_ = std::make_unique<ReplayThread>(
+        std::move(reader),
+        /* read_size */ 0x4000,
+        /* buffer_count */ 3,
+        &ready_signal_,
+        [](uint32_t return_code) {
+            ReplayThreadDoneMessage message{return_code};
+            EventDispatcher::send_message(message);
+        });
+}
+
+void RemoteView::stop() {
+    // This terminates the underlying chThread.
+    replay_thread_.reset();
+    transmitter_model.disable();
+    ready_signal_ = false;
+}
+
+void RemoteView::new_remote() {
+    save_remote();
+    init_remote();
+    refresh_ui();
+
+    // View needs to redraw to hide old buttons.
+    set_dirty();
+}
+
+void RemoteView::open_remote() {
+    auto open_view = nav_.push<FileLoadView>(".REM");
+    open_view->push_dir(u"REMOTES");
+    open_view->on_changed = [this](fs::path path) {
+        save_remote();
+        load_remote(std::move(path));
+        refresh_ui();
+    };
+}
+
+void RemoteView::init_remote() {
+    model_ = {"<Unnamed Remote>", {}};
+    reset_buttons();
+    set_remote_path(next_filename_matching_pattern(u"/REMOTES/REMOTE_????.REM"));
+    set_needs_save(false);
+
+    if (remote_path_.empty())
+        show_error("Couldn't make new remote file.");
+}
+
+bool RemoteView::load_remote(fs::path&& path) {
+    set_remote_path(std::move(path));
+    set_needs_save(false);
+    reset_buttons();
+    return model_.load(remote_path_);
+}
+
+void RemoteView::save_remote(bool show_errors) {
+    if (!needs_save_)
+        return;
+
+    bool ok = model_.save(remote_path_);
+    if (!ok && show_errors)
+        show_error("Save failed for:\n" + remote_path_.stem().string());
+
+    set_needs_save(false);
+}
+
+void RemoteView::rename_remote(const std::string& new_name) {
+    auto folder = remote_path_.parent_path();
+    auto ext = remote_path_.extension();
+    auto new_path = folder / new_name + ext;
+
+    if (file_exists(new_path)) {
+        show_error("Remote " + new_name + " already exists");
+        return;
+    }
+
+    // Rename file if there is one.
+    if (fs::file_exists(remote_path_))
+        rename_file(remote_path_, new_path);
+
+    set_remote_path(std::move(new_path));
+}
+
+void RemoteView::handle_replay_thread_done(uint32_t return_code) {
+    if (return_code == ReplayThread::END_OF_FILE) {
+        if (check_loop.value() && current_btn_) {
+            send_button(*current_btn_);
+            return;
+        }
+    }
+
+    /*
+    // TODO: This can happen when stopping an in-progress Tx.
+    if (return_code == ReplayThread::READ_ERROR)
+        show_error("Bad capture file.");
+    */
+
+    stop();
+}
+
+void RemoteView::set_remote_path(fs::path&& path) {
+    // Unfortunately, have to keep these two in sync because
+    // settings doesn't know about fs::path.
+    remote_path_ = std::move(path);
+    settings_.remote_path = remote_path_.string();
+}
+
+void RemoteView::show_error(const std::string& msg) const {
+    nav_.display_modal("Error", msg);
+}
+
 } /* namespace ui */

firmware/application/apps/ui_remote.hpp

@@ -1,6 +1,5 @@
 /*
- * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
- * Copyright (C) 2018 Furrtek
+ * Copyright (C) 2023 Kyle Reed
  *
  * This file is part of PortaPack.
  *
@@ -21,42 +20,369 @@
  */
 
 #include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_spectrum.hpp"
 #include "ui_transmitter.hpp"
-#include "transmitter_model.hpp"
+
+#include "app_settings.hpp"
+#include "baseband_api.hpp"
+#include "bitmap.hpp"
+#include "file.hpp"
+#include "metadata_file.hpp"
+#include "optional.hpp"
+#include "radio_state.hpp"
+#include "replay_thread.hpp"
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
 
 namespace ui {
 
+/* Maps icon index to bitmap. */
+class RemoteIcons {
+   public:
+    static constexpr const Bitmap* get(uint8_t index) {
+        if (index >= std::size(bitmaps_))
+            return bitmaps_[0];
+
+        return bitmaps_[index];
+    }
+
+    static constexpr size_t size() {
+        return std::size(bitmaps_);
+    }
+
+   private:
+    // NB: Icons need to be 16x16 or they won't fit corrently.
+    static constexpr std::array<const Bitmap*, 25> bitmaps_{
+        nullptr,
+        &bitmap_icon_fox,
+        &bitmap_icon_adsb,
+        &bitmap_icon_ais,
+        &bitmap_icon_aprs,
+        &bitmap_icon_btle,
+        &bitmap_icon_burger,
+        &bitmap_icon_camera,
+        &bitmap_icon_cwgen,
+        &bitmap_icon_dmr,
+        &bitmap_icon_file_image,
+        &bitmap_icon_lge,
+        &bitmap_icon_looking,
+        &bitmap_icon_memory,
+        &bitmap_icon_morse,
+        &bitmap_icon_nrf,
+        &bitmap_icon_notepad,
+        &bitmap_icon_rds,
+        &bitmap_icon_remote,
+        &bitmap_icon_setup,
+        &bitmap_icon_sleep,
+        &bitmap_icon_sonde,
+        &bitmap_icon_stealth,
+        &bitmap_icon_tetra,
+        &bitmap_icon_temperature};
+};
+
+// TODO: Use RGB colors instead?
+/* Maps color index to color. */
+class RemoteColors {
+   public:
+    static constexpr Color get(uint8_t index) {
+        if (index >= std::size(colors_))
+            return colors_[0];
+
+        return colors_[index];
+    }
+
+    static constexpr size_t size() {
+        return std::size(colors_);
+    }
+
+   private:
+    static constexpr std::array<Color, 21> colors_{
+        Color::black(),         // 0
+        Color::white(),         // 1
+        Color::darker_grey(),   // 2
+        Color::dark_grey(),     // 3
+        Color::grey(),          // 4
+        Color::light_grey(),    // 5
+        Color::red(),           // 6
+        Color::orange(),        // 7
+        Color::yellow(),        // 8
+        Color::green(),         // 9
+        Color::blue(),          // 10
+        Color::cyan(),          // 11
+        Color::magenta(),       // 12
+        Color::dark_red(),      // 13
+        Color::dark_orange(),   // 14
+        Color::dark_yellow(),   // 15
+        Color::dark_green(),    // 16
+        Color::dark_blue(),     // 17
+        Color::dark_cyan(),     // 18
+        Color::dark_magenta(),  // 19
+        Color::purple()};       // 20
+};
+
+/* Data model for a remote entry. */
+struct RemoteEntryModel {
+    std::filesystem::path path{};
+    std::string name{};
+    uint8_t icon = 0;
+    uint8_t bg_color = 0;
+    uint8_t fg_color = 0;
+    capture_metadata metadata{};
+    // TODO: start/end position for trimming.
+
+    std::string to_string() const;
+    static Optional<RemoteEntryModel> parse(std::string_view line);
+};
+
+/* Data model for a remote. */
+struct RemoteModel {
+    std::string name{};
+    std::vector<RemoteEntryModel> entries{};
+
+    bool delete_entry(const RemoteEntryModel* entry);
+    bool load(const std::filesystem::path& path);
+    bool save(const std::filesystem::path& path);
+};
+
+/* Button for the remote UI. */
+class RemoteButton : public NewButton {
+   public:
+    std::function<void(RemoteButton&)> on_select2{};
+    std::function<void(RemoteButton&)> on_long_select{};
+
+    RemoteButton(Rect parent_rect, RemoteEntryModel* entry);
+    RemoteButton(const RemoteButton&) = delete;
+    RemoteButton& operator=(const RemoteButton&) = delete;
+
+    void on_focus() override;
+    void on_blur() override;
+    bool on_key(KeyEvent key) override;
+    void paint(Painter& painter) override;
+
+    RemoteEntryModel* entry();
+    void set_entry(RemoteEntryModel* entry);
+
+   protected:
+    Style paint_style() override;
+
+   private:
+    // Hide because it's not used.
+    using NewButton::on_select;
+    RemoteEntryModel* entry_;
+};
+
+/* Settings container for remote. */
+struct RemoteSettings {
+    std::string remote_path{};
+};
+
+/* View for editing a remote entry button. */
+class RemoteEntryEditView : public View {
+   public:
+    std::function<void(RemoteEntryModel&)> on_delete{};
+
+    RemoteEntryEditView(NavigationView& nav, RemoteEntryModel& entry);
+
+    std::string title() const override { return "Edit Button"; };
+    void focus() override;
+
+   private:
+    RemoteEntryModel& entry_;
+
+    void refresh_ui();
+    void load_path(std::filesystem::path&& path);
+
+    Labels labels{
+        {{2 * 8, 1 * 16}, "Name:", Color::light_grey()},
+        {{2 * 8, 2 * 16}, "Path:", Color::light_grey()},
+        {{2 * 8, 3 * 16}, "Freq:", Color::light_grey()},
+        {{17 * 8, 3 * 16}, "MHz", Color::light_grey()},
+        {{2 * 8, 4 * 16}, "Rate:", Color::light_grey()},
+        {{2 * 8, 5 * 16}, "Icon:", Color::light_grey()},
+        {{2 * 8, 6 * 16}, "FG Color:", Color::light_grey()},
+        {{2 * 8, 7 * 16}, "BG Color:", Color::light_grey()},
+        {{8 * 8, 9 * 16}, "Button preview", Color::light_grey()},
+    };
+
+    TextField field_name{{8 * 8, 1 * 16, 20 * 8, 1 * 16}, {}};
+
+    TextField field_path{{8 * 8, 2 * 16, 20 * 8, 1 * 16}, {}};
+
+    FrequencyField field_freq{{8 * 8, 3 * 16}};
+
+    Text text_rate{{8 * 8, 4 * 16, 20 * 8, 1 * 16}, {}};
+
+    NumberField field_icon_index{
+        {8 * 8, 5 * 16},
+        2,
+        {0, RemoteIcons::size() - 1},
+        /*step*/ 1,
+        /*fill*/ ' ',
+        /*loop*/ true};
+
+    NumberField field_fg_color_index{
+        {11 * 8, 6 * 16},
+        2,
+        {0, RemoteColors::size() - 1},
+        /*step*/ 1,
+        /*fill*/ ' ',
+        /*loop*/ true};
+
+    NumberField field_bg_color_index{
+        {11 * 8, 7 * 16},
+        2,
+        {0, RemoteColors::size() - 1},
+        /*step*/ 1,
+        /*fill*/ ' ',
+        /*loop*/ true};
+
+    RemoteButton button_preview{
+        {10 * 8, 11 * 16 - 8, 10 * 8, 50},
+        &entry_};
+
+    NewButton button_delete{
+        {2 * 8, 16 * 16, 4 * 8, 2 * 16},
+        {},
+        &bitmap_icon_trash,
+        Color::red()};
+
+    Button button_done{{11 * 8, 16 * 16, 8 * 8, 2 * 16}, "Done"};
+};
+
+/* App that allows for buttons to be bound to captures for playback. */
 class RemoteView : public View {
    public:
     RemoteView(NavigationView& nav);
+    RemoteView(NavigationView& nav, std::filesystem::path path);
     ~RemoteView();
 
+    RemoteView(const RemoteView&) = delete;
+    RemoteView& operator=(const RemoteView&) = delete;
+
+    std::string title() const override { return "Remote"; };
     void focus() override;
 
-    std::string title() const override { return "Custom remote"; };
-
    private:
-    /*enum tx_modes {
-                IDLE = 0,
-                SINGLE,
-                SCAN
-        };
+    /* Creates the dynamic buttons. */
+    void create_buttons();
+    /* Resets all the pointers to null entries. */
+    void reset_buttons();
+    void refresh_ui();
 
-        tx_modes tx_mode = IDLE;
+    void add_button();
+    void edit_button(RemoteButton& btn);
+    void send_button(RemoteButton& btn);
+    void stop();
+    void new_remote();
+    void open_remote();
+    void init_remote();
+    bool load_remote(std::filesystem::path&& path);
+    void save_remote(bool show_errors = true);
+    void rename_remote(const std::string& new_name);
+    void handle_replay_thread_done(uint32_t return_code);
+    void set_needs_save(bool v = true) { needs_save_ = v; }
+    void set_remote_path(std::filesystem::path&& path);
+    bool is_sending() const { return replay_thread_ != nullptr; }
+    void show_error(const std::string& msg) const;
 
-        struct remote_layout_t {
-                Point position;
-                std::string text;
-        };
+    static constexpr Dim button_rows = 4;
+    static constexpr Dim button_cols = 3;
+    static constexpr uint8_t max_buttons = button_rows * button_cols;
+    static constexpr Dim button_area_height = 200;
+    static constexpr Dim button_width = screen_width / button_cols;
+    static constexpr Dim button_height = button_area_height / button_rows;
 
-        const std::array<remote_layout_t, 32> remote_layout { };*/
+    // This value is mysterious... why?
+    static constexpr uint32_t baseband_bandwidth = 2'500'000;
 
-    Labels labels{
-        {{1 * 8, 0}, "Work in progress...", Color::light_grey()}};
+    NavigationView& nav_;
+    RxRadioState radio_state_{};
 
-    Button button{
-        {60, 64, 120, 32},
-        "Exit"};
+    // Settings
+    RemoteSettings settings_{};
+    app_settings::SettingsManager app_settings_{
+        "tx_remote"sv,
+        app_settings::Mode::TX,
+        {
+            {"remote_path"sv, &settings_.remote_path},
+        }};
+
+    RemoteModel model_{};
+
+    bool needs_save_ = false;
+    std::string temp_buffer_{};
+    std::filesystem::path remote_path_{};
+    RemoteButton* current_btn_{};
+
+    const Point buttons_top_{0, 20};
+    std::vector<std::unique_ptr<RemoteButton>> buttons_{};
+
+    std::unique_ptr<ReplayThread> replay_thread_{};
+    bool ready_signal_{};  // Used to signal ReplayThread ready.
+
+    TextField field_title{
+        {0 * 8, 0 * 16 + 2, 30 * 8, 1 * 16},
+        {}};
+
+    TransmitterView2 tx_view{
+        {0 * 8, 17 * 16},
+        /*short_ui*/ true};
+
+    Checkbox check_loop{
+        {10 * 8, 17 * 16},
+        4,
+        "Loop",
+        /*small*/ true};
+
+    TextField field_filename{
+        {0 * 8, 18 * 16, 17 * 8, 1 * 16},
+        {}};
+
+    NewButton button_add{
+        {17 * 8 + 4, 17 * 16, 4 * 8, 2 * 16},
+        "",
+        &bitmap_icon_add,
+        Color::orange(),
+        /*vcenter*/ true};
+
+    NewButton button_new{
+        {22 * 8, 17 * 16, 4 * 8, 2 * 16},
+        "",
+        &bitmap_icon_new_file,
+        Color::dark_blue(),
+        /*vcenter*/ true};
+
+    NewButton button_open{
+        {26 * 8, 17 * 16, 4 * 8, 2 * 16},
+        "",
+        &bitmap_icon_load,
+        Color::dark_blue(),
+        /*vcenter*/ true};
+
+    spectrum::WaterfallView waterfall{};
+
+    MessageHandlerRegistration message_handler_replay_thread_error{
+        Message::ID::ReplayThreadDone,
+        [this](const Message* p) {
+            auto message = *reinterpret_cast<const ReplayThreadDoneMessage*>(p);
+            handle_replay_thread_done(message.return_code);
+        }};
+
+    MessageHandlerRegistration message_handler_fifo_signal{
+        Message::ID::RequestSignal,
+        [this](const Message* p) {
+            auto message = static_cast<const RequestSignalMessage*>(p);
+            if (message->signal == RequestSignalMessage::Signal::FillRequest) {
+                ready_signal_ = true;
+            }
+        }};
 };
 
 } /* namespace ui */

firmware/application/apps/ui_scanner.cpp

@@ -31,8 +31,6 @@ namespace fs = std::filesystem;
 
 namespace ui {
 
-static const fs::path default_scan_file{u"FREQMAN/SCANNER.TXT"};
-
 ScannerThread::ScannerThread(std::vector<rf::Frequency> frequency_list)
     : frequency_list_{std::move(frequency_list)} {
     _manual_search = false;
@@ -234,7 +232,7 @@ void ScannerView::handle_retune(int64_t freq, uint32_t freq_idx) {
 
     if (!manual_search) {
         if (entries.size() > 0)
-            text_current_index.set(to_string_dec_uint(freq_idx + 1, 3));
+            field_current_index.set_text(to_string_dec_uint(freq_idx + 1, 3));
 
         if (freq_idx < entries.size() && entries[freq_idx].description.size() > 1)
             text_current_desc.set(entries[freq_idx].description);  // Show description from file
@@ -243,9 +241,20 @@ void ScannerView::handle_retune(int64_t freq, uint32_t freq_idx) {
     }
 }
 
+void ScannerView::handle_encoder(EncoderEvent delta) {
+    auto index_step = delta > 0 ? 1 : -1;
+
+    if (scan_thread)
+        scan_thread->set_index_stepper(index_step);
+
+    // Restart browse timer when frequency changes.
+    if (browse_timer != 0)
+        browse_timer = 1;
+}
+
 std::string ScannerView::loaded_filename() const {
-    auto filename = loaded_path.filename().string();
-    if (filename.length() > 23) {  // Truncate and add ellipses if long file name
+    auto filename = freqman_file;
+    if (filename.length() > 23) {  // Truncate long file name.
         filename.resize(22);
         filename = filename + "+";
     }
@@ -266,7 +275,7 @@ ScannerView::~ScannerView() {
 }
 
 void ScannerView::show_max_index() {  // show total number of freqs to scan
-    text_current_index.set("---");
+    field_current_index.set_text("---");
 
     if (entries.size() == FREQMAN_MAX_PER_FILE) {
         text_max_index.set_style(&Styles::red);
@@ -293,7 +302,7 @@ ScannerView::ScannerView(
         &button_load,
         &button_clear,
         &rssi,
-        &text_current_index,
+        &field_current_index,
         &text_max_index,
         &text_current_desc,
         &big_display,
@@ -319,11 +328,7 @@ ScannerView::ScannerView(
     field_step.set_by_value(receiver_model.frequency_step());                     // Default step interval (Hz)
     change_mode((freqman_index_t)field_mode.selected_index_value());
 
-    // FUTURE: perhaps additional settings should be stored in persistent memory vs using defaults
-    rf::Frequency stored_freq = receiver_model.target_frequency();
-    frequency_range.min = stored_freq - 1000000;
     button_manual_start.set_text(to_string_short_freq(frequency_range.min));
-    frequency_range.max = stored_freq + 1000000;
     button_manual_end.set_text(to_string_short_freq(frequency_range.max));
 
     // Button to load a Freqman file.
@@ -340,14 +345,14 @@ ScannerView::ScannerView(
         };
     };
 
-    // Button to clear in-memory frequency list
+    // Button to clear in-memory frequency list.
     button_clear.on_select = [this, &nav](Button&) {
         if (scan_thread && entries.size()) {
             scan_thread->stop();  // STOP SCANNER THREAD
             entries.clear();
 
             show_max_index();  // UPDATE new list size on screen
-            text_current_index.set("");
+            field_current_index.set_text("");
             text_current_desc.set(loaded_filename());
             scan_thread->set_freq_lock(0);  // Reset the scanner lock
 
@@ -355,7 +360,7 @@ ScannerView::ScannerView(
         }
     };
 
-    // Button to configure starting frequency for a manual range search
+    // Button to configure starting frequency for a manual range search.
     button_manual_start.on_select = [this, &nav](Button& button) {
         auto new_view = nav_.push<FrequencyKeypadView>(frequency_range.min);
         new_view->on_changed = [this, &button](rf::Frequency f) {
@@ -364,7 +369,7 @@ ScannerView::ScannerView(
         };
     };
 
-    // Button to configure ending frequency for a manual range search
+    // Button to configure ending frequency for a manual range search.
     button_manual_end.on_select = [this, &nav](Button& button) {
         auto new_view = nav.push<FrequencyKeypadView>(frequency_range.max);
         new_view->on_changed = [this, &button](rf::Frequency f) {
@@ -373,7 +378,7 @@ ScannerView::ScannerView(
         };
     };
 
-    // Button to pause/resume scan (note that some other buttons will trigger resume also)
+    // Button to pause/resume scan (note that some other buttons will trigger resume also).
     button_pause.on_select = [this](ButtonWithEncoder&) {
         if (userpause)
             user_resume();
@@ -384,19 +389,14 @@ ScannerView::ScannerView(
         }
     };
 
-    // Encoder dial causes frequency change when focus is on pause button
+    // Encoder dial causes frequency change when focus is on pause button or current index.
     button_pause.on_change = [this]() {
-        int32_t encoder_delta{(button_pause.get_encoder_delta() > 0) ? 1 : -1};
-
-        if (scan_thread)
-            scan_thread->set_index_stepper(encoder_delta);
-
-        // Restart browse timer when frequency changes
-        if (browse_timer != 0)
-            browse_timer = 1;
-
+        handle_encoder(button_pause.get_encoder_delta());
         button_pause.set_encoder_delta(0);
     };
+    field_current_index.on_encoder_change = [this](TextField&, EncoderEvent delta) {
+        handle_encoder(delta);
+    };
 
     // Button to switch to Audio app
     button_audio_app.on_select = [this](Button&) {
@@ -489,7 +489,7 @@ ScannerView::ScannerView(
     // Button to add current frequency (found during Search) to the Scan Frequency List
     button_add.on_select = [this](Button&) {
         FreqmanDB db;
-        if (db.open(loaded_path, /*create*/ true)) {
+        if (db.open(get_freqman_path(freqman_file), /*create*/ true)) {
             freqman_entry entry{
                 .frequency_a = current_frequency,
                 .type = freqman_type::Single,
@@ -515,23 +515,27 @@ ScannerView::ScannerView(
                 }
             }
         } else {
-            nav_.display_modal("Error", "Cannot open " + loaded_path.filename().string() + "\nfor appending freq.");
+            nav_.display_modal("Error", "Cannot open " + freqman_file + ".TXT\nfor appending freq.");
             bigdisplay_update(-1);  // Need to poke this control after displaying modal?
         }
     };
 
     // PRE-CONFIGURATION:
     field_browse_wait.on_change = [this](int32_t v) { browse_wait = v; };
-    field_browse_wait.set_value(5);
+    field_browse_wait.set_value(browse_wait);
 
     field_lock_wait.on_change = [this](int32_t v) { lock_wait = v; };
-    field_lock_wait.set_value(2);
+    field_lock_wait.set_value(lock_wait);
 
     field_squelch.on_change = [this](int32_t v) { squelch = v; };
-    field_squelch.set_value(-30);
+    field_squelch.set_value(squelch);
+
+    // Disable squelch on the model because RSSI handler is where the
+    // actual squelching is applied for this app.
+    receiver_model.set_squelch_level(0);
 
     // LOAD FREQUENCIES
-    frequency_file_load(default_scan_file);
+    frequency_file_load(get_freqman_path(freqman_file));
 }
 
 void ScannerView::frequency_file_load(const fs::path& path) {
@@ -542,12 +546,11 @@ void ScannerView::frequency_file_load(const fs::path& path) {
     FreqmanDB db;
     if (!db.open(path)) {
         text_current_desc.set("NO " + path.filename().string());
-        loaded_path = default_scan_file;
         return;
     }
 
     entries.clear();
-    loaded_path = path;
+    freqman_file = path.stem().string();
     Optional<scanner_range_t> range;
 
     for (auto entry : db) {
@@ -561,6 +564,7 @@ void ScannerView::frequency_file_load(const fs::path& path) {
             def_step_index = entry.step;
 
         switch (entry.type) {
+            case freqman_type::Repeater:
             case freqman_type::Single:
                 entries.push_back({entry.frequency_a, entry.description});
                 break;
@@ -726,9 +730,6 @@ void ScannerView::change_mode(freqman_index_t new_mod) {
 
 void ScannerView::start_scan_thread() {
     receiver_model.enable();
-    // Disable squelch on the model because RSSI handler is where the
-    // actual squelching is applied for this app.
-    receiver_model.set_squelch_level(0);
     show_max_index();
 
     // Start Scanner Thread

firmware/application/apps/ui_scanner.hpp

@@ -37,7 +37,7 @@
 
 #define SCANNER_SLEEP_MS 50  // ms that Scanner Thread sleeps per loop
 #define STATISTICS_UPDATES_PER_SEC 10
-#define MAX_FREQ_LOCK 10  //# of 50ms cycles scanner locks into freq when signal detected, to verify signal is not spureous
+#define MAX_FREQ_LOCK 10  //# of 50ms cycles scanner locks into freq when signal detected, to verify signal is not spurious
 
 namespace ui {
 
@@ -110,11 +110,29 @@ class ScannerView : public View {
     std::string title() const override { return "Scanner"; };
 
    private:
+    static constexpr const char* default_freqman_file = "SCANNER";
+
+    RxRadioState radio_state_{};
+
+    // Settings
+    uint32_t browse_wait{5};
+    uint32_t lock_wait{2};
+    int32_t squelch{-30};
+    scanner_range_t frequency_range{0, MAX_UFREQ};
+    std::string freqman_file{default_freqman_file};
     app_settings::SettingsManager settings_{
-        "rx_scanner", app_settings::Mode::RX};
+        "rx_scanner"sv,
+        app_settings::Mode::RX,
+        {
+            {"browse_wait"sv, &browse_wait},
+            {"lock_wait"sv, &lock_wait},
+            {"scanner_squelch"sv, &squelch},
+            {"range_min"sv, &frequency_range.min},
+            {"range_max"sv, &frequency_range.max},
+            {"file"sv, &freqman_file},
+        }};
 
     NavigationView& nav_;
-    RxRadioState radio_state_{};
 
     void start_scan_thread();
     void restart_scan();
@@ -128,20 +146,15 @@ class ScannerView : public View {
     void update_squelch_while_paused(int32_t max_db);
     void on_statistics_update(const ChannelStatistics& statistics);
     void handle_retune(int64_t freq, uint32_t freq_idx);
-
+    void handle_encoder(EncoderEvent delta);
     std::string loaded_filename() const;
 
-    scanner_range_t frequency_range{0, 0};
-    int32_t squelch{0};
     uint32_t browse_timer{0};
     uint32_t lock_timer{0};
     uint32_t color_timer{0};
     int32_t bigdisplay_current_color{-2};
     rf::Frequency bigdisplay_current_frequency{0};
-    uint32_t browse_wait{0};
-    uint32_t lock_wait{0};
 
-    std::filesystem::path loaded_path{};
     std::vector<scanner_entry_t> entries{};
     uint32_t current_index{0};
     rf::Frequency current_frequency{0};
@@ -213,8 +226,9 @@ class ScannerView : public View {
         {0 * 16, 2 * 16, 15 * 16, 8},
     };
 
-    Text text_current_index{
+    TextField field_current_index{
         {0, 3 * 16, 3 * 8, 16},
+        {},
     };
 
     Text text_max_index{
@@ -225,9 +239,9 @@ class ScannerView : public View {
         {0, 4 * 16, 240 - 6 * 8, 16},
     };
 
-    BigFrequency big_display{// Show frequency in glamour
-                             {4, 6 * 16, 28 * 8, 52},
-                             0};
+    BigFrequency big_display{
+        {4, 6 * 16, 28 * 8, 52},
+        0};
 
     Button button_manual_start{
         {0 * 8, 11 * 16, 11 * 8, 28},

firmware/application/apps/ui_sd_wipe.cpp

@@ -44,15 +44,21 @@ void WipeSDView::focus() {
     dummy.focus();
 
     if (!confirmed) {
-        nav_.push<ModalMessageView>("Warning !", "Wipe FAT of SD card?", YESCANCEL, [this](bool choice) {
-            if (choice)
-                confirmed = true;
-        });
+        nav_.push<ModalMessageView>(
+            "Warning !",
+            "Wipe FAT of SD card?",
+            YESNO,
+            [this](bool choice) {
+                if (choice)
+                    confirmed = true;
+                else
+                    nav_.pop(false);  // Pop w/o update so the modal will pop off the app.
+            });
     } else {
         if (sdcGetInfo(&SDCD1, &block_device_info) == CH_SUCCESS) {
             thread = chThdCreateFromHeap(NULL, 2048, NORMALPRIO, WipeSDView::static_fn, this);
         } else {
-            nav_.pop();  // Just silently abort for now
+            nav_.pop();  // Just silently abort for now.
         }
     }
 }

firmware/application/apps/ui_sd_wipe.hpp

@@ -38,7 +38,7 @@ class WipeSDView : public View {
     ~WipeSDView();
     void focus() override;
 
-    std::string title() const override { return "Wipe sdcard"; };
+    std::string title() const override { return "Wipe SD Card"; };
 
    private:
     NavigationView& nav_;

firmware/application/apps/ui_search.cpp

@@ -23,7 +23,9 @@
 #include "ui_search.hpp"
 
 #include "baseband_api.hpp"
+#include "binder.hpp"
 #include "string_format.hpp"
+#include "ui_freqman.hpp"
 
 using namespace portapack;
 
@@ -47,8 +49,61 @@ void RecentEntriesTable<SearchRecentEntries>::draw(
     painter.draw_string(target_rect.location(), style, to_string_short_freq(entry.frequency) + " " + entry.time + " " + str_duration);
 }
 
-void SearchView::focus() {
-    field_frequency_min.focus();
+/* SearchView ********************************************/
+
+SearchView::SearchView(
+    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,
+                  &field_threshold,
+                  &text_mean,
+                  &text_slices,
+                  &text_rate,
+                  &text_infos,
+                  &vu_max,
+                  &progress_timers,
+                  &check_snap,
+                  &options_snap,
+                  &big_display,
+                  &recent_entries_view});
+
+    baseband::set_spectrum(SEARCH_SLICE_WIDTH, 31);
+
+    recent_entries_view.set_parent_rect({0, 28 * 8, screen_width, 12 * 8});
+    recent_entries_view.on_select = [this, &nav](const SearchRecentEntry& entry) {
+        nav.push<FrequencySaveView>(entry.frequency);
+    };
+
+    text_mean.set_style(&Styles::grey);
+    text_slices.set_style(&Styles::grey);
+    text_rate.set_style(&Styles::grey);
+    progress_timers.set_style(&Styles::grey);
+    big_display.set_style(&Styles::grey);
+
+    field_frequency_min.set_step(100'000);
+    bind(field_frequency_min, settings_.freq_min, nav, [this](auto) {
+        on_range_changed();
+    });
+
+    field_frequency_max.set_step(100'000);
+    bind(field_frequency_max, settings_.freq_max, nav, [this](auto) {
+        on_range_changed();
+    });
+
+    bind(field_threshold, settings_.power_threshold);
+    bind(check_snap, settings_.snap_search);
+    bind(options_snap, settings_.snap_step);
+
+    progress_timers.set_max(DETECT_DELAY);
+
+    on_range_changed();
+    receiver_model.enable();
 }
 
 SearchView::~SearchView() {
@@ -56,6 +111,18 @@ SearchView::~SearchView() {
     baseband::shutdown();
 }
 
+void SearchView::on_show() {
+    baseband::spectrum_streaming_start();
+}
+
+void SearchView::on_hide() {
+    baseband::spectrum_streaming_stop();
+}
+
+void SearchView::focus() {
+    field_frequency_min.focus();
+}
+
 void SearchView::do_detection() {
     uint8_t power_max = 0;
     int32_t bin_max = -1;
@@ -83,7 +150,7 @@ void SearchView::do_detection() {
         if (power > overall_power_max)
             overall_power_max = power;
 
-        if ((power >= mean_power + power_threshold) && (power > power_max)) {
+        if ((power >= mean_power + settings_.power_threshold) && (power > power_max)) {
             power_max = power;
             bin_max = slices[slice].max_index;
             slice_max = slice;
@@ -104,7 +171,7 @@ void SearchView::do_detection() {
                     }
 
                     // Check range
-                    if ((resolved_frequency >= f_min) && (resolved_frequency <= f_max)) {
+                    if ((resolved_frequency >= settings_.freq_min) && (resolved_frequency <= settings_.freq_max)) {
                         duration = 0;
 
                         auto& entry = ::on_packet(recent, resolved_frequency);
@@ -159,16 +226,47 @@ void SearchView::do_detection() {
     }
 }
 
-void SearchView::add_spectrum_pixel(Color color) {
-    // Is avoiding floats really necessary ?
-    bin_skip_acc += bin_skip_frac;
-    if (bin_skip_acc < 0x10000)
-        return;
+void SearchView::do_timers() {
+    if (timing_div >= 60) {
+        // ~1Hz
 
-    bin_skip_acc -= 0x10000;
+        timing_div = 0;
 
-    if (pixel_index < 240)
-        spectrum_row[pixel_index++] = color;
+        // Update scan rate
+        text_rate.set(to_string_dec_uint(search_counter, 3));
+        search_counter = 0;
+    }
+
+    if (timing_div % 12 == 0) {
+        // ~5Hz
+
+        // Update power levels
+        text_mean.set(to_string_dec_uint(mean_power, 3));
+
+        vu_max.set_value(overall_power_max);
+        vu_max.set_mark(mean_power + settings_.power_threshold);
+    }
+
+    if (timing_div % 6 == 0) {
+        // ~10Hz
+
+        // Update timing indicator
+        if (locked) {
+            progress_timers.set_max(RELEASE_DELAY);
+            progress_timers.set_value(RELEASE_DELAY - release_timer);
+        } else {
+            progress_timers.set_max(DETECT_DELAY);
+            progress_timers.set_value(detect_timer);
+        }
+
+        // Increment timers
+        if (detect_timer < DETECT_DELAY) detect_timer++;
+        if (release_timer < RELEASE_DELAY) release_timer++;
+
+        if (locked) duration++;
+    }
+
+    timing_div++;
 }
 
 void SearchView::on_channel_spectrum(const ChannelSpectrum& spectrum) {
@@ -221,22 +319,14 @@ void SearchView::on_channel_spectrum(const ChannelSpectrum& spectrum) {
     baseband::spectrum_streaming_start();
 }
 
-void SearchView::on_show() {
-    baseband::spectrum_streaming_start();
-}
-
-void SearchView::on_hide() {
-    baseband::spectrum_streaming_stop();
-}
-
 void SearchView::on_range_changed() {
-    rf::Frequency slices_span, center_frequency;
+    rf::Frequency slices_span;
+    rf::Frequency center_frequency;
     int64_t offset;
     size_t slice;
 
-    f_min = field_frequency_min.value();
-    f_max = field_frequency_max.value();
-    search_span = abs(f_max - f_min);
+    // TODO: enforce min < max?
+    search_span = abs(settings_.freq_max - settings_.freq_min);
 
     if (search_span > SEARCH_SLICE_WIDTH) {
         // ex: 100M~115M (15M span):
@@ -253,14 +343,14 @@ void SearchView::on_range_changed() {
         // offset = 0 + 2.5/2 = 1.25M
         offset = ((search_span - slices_span) / 2) + (SEARCH_SLICE_WIDTH / 2);
         // slice_start = 100M + 1.25M = 101.25M
-        center_frequency = std::min(f_min, f_max) + offset;
+        center_frequency = std::min(settings_.freq_min, settings_.freq_max) + offset;
 
         for (slice = 0; slice < slices_nb; slice++) {
             slices[slice].center_frequency = center_frequency;
             center_frequency += SEARCH_SLICE_WIDTH;
         }
     } else {
-        slices[0].center_frequency = (f_max + f_min) / 2;
+        slices[0].center_frequency = (settings_.freq_max + settings_.freq_min) / 2;
         receiver_model.set_target_frequency(slices[0].center_frequency);
 
         slices_nb = 1;
@@ -272,139 +362,16 @@ void SearchView::on_range_changed() {
     slice_counter = 0;
 }
 
-void SearchView::on_lna_changed(int32_t v_db) {
-    receiver_model.set_lna(v_db);
-}
+void SearchView::add_spectrum_pixel(Color color) {
+    // Is avoiding floats really necessary?
+    bin_skip_acc += bin_skip_frac;
+    if (bin_skip_acc < 0x10000)
+        return;
 
-void SearchView::on_vga_changed(int32_t v_db) {
-    receiver_model.set_vga(v_db);
-}
+    bin_skip_acc -= 0x10000;
 
-void SearchView::do_timers() {
-    if (timing_div >= 60) {
-        // ~1Hz
-
-        timing_div = 0;
-
-        // Update scan rate
-        text_rate.set(to_string_dec_uint(search_counter, 3));
-        search_counter = 0;
-    }
-
-    if (timing_div % 12 == 0) {
-        // ~5Hz
-
-        // Update power levels
-        text_mean.set(to_string_dec_uint(mean_power, 3));
-
-        vu_max.set_value(overall_power_max);
-        vu_max.set_mark(mean_power + power_threshold);
-    }
-
-    if (timing_div % 6 == 0) {
-        // ~10Hz
-
-        // Update timing indicator
-        if (locked) {
-            progress_timers.set_max(RELEASE_DELAY);
-            progress_timers.set_value(RELEASE_DELAY - release_timer);
-        } else {
-            progress_timers.set_max(DETECT_DELAY);
-            progress_timers.set_value(detect_timer);
-        }
-
-        // Increment timers
-        if (detect_timer < DETECT_DELAY) detect_timer++;
-        if (release_timer < RELEASE_DELAY) release_timer++;
-
-        if (locked) duration++;
-    }
-
-    timing_div++;
-}
-
-SearchView::SearchView(
-    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,
-                  &field_threshold,
-                  &text_mean,
-                  &text_slices,
-                  &text_rate,
-                  &text_infos,
-                  &vu_max,
-                  &progress_timers,
-                  &check_snap,
-                  &options_snap,
-                  &big_display,
-                  &recent_entries_view});
-
-    baseband::set_spectrum(SEARCH_SLICE_WIDTH, 31);
-
-    recent_entries_view.set_parent_rect({0, 28 * 8, 240, 12 * 8});
-    recent_entries_view.on_select = [this, &nav](const SearchRecentEntry& entry) {
-        nav.push<FrequencyKeypadView>(entry.frequency);
-    };
-
-    text_mean.set_style(&Styles::grey);
-    text_slices.set_style(&Styles::grey);
-    text_rate.set_style(&Styles::grey);
-    progress_timers.set_style(&Styles::grey);
-    big_display.set_style(&Styles::grey);
-
-    check_snap.set_value(true);
-    options_snap.set_selected_index(1);  // 12.5kHz
-
-    field_threshold.set_value(80);
-    field_threshold.on_change = [this](int32_t value) {
-        power_threshold = value;
-    };
-
-    field_frequency_min.set_value(receiver_model.target_frequency() - 1000000);
-    field_frequency_min.set_step(100000);
-    field_frequency_min.on_change = [this](rf::Frequency) {
-        this->on_range_changed();
-    };
-    field_frequency_min.on_edit = [this, &nav]() {
-        auto new_view = nav.push<FrequencyKeypadView>(receiver_model.target_frequency() - 1000000);
-        new_view->on_changed = [this](rf::Frequency f) {
-            this->field_frequency_min.set_value(f);
-        };
-    };
-
-    field_frequency_max.set_value(receiver_model.target_frequency() + 1000000);
-    field_frequency_max.set_step(100000);
-    field_frequency_max.on_change = [this](rf::Frequency) {
-        this->on_range_changed();
-    };
-    field_frequency_max.on_edit = [this, &nav]() {
-        auto new_view = nav.push<FrequencyKeypadView>(receiver_model.target_frequency() + 1000000);
-        new_view->on_changed = [this](rf::Frequency f) {
-            this->field_frequency_max.set_value(f);
-        };
-    };
-
-    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);
-    };
-
-    progress_timers.set_max(DETECT_DELAY);
-
-    on_range_changed();
-
-    receiver_model.enable();
+    if (pixel_index < screen_width)
+        spectrum_row[pixel_index++] = color;
 }
 
 } /* namespace ui */

firmware/application/apps/ui_search.hpp

@@ -20,14 +20,13 @@
  * Boston, MA 02110-1301, USA.
  */
 
+#include "app_settings.hpp"
 #include "receiver_model.hpp"
+#include "recent_entries.hpp"
 #include "radio_state.hpp"
-
 #include "spectrum_color_lut.hpp"
-
 #include "ui_receiver.hpp"
 #include "ui_styles.hpp"
-#include "recent_entries.hpp"
 
 namespace ui {
 
@@ -91,10 +90,31 @@ class SearchView : public View {
    private:
     NavigationView& nav_;
     RxRadioState radio_state_{
+        100'000'000 /* frequency */,
         2500000 /* bandwidth */,
         SEARCH_SLICE_WIDTH /* sampling rate */,
         ReceiverModel::Mode::SpectrumAnalysis};
 
+    // Settings
+    struct SearchSettings {
+        uint32_t power_threshold = 80;
+        rf::Frequency freq_min = 100'000'000;
+        rf::Frequency freq_max = 400'000'000;
+        bool snap_search = true;
+        uint32_t snap_step = 12'500;
+    };
+    SearchSettings settings_{};
+    app_settings::SettingsManager app_settings_{
+        "rx_search"sv,
+        app_settings::Mode::RX,
+        {
+            {"power_threshold"sv, &settings_.power_threshold},
+            {"freq_min"sv, &settings_.freq_min},
+            {"freq_max"sv, &settings_.freq_max},
+            {"snap_search"sv, &settings_.snap_search},
+            {"snap_step"sv, &settings_.snap_step},
+        }};
+
     struct slice_t {
         rf::Frequency center_frequency;
         uint8_t max_power;
@@ -103,33 +123,36 @@ class SearchView : public View {
         int16_t index;
     } slices[32];
 
-    uint32_t bin_skip_acc{0}, bin_skip_frac{};
-    uint32_t pixel_index{0};
-    std::array<Color, 240> spectrum_row = {0};
-    ChannelSpectrumFIFO* fifo{nullptr};
-    rf::Frequency f_min{0}, f_max{0};
-    uint8_t detect_timer{0}, release_timer{0}, timing_div{0};
-    uint8_t overall_power_max{0};
-    uint32_t mean_power{0}, mean_acc{0};
-    uint32_t duration{0};
-    uint32_t power_threshold{80};  // Todo: Put this in persistent / settings
-    rf::Frequency slice_start{0};
-    uint8_t slices_nb{0};
-    uint8_t slice_counter{0};
-    int16_t last_bin{0};
-    uint32_t last_slice{0};
-    Coord last_tick_pos{0};
-    rf::Frequency search_span{0}, resolved_frequency{0};
-    uint16_t locked_bin{0};
-    uint8_t search_counter{0};
-    bool locked{false};
+    uint32_t bin_skip_acc = 0;
+    uint32_t bin_skip_frac = 0;
+    uint32_t pixel_index = 0;
+    std::array<Color, 240> spectrum_row{};
+    ChannelSpectrumFIFO* fifo = nullptr;
 
+    uint8_t detect_timer = 0;
+    uint8_t release_timer = 0;
+    uint8_t timing_div = 0;
+    uint8_t overall_power_max{0};
+    uint32_t mean_power = 0;
+    uint32_t mean_acc = 0;
+    uint32_t duration = 0;
+
+    rf::Frequency slice_start = 0;
+    uint8_t slices_nb = 0;
+    uint8_t slice_counter = 0;
+    int16_t last_bin = 0;
+    uint32_t last_slice = 0;
+    Coord last_tick_pos = 0;
+    rf::Frequency search_span = 0;
+    rf::Frequency resolved_frequency = 0;
+    uint16_t locked_bin = 0;
+    uint8_t search_counter = 0;
+    bool locked = false;
+
+    void do_detection();
+    void do_timers();
     void on_channel_spectrum(const ChannelSpectrum& spectrum);
     void on_range_changed();
-    void do_detection();
-    void on_lna_changed(int32_t v_db);
-    void on_vga_changed(int32_t v_db);
-    void do_timers();
     void add_spectrum_pixel(Color color);
 
     const RecentEntriesColumns columns{{{"Frequency", 9},
@@ -150,6 +173,7 @@ class SearchView : public View {
         {1 * 8, 1 * 16}};
     FrequencyField field_frequency_max{
         {11 * 8, 1 * 16}};
+
     LNAGainField field_lna{
         {22 * 8, 1 * 16}};
     VGAGainField field_vga{
@@ -191,10 +215,10 @@ class SearchView : public View {
         {17 * 8, 15 * 8},  // Position
         7,                 // Length
         {                  // Options
-         {"25kHz  ", 25000},
-         {"12.5kHz", 12500},
-         {"8.33kHz", 8333},
-         {"2.5kHz", 2500},
+         {"25kHz  ", 25'000},
+         {"12.5kHz", 12'500},
+         {"8.33kHz", 8'333},
+         {"2.5kHz", 2'500},
          {"500Hz", 500}}};
 
     BigFrequency big_display{
@@ -207,6 +231,7 @@ class SearchView : public View {
             const auto message = *reinterpret_cast<const ChannelSpectrumConfigMessage*>(p);
             this->fifo = message.fifo;
         }};
+
     MessageHandlerRegistration message_handler_frame_sync{
         Message::ID::DisplayFrameSync,
         [this](const Message* const) {

firmware/application/apps/ui_settings.cpp

@@ -2,6 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2023 gullradriel, Nilorea Studio Inc.
+ * Copyright (C) 2023 Kyle Reed
  *
  * This file is part of PortaPack.
  *
@@ -125,8 +126,29 @@ SetRadioView::SetRadioView(
         nav.pop();
     };
 
+    add_children({
+        &label_source,
+        &value_source,
+        &value_source_frequency,
+        &check_clkout,
+        &field_clkout_freq,
+        &labels_clkout_khz,
+        &labels_bias,
+        &check_bias,
+        &disable_external_tcxo,  // TODO: always show?
+        &button_save,
+        &button_cancel,
+    });
+
     const auto reference = clock_manager.get_reference();
 
+    if (reference.source == ClockManager::ReferenceSource::Xtal) {
+        add_children({
+            &labels_correction,
+            &field_ppm,
+        });
+    }
+
     std::string source_name("---");
     switch (reference.source) {
         case ClockManager::ReferenceSource::Xtal:
@@ -141,34 +163,15 @@ SetRadioView::SetRadioView(
     }
 
     value_source.set(source_name);
-    value_source_frequency.set(to_string_dec_uint(reference.frequency / 1000000, 2) + "." + to_string_dec_uint((reference.frequency % 1000000) / 100, 4, '0') + " MHz");
+    value_source_frequency.set(
+        to_string_dec_uint(reference.frequency / 1000000, 2) + "." +
+        to_string_dec_uint((reference.frequency % 1000000) / 100, 4, '0') + " MHz");
 
+    // Make these Text controls look like Labels.
     label_source.set_style(&Styles::light_grey);
     value_source.set_style(&Styles::light_grey);
     value_source_frequency.set_style(&Styles::light_grey);
 
-    add_children({
-        &label_source,
-        &value_source,
-        &value_source_frequency,
-    });
-
-    if (reference.source == ClockManager::ReferenceSource::Xtal) {
-        add_children({
-            &labels_correction,
-            &field_ppm,
-        });
-    }
-
-    add_children({&check_clkout,
-                  &field_clkout_freq,
-                  &labels_clkout_khz,
-                  &value_freq_step,
-                  &labels_bias,
-                  &check_bias,
-                  &button_save,
-                  &button_cancel});
-
     SetFrequencyCorrectionModel model{
         static_cast<int8_t>(pmem::correction_ppb() / 1000), 0};
 
@@ -181,29 +184,20 @@ SetRadioView::SetRadioView(
         send_system_refresh();
     };
 
-    field_clkout_freq.set_value(pmem::clkout_freq());
-    value_freq_step.set_style(&Styles::light_grey);
+    // Disallow CLKOUT freq change on hackrf_r9 due to dependencies on GP_CLKIN (same Si5351A clock);
+    // see comments in ClockManager::enable_clock_output()
+    if (hackrf_r9) {
+        if (pmem::clkout_freq() != 10000)
+            pmem::set_clkout_freq(10000);
+        field_clkout_freq.set_focusable(false);
+    }
 
-    field_clkout_freq.on_select = [this](NumberField&) {
-        freq_step_khz++;
-        if (freq_step_khz > 3) {
-            freq_step_khz = 0;
-        }
-        switch (freq_step_khz) {
-            case 0:
-                value_freq_step.set("   |");
-                break;
-            case 1:
-                value_freq_step.set("  | ");
-                break;
-            case 2:
-                value_freq_step.set(" |  ");
-                break;
-            case 3:
-                value_freq_step.set("|   ");
-                break;
-        }
-        field_clkout_freq.set_step(pow(10, freq_step_khz));
+    field_clkout_freq.set_value(pmem::clkout_freq());
+    field_clkout_freq.on_change = [this](SymField&) {
+        if (field_clkout_freq.to_integer() < 4)  // Min. CLK out of Si5351A/B/C-B is 2.5khz , but in our application -intermediate freq 800Mhz-,Min working CLK=4khz.
+            field_clkout_freq.set_value(4);
+        if (field_clkout_freq.to_integer() > 60000)
+            field_clkout_freq.set_value(60000);
     };
 
     check_bias.set_value(get_antenna_bias());
@@ -221,10 +215,13 @@ SetRadioView::SetRadioView(
         send_system_refresh();
     };
 
+    disable_external_tcxo.set_value(pmem::config_disable_external_tcxo());
+
     button_save.on_select = [this, &nav](Button&) {
         const auto model = this->form_collect();
         pmem::set_correction_ppb(model.ppm * 1000);
         pmem::set_clkout_freq(model.freq);
+        pmem::set_config_disable_external_tcxo(disable_external_tcxo.value());
         clock_manager.enable_clock_output(pmem::clkout_enabled());
         nav.pop();
     };
@@ -241,7 +238,7 @@ void SetRadioView::form_init(const SetFrequencyCorrectionModel& model) {
 SetFrequencyCorrectionModel SetRadioView::form_collect() {
     return {
         .ppm = static_cast<int8_t>(field_ppm.value()),
-        .freq = static_cast<uint32_t>(field_clkout_freq.value()),
+        .freq = static_cast<uint32_t>(field_clkout_freq.to_integer()),
     };
 }
 
@@ -336,39 +333,49 @@ void SetUIView::focus() {
     button_save.focus();
 }
 
-/* SetAppSettingsView ************************************/
+/* SetSDCardView *********************************************/
 
-SetAppSettingsView::SetAppSettingsView(NavigationView& nav) {
-    add_children({&checkbox_load_app_settings,
-                  &checkbox_save_app_settings,
+SetSDCardView::SetSDCardView(NavigationView& nav) {
+    add_children({&labels,
+                  &checkbox_sdcard_speed,
+                  &button_test_sdcard_high_speed,
+                  &text_sdcard_test_status,
                   &button_save,
                   &button_cancel});
 
-    checkbox_load_app_settings.set_value(pmem::load_app_settings());
-    checkbox_save_app_settings.set_value(pmem::save_app_settings());
+    checkbox_sdcard_speed.set_value(pmem::config_sdcard_high_speed_io());
+
+    button_test_sdcard_high_speed.on_select = [&nav, this](Button&) {
+        pmem::set_config_sdcard_high_speed_io(true, false);
+        text_sdcard_test_status.set("!! HIGH SPEED MODE ON !!");
+    };
 
     button_save.on_select = [&nav, this](Button&) {
-        pmem::set_load_app_settings(checkbox_load_app_settings.value());
-        pmem::set_save_app_settings(checkbox_save_app_settings.value());
+        pmem::set_config_sdcard_high_speed_io(checkbox_sdcard_speed.value(), true);
+        send_system_refresh();
         nav.pop();
     };
+
     button_cancel.on_select = [&nav, this](Button&) {
         nav.pop();
     };
 }
 
-void SetAppSettingsView::focus() {
+void SetSDCardView::focus() {
     button_save.focus();
 }
 
 /* SetConverterSettingsView ******************************/
 
 SetConverterSettingsView::SetConverterSettingsView(NavigationView& nav) {
-    add_children({&check_show_converter,
-                  &check_converter,
-                  &converter_mode,
-                  &button_converter_freq,
-                  &button_return});
+    add_children({
+        &labels,
+        &check_show_converter,
+        &check_converter,
+        &opt_converter_mode,
+        &field_converter_freq,
+        &button_return,
+    });
 
     check_show_converter.set_value(!pmem::ui_hide_converter());
     check_show_converter.on_select = [this](Checkbox&, bool v) {
@@ -378,7 +385,7 @@ SetConverterSettingsView::SetConverterSettingsView(NavigationView& nav) {
         }
         // Retune to take converter change in account.
         receiver_model.set_target_frequency(receiver_model.target_frequency());
-        // Refresh status bar with/out converter
+        // Refresh status bar converter icon.
         send_system_refresh();
     };
 
@@ -389,27 +396,30 @@ SetConverterSettingsView::SetConverterSettingsView(NavigationView& nav) {
             pmem::set_ui_hide_converter(false);
         }
         pmem::set_config_converter(v);
-        // Retune to take converter change in account
+        // Retune to take converter change in account.
         receiver_model.set_target_frequency(receiver_model.target_frequency());
-        // Refresh status bar with/out converter
+        // Refresh status bar converter icon.
         send_system_refresh();
     };
 
-    converter_mode.set_by_value(pmem::config_updown_converter());
-    converter_mode.on_change = [this](size_t, OptionsField::value_t v) {
+    opt_converter_mode.set_by_value(pmem::config_updown_converter());
+    opt_converter_mode.on_change = [this](size_t, OptionsField::value_t v) {
         pmem::set_config_updown_converter(v);
-        // Refresh status bar with icon up or down
+        // Refresh status bar with up or down icon.
         send_system_refresh();
     };
 
-    button_converter_freq.set_text(to_string_short_freq(pmem::config_converter_freq()) + "MHz");
-    button_converter_freq.on_select = [this, &nav](Button& button) {
-        auto new_view = nav.push<FrequencyKeypadView>(pmem::config_converter_freq());
-        new_view->on_changed = [this, &button](rf::Frequency f) {
-            pmem::set_config_converter_freq(f);
-            // Retune to take converter change in account
-            receiver_model.set_target_frequency(receiver_model.target_frequency());
-            button_converter_freq.set_text("<" + to_string_short_freq(f) + " MHz>");
+    field_converter_freq.set_step(1'000'000);
+    field_converter_freq.set_value(pmem::config_converter_freq());
+    field_converter_freq.on_change = [this](rf::Frequency f) {
+        pmem::set_config_converter_freq(f);
+        // Retune to take converter change in account.
+        receiver_model.set_target_frequency(receiver_model.target_frequency());
+    };
+    field_converter_freq.on_edit = [this, &nav]() {
+        auto new_view = nav.push<FrequencyKeypadView>(field_converter_freq.value());
+        new_view->on_changed = [this](rf::Frequency f) {
+            field_converter_freq.set_value(f);
         };
     };
 
@@ -425,46 +435,50 @@ void SetConverterSettingsView::focus() {
 /* SetFrequencyCorrectionView ****************************/
 
 SetFrequencyCorrectionView::SetFrequencyCorrectionView(NavigationView& nav) {
-    add_children({&text_freqCorrection_about,
-                  &frequency_rx_correction_mode,
-                  &frequency_tx_correction_mode,
-                  &button_freq_rx_correction,
-                  &button_freq_tx_correction,
-                  &button_return});
+    add_children({
+        &labels,
+        &opt_rx_correction_mode,
+        &field_rx_correction,
+        &opt_tx_correction_mode,
+        &field_tx_correction,
+        &button_return,
+    });
 
-    frequency_rx_correction_mode.set_by_value(pmem::config_freq_rx_correction_updown());
-    frequency_rx_correction_mode.on_change = [this](size_t, OptionsField::value_t v) {
+    opt_rx_correction_mode.set_by_value(pmem::config_freq_rx_correction_updown());
+    opt_rx_correction_mode.on_change = [this](size_t, OptionsField::value_t v) {
         pmem::set_freq_rx_correction_updown(v);
     };
 
-    frequency_tx_correction_mode.set_by_value(pmem::config_freq_rx_correction_updown());
-    frequency_tx_correction_mode.on_change = [this](size_t, OptionsField::value_t v) {
+    opt_tx_correction_mode.set_by_value(pmem::config_freq_tx_correction_updown());
+    opt_tx_correction_mode.on_change = [this](size_t, OptionsField::value_t v) {
         pmem::set_freq_tx_correction_updown(v);
     };
 
-    button_freq_rx_correction.set_text(to_string_short_freq(pmem::config_freq_rx_correction()) + "MHz (Rx)");
-    button_freq_rx_correction.on_select = [this, &nav](Button& button) {
-        auto new_view = nav.push<FrequencyKeypadView>(pmem::config_converter_freq());
-        new_view->on_changed = [this, &button](rf::Frequency f) {
-            if (f >= MAX_FREQ_CORRECTION)
-                f = MAX_FREQ_CORRECTION;
-            pmem::set_config_freq_rx_correction(f);
-            // Retune to take converter change in account
-            receiver_model.set_target_frequency(receiver_model.target_frequency());
-            button_freq_rx_correction.set_text("<" + to_string_short_freq(f) + " MHz>");
+    field_rx_correction.set_step(100'000);
+    field_rx_correction.set_value(pmem::config_freq_rx_correction());
+    field_rx_correction.on_change = [this](rf::Frequency f) {
+        pmem::set_config_freq_rx_correction(f);
+        // Retune to take converter change in account.
+        receiver_model.set_target_frequency(receiver_model.target_frequency());
+    };
+    field_rx_correction.on_edit = [this, &nav]() {
+        auto new_view = nav.push<FrequencyKeypadView>(field_rx_correction.value());
+        new_view->on_changed = [this](rf::Frequency f) {
+            field_rx_correction.set_value(f);
         };
     };
 
-    button_freq_tx_correction.set_text(to_string_short_freq(pmem::config_freq_tx_correction()) + "MHz (Tx)");
-    button_freq_tx_correction.on_select = [this, &nav](Button& button) {
-        auto new_view = nav.push<FrequencyKeypadView>(pmem::config_converter_freq());
-        new_view->on_changed = [this, &button](rf::Frequency f) {
-            if (f >= MAX_FREQ_CORRECTION)
-                f = MAX_FREQ_CORRECTION;
-            pmem::set_config_freq_tx_correction(f);
-            // Retune to take converter change in account
-            receiver_model.set_target_frequency(receiver_model.target_frequency());
-            button_freq_tx_correction.set_text("<" + to_string_short_freq(f) + " MHz>");
+    field_tx_correction.set_step(100'000);
+    field_tx_correction.set_value(pmem::config_freq_tx_correction());
+    field_tx_correction.on_change = [this](rf::Frequency f) {
+        pmem::set_config_freq_tx_correction(f);
+        // Retune to take converter change in account. NB: receiver_model.
+        receiver_model.set_target_frequency(receiver_model.target_frequency());
+    };
+    field_tx_correction.on_edit = [this, &nav]() {
+        auto new_view = nav.push<FrequencyKeypadView>(field_tx_correction.value());
+        new_view->on_changed = [this](rf::Frequency f) {
+            field_tx_correction.set_value(f);
         };
     };
 
@@ -480,49 +494,52 @@ void SetFrequencyCorrectionView::focus() {
 /* SetPersistentMemoryView *******************************/
 
 SetPersistentMemoryView::SetPersistentMemoryView(NavigationView& nav) {
-    add_children({&text_pmem_about,
-                  &text_pmem_informations,
-                  &text_pmem_status,
-                  &check_use_sdcard_for_pmem,
-                  &button_save_mem_to_file,
-                  &button_load_mem_from_file,
-                  &button_load_mem_defaults,
-                  &button_return});
+    add_children({
+        &labels,
+        &text_pmem_status,
+        &check_use_sdcard_for_pmem,
+        &button_save_mem_to_file,
+        &button_load_mem_from_file,
+        &button_load_mem_defaults,
+        &button_return,
+    });
+
+    text_pmem_status.set_style(&Styles::yellow);
 
     check_use_sdcard_for_pmem.set_value(pmem::should_use_sdcard_for_pmem());
     check_use_sdcard_for_pmem.on_select = [this](Checkbox&, bool v) {
         File pmem_flag_file_handle;
         if (v) {
             if (fs::file_exists(PMEM_FILEFLAG)) {
-                text_pmem_status.set("pmem flag already present");
+                text_pmem_status.set("P.Mem flag file present.");
             } else {
                 auto error = pmem_flag_file_handle.create(PMEM_FILEFLAG);
                 if (error)
-                    text_pmem_status.set("!err. creating pmem flagfile!");
+                    text_pmem_status.set("Error creating P.Mem File!");
                 else
-                    text_pmem_status.set("pmem flag file created");
+                    text_pmem_status.set("P.Mem flag file created.");
             }
         } else {
             auto result = delete_file(PMEM_FILEFLAG);
             if (result.code() != FR_OK)
-                text_pmem_status.set("!err. deleting pmem flagfile!");
+                text_pmem_status.set("Error deleting P.Mem flag!");
             else
-                text_pmem_status.set("pmem flag file deleted");
+                text_pmem_status.set("P.Mem flag file deleted.");
         }
     };
 
     button_save_mem_to_file.on_select = [&nav, this](Button&) {
         if (!pmem::save_persistent_settings_to_file())
-            text_pmem_status.set("!problem saving settings!");
+            text_pmem_status.set("Error saving settings!");
         else
-            text_pmem_status.set("settings saved");
+            text_pmem_status.set("Settings saved.");
     };
 
     button_load_mem_from_file.on_select = [&nav, this](Button&) {
         if (!pmem::load_persistent_settings_from_file()) {
-            text_pmem_status.set("!problem loading settings!");
+            text_pmem_status.set("Error loading settings!");
         } else {
-            text_pmem_status.set("settings loaded");
+            text_pmem_status.set("Settings loaded.");
             // Refresh status bar with icon up or down
             send_system_refresh();
         }
@@ -531,7 +548,7 @@ SetPersistentMemoryView::SetPersistentMemoryView(NavigationView& nav) {
     button_load_mem_defaults.on_select = [&nav, this](Button&) {
         nav.push<ModalMessageView>(
             "Warning!",
-            "This will reset the p.mem\nand set the default settings",
+            "This will reset the P.Mem\nto default settings.",
             YESNO,
             [this](bool choice) {
                 if (choice) {
@@ -577,9 +594,12 @@ void SetAudioView::focus() {
 /* SetQRCodeView *****************************************/
 
 SetQRCodeView::SetQRCodeView(NavigationView& nav) {
-    add_children({&checkbox_bigger_qr,
-                  &button_save,
-                  &button_cancel});
+    add_children({
+        &labels,
+        &checkbox_bigger_qr,
+        &button_save,
+        &button_cancel,
+    });
 
     checkbox_bigger_qr.set_value(pmem::show_bigger_qr_code());
 
@@ -629,16 +649,16 @@ SettingsMenuView::SettingsMenuView(NavigationView& nav) {
     }
     add_items({
         {"Audio", ui::Color::dark_cyan(), &bitmap_icon_speaker, [&nav]() { nav.push<SetAudioView>(); }},
+        {"Calibration", ui::Color::dark_cyan(), &bitmap_icon_options_touch, [&nav]() { nav.push<TouchCalibrationView>(); }},
+        {"Converter", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [&nav]() { nav.push<SetConverterSettingsView>(); }},
+        {"Date/Time", ui::Color::dark_cyan(), &bitmap_icon_options_datetime, [&nav]() { nav.push<SetDateTimeView>(); }},
+        {"Encoder Dial", ui::Color::dark_cyan(), &bitmap_icon_setup, [&nav]() { nav.push<SetEncoderDialView>(); }},
+        {"Freq. Correct", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [&nav]() { nav.push<SetFrequencyCorrectionView>(); }},
+        {"P.Memory Mgmt", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<SetPersistentMemoryView>(); }},
+        {"QR Code", ui::Color::dark_cyan(), &bitmap_icon_qr_code, [&nav]() { nav.push<SetQRCodeView>(); }},
         {"Radio", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [&nav]() { nav.push<SetRadioView>(); }},
         {"User Interface", ui::Color::dark_cyan(), &bitmap_icon_options_ui, [&nav]() { nav.push<SetUIView>(); }},
-        {"Date/Time", ui::Color::dark_cyan(), &bitmap_icon_options_datetime, [&nav]() { nav.push<SetDateTimeView>(); }},
-        {"Calibration", ui::Color::dark_cyan(), &bitmap_icon_options_touch, [&nav]() { nav.push<TouchCalibrationView>(); }},
-        {"App Settings", ui::Color::dark_cyan(), &bitmap_icon_setup, [&nav]() { nav.push<SetAppSettingsView>(); }},
-        {"Converter", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [&nav]() { nav.push<SetConverterSettingsView>(); }},
-        {"FreqCorrection", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [&nav]() { nav.push<SetFrequencyCorrectionView>(); }},
-        {"QR Code", ui::Color::dark_cyan(), &bitmap_icon_qr_code, [&nav]() { nav.push<SetQRCodeView>(); }},
-        {"P.Memory Mgmt", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<SetPersistentMemoryView>(); }},
-        {"Encoder Dial", ui::Color::dark_cyan(), &bitmap_icon_setup, [&nav]() { nav.push<SetEncoderDialView>(); }},
+        {"SD Card", ui::Color::dark_cyan(), &bitmap_icon_sdcard, [&nav]() { nav.push<SetSDCardView>(); }},
     });
     set_max_rows(2);  // allow wider buttons
 }

firmware/application/apps/ui_settings.hpp

@@ -2,6 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2023 gullradriel, Nilorea Studio Inc.
+ * Copyright (C) 2023 Kyle Reed
  *
  * This file is part of PortaPack.
  *
@@ -26,6 +27,7 @@
 
 #include "ui_widget.hpp"
 #include "ui_menu.hpp"
+#include "ui_receiver.hpp"
 #include "ui_navigation.hpp"
 #include "bitmap.hpp"
 #include "ff.h"
@@ -35,8 +37,6 @@
 
 namespace ui {
 
-#define MAX_FREQ_CORRECTION INT32_MAX
-
 struct SetDateTimeModel {
     uint16_t year;
     uint8_t month;
@@ -56,25 +56,28 @@ class SetDateTimeView : public View {
 
    private:
     Labels labels{
-        {{6 * 8, 7 * 16}, "YYYY-MM-DD HH:MM:SS", Color::grey()},
-        {{10 * 8, 9 * 16}, "-  -     :  :", Color::light_grey()}};
+        {{1 * 8, 1 * 16}, "Adjust the RTC clock date &", Color::light_grey()},
+        {{1 * 8, 2 * 16}, "time. If clock resets after", Color::light_grey()},
+        {{1 * 8, 3 * 16}, "reboot, coin batt. is dead. ", Color::light_grey()},
+        {{5 * 8, 8 * 16 - 2}, "YYYY-MM-DD HH:MM:SS", Color::grey()},
+        {{9 * 8, 9 * 16}, "-  -     :  :", Color::light_grey()}};
 
     NumberField field_year{
-        {6 * 8, 9 * 16},
+        {5 * 8, 9 * 16},
         4,
         {2015, 2099},
         1,
         '0',
     };
     NumberField field_month{
-        {11 * 8, 9 * 16},
+        {10 * 8, 9 * 16},
         2,
         {1, 12},
         1,
         '0',
     };
     NumberField field_day{
-        {14 * 8, 9 * 16},
+        {13 * 8, 9 * 16},
         2,
         {1, 31},
         1,
@@ -82,21 +85,21 @@ class SetDateTimeView : public View {
     };
 
     NumberField field_hour{
-        {17 * 8, 9 * 16},
+        {16 * 8, 9 * 16},
         2,
         {0, 23},
         1,
         '0',
     };
     NumberField field_minute{
-        {20 * 8, 9 * 16},
+        {19 * 8, 9 * 16},
         2,
         {0, 59},
         1,
         '0',
     };
     NumberField field_second{
-        {23 * 8, 9 * 16},
+        {22 * 8, 9 * 16},
         2,
         {0, 59},
         1,
@@ -131,47 +134,22 @@ class SetRadioView : public View {
     uint8_t freq_step_khz = 3;
 
     Text label_source{
-        {0, 1 * 16, 17 * 8, 16},
+        {1 * 8, 1 * 16, 17 * 8, 16},
         "Reference Source:"};
 
     Text value_source{
-        {(240 - 11 * 8), 1 * 16, 11 * 8, 16},
-        "---"};
+        {18 * 8, 1 * 16, 11 * 8, 16},
+        ""};
 
     Text value_source_frequency{
-        {(240 - 11 * 8), 2 * 16, 11 * 8, 16},
-        "---"};
+        {18 * 8, 2 * 16, 11 * 8, 16},
+        ""};
 
     Labels labels_correction{
         {{2 * 8, 3 * 16}, "Frequency correction:", Color::light_grey()},
         {{6 * 8, 4 * 16}, "PPM", Color::light_grey()},
     };
 
-    Checkbox check_clkout{
-        {18, (6 * 16 - 4)},
-        13,
-        "Enable CLKOUT"};
-
-    NumberField field_clkout_freq{
-        {20 * 8, 6 * 16},
-        5,
-        {10, 60000},
-        1000,
-        ' '};
-
-    Labels labels_clkout_khz{
-        {{26 * 8, 6 * 16}, "kHz", Color::light_grey()}};
-
-    Text value_freq_step{
-        {21 * 8, (7 * 16), 4 * 8, 16},
-        "|   "};
-
-    Labels labels_bias{
-        {{24, 8 * 16}, "CAUTION: Ensure that all", Color::red()},
-        {{28, 9 * 16}, "devices attached to the", Color::red()},
-        {{8, 10 * 16}, "antenna connector can accept", Color::red()},
-        {{68, 11 * 16}, "a DC voltage!", Color::red()}};
-
     NumberField field_ppm{
         {2 * 8, 4 * 16},
         3,
@@ -180,10 +158,34 @@ class SetRadioView : public View {
         '0',
     };
 
+    Checkbox check_clkout{
+        {18, (6 * 16 - 4)},
+        13,
+        "Enable CLKOUT"};
+
+    SymField field_clkout_freq{
+        {20 * 8, 6 * 16},
+        5,
+        SymField::Type::Dec};
+
+    Labels labels_clkout_khz{
+        {{26 * 8, 6 * 16}, "kHz", Color::light_grey()}};
+
+    Labels labels_bias{
+        {{4 * 8 + 4, 8 * 16}, "CAUTION: Ensure that all", Color::red()},
+        {{5 * 8 + 0, 9 * 16}, "devices attached to the", Color::red()},
+        {{6 * 8 + 0, 10 * 16}, "antenna connector can", Color::red()},
+        {{6 * 8 + 4, 11 * 16}, "accept a DC voltage!", Color::red()}};
+
     Checkbox check_bias{
         {18, 12 * 16},
         5,
-        "Turn on bias voltage"};
+        "Enable DC bias voltage"};
+
+    Checkbox disable_external_tcxo{
+        {18, 14 * 16},
+        5,
+        "Disable external TCXO"};
 
     Button button_save{
         {2 * 8, 16 * 16, 12 * 8, 32},
@@ -298,28 +300,35 @@ class SetUIView : public View {
 
     Button button_cancel{
         {16 * 8, 16 * 16, 12 * 8, 32},
-        "Cancel",
-    };
+        "Cancel"};
 };
 
-class SetAppSettingsView : public View {
+class SetSDCardView : public View {
    public:
-    SetAppSettingsView(NavigationView& nav);
+    SetSDCardView(NavigationView& nav);
 
     void focus() override;
 
-    std::string title() const override { return "AppSettings"; };
+    std::string title() const override { return "SD Card"; };
 
    private:
-    Checkbox checkbox_load_app_settings{
-        {3 * 8, 2 * 16},
-        25,
-        "Load app settings"};
+    Labels labels{
+        // 01234567890123456789012345678
+        {{1 * 8, 120 - 48}, "    HIGH SPEED SDCARD IO     ", Color::light_grey()},
+        {{1 * 8, 120 - 32}, "   May or may not work !!    ", Color::light_grey()}};
 
-    Checkbox checkbox_save_app_settings{
-        {3 * 8, 4 * 16},
-        25,
-        "Save app settings"};
+    Checkbox checkbox_sdcard_speed{
+        {2 * 8, 120},
+        20,
+        "enable high speed IO"};
+
+    Button button_test_sdcard_high_speed{
+        {2 * 8, 152, 27 * 8, 32},
+        "TEST BUTTON (NO PMEM SAVE)"};
+
+    Text text_sdcard_test_status{
+        {2 * 8, 198, 28 * 8, 16},
+        ""};
 
     Button button_save{
         {2 * 8, 16 * 16, 12 * 8, 32},
@@ -327,8 +336,7 @@ class SetAppSettingsView : public View {
 
     Button button_cancel{
         {16 * 8, 16 * 16, 12 * 8, 32},
-        "Cancel",
-    };
+        "Cancel"};
 };
 
 class SetConverterSettingsView : public View {
@@ -340,32 +348,38 @@ class SetConverterSettingsView : public View {
     std::string title() const override { return "Converter"; };
 
    private:
+    Labels labels{
+        {{1 * 8, 1 * 16}, "Options for working with", Color::light_grey()},
+        {{1 * 8, 2 * 16}, "up/down converter hardware", Color::light_grey()},
+        {{1 * 8, 3 * 16}, "like a Ham It Up.", Color::light_grey()},
+        {{2 * 8, 9 * 16 - 2}, "Conversion frequency:", Color::light_grey()},
+        {{18 * 8, 10 * 16}, "MHz", Color::light_grey()},
+    };
+
     Checkbox check_show_converter{
-        {18, 4 * 16},
+        {2 * 8, 5 * 16},
         19,
-        "show/hide converter"};
+        "Show converter icon"};
 
     Checkbox check_converter{
-        {18, 6 * 16},
-        7,
-        "enable/disable converter"};
+        {2 * 8, 7 * 16},
+        16,
+        "Enable converter"};
 
-    OptionsField converter_mode{
-        {18, 8 * 16 + 4},
-        0,
+    OptionsField opt_converter_mode{
+        {5 * 8, 10 * 16},
+        3,
         {
             {" + ", 0},  // up converter
-            {" - ", 1}   // down converter
+            {" - ", 1},  // down converter
         }};
 
-    Button button_converter_freq{
-        {18 + 4 * 8, 8 * 16, 16 * 8, 24},
-        "",
-    };
+    FrequencyField field_converter_freq{
+        {8 * 8, 10 * 16}};
 
     Button button_return{
         {16 * 8, 16 * 16, 12 * 8, 32},
-        "return",
+        "Return",
     };
 };
 
@@ -375,33 +389,36 @@ class SetFrequencyCorrectionView : public View {
 
     void focus() override;
 
-    std::string title() const override { return "FreqCorrect"; };
+    std::string title() const override { return "Freq Correct"; };
 
    private:
-    Text text_freqCorrection_about{
-        {0, 2 * 16, 240, 16},
-        "Set Frequency correction:"};
+    Labels labels{
+        {{1 * 8, 1 * 16}, "Frequency correction allows", Color::light_grey()},
+        {{1 * 8, 2 * 16}, "RX and TX frequencies to be", Color::light_grey()},
+        {{1 * 8, 3 * 16}, "adjusted for all apps.", Color::light_grey()},
+        {{2 * 8, 6 * 16}, "RX Adjustment Frequency", Color::light_grey()},
+        {{18 * 8, 7 * 16}, "MHz", Color::light_grey()},
+        {{2 * 8, 9 * 16}, "TX Adjustment Frequency", Color::light_grey()},
+        {{18 * 8, 10 * 16}, "MHz", Color::light_grey()},
+    };
 
-    OptionsField frequency_rx_correction_mode{
-        {18, 5 * 16 + 4},
-        0,
+    OptionsField opt_rx_correction_mode{
+        {5 * 8, 7 * 16},
+        3,
         {{" + ", 0},
          {" - ", 1}}};
 
-    OptionsField frequency_tx_correction_mode{
-        {18, 9 * 16 + 4},
-        0,
+    FrequencyField field_rx_correction{
+        {8 * 8, 7 * 16}};
+
+    OptionsField opt_tx_correction_mode{
+        {5 * 8, 10 * 16},
+        3,
         {{" + ", 0},
          {" - ", 1}}};
 
-    Button button_freq_rx_correction{
-        {18 + 4 * 8, 5 * 16, 20 * 8, 24},
-        "",
-    };
-    Button button_freq_tx_correction{
-        {18 + 4 * 8, 9 * 16, 20 * 8, 24},
-        "",
-    };
+    FrequencyField field_tx_correction{
+        {8 * 8, 10 * 16}};
 
     Button button_return{
         {16 * 8, 16 * 16, 12 * 8, 32},
@@ -419,11 +436,14 @@ class SetAudioView : public View {
 
    private:
     Labels labels{
-        {{2 * 8, 3 * 16}, "Tone key mix:   %", Color::light_grey()},
+        {{1 * 8, 1 * 16}, "Controls the volume of the", Color::light_grey()},
+        {{1 * 8, 2 * 16}, "tone when transmitting in", Color::light_grey()},
+        {{1 * 8, 3 * 16}, "Soundboard or Mic apps.", Color::light_grey()},
+        {{2 * 8, 5 * 16}, "Tone key mix:   %", Color::light_grey()},
     };
 
     NumberField field_tone_mix{
-        {16 * 8, 3 * 16},
+        {16 * 8, 5 * 16},
         2,
         {10, 99},
         1,
@@ -448,8 +468,13 @@ class SetQRCodeView : public View {
     std::string title() const override { return "QR Code"; };
 
    private:
+    Labels labels{
+        {{1 * 8, 1 * 16}, "Change the size of the QR", Color::light_grey()},
+        {{1 * 8, 2 * 16}, "code shown in Radiosonde.", Color::light_grey()},
+    };
+
     Checkbox checkbox_bigger_qr{
-        {3 * 8, 9 * 16},
+        {3 * 8, 4 * 16},
         20,
         "Show large QR code"};
 
@@ -475,11 +500,13 @@ class SetEncoderDialView : public View {
 
    private:
     Labels labels{
-        {{2 * 8, 3 * 16}, "Dial sensitivity:", Color::light_grey()},
+        {{1 * 8, 1 * 16}, "Adjusts how many steps to", Color::light_grey()},
+        {{1 * 8, 2 * 16}, "change the encoder value.", Color::light_grey()},
+        {{2 * 8, 4 * 16}, "Dial sensitivity:", Color::light_grey()},
     };
 
     OptionsField field_encoder_dial_sensitivity{
-        {20 * 8, 3 * 16},
+        {20 * 8, 4 * 16},
         6,
         {{"LOW", encoder_dial_sensitivity::DIAL_SENSITIVITY_LOW},
          {"NORMAL", encoder_dial_sensitivity::DIAL_SENSITIVITY_NORMAL},
@@ -504,34 +531,32 @@ class SetPersistentMemoryView : public View {
     std::string title() const override { return "P.Mem Mgmt"; };
 
    private:
-    Text text_pmem_about{
-        {0, 1 * 16, 240, 16},
-        "Persistent Memory from/to SD"};
-
-    Text text_pmem_informations{
-        {0, 2 * 16, 240, 16},
-        "use: when no/dead coin bat."};
+    Labels labels{
+        {{1 * 8, 1 * 16}, "Save persistent memory on SD", Color::light_grey()},
+        {{1 * 8, 2 * 16}, "card. Needed when device has", Color::light_grey()},
+        {{1 * 8, 3 * 16}, "dead/missing coin battery.", Color::light_grey()},
+    };
 
     Text text_pmem_status{
-        {0, 3 * 16, 240, 16},
+        {1 * 8, 4 * 16 + 8, 28 * 8, 16},
         ""};
 
     Checkbox check_use_sdcard_for_pmem{
-        {18, 6 * 16},
-        19,
-        "use sdcard for p.mem"};
+        {2 * 8, 6 * 16},
+        21,
+        "Use SD card for P.Mem"};
 
     Button button_save_mem_to_file{
-        {0, 8 * 16, 240, 32},
-        "save p.mem to sdcard"};
+        {1 * 8, 8 * 16, 28 * 8, 2 * 16},
+        "Save P.Mem to SD card"};
 
     Button button_load_mem_from_file{
-        {0, 10 * 16 + 4, 240, 32},
-        "load p.mem from sdcard"};
+        {1 * 8, 10 * 16 + 2, 28 * 8, 2 * 16},
+        "Load P.Mem from SD Card"};
 
     Button button_load_mem_defaults{
-        {0, 12 * 16 + 8, 240, 32},
-        "! reset p.mem, load defaults !"};
+        {1 * 8, 12 * 16 + 4, 28 * 8, 2 * 16},
+        "Reset P.Mem to defaults"};
 
     Button button_return{
         {16 * 8, 16 * 16, 12 * 8, 32},

firmware/application/apps/ui_siggen.cpp

@@ -50,7 +50,7 @@ void SigGenView::update_config() {
 }
 
 void SigGenView::update_tone() {
-    baseband::set_siggen_tone(symfield_tone.value_dec_u32());
+    baseband::set_siggen_tone(symfield_tone.to_integer());
 }
 
 void SigGenView::start_tx() {
@@ -87,18 +87,26 @@ SigGenView::SigGenView(
                   &field_stop,
                   &tx_view});
 
+    symfield_tone.hidden(1);        // At first launch , by default we are in CW Shape has NO MOD , we are not using Tone modulation.
+    symfield_tone.set_value(1000);  // Default: 1000 Hz
     options_shape.on_change = [this](size_t, OptionsField::value_t v) {
         text_shape.set(shape_strings[v]);
         if (auto_update)
             update_config();
+        if ((v == 0) || (v == 6)) {  // In Shapes Options (CW & Pseudo Random Noise) we are not using Tone modulation freq.
+            symfield_tone.hidden(1);
+        } else {
+            symfield_tone.hidden(0);
+        }
+        set_dirty();
     };
     options_shape.set_selected_index(0);
     text_shape.set(shape_strings[0]);
 
     field_stop.set_value(1);
 
-    symfield_tone.set_sym(1, 1);  // Default: 1000 Hz
-    symfield_tone.on_change = [this]() {
+    symfield_tone.set_value(1000);  // Default: 1000 Hz
+    symfield_tone.on_change = [this](SymField&) {
         if (auto_update)
             update_tone();
     };

firmware/application/apps/ui_siggen.hpp

@@ -51,21 +51,23 @@ class SigGenView : public View {
     void on_tx_progress(const uint32_t progress, const bool done);
 
     TxRadioState radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         1536000 /* sampling rate */
     };
     app_settings::SettingsManager settings_{
         "tx_siggen", app_settings::Mode::TX};
 
-    const std::string shape_strings[7] = {
-        "CW-just carrier",
-        "Sine signal    ",
-        "Triangle signal",
-        "Saw up signal  ",
-        "Saw down signal",
-        "Square signal  ",
-        "Noise signal   "  // using 16 bits LFSR register, 16 order polynomial feedback.
-    };
+    const std::string shape_strings[9] = {
+        "CW  (No mod.) ",
+        "Sine mod. FM",
+        "Triangle mod.FM",  // max 15 character text space.
+        "Saw up mod. FM",
+        "Saw down mod.FM",
+        "Square mod. FM",
+        "Pseudo Noise FM",  // using 16 bits LFSR register, 16 order polynomial feedback.
+        "BPSK 0,1,0,1...",
+        "QPSK 00-01-10.."};
 
     bool auto_update{false};
 
@@ -85,16 +87,17 @@ class SigGenView : public View {
          {&bitmap_sig_saw_up, 3},
          {&bitmap_sig_saw_down, 4},
          {&bitmap_sig_square, 5},
-         {&bitmap_sig_noise, 6}}};
+         {&bitmap_sig_noise, 6},
+         {&bitmap_sig_noise, 7},    // Pending to add a correct BPSK icon.
+         {&bitmap_sig_noise, 8}}};  // Pending to add a correct QPSK icon.
 
     Text text_shape{
-        {15 * 8, 4 + 10, 8 * 8, 16},
+        {15 * 8, 4 + 10, 15 * 8, 16},
         ""};
 
     SymField symfield_tone{
-        {13 * 8, 7 * 8},
-        5,
-        SymField::SYMFIELD_DEC};
+        {12 * 8, 7 * 8},
+        5};
 
     Button button_update{
         {5 * 8, 10 * 8, 8 * 8, 3 * 8},

firmware/application/apps/ui_sonde.cpp

@@ -66,9 +66,6 @@ SondeView::SondeView(NavigationView& nav)
                   &button_see_qr,
                   &button_see_map});
 
-    if (!settings_.loaded())
-        field_frequency.set_value(initial_target_frequency);
-
     field_frequency.set_step(500);  // euquiq: was 10000, but we are using this for fine-tunning
 
     geopos.set_read_only(true);
@@ -194,7 +191,7 @@ void SondeView::on_packet(const sonde::Packet& packet) {
 
         if (temp_humid_info.temp != 0) {
             double decimals = abs(get_decimals(temp_humid_info.temp, 10, true));
-            text_temp.set(to_string_dec_int((int)temp_humid_info.temp) + "." + to_string_dec_uint(decimals, 1) + "C");
+            text_temp.set(to_string_dec_int((int)temp_humid_info.temp) + "." + to_string_dec_uint(decimals, 1) + STR_DEGREES_C);
         }
 
         gps_info = packet.get_GPS_data();

firmware/application/apps/ui_sonde.hpp

@@ -68,6 +68,7 @@ class SondeView : public View {
    private:
     NavigationView& nav_;
     RxRadioState radio_state_{
+        402700000 /* frequency */,
         1750000 /* bandwidth */,
         2457600 /* sampling rate */
     };
@@ -75,7 +76,6 @@ class SondeView : public View {
         "rx_sonde", app_settings::Mode::RX};
 
     std::unique_ptr<SondeLogger> logger{};
-    uint32_t target_frequency_{402700000};
     bool logging{false};
     bool use_crc{false};
     bool beep{false};

firmware/application/apps/ui_spectrum_painter.cpp

@@ -85,7 +85,11 @@ SpectrumPainterView::SpectrumPainterView(
 
             if (tx_mode == 0 && image_input_avaliable == false)
                 return;
-
+            /* By experimental test measurement, we got a good painted spectrum quality when selecting
+            a BW GUI App range from 100k ... 2M aprox. In that range , the best TX LPF filter = 1M75 (the min)
+            With this min TX LPF filter , we minimized the harmonics aliasing multipicture overlapped.
+            So original fw 1.7.4., was already selecting the best setting (1M75)  */
+            transmitter_model.set_baseband_bandwidth(1'750'000);  // Already tested, is the best setting for this App.
             transmitter_model.enable();
 
             if (persistent_memory::stealth_mode()) {

firmware/application/apps/ui_spectrum_painter_image.cpp

@@ -40,17 +40,13 @@ SpectrumInputImageView::SpectrumInputImageView(NavigationView& nav) {
         auto open_view = nav.push<FileLoadView>(".bmp");
 
         constexpr auto data_directory = u"SPECTRUM";
-        if (std::filesystem::is_directory(data_directory) == false) {
-            if (make_new_directory(data_directory).ok())
-                open_view->push_dir(data_directory);
-        } else
-            open_view->push_dir(data_directory);
+        ensure_directory(data_directory);
+        open_view->push_dir(data_directory);
 
         open_view->on_changed = [this](std::filesystem::path new_file_path) {
             this->file = new_file_path.string();
             painted = false;
             this->set_dirty();
-
             this->on_input_avaliable();
         };
     };

firmware/application/apps/ui_sstvtx.cpp

@@ -35,7 +35,7 @@ namespace ui {
 
 void SSTVTXView::focus() {
     if (file_error)
-        nav_.display_modal("No files", "No valid bitmaps\nin /sstv directory.", ABORT, nullptr);
+        nav_.display_modal("No files", "No valid bitmaps\nin /sstv directory.", ABORT);
     else
         options_bitmaps.focus();
 }
@@ -160,6 +160,7 @@ void SSTVTXView::start_tx() {
     scanline_counter = 0;
     prepare_scanline();  // Preload one scanline
 
+    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF 1M75, same spectrum as previous fw 1.7.4
     transmitter_model.enable();
 
     baseband::set_sstv_data(