added executeable bit for new scripts (#1471 )

External apps (#1469 )
* implemented external app build * added some ui stuff for testing * added pacman game * wired key to pacman game * fixed pacman drawing issue * changed afsk rx app to be external * fixed ui::NavigationView initialization for external apps * refactoring * refactoring * moved m4 image to external app * added script for external app deployment * refactoring * implemented dynamic app listing * added color to app icon * improved app loading * added external apps to sd card content * refactoring * review findings * typo * review findings * improved memory management of bitmaps
2026-08-27 09:59:03 +00:00 · 2023-10-03 08:17:45 +02:00 · 2023-10-02 20:19:22 +02:00 · 2023-10-01 09:04:37 -07:00 · 2023-09-29 18:55:27 +02:00 · 2023-09-27 21:03:02 +02:00
201 changed files with 16556 additions and 2789 deletions
@@ -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 }}
@@ -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 }}
@@ -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)

@@ -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)
@@ -55,8 +56,15 @@ add_custom_target(
 	program
 	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.
@@ -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)
@@ -182,6 +183,7 @@ set(CPPSRC
 	io_convert.cpp
 	io_file.cpp
 	io_wave.cpp
+	iq_trim.cpp
 	irq_controls.cpp
 	irq_lcd_frame.cpp
 	irq_rtc.cpp
@@ -238,43 +240,63 @@ 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/capture_app.cpp
+	apps/ert_app.cpp
+	apps/gps_sim_app.cpp
+	apps/lge_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_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_iq_trim.cpp
 	apps/ui_jammer.cpp
-    #apps/ui_keyfob.cpp
+    # apps/ui_keyfob.cpp
 	apps/ui_lcr.cpp
-	apps/lge_app.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_test.cpp
 	apps/ui_text_editor.cpp
 	apps/ui_tone_search.cpp
@@ -282,26 +304,6 @@ set(CPPSRC
 	apps/ui_touchtunes.cpp
 	apps/ui_view_wav.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
@@ -316,9 +318,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.
@@ -394,7 +400,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 +469,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
 )

@@ -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,139 @@

 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});
+
+    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 +227,81 @@ 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_{},
-      loaded_{false} {
+      bindings_{},
+      loaded_{false},
+      radio_loaded_{false} {
    settings_.mode = mode;
    settings_.options = options;
-    auto result = load_settings(app_name_, settings_);

-    if (result == ResultCode::Ok) {
-        loaded_ = true;
+    // Pre-alloc enough for app settings and additional settings.
+    additional_settings.reserve(17 + additional_settings.size());
+    bindings_ = std::move(additional_settings);
+
+    // Additional settings should always be loaded because apps now rely
+    // on being able to store UI settings, config, etc. The radio settings
+    // are only loaded if the global option has been enabled.
+    // Add the radio setting bindings if either load or save are enabled.
+    if (portapack::persistent_memory::load_app_settings() ||
+        portapack::persistent_memory::save_app_settings()) {
+        // 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);
+    }
+
+    loaded_ = load_settings(app_name_, bindings_);
+
+    // Only copy to the radio if load was successful.
+    if (loaded_ && portapack::persistent_memory::load_app_settings()) {
+        radio_loaded_ = true;
        copy_to_radio_model(settings_);
    }
 }

 SettingsManager::~SettingsManager() {
-    if (portapack::persistent_memory::save_app_settings()) {
+    // Only save radio settings when the option is enabled.
+    if (portapack::persistent_memory::save_app_settings())
        copy_from_radio_model(settings_);
-        save_settings(app_name_, settings_);
-    }
+
+    save_settings(app_name_, bindings_);
 }

 }  // namespace app_settings
@@ -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,85 @@
 #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 {
+// Bring in the string_view literal.
+using std::literals::operator""sv;

-enum class ResultCode : uint8_t {
-    Ok,                // settings found
-    LoadFailed,        // settings (file) not found
-    SaveFailed,        // unable to save settings
-    SettingsDisabled,  // load/save disabled in settings
+/* 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 +120,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;
@@ -80,9 +144,6 @@ struct AppSettings {
    uint8_t volume;
 };

-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 +151,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,14 +169,19 @@ class SettingsManager {

    /* True if settings were successfully loaded from file. */
    bool loaded() const { return loaded_; }
+
+    /* True if radio settings were successfully loaded from file. */
+    bool radio_loaded() const { return radio_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_;
+    bool radio_loaded_;
 };

 }  // namespace app_settings
@@ -382,7 +382,7 @@ AISAppView::AISAppView(NavigationView& nav)

    recent_entry_detail_view.hidden(true);

-    if (!settings_.loaded())
+    if (!settings_.radio_loaded())
        receiver_model.set_target_frequency(initial_target_frequency);

    receiver_model.enable();
@@ -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);
@@ -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_????.*",
@@ -110,7 +110,7 @@ ERTAppView::ERTAppView(NavigationView&) {
        &recent_entries_view,
    });

-    if (!settings_.loaded())
+    if (!settings_.radio_loaded())
        receiver_model.set_target_frequency(initial_target_frequency);

    receiver_model.enable();
@@ -173,7 +173,7 @@ GpsSimAppView::GpsSimAppView(
        &waterfall,
    });

-    if (!settings_.loaded()) {
+    if (!settings_.radio_loaded()) {
        field_frequency.set_value(initial_target_frequency);
        transmitter_model.set_sampling_rate(2600000);
    }
@@ -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"
@@ -109,10 +106,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},
@@ -69,7 +69,7 @@ void LGEView::generate_frame_touche() {
    // 0D 96 02 12 0E 00 46 28 01 45 27 01 44 23 66 30
    std::vector<uint8_t> data{0x46, 0x28, 0x01, 0x45, 0x27, 0x01, 0x44, 0x23};

-    console.write("\n\x1B\x07Touche:\x1B\x10");
+    console.write("\n" STR_COLOR_LIGHT_GREY "Touche:");
    generate_lge_frame(0x96, (field_player.value() << 8) | field_room.value(), 0x0001, data);
 }

@@ -111,7 +111,7 @@ void LGEView::generate_frame_nickname() {

    data.insert(data.end(), data_footer.begin(), data_footer.end());

-    console.write("\n\x1B\x0ESet nickname:\x1B\x10");
+    console.write("\n" STR_COLOR_YELLOW "Set nickname:");

    generate_lge_frame(0x02, 0x001A, field_player.value(), data);
 }
@@ -141,7 +141,7 @@ void LGEView::generate_frame_team() {

    data.push_back(field_team.value() - 1);  // Color ?

-    console.write("\n\x1B\x0ASet team:\x1B\x10");
+    console.write("\n" STR_COLOR_GREEN "Set team:");

    generate_lge_frame(0x03, data);
 }
@@ -173,9 +173,7 @@ void LGEView::generate_frame_broadcast_nickname() {

    data.push_back(field_team.value());

-    console.write(
-        "\n\x1B\x09"
-        "Broadcast nickname:\x1B\x10");
+    console.write("\n" STR_COLOR_BLUE "Broadcast nickname:");

    generate_lge_frame(0x04, data);
 }
@@ -187,14 +185,14 @@ void LGEView::generate_frame_start() {

    // data[0] = field_room.value();	// ?

-    console.write("\n\x1B\x0DStart:\x1B\x10");
+    console.write("\n" STR_COLOR_MAGENTA "Start:");
    generate_lge_frame(0x05, data);
 }

 void LGEView::generate_frame_gameover() {
    std::vector<uint8_t> data{(uint8_t)field_room.value()};

-    console.write("\n\x1B\x0CGameover:\x1B\x10");
+    console.write("\n" STR_COLOR_RED "Gameover:");
    generate_lge_frame(0x0D, data);
 }

@@ -229,9 +227,7 @@ void LGEView::generate_frame_collier() {

    data.push_back(checksum - id);

-    console.write(
-        "\n\x1B\x06"
-        "Config:\x1B\x10");
+    console.write("\n" STR_COLOR_DARK_YELLOW "Config:");
    generate_lge_frame(0x00, 0x3713, 0x3713, data);
 }

@@ -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,103 @@ 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())
+    // 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;
+    }
+    if (!app_settings_.radio_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;
    }

-    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 +149,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 */
@@ -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,98 @@ 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(); };
+    static constexpr uint32_t initial_target_frequency = 466'175'000;
+    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};

-    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 +296,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 */
@@ -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();
 }

@@ -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},
@@ -157,7 +157,7 @@ TPMSAppView::TPMSAppView(NavigationView&) {
                  &field_vga,
                  &recent_entries_view});

-    if (!settings_.loaded())
+    if (!settings_.radio_loaded())
        receiver_model.set_target_frequency(initial_target_frequency);

    receiver_model.enable();
@@ -146,9 +146,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}};
@@ -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,15 @@ 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("");
                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 +53,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");
@@ -40,24 +40,22 @@ void RecentEntriesTable<AircraftRecentEntries>::draw(
    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;
+        entry_string = "";
        target_color = Color::green();
    } else if (entry_age < ADSB_RECENT) {
-        aged_color = 0x07;
+        entry_string = STR_COLOR_LIGHT_GREY;
        target_color = Color::light_grey();
    } else {
-        aged_color = 0x08;
+        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 + "   ") +
        to_string_dec_uint((unsigned int)(entry.pos.altitude / 100), 4) +
@@ -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();

@@ -135,7 +135,7 @@ class ADSBSquawkView : public OptionTabView {
    SymField field_squawk{
        {10 * 8, 2 * 16},
        4,
-        SymField::SYMFIELD_OCT};
+        SymField::Type::Oct};
 };

 class ADSBTXThread {
@@ -235,7 +235,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},
@@ -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(), ' ');
@@ -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;
@@ -68,7 +68,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 +80,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},
@@ -42,12 +42,12 @@ CoasterPagerView::~CoasterPagerView() {
 }

 void CoasterPagerView::generate_frame() {
-    uint8_t frame[19];
-    uint32_t c;
+    constexpr uint8_t frame_bytes = 19;
+    uint8_t frame[frame_bytes];

    // Preamble (8 bytes)
-    for (c = 0; c < 8; c++)
-        frame[c] = 0x55;  // Isn't this 0xAA ?
+    for (uint8_t c = 0; c < 8; c++)
+        frame[c] = 0x55;

    // Sync word
    frame[8] = 0x2D;
@@ -57,11 +57,11 @@ void CoasterPagerView::generate_frame() {
    frame[10] = 8;

    // Data
-    for (c = 0; c < 8; c++)
-        frame[c + 11] = (sym_data.get_sym(c * 2) << 4) | sym_data.get_sym(c * 2 + 1);
+    auto data_bytes = to_byte_array(sym_data.to_integer());
+    memcpy(&frame[11], data_bytes.data(), data_bytes.size());

    // Copy for baseband
-    memcpy(shared_memory.bb_data.data, frame, 19);
+    memcpy(shared_memory.bb_data.data, frame, frame_bytes);
 }

 void CoasterPagerView::start_tx() {
@@ -72,12 +72,7 @@ void CoasterPagerView::start_tx() {
    baseband::set_fsk_data(19 * 8, 2280000 / 1000, 5000, 32);
 }

-void CoasterPagerView::on_tx_progress(const uint32_t progress, const bool done) {
-    (void)progress;
-
-    uint16_t address = 0;
-    uint32_t c;
-
+void CoasterPagerView::on_tx_progress(const uint32_t /*progress*/, const bool done) {
    if (done) {
        if (tx_mode == SINGLE) {
            transmitter_model.disable();
@@ -85,18 +80,12 @@ void CoasterPagerView::on_tx_progress(const uint32_t progress, const bool done)
            tx_view.set_transmitting(false);
        } else if (tx_mode == SCAN) {
            // Increment address
-
-            for (c = 0; c < 4; c++) {
-                address <<= 4;
-                address |= sym_data.get_sym(12 + c);
-            }
+            uint64_t data = sym_data.to_integer();
+            uint16_t address = data & 0xFFFF;

            address++;
-
-            for (c = 0; c < 4; c++) {
-                sym_data.set_sym(15 - c, address & 0x0F);
-                address >>= 4;
-            }
+            data = (data & 0xFFFFFFFFFFFF0000) + address;
+            sym_data.set_value(data);

            start_tx();
        }
@@ -104,9 +93,6 @@ void CoasterPagerView::on_tx_progress(const uint32_t progress, const bool done)
 }

 CoasterPagerView::CoasterPagerView(NavigationView& nav) {
-    const uint8_t data_init[8] = {0x44, 0x01, 0x3B, 0x30, 0x30, 0x30, 0x34, 0xBC};
-    uint32_t c;
-
    baseband::run_image(portapack::spi_flash::image_tag_fsktx);

    add_children({&labels,
@@ -115,9 +101,7 @@ CoasterPagerView::CoasterPagerView(NavigationView& nav) {
                  &text_message,
                  &tx_view});

-    // Bytes to nibbles
-    for (c = 0; c < 16; c++)
-        sym_data.set_sym(c, (data_init[c >> 1] >> ((c & 1) ? 0 : 4)) & 0x0F);
+    sym_data.set_value(0x44013B30303034BC);

    checkbox_scan.set_value(false);

@@ -68,17 +68,19 @@ class CoasterPagerView : public View {

    SymField sym_data{
        {7 * 8, 8 * 8},
-        16,  // 14 ? 12 ?
-        SymField::SYMFIELD_HEX};
+        16,
+        SymField::Type::Hex};

    Checkbox checkbox_scan{
        {10 * 8, 14 * 8},
        4,
        "Scan"};

-    /*ProgressBar progressbar {
-                { 5 * 8, 12 * 16, 20 * 8, 16 },
-        };*/
+    /*
+    ProgressBar progressbar {
+        { 5 * 8, 12 * 16, 20 * 8, 16 }};
+    */
+
    Text text_message{
        {5 * 8, 13 * 16, 20 * 8, 16},
        ""};
@@ -20,6 +20,7 @@
 */

 #include "ui_debug.hpp"
+#include "debug.hpp"

 #include "ch.h"

@@ -127,7 +128,7 @@ TemperatureWidget::temperature_t TemperatureWidget::temperature(const sample_t s
 }

 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(
@@ -397,16 +398,17 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
        add_items({{"..", ui::Color::light_grey(), &bitmap_icon_previous, [&nav]() { nav.pop(); }}});
    }
    add_items({
+        {"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(); }},
+        //{"Fonts Viewer", ui::Color::dark_cyan(), &bitmap_icon_notepad, [&nav]() { nav.push<DebugFontsView>(); }},  // temporarily disabled to conserve ROM space
+        {"M0 Stack Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { stack_dump(); }},
        {"Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryView>(); }},
+        {"P.Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugPmemView>(); }},
+        {"Peripherals", ui::Color::dark_cyan(), &bitmap_icon_peripherals, [&nav]() { nav.push<DebugPeripheralsMenuView>(); }},
        //{ "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>(); }},
    });
    set_max_rows(2);  // allow wider buttons
 }
@@ -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 {
@@ -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 {
@@ -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();
@@ -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},
@@ -27,6 +27,7 @@
 #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 "string_format.hpp"
@@ -44,6 +45,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 +108,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;
 }
@@ -185,11 +190,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 +254,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 +287,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 +328,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 +350,6 @@ FileSaveView::FileSaveView(
        file_{ file }
 {
        add_children({
-                &labels,
                &text_path,
                &button_edit_path,
                &text_name,
@@ -523,6 +530,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 +556,6 @@ FileManagerView::FileManagerView(

    add_children({
        &menu_view,
-        &labels,
        &text_date,
        &button_rename,
        &button_delete,
@@ -560,10 +569,16 @@ FileManagerView::FileManagerView(
    });

    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 +637,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.");
    };
@@ -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.
    };

@@ -115,11 +116,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 +214,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 +270,8 @@ class FileManagerView : public FileManBaseView {
        {4 * 8, 34 * 8, 4 * 8, 32},
        {},
        &bitmap_icon_options_datetime,
-        Color::orange()};
+        Color::orange(),
+        /*vcenter*/ true};
 };

 } /* namespace ui */
@@ -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)
@@ -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},
@@ -0,0 +1,194 @@
+/*
+ * 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,
+        &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) {
+            path_ = std::move(path);
+            profile_capture();
+            compute_range();
+            refresh_ui();
+        };
+    };
+
+    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();
+    };
+
+    button_trim.on_select = [this](Button&) {
+        if (trim_capture()) {
+            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));
+    text_max.set(to_string_dec_uint(info_->max_power));
+    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());
+    progress_ui.clear();
+
+    if (!trimmed)
+        nav_.display_modal("Error", "Trimming failed.");
+
+    return trimmed;
+}
+
+}  // namespace ui
@@ -0,0 +1,152 @@
+/*
+ * 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);
+
+    std::string title() const override { return "IQ Trim"; }
+    void paint(Painter& painter) override;
+    void focus() override;
+
+   private:
+    /* 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()},
+    };
+
+    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, 10 * 8, 1 * 16},
+        "0"};
+
+    NumberField field_cutoff{
+        {9 * 8, 10 * 16},
+        3,
+        {1, 100},
+        1,
+        ' '};
+
+    Button button_trim{
+        {20 * 8, 16 * 16, 8 * 8, 2 * 16},
+        "Trim"};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_IQ_TRIM_H__*/
@@ -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();

@@ -48,7 +48,7 @@ class KeyfobView : public View {
        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 +98,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},
@@ -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;
@@ -174,48 +176,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);
    }
@@ -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{
@@ -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
@@ -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},
@@ -633,7 +633,7 @@ 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.set_target_frequency(tx_frequency);
    transmitter_model.disable();
    if (rx_enabled)  // Also turn off audio rx if enabled
        rxaudio(false);
@@ -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"
@@ -219,10 +216,8 @@ 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},
@@ -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);

@@ -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},
@@ -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;
@@ -142,16 +142,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"};
@@ -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,17 +266,16 @@ void PlaylistView::send_current_track() {
        return;
    }

-    // ReplayThread starts immediately on construction so
-    // these need to be set before creating the ReplayThread.
+    // Update the sample rate in proc_replay baseband.
+    baseband::set_sample_rate(current()->metadata.sample_rate,
+                              get_oversample_rate(current()->metadata.sample_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(current()->metadata.sample_rate * 8);
+    transmitter_model.set_sampling_rate(get_actual_sample_rate(current()->metadata.sample_rate));
    transmitter_model.set_baseband_bandwidth(baseband_bandwidth);
    transmitter_model.enable();

-    // 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());
-
    // 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);
@@ -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,7 @@ class PlaylistView : public View {

    // More header == less spectrum view.
    static constexpr ui::Dim header_height = 6 * 16;
-    static constexpr uint32_t baseband_bandwidth = 2500000;
+    static constexpr uint32_t baseband_bandwidth = 2'500'000;

    struct playlist_entry {
        std::filesystem::path path{};
@@ -118,14 +115,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 +129,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},
@@ -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;
@@ -137,12 +137,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)
@@ -94,8 +94,7 @@ class POCSAGTXView : public View {

    SymField field_address{
        {11 * 8, 6 * 8},
-        7,
-        SymField::SYMFIELD_DEC};
+        7};

    OptionsField options_type{
        {11 * 8, 8 * 8},
@@ -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
@@ -287,7 +287,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 },
@@ -37,6 +37,22 @@ namespace fs = std::filesystem;

 namespace ui {

+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();
 }
@@ -160,67 +176,16 @@ 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();
+    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 +255,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 +268,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();
@@ -373,29 +325,17 @@ ReconView::ReconView(NavigationView& nav)
    };

    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 +459,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.
@@ -562,9 +501,14 @@ ReconView::ReconView(NavigationView& nav)
        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();

@@ -690,16 +634,9 @@ 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);
            freqlist_cleared_for_ui_action = false;
@@ -747,7 +684,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);
@@ -839,17 +775,7 @@ 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();
 }
@@ -861,10 +787,6 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
    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
@@ -892,7 +814,6 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
            status = 0;
            freq_lock = 0;
            timer = local_recon_lock_duration;
-            big_display.set_style(&Styles::white);
        }
        if (freq_lock < recon_lock_nb_match)  // LOCKING
        {
@@ -1202,48 +1123,50 @@ size_t ReconView::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("        ");
            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 +1174,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);
@@ -68,8 +68,9 @@ class ReconView : public View {

    RxRadioState radio_state_{};
    app_settings::SettingsManager settings_{
-        "rx_recon", app_settings::Mode::RX};
+        "rx_recon"sv, app_settings::Mode::RX};

+    void check_update_ranges_from_current();
    void set_loop_config(bool v);
    void clear_freqlist_for_ui_action();
    void reset_indexes();
@@ -89,8 +90,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();
@@ -163,6 +163,21 @@ class ReconView : public View {
    systime_t chrono_start{};
    systime_t chrono_end{};

+    // 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{
@@ -31,9 +31,6 @@
 #include "ui_navigation.hpp"
 #include "string_format.hpp"

-// maximum usable freq
-#define MAX_UFREQ 7200000000
-
 // 1Mhz helper
 #ifdef OneMHz
 #undef OneMHz
@@ -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 */
@@ -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 */
@@ -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) {
@@ -726,9 +729,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
@@ -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},
@@ -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.
        }
    }
 }
@@ -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_;
@@ -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 */
@@ -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 {

@@ -95,6 +94,26 @@ class SearchView : public View {
        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 +122,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 +172,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 +214,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 +230,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) {
@@ -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,30 @@ SetRadioView::SetRadioView(
        nav.pop();
    };

+    add_children({
+        &label_source,
+        &value_source,
+        &value_source_frequency,
+        &check_clkout,
+        &field_clkout_freq,
+        &labels_clkout_khz,
+        &value_freq_step,
+        &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 +164,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};

@@ -221,10 +225,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();
    };
@@ -339,10 +346,13 @@ void SetUIView::focus() {
 /* SetAppSettingsView ************************************/

 SetAppSettingsView::SetAppSettingsView(NavigationView& nav) {
-    add_children({&checkbox_load_app_settings,
-                  &checkbox_save_app_settings,
-                  &button_save,
-                  &button_cancel});
+    add_children({
+        &labels,
+        &checkbox_load_app_settings,
+        &checkbox_save_app_settings,
+        &button_save,
+        &button_cancel,
+    });

    checkbox_load_app_settings.set_value(pmem::load_app_settings());
    checkbox_save_app_settings.set_value(pmem::save_app_settings());
@@ -364,11 +374,14 @@ void SetAppSettingsView::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 +391,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 +402,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 +441,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_rx_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 +500,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 +554,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 +600,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());

@@ -628,17 +654,17 @@ SettingsMenuView::SettingsMenuView(NavigationView& nav) {
        add_items({{"..", ui::Color::light_grey(), &bitmap_icon_previous, [&nav]() { nav.pop(); }}});
    }
    add_items({
+        {"App Settings", ui::Color::dark_cyan(), &bitmap_icon_setup, [&nav]() { nav.push<SetAppSettingsView>(); }},
        {"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>(); }},
    });
    set_max_rows(2);  // allow wider buttons
 }
@@ -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,22 +134,30 @@ 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()},
    };

+    NumberField field_ppm{
+        {2 * 8, 4 * 16},
+        3,
+        {-50, 50},
+        1,
+        '0',
+    };
+
    Checkbox check_clkout{
        {18, (6 * 16 - 4)},
        13,
@@ -167,23 +178,20 @@ class SetRadioView : public View {
        "|   "};

    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,
-        {-50, 50},
-        1,
-        '0',
-    };
+        {{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},
@@ -307,19 +315,25 @@ class SetAppSettingsView : public View {
    SetAppSettingsView(NavigationView& nav);

    void focus() override;
-
-    std::string title() const override { return "AppSettings"; };
+    std::string title() const override { return "App Settings"; };

   private:
+    Labels labels{
+        {{1 * 8, 1 * 16}, "App settings are saved to", Color::light_grey()},
+        {{1 * 8, 2 * 16}, "the SD card in /SETTINGS.", Color::light_grey()},
+        {{1 * 8, 3 * 16}, "Radio settings may also be", Color::light_grey()},
+        {{1 * 8, 4 * 16}, "loaded or saved per app.", Color::light_grey()},
+    };
+
    Checkbox checkbox_load_app_settings{
-        {3 * 8, 2 * 16},
+        {3 * 8, 6 * 16},
        25,
-        "Load app settings"};
+        "Load radio settings"};

    Checkbox checkbox_save_app_settings{
-        {3 * 8, 4 * 16},
+        {3 * 8, 8 * 16},
        25,
-        "Save app settings"};
+        "Save radio settings"};

    Button button_save{
        {2 * 8, 16 * 16, 12 * 8, 32},
@@ -340,32 +354,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 +395,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 +442,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 +474,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 +506,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 +537,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},
@@ -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() {
@@ -97,8 +97,8 @@ SigGenView::SigGenView(

    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();
    };
@@ -92,9 +92,8 @@ class SigGenView : public View {
        ""};

    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},
@@ -66,7 +66,7 @@ SondeView::SondeView(NavigationView& nav)
                  &button_see_qr,
                  &button_see_map});

-    if (!settings_.loaded())
+    if (!settings_.radio_loaded())
        field_frequency.set_value(initial_target_frequency);

    field_frequency.set_step(500);  // euquiq: was 10000, but we are using this for fine-tunning
@@ -194,7 +194,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();
@@ -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();
        };
    };
@@ -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();
 }
@@ -29,14 +29,6 @@
 using namespace portapack;
 namespace fs = std::filesystem;

-namespace {
-/*void log(const std::string& msg) {
-    LogFile log{};
-    log.append("LOGS/Notepad.txt");
-    log.write_entry(msg);
-}*/
-}  // namespace
-
 namespace ui {

 /* TextViewer *******************************************************/
@@ -360,6 +352,8 @@ TextEditorView::TextEditorView(NavigationView& nav)
            &text_size,
        });

+    viewer.set_font_zoom(enable_zoom);
+
    viewer.on_select = [this]() {
        // Treat as if menu button was pressed.
        if (button_menu.on_select)
@@ -382,7 +376,7 @@ TextEditorView::TextEditorView(NavigationView& nav)
    };

    menu.on_zoom() = [this]() {
-        viewer.toggle_font_zoom();
+        enable_zoom = viewer.toggle_font_zoom();
        refresh_ui();
        hide_menu(true);
    };
@@ -411,16 +405,9 @@ TextEditorView::TextEditorView(NavigationView& nav)
    };

    menu.on_open() = [this]() {
-        /*show_save_prompt([this]() {
+        show_save_prompt([this]() {
            show_file_picker();
-        });*/
-        // HACK: above should work but it's faulting.
-        if (!file_dirty_) {
-            show_file_picker();
-        } else {
-            show_save_prompt(nullptr);
-            show_file_picker(false);
-        }
+        });
    };

    menu.on_save() = [this]() {
@@ -528,16 +515,16 @@ void TextEditorView::hide_menu(bool hidden) {
    set_dirty();
 }

-void TextEditorView::show_file_picker(bool immediate) {
-    // TODO: immediate is a hack until nav_.on_pop is fixed.
-    auto open_view = immediate ? nav_.push<FileLoadView>("") : nav_.push_under_current<FileLoadView>("");
-
-    if (open_view) {
-        open_view->on_changed = [this](std::filesystem::path path) {
-            open_file(path);
+void TextEditorView::show_file_picker() {
+    auto open_view = nav_.push<FileLoadView>("");
+    open_view->on_changed = [this](std::filesystem::path path) {
+        // Can't update the UI focus while the FileLoadView is still up.
+        // Do this on a continuation instead of in on_changed.
+        nav_.set_on_pop([this, p = std::move(path)]() {
+            open_file(p);
            hide_menu();
-        };
-    }
+        });
+    };
 }

 void TextEditorView::show_edit_line() {
@@ -19,10 +19,6 @@
 * Boston, MA 02110-1301, USA.
 */

-/* TODO:
- * - Busy indicator while reading files.
- */
-
 #ifndef __UI_TEXT_EDITOR_H__
 #define __UI_TEXT_EDITOR_H__

@@ -32,6 +28,7 @@
 #include "ui_styles.hpp"
 #include "ui_widget.hpp"

+#include "app_settings.hpp"
 #include "file_wrapper.hpp"
 #include "optional.hpp"

@@ -80,7 +77,10 @@ class TextViewer : public Widget {

    const Style& style() { return *font_style; }
    void set_font_zoom(bool zoom);
-    void toggle_font_zoom() { set_font_zoom(!font_zoom); };
+    bool toggle_font_zoom() {
+        set_font_zoom(!font_zoom);
+        return font_zoom;
+    };

   private:
    bool font_zoom{};
@@ -220,6 +220,12 @@ class TextEditorView : public View {
    void on_show() override;

   private:
+    // Settings
+    bool enable_zoom = false;
+    SettingsStore settings_store_{
+        "notepad"sv,
+        {{"enable_zoom"sv, &enable_zoom}}};
+
    static constexpr size_t max_edit_length = 1024;
    std::string edit_line_buffer_{};

@@ -228,7 +234,7 @@ class TextEditorView : public View {
    void refresh_ui();
    void update_position();
    void hide_menu(bool hidden = true);
-    void show_file_picker(bool immediate = true);
+    void show_file_picker();
    void show_edit_line();
    void show_save_prompt(std::function<void()> continuation);

@@ -242,8 +248,8 @@ class TextEditorView : public View {
    bool has_temp_file_{false};

    TextViewer viewer{
-        /* 272 = 320 - 16 (top bar) - 32 (bottom controls) */
-        {0, 0, 240, 272}};
+        /* 272 = screen_height - 16 (top bar) - 32 (bottom controls) */
+        {0, 0, screen_width, 272}};

    TextEditorMenu menu{};

@@ -251,7 +257,8 @@ class TextEditorView : public View {
        {26 * 8, 34 * 8, 4 * 8, 4 * 8},
        {},
        &bitmap_icon_controls,
-        Color::dark_grey()};
+        Color::dark_grey(),
+        /*vcenter*/ true};

    Text text_position{
        {0 * 8, 34 * 8, 26 * 8, 2 * 8},
@@ -138,17 +138,20 @@ ViewWavView::ViewWavView(
    reset_controls();
    button_open.on_select = [this, &nav](Button&) {
        auto open_view = nav.push<FileLoadView>(".WAV");
-        open_view->on_changed = [this](std::filesystem::path file_path) {
-            if (!wav_reader->open(file_path)) {
-                nav_.display_modal("Error", "Couldn't open file.");
-                return;
-            }
-            if ((wav_reader->channels() != 1) || (wav_reader->bits_per_sample() != 16)) {
-                nav_.display_modal("Error", "Wrong format.\nWav viewer only accepts\n16-bit mono files.");
-                return;
-            }
-            load_wav(file_path);
-            field_pos_seconds.focus();
+        open_view->on_changed = [this, &nav](std::filesystem::path file_path) {
+            // Can't show new dialogs in an on_changed handler, so use continuation.
+            nav.set_on_pop([this, &nav, file_path]() {
+                if (!wav_reader->open(file_path)) {
+                    nav_.display_modal("Error", "Couldn't open file.");
+                    return;
+                }
+                if ((wav_reader->channels() != 1) || (wav_reader->bits_per_sample() != 16)) {
+                    nav_.display_modal("Error", "Wrong format.\nWav viewer only accepts\n16-bit mono files.");
+                    return;
+                }
+                load_wav(file_path);
+                field_pos_seconds.focus();
+            });
        };
    };

@@ -189,7 +189,16 @@ void kill_afsk() {
    send_message(&message);
 }

-void set_audiotx_config(const uint32_t divider, const float deviation_hz, const float audio_gain, uint8_t audio_shift_bits_s16, const uint32_t tone_key_delta, const bool am_enabled, const bool dsb_enabled, const bool usb_enabled, const bool lsb_enabled) {
+void set_audiotx_config(
+    const uint32_t divider,
+    const float deviation_hz,
+    const float audio_gain,
+    uint8_t audio_shift_bits_s16,
+    const uint32_t tone_key_delta,
+    const bool am_enabled,
+    const bool dsb_enabled,
+    const bool usb_enabled,
+    const bool lsb_enabled) {
    const AudioTXConfigMessage message{
        divider,
        deviation_hz,
@@ -320,6 +329,30 @@ void run_image(const spi_flash::image_tag_t image_tag) {
    }
 }

+void run_prepared_image(const uint32_t m4_code) {
+    if (baseband_image_running) {
+        chDbgPanic("BBRunning");
+    }
+
+    creg::m4txevent::clear();
+    shared_memory.clear_baseband_ready();
+
+    m4_init_prepared(m4_code, false);
+    baseband_image_running = true;
+
+    creg::m4txevent::enable();
+
+    if constexpr (enforce_core_sync) {
+        // Wait up to 3 seconds for baseband to start handling events.
+        auto count = 3'000u;
+        while (!shared_memory.baseband_ready && --count)
+            chThdSleepMilliseconds(1);
+
+        if (count == 0)
+            chDbgPanic("Baseband Sync Fail");
+    }
+}
+
 void shutdown() {
    if (!baseband_image_running) {
        return;
@@ -347,13 +380,8 @@ void spectrum_streaming_stop() {
    send_message(&message);
 }

-void set_sample_rate(const uint32_t sample_rate) {
-    SamplerateConfigMessage message{sample_rate};
-    send_message(&message);
-}
-
-void set_oversample_rate(OversampleRate oversample_rate) {
-    OversampleRateConfigMessage message{oversample_rate};
+void set_sample_rate(uint32_t sample_rate, OversampleRate oversample_rate) {
+    SampleRateConfigMessage message{sample_rate, oversample_rate};
    send_message(&message);
 }

@@ -89,13 +89,14 @@ void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bo
 void request_beep();

 void run_image(const portapack::spi_flash::image_tag_t image_tag);
+void run_prepared_image(const uint32_t m4_code);
 void shutdown();

 void spectrum_streaming_start();
 void spectrum_streaming_stop();

-void set_sample_rate(const uint32_t sample_rate);
-void set_oversample_rate(OversampleRate oversample_rate);
+/* NB: sample_rate should be desired rate. Don't pre-scale. */
+void set_sample_rate(uint32_t sample_rate, OversampleRate oversample_rate = OversampleRate::None);
 void capture_start(CaptureConfig* const config);
 void capture_stop();
 void replay_start(ReplayConfig* const config);
@@ -0,0 +1,117 @@
+/*
+ * 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 __BINDER_H__
+#define __BINDER_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_widget.hpp"
+
+namespace ui {
+
+/* Default no-op binding callback. */
+struct NoOp {
+    NoOp() {}
+    template <typename T>
+    void operator()(T) const {}
+};
+
+/* The gist of the bind functions is to bind a control
+ * to a value.
+ *     bind(control, value)
+ *
+ * An optional callback can be specified which will be called
+ * when the control's value is changed.
+ *    bind(control, value, [](auto new_val) { ... });
+ *
+ * Some controls need a reference to the NavigationView so
+ * edit dialogs (like text_prompt) can be launched.
+ *    bind(control, value, nav, [](auto new_val) { ... });
+ *
+ * Be careful with lifetime of captured objects. Most things
+ * are captured by reference so the caller will need to ensure
+ * adequate lifetime of the referenced instances.
+ */
+
+template <typename T, typename Fn = NoOp>
+void bind(Checkbox& check, T& value, Fn fn = Fn{}) {
+    check.set_value(value);
+    check.on_select = [&value, fn](Checkbox&, bool b) {
+        value = b;
+        fn(value);
+    };
+}
+
+template <typename T, typename Fn = NoOp>
+void bind(NumberField& field, T& value, Fn fn = Fn{}) {
+    field.set_value(value);
+    field.on_change = [&value, fn](int32_t v) {
+        value = v;
+        fn(value);
+    };
+}
+
+template <typename T, typename Fn = NoOp>
+void bind(OptionsField& field, T& value, Fn fn = Fn{}) {
+    field.set_by_value(static_cast<int32_t>(value));
+    field.on_change = [&value, fn](size_t, auto v) {
+        value = static_cast<T>(v);
+        fn(value);
+    };
+}
+
+template <typename T, typename Fn = NoOp>
+void bind(FrequencyField& field, T& value, NavigationView& nav, Fn fn = Fn{}) {
+    field.set_value(value);
+    field.on_change = [&value, fn](rf::Frequency f) {
+        value = f;
+        fn(value);
+    };
+    field.on_edit = [&field, &value, &nav]() {
+        auto freq_view = nav.push<FrequencyKeypadView>(value);
+        freq_view->on_changed = [&field](rf::Frequency f) {
+            field.set_value(f);
+        };
+    };
+}
+
+template <typename T, typename Fn = NoOp>
+void bind(TextField& field, T& value, NavigationView& nav, Fn fn = Fn{}) {
+    field.set_text(value);
+    field.on_change = [&value, fn](TextField& tf) {
+        value = tf.get_text();
+        fn(value);
+    };
+    // text_prompt needs a mutable working buffer.
+    // Capture a new string and make the lambda mutable so it can be modified.
+    field.on_select = [&nav, buf = std::string{}](TextField& tf) mutable {
+        buf = tf.get_text();
+        text_prompt(nav, buf, /*max_length*/ 255,
+                    [&tf](std::string& str) {
+                        tf.set_text(str);
+                    });
+    };
+}
+
+}  // namespace ui
+
+#endif /*__BINDER_H__*/
@@ -325,12 +325,18 @@ uint32_t ClockManager::measure_gp_clkin_frequency() {
 }

 bool ClockManager::loss_of_signal() {
-    return hackrf_r9
-               ? clock_generator.plla_loss_of_signal()
-               : clock_generator.clkin_loss_of_signal();
+    if (hackrf_r9) {
+        const auto frequency = measure_gp_clkin_frequency();
+        return (frequency < 9850000) || (frequency > 10150000);
+    } else {
+        return clock_generator.clkin_loss_of_signal();
+    }
 }

 ClockManager::ReferenceSource ClockManager::detect_reference_source() {
+    if (portapack::persistent_memory::config_disable_external_tcxo())
+        return ReferenceSource::Xtal;
+
    if (loss_of_signal()) {
        // No external reference. Turn on PortaPack reference (if present).
        portapack_tcxo_enable();
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config_mode.hpp"
+#include "core_control.hpp"
+#include "hackrf_gpio.hpp"
+#include "portapack_hal.hpp"
+
+void config_mode_blink_until_dfu();
+
+void config_mode_set() {
+    portapack::persistent_memory::set_config_mode_storage(CONFIG_MODE_GUARD_VALUE);
+}
+
+bool config_mode_should_enter() {
+    return portapack::persistent_memory::config_mode_storage() == CONFIG_MODE_GUARD_VALUE;
+}
+
+void config_mode_clear() {
+    portapack::persistent_memory::set_config_mode_storage(CONFIG_MODE_NORMAL_VALUE);
+}
+
+uint32_t blink_patterns[] = {
+    0x00000000,  // 0 Off
+    0xFFFFFFFF,  // 1 On
+    0xF0F0F0F0,  // 2 blink fast
+    0x00FF00FF,  // 3 blink slow
+    0xFFF3FFF3   // 4 inverse blink slow
+};
+
+void config_mode_run() {
+    configure_pins_portapack();
+    portapack::gpio_dfu.input();
+    portapack::persistent_memory::cache::init();
+
+    if (hackrf_r9) {
+        // When this runs on the hackrf r9 there likely was a crash during the last boot
+        // caused by the external tcxo. So we disable it unless the user is intentially
+        // running the config mode by pressing reset twice followed by pressing DFU.
+        auto old_disable_external_tcxo = portapack::persistent_memory::config_disable_external_tcxo();
+        portapack::persistent_memory::set_config_disable_external_tcxo(true);
+        portapack::persistent_memory::cache::persist();
+
+        config_mode_blink_until_dfu();
+
+        portapack::persistent_memory::set_config_disable_external_tcxo(old_disable_external_tcxo);
+        portapack::persistent_memory::cache::persist();
+    } else {
+        config_mode_blink_until_dfu();
+    }
+
+    auto last_dfu_btn = portapack::gpio_dfu.read();
+
+    int32_t counter = 0;
+    int8_t blink_pattern_value = portapack::persistent_memory::config_cpld() +
+                                 (portapack::persistent_memory::config_disable_external_tcxo() ? 5 : 0);
+
+    while (true) {
+        auto dfu_btn = portapack::gpio_dfu.read();
+        auto dfu_clicked = last_dfu_btn == true && dfu_btn == false;
+        last_dfu_btn = dfu_btn;
+
+        if (dfu_clicked) {
+            int8_t value = portapack::persistent_memory::config_cpld() +
+                           (portapack::persistent_memory::config_disable_external_tcxo() ? 5 : 0);
+
+            blink_pattern_value = value = (value + 1) % 10;
+
+            portapack::persistent_memory::set_config_cpld(value % 5);
+            portapack::persistent_memory::set_config_disable_external_tcxo((value / 5) == 1);
+
+            portapack::persistent_memory::cache::persist();
+        }
+
+        auto tx_blink_pattern = blink_patterns[blink_pattern_value % 5];
+        auto rx_blink_pattern = blink_patterns[blink_pattern_value / 5];
+
+        auto tx_value = ((tx_blink_pattern >> ((counter >> 0) & 31)) & 0x1) == 0x1;
+        if (tx_value) {
+            hackrf::one::led_tx.on();
+        } else {
+            hackrf::one::led_tx.off();
+        }
+
+        auto rx_value = ((rx_blink_pattern >> ((counter >> 0) & 31)) & 0x1) == 0x1;
+        if (rx_value) {
+            hackrf::one::led_rx.on();
+        } else {
+            hackrf::one::led_rx.off();
+        }
+
+        chThdSleepMilliseconds(100);
+        counter++;
+    }
+}
+
+void config_mode_blink_until_dfu() {
+    while (true) {
+        hackrf::one::led_tx.on();
+        hackrf::one::led_rx.on();
+        hackrf::one::led_usb.on();
+        chThdSleepMilliseconds(10);
+
+        hackrf::one::led_tx.off();
+        hackrf::one::led_rx.off();
+        hackrf::one::led_usb.off();
+        chThdSleepMilliseconds(115);
+
+        auto dfu_btn = portapack::gpio_dfu.read();
+        if (dfu_btn)
+            break;
+    }
+
+    while (true) {
+        chThdSleepMilliseconds(10);
+
+        auto dfu_btn = portapack::gpio_dfu.read();
+        if (!dfu_btn)
+            break;
+    }
+
+    chThdSleepMilliseconds(10);
+}
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __CONFIG_MODE_H__
+#define __CONFIG_MODE_H__
+
+#include "ch.h"
+
+#include "portapack.hpp"
+#include "portapack_shared_memory.hpp"
+#include "portapack_persistent_memory.hpp"
+
+void config_mode_set();
+bool config_mode_should_enter();
+void config_mode_clear();
+
+void config_mode_run();
+
+#endif /* __CONFIG_MODE_H__ */
@@ -59,6 +59,19 @@ void m4_init(const spi_flash::image_tag_t image_tag, const memory::region_t to,
    chDbgPanic("NoImg");
 }

+void m4_init_prepared(const uint32_t m4_code, const bool full_reset) {
+    /* M4 core is assumed to be sleeping with interrupts off, so we can mess
+     * with its address space and RAM without concern.
+     */
+    LPC_CREG->M4MEMMAP = m4_code;
+
+    /* Reset M4 core and optionally all peripherals */
+    LPC_RGU->RESET_CTRL[0] = (full_reset) ? (1 << 1)    // PERIPH_RST
+                                          : (1 << 13);  // M4_RST
+
+    return;
+}
+
 void m4_request_shutdown() {
    baseband::shutdown();
 }
@@ -28,6 +28,7 @@
 #include "spi_image.hpp"

 void m4_init(const portapack::spi_flash::image_tag_t image_tag, const portapack::memory::region_t to, const bool full_reset);
+void m4_init_prepared(const uint32_t m4_code, const bool full_reset);
 void m4_request_shutdown();

 void m0_halt();
@@ -30,6 +30,7 @@
 #include "portapack.hpp"
 #include "string_format.hpp"
 #include "ui_styles.hpp"
+#include "irq_controls.hpp"

 using namespace ui;

@@ -46,10 +47,12 @@ void __debug_log(const std::string& msg) {
    pg_debug_log->write_entry(msg);
 }

-void runtime_error(LED);
+void runtime_error(uint8_t source);
 std::string number_to_hex_string(uint32_t);
 void draw_line(int32_t, const char*, regarm_t);
+void draw_stack_dump();
 static bool error_shown = false;
+uint32_t fault_address{0};

 void draw_guru_meditation_header(uint8_t source, const char* hint) {
    Painter painter;
@@ -67,8 +70,10 @@ void draw_guru_meditation_header(uint8_t source, const char* hint) {
    painter.draw_string({48, 24}, Styles::white, "M? Guru");
    painter.draw_string({48 + 8 * 8, 24}, Styles::white, "Meditation");

-    if (source == CORTEX_M0)
+    if (source == CORTEX_M0) {
        painter.draw_string({48 + 8, 24}, Styles::white, "0");
+        painter.draw_string({24, 320 - 32}, Styles::white, "Press DFU for Stack Dump");
+    }

    if (source == CORTEX_M4)
        painter.draw_string({48 + 8, 24}, Styles::white, "4");
@@ -83,11 +88,7 @@ void draw_guru_meditation(uint8_t source, const char* hint) {
        draw_guru_meditation_header(source, hint);
    }

-    if (source == CORTEX_M0)
-        runtime_error(hackrf::one::led_rx);
-
-    if (source == CORTEX_M4)
-        runtime_error(hackrf::one::led_tx);
+    runtime_error(source);
 }

 void draw_guru_meditation(uint8_t source, const char* hint, struct extctx* ctxp, uint32_t cfsr = 0) {
@@ -110,6 +111,7 @@ void draw_guru_meditation(uint8_t source, const char* hint, struct extctx* ctxp,
            // to see whats causing the fault.
            draw_line(80 + i++ * 20, "lr:", ctxp->lr_thd);
            draw_line(80 + i++ * 20, "pc:", ctxp->pc);
+            fault_address = (uint32_t)ctxp->pc;

            // see SCB_CFSR_* in libopencm3/cm3/scb.h for details
            if (cfsr != 0)
@@ -117,11 +119,7 @@ void draw_guru_meditation(uint8_t source, const char* hint, struct extctx* ctxp,
        }
    }

-    if (source == CORTEX_M0)
-        runtime_error(hackrf::one::led_rx);
-
-    if (source == CORTEX_M4)
-        runtime_error(hackrf::one::led_tx);
+    runtime_error(source);
 }

 void draw_line(int32_t y_offset, const char* label, regarm_t value) {
@@ -131,7 +129,9 @@ void draw_line(int32_t y_offset, const char* label, regarm_t value) {
    painter.draw_string({15 + 8 * 8, y_offset}, Styles::white, to_string_hex((uint32_t)value, 8));
 }

-void runtime_error(LED led) {
+void runtime_error(uint8_t source) {
+    LED led = (source == CORTEX_M0) ? hackrf::one::led_rx : hackrf::one::led_tx;
+
    led.off();

    while (true) {
@@ -139,9 +139,180 @@ void runtime_error(LED led) {
        while (n--)
            ;
        led.toggle();
+
+        // Stack dump will cover entire screen, so wait for DFU button press to attempt it
+        if (swizzled_switches() & (1 << (int)Switch::Dfu)) {
+            draw_stack_dump();
+        }
    }
 }

+// This function should only be called with interrupts disabled due to reading swizzled_switches()
+// Using the stack while dumping the stack isn't ideal, but hopefully anything imporant is still on the call stack.
+void draw_stack_dump() {
+    Painter painter;
+    uint32_t* p{&__process_stack_base__};
+    constexpr int border{8};
+    int x, y;
+    int n{0};
+    bool clear_rect{true};
+    bool first_pass{true};
+
+    // NOTE: Stays in this loop forever unless LEFT button pressed
+    while (1) {
+        if (clear_rect) {
+            painter.fill_rectangle(
+                {border, border, portapack::display.width() - (border * 2), portapack::display.height() - (border * 2)},
+                Color::black());
+            x = y = border;
+            clear_rect = false;
+        }
+
+        // skip past unused stack words on 1st pass
+        if (first_pass) {
+            first_pass = false;
+            while ((*p == CRT0_STACKS_FILL_PATTERN) && (p < &__process_stack_end__))
+                p++;
+
+            auto stack_space_left = p - &__process_stack_base__;
+
+            // NOTE: in situations like a hard fault it seems not possible to write strings longer than 16 characters.
+            painter.draw_string({x, y}, Styles::white_small, to_string_hex((uint32_t)&__process_stack_base__, 8));
+            x += 8 * 5;
+            painter.draw_string({x, y}, Styles::white_small, " M0 STACK free=");
+            x += 15 * 5;
+            painter.draw_string({x, y}, Styles::white_small, to_string_dec_uint(stack_space_left));
+            x = border;
+            y += 8;
+
+            // align subsequent lines to start on 16-byte boundaries
+            p -= (stack_space_left & 3);
+        }
+
+        // print one page of stack dump
+        while ((p < &__process_stack_end__) && (y < portapack::display.height() - border - 8)) {
+            // show address if start of line
+            if (n++ == 0) {
+                painter.draw_string({x, y}, Styles::white_small, to_string_hex((uint32_t)p, 8) + ":");
+                x += 9 * 5 - 2;  // note: saving 2 pixels here to prevent reaching right border
+            }
+
+            // show stack word -- highlight if a possible code address (low bit will be set too for !thumb) or actual fault address
+            bool code_addr = (*p > 0x1400) && (*p < 0x80000) && (((*p) & 0x1) == 0x1);  // approximate address range of code .text region in ROM
+            Style style = (fault_address && *p == fault_address) ? Styles::bg_yellow_small : (code_addr ? Styles::bg_white_small : Styles::white_small);
+            painter.draw_string({x, y}, style, " " + to_string_hex(*p, 8));
+            x += 9 * 5;
+
+            // new line?
+            if (n == 4) {
+                n = 0;
+                x = border;
+                y += 8;
+            }
+
+            // point to next stack word
+            p++;
+        }
+
+        // Out of room on the screen or end of stack - allow Up/Down paging.
+        // First wait for button release from previous press.
+        // NOTE: can't call swizzle_switches() with interrupted enabled!
+        while (swizzled_switches() & ((1 << (int)Switch::Right) | (1 << (int)Switch::Left) | (1 << (int)Switch::Down) | (1 << (int)Switch::Up) | (1 << (int)Switch::Sel) | (1 << (int)Switch::Dfu)))
+            ;
+
+        painter.draw_string({border, portapack::display.height() - border - 8}, Styles::white_small, "Use UP/DOWN key");
+
+        // Wait for button press.
+        while (1) {
+            auto switches = swizzled_switches();
+
+            // If LEFT button pressed, exit
+            if (switches & (1 << (int)Switch::Left))
+                return;
+
+            // If DOWN pressed; continue to show next page
+            if (switches & (1 << (int)Switch::Down))
+                break;
+
+            // If UP pressed, scroll back by one page
+            if (switches & (1 << (int)Switch::Up)) {
+                // Back up pointer by offset on this screen plus one full screen of 8 pixels per line & 4 words per line
+                // (underflow can't happen here due to stack address range in RAM)
+                p -= ((y - border) + (portapack::display.height() - (border * 2 + 1 * 8))) / (8 / 4);
+                if (p < &__process_stack_base__)
+                    p = &__process_stack_base__;
+                break;
+            }
+
+            // If SEL button pressed, try writing to file (likely to hang in fault condition but heh)
+            if (switches & (1 << (int)Switch::Sel))
+                stack_dump();
+        }
+
+        // clear screen to allow new range to be displayed, if we're not at the end
+        if (p < &__process_stack_end__)
+            clear_rect = true;
+    }
+}
+
+// Disk I/O in this function doesn't work after a fault
+// Using the stack while dumping the stack isn't ideal, but hopefully anything imporant is still on the call stack.
+bool stack_dump() {
+    Painter painter;
+    std::string debug_dir = "DEBUG";
+    std::filesystem::path filename{};
+    File stack_dump_file{};
+    bool error;
+    std::string str;
+    uint32_t* p;
+    int n{0};
+    bool data_found{false};
+
+    make_new_directory(debug_dir);
+    filename = next_filename_matching_pattern(debug_dir + "/STACK_DUMP_????.TXT");
+    error = filename.empty();
+    if (!error)
+        error = stack_dump_file.create(filename) != 0;
+    if (error) {
+        painter.draw_string({16, 320 - 32}, ui::Styles::red, "ERROR DUMPING " + filename.filename().string() + "!");
+        return false;
+    }
+
+    for (p = &__process_stack_base__; p < &__process_stack_end__; p++) {
+        // skip past unused stack words
+        if (!data_found) {
+            if (*p == CRT0_STACKS_FILL_PATTERN)
+                continue;
+            else {
+                data_found = true;
+                auto stack_space_left = p - &__process_stack_base__;
+                stack_dump_file.write_line(to_string_hex((uint32_t)&__process_stack_base__, 8) + ": Unused words " + to_string_dec_uint(stack_space_left));
+
+                // align subsequent lines to start on 16-byte boundaries
+                p -= (stack_space_left & 3);
+            }
+        }
+
+        // write address
+        if (n++ == 0) {
+            str = to_string_hex((uint32_t)p, 8) + ":";
+            stack_dump_file.write(str.data(), 9);
+        }
+
+        // write stack dword
+        str = " " + to_string_hex(*p, 8);
+        stack_dump_file.write(str.data(), 9);
+
+        if (n == 4) {
+            stack_dump_file.write("\r\n", 2);
+            n = 0;
+        }
+    }
+
+    painter.draw_string({16, 320 - 32}, ui::Styles::green, filename.filename().string() + " dumped!");
+    return true;
+}
+
 extern "C" {
 #if CH_DBG_ENABLED
 void port_halt(void) {
@@ -47,4 +47,6 @@ inline uint32_t get_free_stack_space() {
    return stack_space_left;
 }

+bool stack_dump();
+
 #endif /*__DEBUG_H__*/
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_afsk_rx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::afsk_rx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<AFSKRxView>();
+}
+}  // namespace ui::external_app::afsk_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_afsk_rx.application_information"), used)) application_information_t _application_information_afsk_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::afsk_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "AFSK",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xF8,
+        0x1F,
+        0x04,
+        0x20,
+        0x02,
+        0x40,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xAB,
+        0xDF,
+        0xAB,
+        0xDF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::RX,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_afsk_rx */ {'P', 'A', 'F', 'R'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -32,20 +32,21 @@

 using namespace portapack;
 using namespace modems;
+using namespace ui;
+
+namespace ui::external_app::afsk_rx {

 void AFSKLogger::log_raw_data(const std::string& data) {
    log_file.write_entry(data);
 }

-namespace ui {
-
 void AFSKRxView::focus() {
    field_frequency.focus();
 }

 AFSKRxView::AFSKRxView(NavigationView& nav)
    : nav_{nav} {
-    baseband::run_image(portapack::spi_flash::image_tag_afsk_rx);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());

    add_children({&rssi,
                  &channel,
@@ -147,4 +148,4 @@ AFSKRxView::~AFSKRxView() {
    baseband::shutdown();
 }

-} /* namespace ui */
+}  // namespace ui::external_app::afsk_rx
@@ -33,6 +33,10 @@
 #include "log_file.hpp"
 #include "utility.hpp"

+using namespace ui;
+
+namespace ui::external_app::afsk_rx {
+
 class AFSKLogger {
   public:
    Optional<File::Error> append(const std::string& filename) {
@@ -45,8 +49,6 @@ class AFSKLogger {
    LogFile log_file{};
 };

-namespace ui {
-
 class AFSKRxView : public View {
   public:
    AFSKRxView(NavigationView& nav);
@@ -94,15 +96,15 @@ class AFSKRxView : public View {
        false};

    Text text_debug{
-        {0 * 8, 12 + 2 * 16, 240, 16},
+        {0 * 8, 12 + 2 * 16, screen_width, 16},
        "DEBUG"};

    Button button_modem_setup{
-        {240 - 12 * 8, 1 * 16, 96, 24},
+        {screen_width - 12 * 8, 1 * 16, 96, 24},
        "Modem setup"};

    Console console{
-        {0, 4 * 16, 240, 240}};
+        {0, 4 * 16, 240, screen_width}};

    void on_data_afsk(const AFSKDataMessage& message);

@@ -116,6 +118,6 @@ class AFSKRxView : public View {
        }};
 };

-} /* namespace ui */
+}  // namespace ui::external_app::afsk_rx

 #endif /*__UI_AFSK_RX_H__*/
@@ -0,0 +1,15 @@
+set(EXTCPPSRC
+
+	#pacman
+	external/pacman/main.cpp
+	external/pacman/ui_pacman.cpp
+	
+	#afsk_rx
+	external/afsk_rx/main.cpp
+	external/afsk_rx/ui_afsk_rx.cpp
+)
+
+set(EXTAPPLIST
+	pacman
+	afsk_rx
+)
@@ -0,0 +1,37 @@
+/*
+    Copyright (C) 2023 Bernd Herzog
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+MEMORY
+{
+    /* external apps: regions can't overlap so addresses are corrected after build */
+    ram_external_app_pacman     (rwx) : org = 0xEEE90000, len = 40k
+    ram_external_app_afsk_rx    (rwx) : org = 0xEEEA0000, len = 40k
+}
+
+SECTIONS
+{
+    .external_app_pacman : ALIGN(16) SUBALIGN(16)
+    {
+        KEEP(*(.external_app.app_pacman.application_information));
+        *(*ui*external_app*pacman*);
+    } > ram_external_app_pacman
+
+    .external_app_afsk_rx : ALIGN(16) SUBALIGN(16)
+    {
+        KEEP(*(.external_app.app_afsk_rx.application_information));
+        *(*ui*external_app*afsk_rx*);
+    } > ram_external_app_afsk_rx
+}
@@ -0,0 +1,66 @@
+/******************************************************************************/
+/*                                                                            */
+/*  PACMAN GAME FOR ARDUINO DUE                                               */
+/*                                                                            */
+/******************************************************************************/
+/*  Copyright (c) 2014  Dr. NCX (mirracle.mxx@gmail.com)                      */
+/*                                                                            */
+/* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL              */
+/* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED              */
+/* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR    */
+/* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES      */
+/* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,     */
+/* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,     */
+/* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS        */
+/* SOFTWARE.                                                                  */
+/*                                                                            */
+/*  MIT license, all text above must be included in any redistribution.       */
+
+// #include "ili9328.h"
+
+typedef uint16_t ushort;
+
+#define C16(_rr, _gg, _bb) ((ushort)(((_rr & 0xF8) << 8) | ((_gg & 0xFC) << 3) | ((_bb & 0xF8) >> 3)))
+
+uint16_t _paletteW[] =
+    {
+        C16(0, 0, 0),
+        C16(255, 0, 0),     // 1 red
+        C16(222, 151, 81),  // 2 brown
+        C16(255, 0, 255),   // 3 pink
+
+        C16(0, 0, 0),
+        C16(0, 255, 255),   // 5 cyan
+        C16(71, 84, 255),   // 6 mid blue
+        C16(255, 184, 81),  // 7 lt brown
+
+        C16(0, 0, 0),
+        C16(255, 255, 0),  // 9 yellow
+        C16(0, 0, 0),
+        C16(33, 33, 255),  // 11 blue
+
+        C16(0, 255, 0),      // 12 green
+        C16(71, 84, 174),    // 13 aqua
+        C16(255, 184, 174),  // 14 lt pink
+        C16(222, 222, 255),  // 15 whiteish
+};
+
+void drawIndexedmap(uint8_t* indexmap, int16_t x, uint16_t y) {
+    ui::Painter painter;
+
+    byte i = 0;
+    word color = (word)_paletteW[indexmap[0]];
+    for (byte tmpY = 0; tmpY < 8; tmpY++) {
+        byte width = 1;
+        for (byte tmpX = 0; tmpX < 8; tmpX++) {
+            word next_color = (word)_paletteW[indexmap[++i]];
+            if ((color != next_color && width >= 1) || tmpX == 7) {
+                painter.draw_hline({x + tmpX - width + 1, y + tmpY}, width, ui::Color(color));
+
+                color = next_color;
+                width = 0;
+            }
+            width++;
+        }
+    }
+}
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_pacman.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::pacman {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<PacmanView>();
+}
+}  // namespace ui::external_app::pacman
+
+extern "C" {
+
+__attribute__((section(".external_app.app_pacman.application_information"), used)) application_information_t _application_information_pacman = {
+    /*.memory_location = */ (uint8_t*)0x00000000,  // will be filled at compile time
+    /*.externalAppEntry = */ ui::external_app::pacman::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Pac-Man",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xC0,
+        0x07,
+        0xE0,
+        0x0F,
+        0xF0,
+        0x1F,
+        0xF8,
+        0x07,
+        0xF8,
+        0x01,
+        0x78,
+        0x00,
+        0xF8,
+        0x01,
+        0xF8,
+        0x07,
+        0xF0,
+        0x1F,
+        0xE0,
+        0x0F,
+        0xC0,
+        0x07,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::UTILITIES,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_noop */ {'\0', '\0', '\0', '\0'},  // optional
+    /*.m4_app_offset = */ 0x00000000,                                                  // will be filled at compile time
+};
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Bernd Herzog	abb42e8df4	added executeable bit for new scripts (#1471 )	2023-10-03 08:17:45 +02:00
Bernd Herzog	7fdb1af69d	External apps (#1469 ) * implemented external app build * added some ui stuff for testing * added pacman game * wired key to pacman game * fixed pacman drawing issue * changed afsk rx app to be external * fixed ui::NavigationView initialization for external apps * refactoring * refactoring * moved m4 image to external app * added script for external app deployment * refactoring * implemented dynamic app listing * added color to app icon * improved app loading * added external apps to sd card content * refactoring * review findings * typo * review findings * improved memory management of bitmaps	2023-10-02 20:19:22 +02:00
Kyle Reed	78713cc2af	Search cleanup, more binder support (#1467 )	2023-10-01 09:04:37 -07:00
Kyle Reed	951890eaff	Add Binder helper methods (#1465 ) * Add binder, fix focus on remote btn delete * Use binder for freqman edit	2023-09-29 18:55:27 +02:00
Kyle Reed	fb00bfac3f	Nav stack cleanup (#1460 ) * Minor nav stack fixes * Nav stack cleanup * Additional cleanup, fix notepad crash * Fix abort/cancel * Fix for nasty focus bug * Format	2023-09-27 21:03:02 +02:00
Kyle Reed	a6a1483083	Improved trimming (#1458 ) * Add threshold UI * WIP Better trimming * Rewrite mostly done WIP * WIP - trim idea * WIP threshold trimming * WIP with new design * Cleanup	2023-09-23 21:56:37 +02:00
Kyle Reed	ef03f020ce	IQ Trim app and Capture auto-trim (#1456 ) * Add IQ Trim app WIP * Add 'trim' checkbox to capture * Implement trimming * Finish auto-trim * Stray //	2023-09-21 17:43:10 +02:00
Kyle Reed	070eb4003e	Remove proc pocsag & add keep/drop filtering (#1453 ) * Remove proc_pocsag from build, use new proc in app * Add support for keep/drop filtering	2023-09-19 11:46:30 +02:00
Kyle Reed	fca373d936	Add Remote App & UI updates. (#1451 ) * Alpha order sub-menus * WIP Getting Remote types outlined * WIP building UI * WIP adding RemoteButton control * WIP Fix build * WIP Basic editing support * Border on the active button * Make TxView2 sane * Add easier RGB color creation from uint32 * Center some button icons * WIP Remote - main UI * WIP main UI mostly working, can send * Add 'join' utility * WIP save/load * Pre-alloc buttons to prevent focus dangling * Alpha order settings/debug pages * Add UI for picking capture and set frequency * WIP Getting really close now * Fix path for init name * Some fit & finish	2023-09-18 23:22:46 +02:00
Kyle Reed	537cf2e79b	Fix console scroll - comment on how scrolling works (#1448 ) * Force console scroll area to be multiple of line height. Tons of comments. * Resize POCSAG console to fill height. * Make scoll behavior comment clearer	2023-09-14 20:20:40 +02:00
Kyle Reed	af424aa5f8	SymField rewrite (#1444 ) * First WIP symfield * Cleanup widget code * Rebase and format * Fix 'to_integer' bug, fix siggen UI. * to_string_hex fix, unit tests for string code * Pass instance in callback * Fix on_change callbacks * Fix keyfob (not active) * to_byte_array, coaster tx cleanup * Add to_byte_array tests * Changes in ui_numbers * Fix ui_encoders * Format * Fix modemsetup view's symfields * Remove header * Format	2023-09-12 12:38:19 -07:00
Kyle Reed	70e0f2913f	App Settings w/out radio settings, Settings UI cleanup (#1443 ) * Make app settings more consistent * Allow app settings to always work for custom settings	2023-09-10 17:04:20 -07:00
Kyle Reed	b28283271b	POCSAG clock detection 🐋 improvement(?) (#1442 ) * WIP convergence * Tighter code, allow for sample nudges during clock discovery.	2023-09-09 17:49:22 +02:00
Kyle Reed	4926cf8df5	POCSAG2 Revised bit extractor (#1439 ) * Better bit extraction WIP * Parallel clock signal detection for bit extraction * Relax clock detection accuracy. * Reset RateInfo state. TODOs	2023-09-09 15:18:42 +02:00
Kyle Reed	b3312a704a	Save 'raw log' setting (#1438 )	2023-09-08 21:20:26 +02:00
Kyle Reed	31e8019642	POCSAG Processor Rewrite (#1437 ) * WIP Refactoring * WordExtractor building * Fix buffer sizes and squelch execute * Move impls to cpp file * Baud indicator * WIP new bit extractor * New approach for bit extraction. * Code fit and finish * Fix case on button * Cleanup * Adjust rate miss threshold * Fix count bits error calculation.	2023-09-08 19:41:09 +02:00
Bernd Herzog	9525738118	Config mode hackrf r9 disable external tcxo fallback (#1434 ) * implemented auto disable of external tcxo if r9 crash during boot	2023-09-05 10:32:44 +02:00
Bernd Herzog	62310ad9a9	Config mode (#1433 ) * Allow code to run without a token * Reverted submodule change by mistake * WIP force tcxo * Added check to hide if not an R9 * Fixed comments * Updated name * Fixed crashing on TCXO switching * Fixed the reboot issue * Updated boot order * Cleaned up comments * added new recovery mode * added IO * implemented cpld mode change * whitespace change * renamed config mode * inverted logic * removed r9 dependency * added disable external tcxo option to config mode * fixed CLKIN detection for r9 * integrated tcxo setting into clock selection Co-authored-by @jLynx	2023-09-04 17:46:07 +02:00
Kyle Reed	4819a2f4e2	Decode status widget (#1431 ) * Initial cleanup of pocsag beta, using DSP filters * Better filter params * Better filter * Add signal diagnostics widgets * POCSAG procs sends stats messages * Only draw 32 bits * Add AudioNormalizer filter	2023-09-03 21:49:44 -07:00
Brumi-2021	2435ee780f	Small fine tuning xOVS selection for BW 25k (#1430 ) * Small fine tuning xOVS selection for BW 25k * Comments , same growing order ending with dot.	2023-09-02 00:35:43 +02:00
Kyle Reed	5d602ece5c	Add second pocsag proc for experimenting (#1428 )	2023-08-31 08:05:49 +02:00
Mark Thompson	900086c1c9	Fixed 0.1Hz error in tone key frequencies 146.2, 156.7, and 162.2 (#1427 ) * Fixed tone key freq truncation in float->int conversion * Round integer division when displaying tone key freq	2023-08-31 08:04:47 +02:00
Kyle Reed	07be74701f	POCSAG Squelch and Filtering (#1424 ) * Disable audio processing when not using squelch * Add 2k4 lowpass fitler for 24Khz audio for POCSAG	2023-08-30 19:24:35 +02:00
Kyle Reed	f46e20c977	Explain and clean up decimator scalars (#1422 )	2023-08-30 09:05:49 -07:00
Kyle Reed	4bc752b7a8	Support file count on sub-folders (#1423 )	2023-08-30 09:05:35 -07:00
Brumi-2021	c28b608146	Minor issue : Slow down scrolling speed in BW 1.5Mhz onwards , and adding some TODO comments. (#1419 ) * Slow down scrolling speed in BW 1.5Mhz onwards * Revert added comments	2023-08-30 17:13:40 +02:00
Kyle Reed	bd4948602a	Fix RSSI for apps using proc_capture (#1420 ) * Fix RSSI for apps using proc_capture * Update comment	2023-08-30 17:13:14 +02:00
Mark Thompson	4774b3097f	Support for displaying stack on screen after a fault (for debug) (#1416 ) * Support for displaying stack on screen after a fault * Update debug.cpp * Highlight possible addresses on stack & support Up key * Add small background white style * Add small background white style * Update debug.cpp * Highlight fault PC in yellow * Add bg_yellow_small style * Add bg_yellow_small style * Clang - trailing space	2023-08-29 23:26:58 -05:00
Kyle Reed	de81156223	Support for 1.25MHz capture (#1418 ) * Advanced draft decim /4 just waterfall ok * apply some Kall's corrections + formatting * Tidy up both decim_factors * New refine optimizations * Format issues * more format issues ...mmmm * comments update * WIP Cleanup * WIP * WIP - add variant * Use std::visit to dispatch MultiDecimator -- fluent API * Clean up comments * Merge next and fix compilation * Fix odd loop in BlockDecimator * Clean up spectrum math * Descibe spectrum update math better, more clear math. * Apply spectrum interval correction at 1.5M * Increase replay buffer to handle x4 ovs --------- Co-authored-by: Brumi-2021 <ea3hqj@gmail.com>	2023-08-29 19:26:38 +02:00
Kyle Reed	e7e1bedcad	Support squelch in pocsag (#1415 ) * Support squelch in pocsag * Revert smooth threshold	2023-08-27 15:56:40 -07:00
Mark Thompson	d8930db8af	Add Stack Dump option to debug menu and to GURU meditation fault (#1414 ) * Stack dump * Stack dump * Stack dump * Stack dump * Stack dump * Stack dump * Update debug.cpp * Clang * Update debug.cpp * Skip dumping unused bytes of stack	2023-08-27 00:33:27 -05:00
Kyle Reed	014db9e233	Option to hide address only messages (#1413 )	2023-08-26 19:32:02 -07:00
Kyle Reed	933920edfd	POCSAG State machine fix (#1410 ) * Reset color for well-formed message fragments * better colors * Fix POGSAG decode state machine * Invert is_message to make more clear * Use new escape string constants * Run ECC twice, better diagnostics * center status icon --------- Co-authored-by: kallanreed <kallanreed@noreply.github.com>	2023-08-26 13:43:34 -05:00
Mark Thompson	cf25d85d51	Declare escape strings for colored text (#1409 ) * Color strings * Color strings * Color strings * Color strings * Color strings * Color strings & fix first group scrolling off screen * Color strings * Color strings * Clang * Clang * Clang attempt #3 * Update ui_painter.cpp * Update ui_widget.cpp * Clang test * Clang * Clang test * Update ui_about_simple.cpp * Update lge_app.cpp	2023-08-25 20:01:37 -05:00
Kyle Reed	9af1308e29	Pocsag UX Revamp (#1408 ) * Set bandwidth_filter in pogsac * WIP pocsag UI revamp * Settings UI, better console, UI Revamp * Add baud rate to error messages * Reset last_addr in error cases * Show malformed messages as different color vs hiding * Use light grey to indicate low quality decode --------- Co-authored-by: kallanreed <kallanreed@noreply.github.com>	2023-08-25 14:45:02 -07:00
Mark Thompson	f4496d8f45	Enable lto optimization for application code only (#1405 ) Enabling for tonight's nightly build. (Haven't heard of any issues yet.)	2023-08-24 11:14:57 -05:00
Mark Thompson	966d1c938b	Automatically switch to C8 capture format when bandwidth >1.5MHz (#1404 ) * Automatically select C8 * Automatically select C8	2023-08-24 10:14:18 +02:00
Kyle Reed	f537c7896e	Scanner persisted freq file, TextField for current item (#1403 ) * Don't truncate string passed to Text widget * Focus TextField on touch like other fields * TextField for current, save last opened freq file	2023-08-23 11:51:28 -07:00
Kyle Reed	4a1479957c	More settings and cleanup (#1402 )	2023-08-22 12:09:59 -07:00
Kyle Reed	dc9a16c54b	Looking Glass - persist range/preset settings, UI tweaks (#1401 ) * WIP * Add encoder support for TextField * Working settings, use TextField * Remove unneeded blanking rectangle	2023-08-22 07:56:10 -07:00
Kyle Reed	a476647d70	Don't use raw new/delete (#1398 ) * Use unique_ptr in ui_btngrid * Use unique_ptr for ui_menu * Use unique_ptr for rssi_dma * Use unique_ptr for painter	2023-08-21 10:17:23 +02:00
Mark Thompson	95a48e5693	Store search range in settings file (#1397 ) * MAX_UFREQ * Use settings file for search range	2023-08-21 10:16:49 +02:00
Mark Thompson	09404ca198	Default to AK4951 speaker disabled (#1396 )	2023-08-20 22:28:23 +02:00
Kyle Reed	564f76b47d	Use new settings API in recon and scanner (#1394 ) * Use new settings in recon * Trim on string value read, remove dupe entry * Check update_range flag when setting values * Add a few saved settings to scanner * Add copywrite note	2023-08-20 22:28:02 +02:00
Mark Thompson	c6424f1623	Display degree symbol in TPMS, Sonde, and Temperature apps; disabled Font Viewer (#1388 ) * Display degrees symbol; disable Font Viewer app to save ROM space	2023-08-20 11:14:22 +02:00
Mark Thompson	a4325ac20d	Disable audio by default at power-up (#1393 )	2023-08-20 11:13:04 +02:00
Kyle Reed	d8a6422d37	Consolidate old and new style app settings (#1391 ) * Consolidate old and new style app settings * Remove unused ctor	2023-08-19 09:02:26 -07:00
gullradriel	cc963c3562	Recon: Only update manual field if current entry is a range (#1387 )	2023-08-18 22:05:28 +02:00
Kyle Reed	63f99742fc	First pass at custom app-settings support (#1381 ) * First draft of custom app settings support. * WIP new settings * Working per-app custom settings * Revert design to use "bound settings"	2023-08-18 12:35:41 -07:00
Brumi-2021	a4636d7872	Finalise all low bit rate Capture App with x64 (#1386 ) * Finalise all low bit rate Capture App with x64 * Adding back also 25k BW option	2023-08-18 14:49:22 +02:00
gullradriel	bd2ee03e44	Restoring part of old timer, fixed sd loading (#1385 )	2023-08-17 17:28:12 +02:00
Mark Thompson	deeb81c183	Correct text field width (#1383 )	2023-08-17 00:45:24 +02:00
Brumi-2021	12dbf957b3	Extend REC low bit rate bandwith options in Capture App till 75khz (#1380 ) * working_x32_Capture_till_75Khz * format issues * apply better accurate comments * auto format issues	2023-08-16 23:26:59 +02:00
Mark Thompson	e1cc0b1ad0	Show file count in each directory, and moved "Too many files" message (#1376 ) * Added file_count() function * Show file count in each directory; moved "Too many files!" warning	2023-08-16 10:00:46 +02:00
gullradriel	f079d57fc6	Recon: fixed behavior of auto update m-ranges (#1374 ) and coloring * Fixed behavior of auto update m-ranges, added min and max to sd load and save if option not used * changing xor swap by std::swap * Fixed consecutive green color	2023-08-15 18:29:16 +02:00
Brumi-2021	09b9ed642f	avoid yellow icon in Audio App (minor issue) (#1372 ) * avoid yellow icon in Audio App * clear readability * just more clear parentesis	2023-08-13 16:52:54 -05:00
Mark Thompson	e74a9f3b41	Limit text string length to fit Text widget rectangle (#1370 ) * Limit string length to fit Text rectangle * Update ui_widget.cpp	2023-08-13 20:34:46 +02:00
Mark Thompson	ff7a9d10cb	Load App Settings after initializing RadioState (#1371 )	2023-08-13 20:33:31 +02:00
Brumi-2021	5cfd7f1dc2	Small error correction to PR 1367 (#1368 )	2023-08-12 10:57:16 -05:00
Brumi-2021	853ca2ef53	Solve_quality_problem_low_bit_rate_100k_150k_REC_Capture_App (#1367 ) * Solve_low_bit_rate_150k_Capture_App * Applying review comments. * format issues * Adding back requested previous low bit rates	2023-08-12 09:20:15 -05:00
Brumi-2021	cb0a4854f5	Increase REC BW Option till 1Mhz Capture App (#1352 ) * Increase REC BW Option till 1Mhz Capture App * Format issues * miss type correction * format issues	2023-08-06 21:54:24 +02:00
Mark Thompson	1188157a3e	Reject bmp images that aren't 240 pixels wide (#1351 )	2023-08-05 17:14:18 +02:00
gullradriel	2ae639412d	fix/simplify internal timing (#1348 ) * fix/simplify internal timing	2023-08-04 07:56:39 +02:00
Kyle Reed	37386c29cb	Oversample (#1336 ) * WIP Oversample cleanup * WIP * WIP * WIP dynamic interpolation * WIP cleanup * Fix math errors * Add some optional assertions * Add support for x32 interpolation * Update proc_replay.cpp Typo	2023-08-02 21:59:26 +02:00