updated submodule (#1551 )

Co-authored-by: GullCode <gullradriel@hotmail.com>
BLE Rx improvements. (#1550 )
2026-09-15 02:52:58 +00:00 · 2023-11-04 22:41:38 -05:00 · 2023-11-04 08:29:48 +01:00 · 2023-11-03 08:08:49 +01:00 · 2023-11-02 19:47:34 +01:00 · 2023-11-02 17:32:29 +01:00
188 changed files with 18610 additions and 1829 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 }}
@@ -1 +1 @@
-v1.7.3
+v1.7.4
@@ -1 +1 @@
-v1.7.4
+v1.8.0
@@ -55,10 +55,11 @@ CMakeFiles/
 # Debugging
 .gdbinit*

-# Editor files
+# Editor/IDE files
 *.sublime-project
 *.sublime-workspace
 .vscode
+.idea

 # VSCodium extensions
 .history
@@ -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)

@@ -8,11 +8,11 @@ This is a fork of the [Havoc](https://github.com/furrtek/portapack-havoc/) firmw

 *[PortaPack H2+HackRF+battery](https://s.click.aliexpress.com/e/_DmU7GQX) (clone) with a custom [3d printed case](https://github.com/eried/portapack-mayhem/wiki/H2-Enclosure)*

-# Quick overview
+# What is this?

-If you are new to *HackRF+PortaPack+Mayhem*, there is an awesome introductory video by [Tech Minds](https://www.youtube.com/channel/UC9a8Z6Sp6eb2s3O79pX5Zvg) available:
+If you are new to *HackRF+PortaPack+Mayhem*, check this video:

-[![Setup and overview](https://img.youtube.com/vi/kjFB58Y1TAo/0.jpg)](https://www.youtube.com/watch?v=kjFB58Y1TAo)
+[![What is?](https://img.youtube.com/vi/alrFbY5vxt4/0.jpg)](https://www.youtube.com/watch?v=alrFbY5vxt4)

 # Frequently Asked Questions

@@ -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")
@@ -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
@@ -242,6 +244,8 @@ set(CPPSRC
 	apps/ais_app.cpp
 	apps/analog_audio_app.cpp
 	apps/analog_tv_app.cpp
+	apps/ble_rx_app.cpp
+	apps/ble_tx_app.cpp
 	apps/capture_app.cpp
 	apps/ert_app.cpp
 	apps/gps_sim_app.cpp
@@ -255,7 +259,6 @@ set(CPPSRC
 	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_aprs_tx.cpp
 	apps/ui_bht_tx.cpp
@@ -267,6 +270,7 @@ set(CPPSRC
 	apps/ui_fileman.cpp
 	apps/ui_flash_utility.cpp
 	apps/ui_freqman.cpp
+	apps/ui_fsk_rx.cpp
 	apps/ui_iq_trim.cpp
 	apps/ui_jammer.cpp
    # apps/ui_keyfob.cpp
@@ -321,6 +325,9 @@ set(CPPSRC
 	${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.
@@ -396,7 +403,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)
@@ -465,12 +472,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
 )

@@ -156,6 +156,7 @@ bool save_settings(std::string_view store_name, const SettingBindings& bindings)
    File f;
    auto path = get_settings_path(std::string{store_name});

+    make_new_directory(SETTINGS_DIR);
    auto error = f.create(path);
    if (error)
        return false;
@@ -244,62 +245,58 @@ SettingsManager::SettingsManager(
    : app_name_{app_name},
      settings_{},
      bindings_{},
-      loaded_{false},
-      radio_loaded_{false} {
+      loaded_{false} {
    settings_.mode = mode;
    settings_.options = options;

    // Pre-alloc enough for app settings and additional settings.
-    additional_settings.reserve(17 + additional_settings.size());
+    additional_settings.reserve(COMMON_APP_SETTINGS_COUNT + 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);
-        }
+    // Settings should always be loaded because apps now rely
+    // on being able to store UI settings, config, etc.

-        // 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);
+    // Transmitter model settings.
+    if (flags_enabled(mode, Mode::TX)) {
+        bindings_.emplace_back("tx_frequency"sv, &settings_.tx_frequency);
+        bindings_.emplace_back("tx_amp"sv, &settings_.tx_amp);
+        bindings_.emplace_back("tx_gain"sv, &settings_.tx_gain);
+        bindings_.emplace_back("channel_bandwidth"sv, &settings_.channel_bandwidth);
    }

+    // Receiver model settings.
+    if (flags_enabled(mode, Mode::RX)) {
+        bindings_.emplace_back("rx_frequency"sv, &settings_.rx_frequency);
+        bindings_.emplace_back("lna"sv, &settings_.lna);
+        bindings_.emplace_back("vga"sv, &settings_.vga);
+        bindings_.emplace_back("rx_amp"sv, &settings_.rx_amp);
+        bindings_.emplace_back("modulation"sv, &settings_.modulation);
+        bindings_.emplace_back("am_config_index"sv, &settings_.am_config_index);
+        bindings_.emplace_back("nbfm_config_index"sv, &settings_.nbfm_config_index);
+        bindings_.emplace_back("wfm_config_index"sv, &settings_.wfm_config_index);
+        bindings_.emplace_back("squelch"sv, &settings_.squelch);
+    }
+
+    // Common model settings.
+    bindings_.emplace_back("baseband_bandwidth"sv, &settings_.baseband_bandwidth);
+    bindings_.emplace_back("sampling_rate"sv, &settings_.sampling_rate);
+    bindings_.emplace_back("step"sv, &settings_.step);
+    bindings_.emplace_back("volume"sv, &settings_.volume);
+
+    // RadioState should have initialized default radio parameters before this function;
+    // copy them to settings_ before checking settings .ini file (in case the file doesn't exist
+    // or doesn't include all parameters). Settings in the file can overwrite all, or a subset of parameters.
+    copy_from_radio_model(settings_);
+
    loaded_ = load_settings(app_name_, bindings_);

    // Only copy to the radio if load was successful.
-    if (loaded_ && portapack::persistent_memory::load_app_settings()) {
-        radio_loaded_ = true;
+    if (loaded_)
        copy_to_radio_model(settings_);
-    }
 }

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

    save_settings(app_name_, bindings_);
 }
@@ -36,9 +36,14 @@
 #include "max283x.hpp"
 #include "string_format.hpp"

+// Folder to store app settings, pmem_fileflag, and date_fileflag
+#define SETTINGS_DIR u"/SETTINGS"
+
 // Bring in the string_view literal.
 using std::literals::operator""sv;

+#define COMMON_APP_SETTINGS_COUNT 19
+
 /* Represents a named setting bound to a variable instance. */
 /* Using void* instead of std::variant, because variant is a pain to dispatch over. */
 class BoundSetting {
@@ -140,8 +145,8 @@ struct AppSettings {
    uint8_t nbfm_config_index = 0;
    uint8_t wfm_config_index = 0;
    uint8_t squelch = 80;
-
    uint8_t volume;
+    // NOTE: update COMMON_APP_SETTINGS_COUNT when adding to this
 };

 /* Copies common values to the receiver/transmitter models. */
@@ -170,8 +175,6 @@ 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_; }
@@ -181,7 +184,6 @@ class SettingsManager {
    AppSettings settings_;
    SettingBindings bindings_;
    bool loaded_;
-    bool radio_loaded_;
 };

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

    bool logging{false};
    uint32_t packet_counter{0};
@@ -382,9 +382,6 @@ AISAppView::AISAppView(NavigationView& nav)

    recent_entry_detail_view.hidden(true);

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

    options_channel.on_change = [this](size_t, OptionsField::value_t v) {
@@ -162,9 +162,8 @@ class AISAppView : public View {
    std::string title() const override { return "AIS RX"; };

   private:
-    static constexpr uint32_t initial_target_frequency = 162025000;
-
    RxRadioState radio_state_{
+        162025000 /* frequency*/,
        1750000 /* bandwidth */,
        2457600 /* sampling rate */
    };
@@ -0,0 +1,553 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ble_rx_app.hpp"
+#include "ble_tx_app.hpp"
+
+#include "ui_modemsetup.hpp"
+
+#include "modems.hpp"
+#include "audio.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "ui_textentry.hpp"
+
+using namespace portapack;
+using namespace modems;
+
+void BLELogger::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+std::string pad_string_with_spaces(int snakes) {
+    std::string paddedStr(snakes, ' ');
+    return paddedStr;
+}
+
+uint64_t copy_mac_address_to_uint64(const uint8_t* macAddress) {
+    uint64_t result = 0;
+
+    // Copy each byte of the MAC address to the corresponding byte in the uint64_t.
+    for (int i = 0; i < 6; ++i) {
+        result |= static_cast<uint64_t>(macAddress[i]) << ((5 - i) * 8);
+    }
+
+    return result;
+}
+
+namespace ui {
+template <>
+void RecentEntriesTable<BleRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line{};
+
+    if (!entry.nameString.empty()) {
+        line = entry.nameString;
+
+        if (line.length() < 17) {
+            line += pad_string_with_spaces(17 - line.length());
+        } else {
+            line = truncate(line, 17);
+        }
+    } else {
+        line = to_string_mac_address(entry.packetData.macAddress, 6);
+    }
+
+    // Pushing single digit values down right justified.
+    std::string hitsStr = to_string_dec_int(entry.numHits);
+    int hitsDigits = hitsStr.length();
+    uint8_t hits_spacing = 8 - hitsDigits;
+
+    // Pushing single digit values down right justified.
+    std::string dbStr = to_string_dec_int(entry.dbValue);
+    int dbDigits = dbStr.length();
+    uint8_t db_spacing = 5 - dbDigits;
+
+    line += pad_string_with_spaces(hits_spacing) + hitsStr;
+
+    line += pad_string_with_spaces(db_spacing) + dbStr;
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const BleRecentEntry& entry)
+    : nav_{nav},
+      entry_{entry} {
+    add_children({&button_done,
+                  &label_mac_address,
+                  &text_mac_address,
+                  &labels});
+
+    text_mac_address.set(to_string_mac_address(entry.packetData.macAddress, 6));
+
+    button_done.on_select = [this](const ui::Button&) {
+        nav_.pop();
+    };
+}
+
+void BleRecentEntryDetailView::update_data() {
+}
+
+void BleRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+Rect BleRecentEntryDetailView::draw_field(
+    Painter& painter,
+    const Rect& draw_rect,
+    const Style& style,
+    const std::string& label,
+    const std::string& value) {
+    const int label_length_max = 4;
+
+    painter.draw_string(Point{draw_rect.left(), draw_rect.top()}, style, label);
+    painter.draw_string(Point{draw_rect.left() + (label_length_max + 1) * 8, draw_rect.top()}, style, value);
+
+    return {draw_rect.left(), draw_rect.top() + draw_rect.height(), draw_rect.width(), draw_rect.height()};
+}
+
+void BleRecentEntryDetailView::paint(Painter& painter) {
+    View::paint(painter);
+
+    const auto s = style();
+    const auto rect = screen_rect();
+
+    auto field_rect = Rect{rect.left(), rect.top() + 48, rect.width(), 16};
+
+    uint8_t type[total_data_lines];
+    uint8_t length[total_data_lines];
+    uint8_t data[total_data_lines][40];
+
+    int currentByte = 0;
+    int currentPacket = 0;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+
+    for (currentByte = 0; (currentByte < entry_.packetData.dataLen) && (currentPacket < total_data_lines);) {
+        length[currentPacket] = entry_.packetData.data[currentByte++];
+        type[currentPacket] = entry_.packetData.data[currentByte++];
+
+        // Subtract 1 because type is part of the length.
+        for (i = 0; i < length[currentPacket] - 1; i++) {
+            data[currentPacket][i] = entry_.packetData.data[currentByte++];
+        }
+
+        currentPacket++;
+    }
+
+    for (i = 0; i < currentPacket; i++) {
+        uint8_t number_data_lines = ceil((float)(length[i] - 1) / 10.0);
+        uint8_t current_line = 0;
+        std::array<std::string, total_data_lines> data_strings{};
+
+        for (j = 0; (j < (number_data_lines * 10)) && (j < length[i] - 1); j++) {
+            if ((j / 10) != current_line) {
+                current_line++;
+            }
+
+            data_strings[current_line] += to_string_hex(data[i][j], 2);
+        }
+
+        // Read the type back to the total length.
+        field_rect = draw_field(painter, field_rect, s, to_string_hex(length[i]), to_string_hex(type[i]) + pad_string_with_spaces(3) + data_strings[0]);
+
+        if (number_data_lines > 1) {
+            for (k = 1; k < number_data_lines; k++) {
+                if (data_strings[k].empty()) {
+                    field_rect = draw_field(painter, field_rect, s, "", pad_string_with_spaces(5) + data_strings[k]);
+                }
+            }
+        }
+    }
+}
+
+void BleRecentEntryDetailView::set_entry(const BleRecentEntry& entry) {
+    entry_ = entry;
+    set_dirty();
+}
+
+static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
+    uint64_t freq_hz;
+
+    switch (channel_number) {
+        case 37:
+            freq_hz = 2'402'000'000ull;
+            break;
+        case 38:
+            freq_hz = 2'426'000'000ull;
+            break;
+        case 39:
+            freq_hz = 2'480'000'000ull;
+            break;
+        case 0 ... 10:
+            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
+            break;
+        case 11 ... 36:
+            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
+            break;
+        default:
+            freq_hz = UINT64_MAX;
+    }
+
+    return freq_hz;
+}
+
+void BLERxView::focus() {
+    options_channel.focus();
+}
+
+BLERxView::BLERxView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_btle_rx);
+
+    add_children({&rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &options_channel,
+                  &field_frequency,
+                  &check_log,
+                  &label_sort,
+                  &options_sort,
+                  &button_filter,
+                  &button_switch,
+                  &recent_entries_view,
+                  &recent_entries_filter_view,
+                  &recent_entry_detail_view});
+
+    recent_entry_detail_view.hidden(true);
+    recent_entries_filter_view.hidden(true);
+
+    recent_entries_view.on_select = [this](const BleRecentEntry& entry) {
+        nav_.push<BleRecentEntryDetailView>(entry);
+    };
+
+    recent_entries_filter_view.on_select = [this](const BleRecentEntry& entry) {
+        nav_.push<BleRecentEntryDetailView>(entry);
+    };
+
+    button_filter.on_select = [this, &nav](Button&) {
+        text_prompt(
+            nav,
+            filterBuffer,
+            64,
+            [this](std::string& buffer) {
+                on_switch_table(buffer);
+            });
+    };
+
+    button_switch.on_select = [this, &nav](Button&) {
+        nav_.set_on_pop([this]() { nav_.push<BLETxView>(); });
+        nav_.pop();
+    };
+
+    field_frequency.set_step(0);
+
+    check_log.set_value(logging);
+
+    check_log.on_select = [this](Checkbox&, bool v) {
+        str_log = "";
+        logging = v;
+
+        if (logger && logging)
+            logger->append(LOG_ROOT_DIR "/BLELOG_" + to_string_timestamp(rtc_time::now()) + ".TXT");
+    };
+
+    options_channel.on_change = [this](size_t, int32_t i) {
+        field_frequency.set_value(get_freq_by_channel_number(i));
+        channel_number = i;
+
+        baseband::set_btlerx(channel_number);
+    };
+
+    options_sort.on_change = [this](size_t, int32_t i) {
+        switch (i) {
+            case 0:
+                sortEntriesBy(
+                    recent, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
+                sortEntriesBy(
+                    filterEntries, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
+                break;
+            case 1:
+                sortEntriesBy(
+                    recent, [](const BleRecentEntry& entry) { return entry.numHits; }, false);
+                sortEntriesBy(
+                    filterEntries, [](const BleRecentEntry& entry) { return entry.numHits; }, false);
+                break;
+            case 2:
+                sortEntriesBy(
+                    recent, [](const BleRecentEntry& entry) { return entry.dbValue; }, true);
+                sortEntriesBy(
+                    filterEntries, [](const BleRecentEntry& entry) { return entry.dbValue; }, true);
+                break;
+            case 3:
+                sortEntriesBy(
+                    recent, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
+                sortEntriesBy(
+                    filterEntries, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
+                break;
+            case 4:
+                sortEntriesBy(
+                    recent, [](const BleRecentEntry& entry) { return entry.nameString; }, true);
+                sortEntriesBy(
+                    filterEntries, [](const BleRecentEntry& entry) { return entry.nameString; }, true);
+                break;
+            default:
+                break;
+        }
+
+        recent_entries_view.set_dirty();
+        recent_entries_filter_view.set_dirty();
+    };
+
+    options_channel.set_selected_index(0, true);
+    options_sort.set_selected_index(0, true);
+
+    logger = std::make_unique<BLELogger>();
+
+    // Auto-configure modem for LCR RX (will be removed later)
+    baseband::set_btlerx(channel_number);
+
+    receiver_model.enable();
+}
+
+void BLERxView::on_data(BlePacketData* packet) {
+    std::string str_console = "";
+
+    if (!logging) {
+        str_log = "";
+    }
+
+    switch ((ADV_PDU_TYPE)packet->type) {
+        case ADV_IND:
+            str_console += "ADV_IND";
+            break;
+        case ADV_DIRECT_IND:
+            str_console += "ADV_DIRECT_IND";
+            break;
+        case ADV_NONCONN_IND:
+            str_console += "ADV_NONCONN_IND";
+            break;
+        case SCAN_REQ:
+            str_console += "SCAN_REQ";
+            break;
+        case SCAN_RSP:
+            str_console += "SCAN_RSP";
+            break;
+        case CONNECT_REQ:
+            str_console += "CONNECT_REQ";
+            break;
+        case ADV_SCAN_IND:
+            str_console += "ADV_SCAN_IND";
+            break;
+        case RESERVED0:
+        case RESERVED1:
+        case RESERVED2:
+        case RESERVED3:
+        case RESERVED4:
+        case RESERVED5:
+        case RESERVED6:
+        case RESERVED7:
+        case RESERVED8:
+            str_console += "RESERVED";
+            break;
+        default:
+            str_console += "UNKNOWN";
+            break;
+    }
+
+    str_console += " Len:";
+    str_console += to_string_dec_uint(packet->size);
+
+    str_console += "\n";
+
+    str_console += "Mac:";
+    str_console += to_string_mac_address(packet->macAddress, 6);
+
+    str_console += "\n";
+    str_console += "Data:";
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        str_console += to_string_hex(packet->data[i], 2);
+    }
+
+    str_console += "\n";
+
+    uint64_t macAddressEncoded = copy_mac_address_to_uint64(packet->macAddress);
+
+    // Start of Packet stuffing.
+    // Masking off the top 2 bytes to avoid invalid keys.
+    auto& entry = ::on_packet(recent, macAddressEncoded & 0xFFFFFFFFFFFF);
+    truncate_entries(recent, 32);
+    updateEntry(packet, entry);
+
+    // Log at End of Packet.
+    if (logger && logging) {
+        logger->log_raw_data(str_console);
+    }
+}
+
+void BLERxView::on_switch_table(const std::string value) {
+    filter = value;
+
+    if (!value.empty()) {
+        removeEntriesWithoutKey(recent, filterEntries, [&value](const BleRecentEntry& entry) {
+            return entry.dataString.find(value) == std::string::npos;
+        });
+
+        recent_entries_view.set_dirty();
+
+        recent_entries_filter_view.hidden(false);
+        recent_entries_view.hidden(true);
+    } else {
+        recent_entries_view.hidden(false);
+        recent_entries_filter_view.hidden(true);
+    }
+
+    recent_entries_view.set_dirty();
+    recent_entries_filter_view.set_dirty();
+}
+
+void BLERxView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
+    recent_entries_view.set_parent_rect(content_rect);
+    recent_entry_detail_view.set_parent_rect(content_rect);
+    recent_entries_filter_view.set_parent_rect(content_rect);
+}
+
+BLERxView::~BLERxView() {
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry) {
+    std::string data_string;
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        data_string += to_string_hex(packet->data[i], 2);
+    }
+
+    entry.dbValue = packet->max_dB;
+    entry.timestamp = to_string_timestamp(rtc_time::now());
+    entry.dataString = data_string;
+
+    entry.packetData.type = packet->type;
+    entry.packetData.size = packet->size;
+    entry.packetData.dataLen = packet->dataLen;
+
+    entry.packetData.macAddress[0] = packet->macAddress[0];
+    entry.packetData.macAddress[1] = packet->macAddress[1];
+    entry.packetData.macAddress[2] = packet->macAddress[2];
+    entry.packetData.macAddress[3] = packet->macAddress[3];
+    entry.packetData.macAddress[4] = packet->macAddress[4];
+    entry.packetData.macAddress[5] = packet->macAddress[5];
+
+    entry.numHits++;
+
+    for (int i = 0; i < packet->dataLen; i++) {
+        entry.packetData.data[i] = packet->data[i];
+    }
+
+    entry.nameString = "";
+
+    uint8_t currentByte = 0;
+    uint8_t length = 0;
+    uint8_t type = 0;
+
+    bool stringFound = false;
+
+    for (currentByte = 0; (currentByte < entry.packetData.dataLen);) {
+        length = entry.packetData.data[currentByte++];
+        type = entry.packetData.data[currentByte++];
+
+        // Subtract 1 because type is part of the length.
+        for (int i = 0; i < length - 1; i++) {
+            if (((type == 0x08) || (type == 0x09)) && !stringFound) {
+                entry.nameString += (char)entry.packetData.data[currentByte];
+            }
+
+            currentByte++;
+        }
+
+        if (!entry.nameString.empty()) {
+            stringFound = true;
+        }
+    }
+
+    switch (options_sort.selected_index()) {
+        case 0:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
+            sortEntriesBy(
+                filterEntries, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
+            break;
+        case 1:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.numHits; }, false);
+            sortEntriesBy(
+                filterEntries, [](const BleRecentEntry& entry) { return entry.numHits; }, false);
+            break;
+        case 2:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.dbValue; }, true);
+            sortEntriesBy(
+                filterEntries, [](const BleRecentEntry& entry) { return entry.dbValue; }, true);
+            break;
+        case 3:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
+            sortEntriesBy(
+                filterEntries, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
+            break;
+        case 4:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.nameString; }, true);
+            sortEntriesBy(
+                filterEntries, [](const BleRecentEntry& entry) { return entry.nameString; }, true);
+            break;
+        default:
+            break;
+    }
+
+    on_switch_table(filter);
+
+    // TODO: Crude hack, should be a more formal listener arrangement...
+    if (entry.key() == recent_entry_detail_view.entry().key()) {
+        recent_entry_detail_view.set_entry(entry);
+    }
+}
+
+} /* namespace ui */
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLE_RX_APP_H__
+#define __BLE_RX_APP_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+#include "recent_entries.hpp"
+
+class BLELogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+typedef enum {
+    ADV_IND = 0,
+    ADV_DIRECT_IND = 1,
+    ADV_NONCONN_IND = 2,
+    SCAN_REQ = 3,
+    SCAN_RSP = 4,
+    CONNECT_REQ = 5,
+    ADV_SCAN_IND = 6,
+    RESERVED0 = 7,
+    RESERVED1 = 8,
+    RESERVED2 = 9,
+    RESERVED3 = 10,
+    RESERVED4 = 11,
+    RESERVED5 = 12,
+    RESERVED6 = 13,
+    RESERVED7 = 14,
+    RESERVED8 = 15
+} ADV_PDU_TYPE;
+
+struct BleRecentEntry {
+    using Key = uint64_t;
+
+    static constexpr Key invalid_key = 0xffffffff;
+
+    uint64_t macAddress;
+    int dbValue;
+    BlePacketData packetData;
+    std::string timestamp;
+    std::string dataString;
+    std::string nameString;
+    uint16_t numHits;
+
+    BleRecentEntry()
+        : BleRecentEntry{0} {
+    }
+
+    BleRecentEntry(
+        const uint64_t macAddress)
+        : macAddress{macAddress},
+          dbValue{},
+          packetData{},
+          timestamp{},
+          dataString{},
+          nameString{},
+          numHits{} {
+    }
+
+    Key key() const {
+        return macAddress;
+    }
+};
+
+using BleRecentEntries = RecentEntries<BleRecentEntry>;
+using BleRecentEntriesView = RecentEntriesView<BleRecentEntries>;
+
+class BleRecentEntryDetailView : public View {
+   public:
+    BleRecentEntryDetailView(NavigationView& nav, const BleRecentEntry& entry);
+
+    void set_entry(const BleRecentEntry& new_entry);
+    const BleRecentEntry& entry() const { return entry_; };
+
+    void update_data();
+    void focus() override;
+    void paint(Painter&) override;
+
+   private:
+    NavigationView& nav_;
+    BleRecentEntry entry_{};
+
+    static constexpr uint8_t total_data_lines{5};
+
+    Labels label_mac_address{
+        {{0 * 8, 0 * 16}, "Mac Address:", Color::light_grey()}};
+
+    Text text_mac_address{
+        {12 * 8, 0 * 16, 17 * 8, 16},
+        "-"};
+
+    Labels labels{
+        {{0 * 8, 2 * 16}, "Len", Color::light_grey()},
+        {{5 * 8, 2 * 16}, "Type", Color::light_grey()},
+        {{10 * 8, 2 * 16}, "Value", Color::light_grey()},
+    };
+
+    Button button_done{
+        {125, 224, 96, 24},
+        "Done"};
+
+    bool send_updates{false};
+
+    Rect draw_field(
+        Painter& painter,
+        const Rect& draw_rect,
+        const Style& style,
+        const std::string& label,
+        const std::string& value);
+};
+
+class BLERxView : public View {
+   public:
+    BLERxView(NavigationView& nav);
+    ~BLERxView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    std::string title() const override { return "BLE RX"; };
+
+   private:
+    void on_data(BlePacketData* packetData);
+    void on_switch_table(const std::string value);
+    void updateEntry(const BlePacketData* packet, BleRecentEntry& entry);
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{
+        2402000000 /* frequency */,
+        4000000 /* bandwidth */,
+        4000000 /* sampling rate */,
+        ReceiverModel::Mode::WidebandFMAudio};
+    app_settings::SettingsManager settings_{
+        "BLE Rx", app_settings::Mode::RX};
+
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+    uint8_t channel_number = 37;
+
+    std::string filterBuffer{};
+    std::string filter{};
+
+    static constexpr auto header_height = 3 * 16;
+    static constexpr auto switch_button_height = 3 * 16;
+
+    OptionsField options_channel{
+        {0 * 8, 0 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39}}};
+
+    RxFrequencyField field_frequency{
+        {6 * 8, 0 * 16},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {16 * 8, 0 * 16}};
+
+    LNAGainField field_lna{
+        {18 * 8, 0 * 16}};
+
+    VGAGainField field_vga{
+        {21 * 8, 0 * 16}};
+
+    RSSI rssi{
+        {24 * 8, 0, 6 * 8, 4}};
+
+    Channel channel{
+        {24 * 8, 5, 6 * 8, 4}};
+
+    Labels label_sort{
+        {{0 * 8, 3 * 8}, "Sort:", Color::light_grey()}};
+
+    OptionsField options_sort{
+        {5 * 8, 3 * 8},
+        4,
+        {{"MAC", 0},
+         {"Hits", 1},
+         {"dB", 2},
+         {"Time", 3},
+         {"Name", 4}}};
+
+    Button button_filter{
+        {12 * 8, 3 * 8, 4 * 8, 16},
+        "Filter"};
+
+    Checkbox check_log{
+        {20 * 8, 3 * 8},
+        3,
+        "Log",
+        true};
+
+    Console console{
+        {0, 4 * 16, 240, 240}};
+
+    Button button_switch{
+        {8 * 8, 16 * 16, 14 * 8, 2 * 16},
+        "Switch to Tx"};
+
+    std::string str_log{""};
+    bool logging{false};
+
+    std::unique_ptr<BLELogger> logger{};
+
+    BleRecentEntries recent{};
+    BleRecentEntries filterEntries{};
+
+    const RecentEntriesColumns columns{{
+        {"Mac Address", 17},
+        {"Hits", 7},
+        {"dB", 4},
+    }};
+
+    BleRecentEntry entry_{};
+    BleRecentEntriesView recent_entries_view{columns, recent};
+    BleRecentEntriesView recent_entries_filter_view{columns, filterEntries};
+    BleRecentEntryDetailView recent_entry_detail_view{nav_, entry_};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::BlePacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const BLEPacketMessage*>(p);
+            this->on_data(message->packet);
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/
@@ -0,0 +1,420 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ble_tx_app.hpp"
+#include "ble_rx_app.hpp"
+
+#include "ui_fileman.hpp"
+#include "ui_modemsetup.hpp"
+
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "io_file.hpp"
+#include "modems.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "rtc_time.hpp"
+#include "string_format.hpp"
+
+using namespace portapack;
+using namespace modems;
+namespace fs = std::filesystem;
+
+void BLELoggerTx::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+bool hasValidHexPairs(const std::string& str, int totalPairs) {
+    int validPairs = 0;
+
+    for (int i = 0; i < totalPairs * 2; i += 2) {
+        char c1 = str[i];
+        char c2 = str[i + 1];
+
+        if (!(std::isxdigit(c1) && std::isxdigit(c2))) {
+            return false;  // Return false if any pair is invalid.
+        }
+
+        validPairs++;
+    }
+
+    return (validPairs == totalPairs);
+}
+
+std::vector<std::string> splitIntoStrings(const char* input) {
+    std::vector<std::string> result;
+    int length = std::strlen(input);
+    int start = 0;
+
+    while (start < length) {
+        int remaining = length - start;
+        int chunkSize = (remaining > 30) ? 30 : remaining;
+        result.push_back(std::string(input + start, chunkSize));
+        start += chunkSize;
+    }
+
+    return result;
+}
+
+uint32_t stringToUint32(const std::string& str) {
+    size_t pos = 0;
+    uint32_t result = 0;
+
+    while (pos < str.size() && std::isdigit(str[pos])) {
+        int digit = str[pos] - '0';
+
+        // Check for overflow before adding the next digit
+        if (result > (UINT32_MAX - digit) / 10) {
+            return 0;
+        }
+
+        result = result * 10 + digit;
+        pos++;
+    }
+
+    return result;
+}
+
+void readUntil(File& file, char* result, std::size_t maxBufferSize, char delimiter) {
+    std::size_t bytesRead = 0;
+
+    while (true) {
+        char ch;
+        File::Result<File::Size> readResult = file.read(&ch, 1);
+
+        if (readResult.is_ok() && readResult.value() > 0) {
+            if (ch == delimiter) {
+                // Found a space character, stop reading
+                break;
+            } else if (bytesRead < maxBufferSize) {
+                // Append the character to the result if there's space
+                result[bytesRead++] = ch;
+            } else {
+                // Buffer is full, break to prevent overflow
+                break;
+            }
+        } else {
+            break;  // End of file or error
+        }
+    }
+
+    // Null-terminate the result string
+    result[bytesRead] = '\0';
+}
+
+void generateRandomMacAddress(char* macAddress) {
+    const char hexDigits[] = "0123456789ABCDEF";
+
+    // Generate 12 random hexadecimal characters
+    for (int i = 0; i < 12; i++) {
+        int randomIndex = rand() % 16;
+        macAddress[i] = hexDigits[randomIndex];
+    }
+    macAddress[12] = '\0';  // Null-terminate the string
+}
+
+static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
+    uint64_t freq_hz;
+
+    switch (channel_number) {
+        case 37:
+            freq_hz = 2'402'000'000ull;
+            break;
+        case 38:
+            freq_hz = 2'426'000'000ull;
+            break;
+        case 39:
+            freq_hz = 2'480'000'000ull;
+            break;
+        case 0 ... 10:
+            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
+            break;
+        case 11 ... 36:
+            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
+            break;
+        default:
+            freq_hz = UINT64_MAX;
+    }
+
+    return freq_hz;
+}
+
+namespace ui {
+
+void BLETxView::focus() {
+    button_open.focus();
+}
+
+bool BLETxView::is_active() const {
+    return (bool)is_running;
+}
+
+void BLETxView::file_error() {
+    nav_.display_modal("Error", "File read error.");
+}
+
+void BLETxView::toggle() {
+    if (is_active()) {
+        stop();
+    } else {
+        start();
+    }
+}
+
+void BLETxView::start() {
+    // Generate new random Mac Address.
+    generateRandomMacAddress(randomMac);
+
+    if (!is_active()) {
+        // Check if file is present before continuing.
+        File data_file;
+
+        auto error = data_file.open(file_path);
+        if (error) {
+            file_error();
+            check_loop.set_value(false);
+            return;
+        } else {
+            // Send first or single packet.
+            packet_counter = packets[current_packet].packet_count;
+            progressbar.set_max(packets[current_packet].packet_count);
+            button_play.set_bitmap(&bitmap_stop);
+
+            baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
+            transmitter_model.enable();
+
+            is_running = true;
+        }
+    } else {
+        // Send next packet.
+        baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
+    }
+
+    if ((packet_counter % 10) == 0) {
+        text_packets_sent.set(to_string_dec_uint(packet_counter));
+    }
+
+    packet_counter--;
+
+    progressbar.set_value(packets[current_packet].packet_count - packet_counter);
+}
+
+void BLETxView::stop() {
+    transmitter_model.disable();
+    progressbar.set_value(0);
+    button_play.set_bitmap(&bitmap_play);
+    check_loop.set_value(false);
+
+    current_packet = 0;
+    text_packets_sent.set(to_string_dec_uint(packets[0].packet_count));
+    packet_counter = packets[0].packet_count;
+    update_packet_display(packets[0]);
+
+    is_running = false;
+}
+
+void BLETxView::on_tx_progress(const bool done) {
+    if (done) {
+        if (is_active()) {
+            // Reached end of current packet repeats.
+            if (packet_counter == 0) {
+                // Done sending all packets.
+                if (current_packet == (num_packets - 1)) {
+                    // If looping, restart from beginning.
+                    if (check_loop.value()) {
+                        current_packet = 0;
+                        packet_counter = packets[current_packet].packet_count;
+                        update_packet_display(packets[current_packet]);
+                    } else {
+                        stop();
+                    }
+                } else {
+                    current_packet++;
+                    packet_counter = packets[current_packet].packet_count;
+                    update_packet_display(packets[current_packet]);
+                }
+            } else {
+                if ((timer_count % timer_period) == 0) {
+                    start();
+                }
+            }
+
+            timer_count++;
+        }
+    }
+}
+
+BLETxView::BLETxView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+
+    add_children({&button_open,
+                  &text_filename,
+                  &progressbar,
+                  &check_rand_mac,
+                  &field_frequency,
+                  &tx_view,  // now it handles previous rfgain, rfamp.
+                  &check_loop,
+                  &button_play,
+                  &label_speed,
+                  &options_speed,
+                  &options_channel,
+                  &options_adv_type,
+                  &label_packet_index,
+                  &text_packet_index,
+                  &label_packets_sent,
+                  &text_packets_sent,
+                  &label_mac_address,
+                  &text_mac_address,
+                  &label_data_packet,
+                  &button_switch,
+                  &console});
+
+    field_frequency.set_step(0);
+
+    button_play.on_select = [this](ImageButton&) {
+        this->toggle();
+    };
+
+    options_channel.on_change = [this](size_t, int32_t i) {
+        field_frequency.set_value(get_freq_by_channel_number(i));
+        channel_number = i;
+    };
+
+    options_speed.on_change = [this](size_t, int32_t i) {
+        timer_period = i;
+    };
+
+    options_adv_type.on_change = [this](size_t, int32_t i) {
+        pduType = (PKT_TYPE)i;
+    };
+
+    options_speed.set_selected_index(0);
+
+    check_rand_mac.set_value(false);
+    check_rand_mac.on_select = [this](Checkbox&, bool v) {
+        random_mac = v;
+    };
+
+    button_open.on_select = [this, &nav](Button&) {
+        auto open_view = nav.push<FileLoadView>(".TXT");
+        open_view->on_changed = [this](std::filesystem::path new_file_path) {
+            on_file_changed(new_file_path);
+
+            nav_.set_on_pop([this]() { button_play.focus(); });
+        };
+    };
+
+    button_switch.on_select = [this, &nav](Button&) {
+        nav_.set_on_pop([this]() { nav_.push<BLERxView>(); });
+        nav_.pop();
+    };
+}
+
+void BLETxView::on_file_changed(const fs::path& new_file_path) {
+    file_path = fs::path(u"/") + new_file_path;
+    num_packets = 0;
+
+    {  // Get the size of the data file.
+        File data_file;
+        auto error = data_file.open(file_path);
+        if (error) {
+            file_error();
+            file_path = "";
+            return;
+        }
+
+        do {
+            readUntil(data_file, packets[num_packets].macAddress, mac_address_size_str, ' ');
+            readUntil(data_file, packets[num_packets].advertisementData, max_packet_size_str, ' ');
+            readUntil(data_file, packets[num_packets].packetCount, max_packet_repeat_str, '\n');
+
+            uint64_t macAddressSize = strlen(packets[num_packets].macAddress);
+            uint64_t advertisementDataSize = strlen(packets[num_packets].advertisementData);
+            uint64_t packetCountSize = strlen(packets[num_packets].packetCount);
+
+            packets[num_packets].packet_count = stringToUint32(packets[num_packets].packetCount);
+            packet_counter = packets[num_packets].packet_count;
+
+            // Verify Data.
+            if ((macAddressSize == mac_address_size_str) && (advertisementDataSize < max_packet_size_str) && (packetCountSize < max_packet_repeat_str) &&
+                hasValidHexPairs(packets[num_packets].macAddress, macAddressSize / 2) && hasValidHexPairs(packets[num_packets].advertisementData, advertisementDataSize / 2) && (packets[num_packets].packet_count > 0) && (packets[num_packets].packet_count < max_packet_repeat_count)) {
+                text_filename.set(truncate(file_path.filename().string(), 12));
+
+            } else {
+                // Did not find any packets.
+                if (num_packets == 0) {
+                    file_path = "";
+                    return;
+                }
+
+                break;
+            }
+
+            num_packets++;
+
+        } while (num_packets < max_num_packets);
+
+        update_packet_display(packets[0]);
+    }
+}
+
+void BLETxView::on_data(uint32_t value, bool is_data) {
+    std::string str_console = "";
+
+    if (is_data) {
+        str_console += (char)(value);
+    }
+
+    console.write(str_console);
+}
+
+void BLETxView::update_packet_display(BLETxPacket packet) {
+    std::string formattedMacAddress = to_string_formatted_mac_address(packet.macAddress);
+
+    std::vector<std::string> strings = splitIntoStrings(packet.advertisementData);
+
+    text_packet_index.set(to_string_dec_uint(current_packet));
+
+    text_packets_sent.set(to_string_dec_uint(packet.packet_count));
+
+    text_mac_address.set(formattedMacAddress);
+
+    console.clear(true);
+
+    for (const std::string& str : strings) {
+        console.writeln(str);
+    }
+}
+
+void BLETxView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
+    console.set_parent_rect(content_rect);
+}
+
+BLETxView::~BLETxView() {
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+} /* namespace ui */
@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLE_TX_APP_H__
+#define __BLE_TX_APP_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "replay_thread.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+#include "recent_entries.hpp"
+
+#include <string>
+#include <memory>
+
+class BLELoggerTx {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+
+class BLETxView : public View {
+   public:
+    BLETxView(NavigationView& nav);
+    ~BLETxView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    bool is_active() const;
+    void toggle();
+    void start();
+    void stop();
+    void handle_replay_thread_done(const uint32_t return_code);
+    void file_error();
+
+    std::string title() const override { return "BLE TX"; };
+
+    struct BLETxPacket {
+        char macAddress[13];
+        char advertisementData[63];
+        char packetCount[11];
+        uint32_t packet_count;
+    };
+
+   private:
+    void on_data(uint32_t value, bool is_data);
+    void on_tx_progress(const bool done);
+    void on_file_changed(const std::filesystem::path& new_file_path);
+    void update_packet_display(BLETxPacket packet);
+
+    NavigationView& nav_;
+    TxRadioState radio_state_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */
+    };
+    app_settings::SettingsManager settings_{
+        "ble_tx_app", app_settings::Mode::TX};
+
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+
+    std::filesystem::path file_path{};
+    uint8_t channel_number = 37;
+
+    char randomMac[13] = "010203040506";
+
+    bool is_running = false;
+    uint64_t timer_count{0};
+    uint64_t timer_period{256};
+    bool repeatLoop = false;
+    uint32_t packet_counter{0};
+    uint32_t num_packets{0};
+    uint32_t current_packet{0};
+    bool random_mac = false;
+
+    enum PKT_TYPE {
+        INVALID_TYPE,
+        RAW,
+        DISCOVERY,
+        IBEACON,
+        ADV_IND,
+        ADV_DIRECT_IND,
+        ADV_NONCONN_IND,
+        ADV_SCAN_IND,
+        SCAN_REQ,
+        SCAN_RSP,
+        CONNECT_REQ,
+        LL_DATA,
+        LL_CONNECTION_UPDATE_REQ,
+        LL_CHANNEL_MAP_REQ,
+        LL_TERMINATE_IND,
+        LL_ENC_REQ,
+        LL_ENC_RSP,
+        LL_START_ENC_REQ,
+        LL_START_ENC_RSP,
+        LL_UNKNOWN_RSP,
+        LL_FEATURE_REQ,
+        LL_FEATURE_RSP,
+        LL_PAUSE_ENC_REQ,
+        LL_PAUSE_ENC_RSP,
+        LL_VERSION_IND,
+        LL_REJECT_IND,
+        NUM_PKT_TYPE
+    };
+
+    static constexpr uint8_t mac_address_size_str{12};
+    static constexpr uint8_t max_packet_size_str{62};
+    static constexpr uint8_t max_packet_repeat_str{10};
+    static constexpr uint32_t max_packet_repeat_count{UINT32_MAX};
+    static constexpr uint32_t max_num_packets{256};
+
+    BLETxPacket packets[max_num_packets];
+
+    PKT_TYPE pduType = {DISCOVERY};
+
+    static constexpr auto header_height = 9 * 16;
+    static constexpr auto switch_button_height = 3 * 16;
+
+    Button button_open{
+        {0 * 8, 0 * 16, 10 * 8, 2 * 16},
+        "Open file"};
+
+    Text text_filename{
+        {11 * 8, 0 * 16, 12 * 8, 16},
+        "-"};
+
+    ProgressBar progressbar{
+        {11 * 8, 1 * 16, 9 * 8, 16}};
+
+    Checkbox check_rand_mac{
+        {21 * 8, 1 * 16},
+        6,
+        "Random",
+        true};
+
+    TxFrequencyField field_frequency{
+        {0 * 8, 2 * 16},
+        nav_};
+
+    TransmitterView2 tx_view{
+        {11 * 8, 2 * 16},
+        /*short_ui*/ true};
+
+    Checkbox check_loop{
+        {21 * 8, 2 * 16},
+        4,
+        "Loop",
+        true};
+
+    ImageButton button_play{
+        {28 * 8, 2 * 16, 2 * 8, 1 * 16},
+        &bitmap_play,
+        Color::green(),
+        Color::black()};
+
+    Labels label_speed{
+        {{0 * 8, 6 * 8}, "Speed:", Color::light_grey()}};
+
+    OptionsField options_speed{
+        {7 * 8, 6 * 8},
+        3,
+        {{"1 ", 256},
+         {"2 ", 128},
+         {"3 ", 64},
+         {"4 ", 32},
+         {"5 ", 16}}};
+
+    OptionsField options_channel{
+        {11 * 8, 6 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39}}};
+
+    OptionsField options_adv_type{
+        {17 * 8, 6 * 8},
+        14,
+        {{"DISCOVERY ", DISCOVERY},
+         {"ADV_IND", ADV_IND},
+         {"ADV_DIRECT", ADV_DIRECT_IND},
+         {"ADV_NONCONN", ADV_NONCONN_IND},
+         {"SCAN_REQ", SCAN_REQ},
+         {"SCAN_RSP", SCAN_RSP},
+         {"CONNECT_REQ", CONNECT_REQ}}};
+
+    Labels label_packet_index{
+        {{0 * 8, 10 * 8}, "Packet Index:", Color::light_grey()}};
+
+    Text text_packet_index{
+        {13 * 8, 5 * 16, 12 * 8, 16},
+        "-"};
+
+    Labels label_packets_sent{
+        {{0 * 8, 12 * 8}, "Packets Left:", Color::light_grey()}};
+
+    Text text_packets_sent{
+        {13 * 8, 6 * 16, 12 * 8, 16},
+        "-"};
+
+    Labels label_mac_address{
+        {{0 * 8, 14 * 8}, "Mac Address:", Color::light_grey()}};
+
+    Text text_mac_address{
+        {12 * 8, 7 * 16, 20 * 8, 16},
+        "-"};
+
+    Labels label_data_packet{
+        {{0 * 8, 16 * 8}, "Packet Data:", Color::light_grey()}};
+
+    Console console{
+        {0, 8 * 16, 240, 240}};
+
+    Button button_switch{
+        {8 * 8, 16 * 16, 14 * 8, 2 * 16},
+        "Switch to Rx"};
+
+    std::string str_log{""};
+    bool logging{true};
+    bool logging_done{false};
+
+    std::unique_ptr<BLELoggerTx> logger{};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::AFSKData,
+        [this](Message* const p) {
+            const auto message = static_cast<const AFSKDataMessage*>(p);
+            this->on_data(message->value, message->is_data);
+        }};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.done);
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/
@@ -110,9 +110,6 @@ ERTAppView::ERTAppView(NavigationView&) {
        &recent_entries_view,
    });

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

    logger = std::make_unique<ERTLogger>();
@@ -123,12 +123,11 @@ class ERTAppView : public View {
    std::string title() const override { return "ERT RX"; };

   private:
-    static constexpr uint32_t initial_target_frequency = 911600000;
-
    ERTRecentEntries recent{};
    std::unique_ptr<ERTLogger> logger{};

    RxRadioState radio_state_{
+        911600000 /* frequency */,
        2500000 /* bandwidth */,
        4194304 /* sampling rate */};
    app_settings::SettingsManager settings_{
@@ -74,7 +74,10 @@ void GpsSimAppView::on_file_changed(const fs::path& new_file_path) {
    auto duration = ms_duration(file_size, transmitter_model.sampling_rate(), 2);
    text_duration.set(to_string_time_ms(duration));

-    button_play.focus();
+    // TODO: fix in UI framework with 'try_focus()'?
+    // Hack around focus getting called by ctor before parent is set.
+    if (parent())
+        button_play.focus();
 }

 void GpsSimAppView::on_tx_progress(const uint32_t progress) {
@@ -173,11 +176,6 @@ GpsSimAppView::GpsSimAppView(
        &waterfall,
    });

-    if (!settings_.radio_loaded()) {
-        field_frequency.set_value(initial_target_frequency);
-        transmitter_model.set_sampling_rate(2600000);
-    }
-
    field_frequency.set_step(5000);

    button_play.on_select = [this](ImageButton&) {
@@ -51,21 +51,17 @@ class GpsSimAppView : public View {
    std::string title() const override { return "GPS Sim TX"; };

   private:
-    static constexpr uint32_t initial_target_frequency = 1575420000;
-
    NavigationView& nav_;
-    RxRadioState radio_state_{
-        3000000 /* bandwidth */,
-        500000 /* sampling rate */
+    TxRadioState radio_state_{
+        1575420000 /* frequency */,
+        15000000 /* bandwidth */,
+        2600000 /* sampling rate */
    };
    app_settings::SettingsManager settings_{
        "tx_gps", app_settings::Mode::TX};

    static constexpr ui::Dim header_height = 3 * 16;

-    int32_t tx_gain{47};
-    bool rf_amp{true};                                       // aux private var to store temporal, same as Replay App rf_amp user selection.
-    static constexpr uint32_t baseband_bandwidth = 3000000;  // filter bandwidth
    const size_t read_size{16384};
    const size_t buffer_count{3};

@@ -238,6 +238,10 @@ void LGEView::start_tx() {
        tx_view.set_dirty();
    }

+    /* By experimental test, previous fw 1.7.4 seems to have setting , tx LPF = 5Mhz
+    This LGE - seems to be for controlling a "laser tag equipment" (Havoc app) , modulated  FSK , low bauds,
+    and using max GUI fm dev 150k , we are still in NBFM, let's reduce slightly original TX LPF 5M ->2M5*/
+    transmitter_model.set_baseband_bandwidth(2'500'000);
    transmitter_model.enable();

    chThdSleep(100);
@@ -51,6 +51,7 @@ class LGEView : public View {
    };

    TxRadioState radio_state_{
+        868067000 /* frequency */,
        1750000 /* bandwidth */,
        2280000 /* sampling rate */
    };
@@ -114,9 +114,6 @@ POCSAGAppView::POCSAGAppView(NavigationView& nav)
                                    ? FILTER_NONE
                                    : FILTER_DROP;
    }
-    if (!app_settings_.radio_loaded()) {
-        field_frequency.set_value(initial_target_frequency);
-    }

    logger.append(LOG_ROOT_DIR "/POCSAG.TXT");

@@ -197,14 +197,17 @@ class POCSAGAppView : public View {
    void focus() override;

   private:
-    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_{};
+    RxRadioState radio_state_{
+        466175000 /* frequency*/,
+        max283x::filter::bandwidth_minimum /* bandwidth */,
+        3072000 /* sampling rate */
+    };

    // Settings
    POCSAGSettings settings_{};
@@ -50,6 +50,7 @@ class SoundBoardView : public View {

   private:
    TxRadioState radio_state_{
+        0 /* frequency */,
        1750000 /* bandwidth */,
        1536000 /* sampling rate */
    };
@@ -157,9 +157,6 @@ TPMSAppView::TPMSAppView(NavigationView&) {
                  &field_vga,
                  &recent_entries_view});

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

    options_band.on_change = [this](size_t, OptionsField::value_t v) {
@@ -102,9 +102,8 @@ class TPMSAppView : public View {
    std::string title() const override { return "TPMS RX"; };

   private:
-    static constexpr uint32_t initial_target_frequency = 315000000;
-
    RxRadioState radio_state_{
+        315000000 /* frequency*/,
        1750000 /* bandwidth */,
        2457600 /* sampling rate */};
    app_settings::SettingsManager settings_{
@@ -135,7 +134,7 @@ class TPMSAppView : public View {
        3,
        {
            {"315", 315000000},
-            {"433", 433920000},
+            {"434", 433920000},
        }};

    OptionsField options_pressure{
@@ -37,6 +37,7 @@ void AboutView::update() {
                break;
            case 2:
                console.writeln("NotherNgineer,zxkmm,u-foka");
+                console.writeln("Netro");
                console.writeln("");
                break;

@@ -34,6 +34,8 @@ using namespace portapack;

 namespace ui {

+bool ac_details_view_active{false};
+
 template <>
 void RecentEntriesTable<AircraftRecentEntries>::draw(
    const Entry& entry,
@@ -182,6 +184,7 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
            break;
    }
    button_close.on_select = [&nav](Button&) {
+        ac_details_view_active = false;
        nav.pop();
    };
 };
@@ -217,6 +220,7 @@ void ADSBRxDetailsView::update(const AircraftRecentEntry& entry) {
 }

 ADSBRxDetailsView::~ADSBRxDetailsView() {
+    ac_details_view_active = false;
    on_close_();
 }

@@ -260,6 +264,7 @@ ADSBRxDetailsView::ADSBRxDetailsView(
    text_icao_address.set(to_string_hex(entry_copy.ICAO_address, 6));

    button_aircraft_details.on_select = [this, &nav](Button&) {
+        ac_details_view_active = true;
        aircraft_details_view = nav.push<ADSBRxAircraftDetailsView>(entry_copy, [this]() { send_updates = false; });
        send_updates = false;
    };
@@ -433,6 +438,11 @@ void ADSBRxView::updateDetailsAndMap(int ageStep) {
    ui::GeoMarker marker;
    bool storeNewMarkers = false;

+    // NB: Temporarily pausing updates in rtc_timer_tick context when viewing AC Details screen (kludge for some Guru faults)
+    // TODO: More targeted blocking of updates in rtc_timer_tick when ADSB processes are running
+    if (ac_details_view_active)
+        return;
+
    // Sort and truncate the entries, grouped, newest group first
    sort_entries_by_state();
    truncate_entries(recent);
@@ -511,7 +521,6 @@ ADSBRxView::ADSBRxView(NavigationView& nav) {

    baseband::set_adsb();

-    receiver_model.set_target_frequency(1'090'000'000);
    receiver_model.enable();
 }

@@ -342,6 +342,7 @@ class ADSBRxView : public View {

   private:
    RxRadioState radio_state_{
+        1090000000 /* frequency */,
        2500000 /* bandwidth */,
        2000000 /* sampling rate */,
        ReceiverModel::Mode::SpectrumAnalysis};
@@ -296,6 +296,9 @@ void ADSBTxView::generate_frames() {
 void ADSBTxView::start_tx() {
    generate_frames();

+    /* Already tested , with SDR Angel + another Hackrf RX  and dump1090 + SDR RLT. Final conclusion is TX LPF 6 Mhz is
+     * the best settings to fulfill ADSB transponder spectrum mask requirements (<=-20 dB's at +-7Mhz , <=-40 dB's at +-23Mhz )
+     * and not showing any ADSB data decoding degradation.*/
    transmitter_model.enable();

    baseband::set_adsb();
@@ -203,7 +203,8 @@ class ADSBTxView : public View {
        };*/

    TxRadioState radio_state_{
-        10000000 /* bandwidth */,
+        1090000000 /* frequency */,
+        6000000 /* bandwidth */,
        4000000 /* sampling rate */
    };
    app_settings::SettingsManager settings_{
@@ -190,7 +190,11 @@ class APRSRxView : public View {
    bool reset_console = false;

    NavigationView& nav_;
-    RxRadioState radio_state_{};
+    RxRadioState radio_state_{
+        144390000 /* frequency */,
+        1750000 /* bandwidth */,
+        3072000 /* sampling rate */
+    };
    app_settings::SettingsManager settings_{
        "rx_aprs", app_settings::Mode::RX};

@@ -46,6 +46,7 @@ class APRSTXView : public View {

   private:
    TxRadioState radio_state_{
+        144390000 /* frequency */,
        1750000 /* bandwidth */,
        AFSK_TX_SAMPLERATE /* sampling rate */
    };
@@ -54,7 +54,6 @@ BTLERxView::BTLERxView(NavigationView& nav)
                  &console});

    // Auto-configure modem for LCR RX (TODO: remove later)
-    field_frequency.set_value(2426000000);
    auto def_bell202 = &modem_defs[0];
    persistent_memory::set_modem_baudrate(def_bell202->baudrate);
    serial_format_t serial_format;
@@ -71,7 +70,7 @@ BTLERxView::BTLERxView(NavigationView& nav)
    };

    // Auto-configure modem for LCR RX (will be removed later)
-    baseband::set_btle(persistent_memory::modem_baudrate(), 8, 0, false);
+    baseband::set_btlerx(channel_number);

    audio::set_rate(audio::Rate::Hz_24000);
    audio::output::start();
@@ -50,6 +50,7 @@ class BTLERxView : public View {

    NavigationView& nav_;
    RxRadioState radio_state_{
+        2426000000 /* frequency */,
        4000000 /* bandwidth */,
        4000000 /* sampling rate */,
        ReceiverModel::Mode::WidebandFMAudio};
@@ -59,6 +60,8 @@ class BTLERxView : public View {
    uint8_t console_color{0};
    uint32_t prev_value{0};

+    static constexpr uint8_t channel_number = 37;
+
    RFAmpField field_rf_amp{
        {13 * 8, 0 * 16}};
    LNAGainField field_lna{
@@ -52,11 +52,12 @@ class CoasterPagerView : public View {
    tx_modes tx_mode = IDLE;

    TxRadioState radio_state_{
+        433920000, /* frequency */
        1750000 /* bandwidth */,
        2280000 /* sampling rate */
    };
    app_settings::SettingsManager settings_{
-        "tx_coaster", app_settings::Mode::TX};
+        "tx_burger", app_settings::Mode::TX};

    void start_tx();
    void generate_frame();
@@ -34,6 +34,7 @@
 #include "ui_font_fixed_8x16.hpp"
 #include "ui_styles.hpp"
 #include "ui_painter.hpp"
+#include "ui_external_items_menu_loader.hpp"

 #include "portapack.hpp"
 #include "portapack_persistent_memory.hpp"
@@ -400,7 +401,6 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
    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>(); }},
@@ -410,6 +410,11 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
        {"Temperature", ui::Color::dark_cyan(), &bitmap_icon_temperature, [&nav]() { nav.push<TemperatureView>(); }},
        {"Touch Test", ui::Color::dark_cyan(), &bitmap_icon_notepad, [&nav]() { nav.push<DebugScreenTest>(); }},
    });
+
+    for (auto const& gridItem : ExternalItemsMenuLoader::load_external_items(app_location_t::DEBUG, nav)) {
+        add_item(gridItem);
+    };
+
    set_max_rows(2);  // allow wider buttons
 }

@@ -469,41 +474,6 @@ uint32_t DebugPmemView::registers_widget_feed(const size_t register_number) {
    return data.regfile[(page_size * page + register_number) / 4] >> (register_number % 4 * 8);
 }

-/* DebugFontsView *******************************************************/
-
-uint16_t DebugFontsView::display_font(Painter& painter, uint16_t y_offset, const Style* font_style, std::string_view font_name) {
-    auto char_width{font_style->font.char_width()};
-    auto char_height{font_style->font.line_height()};
-    auto cpl{((screen_width / char_width) - 6) & 0xF8};  // Display a multiple of 8 characters per line
-    uint16_t line_pos{y_offset};
-
-    painter.draw_string({0, y_offset}, *font_style, font_name);
-
-    // Displaying ASCII+extended characters from 0x20 to 0xFF
-    for (uint8_t c = 0; c <= 0xDF; c++) {
-        line_pos = y_offset + ((c / cpl) + 2) * char_height;
-
-        if ((c % cpl) == 0)
-            painter.draw_string({0, line_pos}, *font_style, "Ox" + to_string_hex(c + 0x20, 2));
-
-        painter.draw_char({((c % cpl) + 5) * char_width, line_pos}, *font_style, (char)(c + 0x20));
-    }
-
-    return line_pos + char_height;
-}
-
-void DebugFontsView::paint(Painter& painter) {
-    int16_t line_pos;
-
-    line_pos = display_font(painter, 32, &Styles::white, "Fixed 8x16");
-    display_font(painter, line_pos + 16, &Styles::white_small, "Fixed 5x8");
-}
-
-DebugFontsView::DebugFontsView(NavigationView& nav)
-    : nav_{nav} {
-    set_focusable(true);
-}
-
 /* DebugScreenTest ****************************************************/

 DebugScreenTest::DebugScreenTest(NavigationView& nav)
@@ -310,17 +310,6 @@ class DebugPmemView : public View {
    uint32_t registers_widget_feed(const size_t register_number);
 };

-class DebugFontsView : public View {
-   public:
-    DebugFontsView(NavigationView& nav);
-    void paint(Painter& painter) override;
-    std::string title() const override { return "Fonts"; };
-
-   private:
-    uint16_t display_font(Painter& painter, uint16_t y_offset, const Style* font_style, std::string_view font_name);
-    NavigationView& nav_;
-};
-
 class DebugScreenTest : public View {
   public:
    DebugScreenTest(NavigationView& nav);
@@ -92,7 +92,9 @@ DfuMenu2::DfuMenu2(NavigationView& nav)
                  &text_info_line_5,
                  &text_info_line_6,
                  &text_info_line_7,
-                  &text_info_line_8});
+                  &text_info_line_8,
+                  &text_info_line_9,
+                  &text_info_line_10});
 }

 void DfuMenu2::paint(Painter& painter) {
@@ -103,10 +105,12 @@ void DfuMenu2::paint(Painter& painter) {
    text_info_line_5.set(to_string_dec_uint(portapack::receiver_model.am_configuration(), 10));
    text_info_line_6.set(to_string_dec_uint(portapack::receiver_model.nbfm_configuration(), 10));
    text_info_line_7.set(to_string_dec_uint(portapack::receiver_model.wfm_configuration(), 10));
-    text_info_line_8.set("");
+    text_info_line_8.set(to_string_dec_uint(portapack::transmitter_model.target_frequency(), 10));
+    text_info_line_9.set(to_string_dec_uint(portapack::transmitter_model.baseband_bandwidth(), 10));
+    text_info_line_10.set(to_string_dec_uint(portapack::transmitter_model.sampling_rate(), 10));

    constexpr auto margin = 5;
-    constexpr auto lines = 8 + 2;
+    constexpr auto lines = 10 + 2;

    painter.fill_rectangle(
        {{5 * CHARACTER_WIDTH - margin, 3 * LINE_HEIGHT - margin},
@@ -77,17 +77,19 @@ class DfuMenu2 : public View {
   private:
    NavigationView& nav_;

-    Text text_head{{6 * CHARACTER_WIDTH, 3 * LINE_HEIGHT, 8 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, "Receiver"};
+    Text text_head{{6 * CHARACTER_WIDTH, 3 * LINE_HEIGHT, 14 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, "Radio Settings"};

    Labels labels{
-        {{5 * CHARACTER_WIDTH, 5 * LINE_HEIGHT}, "Tgt freq:", Color::dark_cyan()},
-        {{5 * CHARACTER_WIDTH, 6 * LINE_HEIGHT}, "Bandwidt:", Color::dark_cyan()},
-        {{5 * CHARACTER_WIDTH, 7 * LINE_HEIGHT}, "Sampl Rt:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 5 * LINE_HEIGHT}, "RX Freq:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 6 * LINE_HEIGHT}, "RX BW:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 7 * LINE_HEIGHT}, "RX SampR:", Color::dark_cyan()},
        {{5 * CHARACTER_WIDTH, 8 * LINE_HEIGHT}, "Modulatn:", Color::dark_cyan()},
        {{5 * CHARACTER_WIDTH, 9 * LINE_HEIGHT}, "AM cfg:", Color::dark_cyan()},
        {{5 * CHARACTER_WIDTH, 10 * LINE_HEIGHT}, "NBFM cfg:", Color::dark_cyan()},
        {{5 * CHARACTER_WIDTH, 11 * LINE_HEIGHT}, "WFM cfg:", Color::dark_cyan()},
-        {{5 * CHARACTER_WIDTH, 12 * LINE_HEIGHT}, "", Color::dark_cyan()}};
+        {{5 * CHARACTER_WIDTH, 12 * LINE_HEIGHT}, "TX Freq:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 13 * LINE_HEIGHT}, "TX BW:", Color::dark_cyan()},
+        {{5 * CHARACTER_WIDTH, 14 * LINE_HEIGHT}, "TX SampR:", Color::dark_cyan()}};

    Text text_info_line_1{{14 * CHARACTER_WIDTH, 5 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
    Text text_info_line_2{{14 * CHARACTER_WIDTH, 6 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
@@ -97,6 +99,8 @@ class DfuMenu2 : public View {
    Text text_info_line_6{{14 * CHARACTER_WIDTH, 10 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
    Text text_info_line_7{{14 * CHARACTER_WIDTH, 11 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
    Text text_info_line_8{{14 * CHARACTER_WIDTH, 12 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_9{{14 * CHARACTER_WIDTH, 13 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_10{{14 * CHARACTER_WIDTH, 14 * LINE_HEIGHT, 10 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
 };

 } /* namespace ui */
@@ -269,6 +269,9 @@ void EncodersView::start_tx(const bool scan) {
    repeat_index = 1;
    update_progress();

+    /* Setting TX LPF 1M75 in this TX OOK App  , We got same results as fw 1.7.4
+     * Looking max BW of this app, we tested , Selecting OOK type 145026 with CLK 455K and max DEV. 150k,
+     * and we got BW +-2Mhz , with that TX LPF 1M75, it is fine.*/
    transmitter_model.enable();

    baseband::set_ook_data(
@@ -185,6 +185,7 @@ class EncodersView : public View {
    };

    TxRadioState radio_state_{
+        433920000 /* frequency */,
        1750000 /* bandwidth */,
        OOK_SAMPLERATE /* sampling rate */
    };
@@ -30,6 +30,7 @@
 #include "ui_remote.hpp"
 #include "ui_ss_viewer.hpp"
 #include "ui_text_editor.hpp"
+#include "ui_iq_trim.hpp"
 #include "string_format.hpp"
 #include "portapack.hpp"
 #include "event_m0.hpp"
@@ -108,14 +109,17 @@ bool partner_file_prompt(
    if (partner.empty())
        return false;

-    nav.push_under_current<ModalMessageView>(
-        "Partner File",
-        partner.filename().string() + "\n" + action_name + " this file too?",
-        YESNO,
-        [&nav, partner, on_partner_action](bool choice) {
-            if (on_partner_action)
-                on_partner_action(partner, choice);
-        });
+    // Display the continuation UI once the current has been popped.
+    nav.set_on_pop([&nav, partner, action_name, on_partner_action] {
+        nav.display_modal(
+            "Partner File",
+            partner.filename().string() + "\n" + action_name + " this file too?",
+            YESNO,
+            [&nav, partner, on_partner_action](bool choice) {
+                if (on_partner_action)
+                    on_partner_action(partner, choice);
+            });
+    });

    return true;
 }
@@ -189,8 +193,8 @@ FileManBaseView::FileManBaseView(
                  &text_current,
                  &button_exit});

-    button_exit.on_select = [this, &nav](Button&) {
-        nav.pop();
+    button_exit.on_select = [this](Button&) {
+        nav_.pop();
    };

    if (!sdcIsCardInserted(&SDCD1)) {
@@ -325,9 +329,9 @@ FileLoadView::FileLoadView(
        if (get_selected_entry().is_directory) {
            push_dir(get_selected_entry().path);
        } else {
-            nav_.pop();
            if (on_changed)
                on_changed(get_selected_full_path());
+            nav_.pop();
        }
    };
 }
@@ -563,6 +567,7 @@ FileManagerView::FileManagerView(
        &button_new_file,
        &button_open_notepad,
        &button_rename_timestamp,
+        &button_open_iq_trim,
    });

    menu_view.on_highlight = [this]() {
@@ -645,6 +650,14 @@ FileManagerView::FileManagerView(
        } else
            nav_.display_modal("Timestamp Rename", "Can't rename that.");
    };
+
+    button_open_iq_trim.on_select = [this]() {
+        auto path = get_selected_full_path();
+        if (selected_is_valid() && !get_selected_entry().is_directory && is_cxx_capture_file(path)) {
+            nav_.push<IQTrimView>(path);
+        } else
+            nav_.display_modal("IQ Trim", "Not a capture file.");
+    };
 }

 }  // namespace ui
@@ -272,6 +272,12 @@ class FileManagerView : public FileManBaseView {
        &bitmap_icon_options_datetime,
        Color::orange(),
        /*vcenter*/ true};
+
+    NewButton button_open_iq_trim{
+        {9 * 8, 34 * 8, 4 * 8, 32},
+        {},
+        &bitmap_icon_trim,
+        Color::orange()};
 };

 } /* 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,197 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_fsk_rx.hpp"
+
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "string_format.hpp"
+#include "utility.hpp"
+
+#include "ui_freqman.hpp"
+
+using namespace portapack;
+namespace pmem = portapack::persistent_memory;
+
+void FskRxLogger::log_raw_data(const std::string& data, const uint32_t frequency) {
+    std::string entry = "Raw: F:" + to_string_dec_uint(frequency) + "Hz";
+
+    // // Raw hex dump of all the codewords
+    // for (size_t c = 0; c < 16; c++)
+    //     entry += to_string_hex(packet[c], 8) + " ";
+
+    log_file.write_entry(data + entry);
+}
+
+void FskRxLogger::log_decoded(Timestamp timestamp, const std::string& text) {
+    log_file.write_entry(timestamp, text);
+}
+
+namespace ui {
+//---------------------------------------------------------------------------------------------------------------
+//  Console View
+//---------------------------------------------------------------------------------------------------------------
+FskRxAppConsoleView::FskRxAppConsoleView(NavigationView& nav, Rect parent_rect)
+    : View(parent_rect), nav_{nav} {
+    add_child(&console);
+};
+
+void FskRxAppConsoleView::on_packet(uint32_t value, bool is_data) {
+    if (is_data) {
+        console.write(to_string_dec_uint(value) + " ");
+    }
+}
+
+void FskRxAppConsoleView::on_show() {
+    hidden(false);
+}
+
+void FskRxAppConsoleView::on_hide() {
+    hidden(true);
+}
+
+FskRxAppConsoleView::~FskRxAppConsoleView() {
+}
+
+//---------------------------------------------------------------------------------------------------------------
+//  Spectrum View
+//---------------------------------------------------------------------------------------------------------------
+FskRxAppView::FskRxAppView(NavigationView& nav, Rect parent_rect)
+    : View(parent_rect), nav_{nav} {
+    add_child(&waterfall);
+    hidden(true);
+}
+
+FskRxAppView::~FskRxAppView() {
+}
+
+void FskRxAppView::focus() {
+}
+
+void FskRxAppView::on_show() {
+    hidden(false);
+    waterfall.start();
+}
+
+void FskRxAppView::on_hide() {
+    hidden(true);
+    waterfall.stop();
+}
+
+//---------------------------------------------------------------------------------------------------------------
+//  Base View
+//---------------------------------------------------------------------------------------------------------------
+FskxRxMainView::FskxRxMainView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&tab_view,
+                  &view_data,
+                  &view_stream,
+                  &labels,
+                  &rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_frequency,
+                  &deviation_frequency,
+                  &record_view});
+
+    baseband::run_image(portapack::spi_flash::image_tag_fskrx);
+
+    // DEBUG
+    record_view.on_error = [&nav](std::string message) {
+        nav.display_modal("Error", message);
+    };
+
+    deviation_frequency.on_change = [this](rf::Frequency f) {
+        refresh_ui(f);
+    };
+
+    // Set initial sampling rate
+    /* Bandwidth of 2FSK is 2 * Deviation */
+    record_view.set_sampling_rate(initial_deviation * 2);
+
+    field_frequency.set_value(initial_target_frequency);
+    deviation_frequency.set_value(initial_deviation);
+
+    logger.append(LOG_ROOT_DIR "/FSKRX.TXT");
+
+    baseband::set_fsk(initial_deviation);
+
+    audio::output::start();
+    receiver_model.enable();
+}
+
+void FskxRxMainView::handle_decoded(Timestamp timestamp, const std::string& prefix) {
+    if (logging()) {
+        logger.log_decoded(timestamp, prefix);
+    }
+}
+
+void FskxRxMainView::refresh_ui(rf::Frequency deviationHz) {
+    /* Nyquist would imply a sample rate of 2x bandwidth, but because the ADC
+     * provides 2 values (I,Q), the sample_rate is equal to bandwidth here. */
+    /* Bandwidth of 2FSK is 2 * Deviation */
+    auto sample_rate = deviationHz * 2;
+
+    /* base_rate (bandwidth) is used for FFT calculation and display LCD, and also in recording writing SD Card rate. */
+    /* ex. sampling_rate values, 4Mhz, when recording 500 kHz (BW) and fs 8 Mhz, when selected 1 Mhz BW ... */
+    /* ex. recording 500kHz BW to .C16 file, base_rate clock 500kHz x2(I,Q) x 2 bytes (int signed) =2MB/sec rate SD Card. */
+
+    if (!view_stream.hidden()) {
+        view_stream.waterfall.stop();
+    }
+
+    // record_view determines the correct oversampling to apply and returns the actual sample rate.
+    // NB: record_view is what actually updates proc_capture baseband settings.
+    auto actual_sample_rate = record_view.set_sampling_rate(sample_rate);
+
+    // Update the radio model with the actual sampling rate.
+    receiver_model.set_sampling_rate(actual_sample_rate);
+
+    // Get suitable anti-aliasing BPF bandwidth for MAX2837 given the actual sample rate.
+    auto anti_alias_filter_bandwidth = filter_bandwidth_for_sampling_rate(actual_sample_rate);
+    receiver_model.set_baseband_bandwidth(anti_alias_filter_bandwidth);
+
+    if (!view_stream.hidden()) {
+        view_stream.waterfall.start();
+    }
+}
+
+void FskxRxMainView::focus() {
+    field_frequency.focus();
+}
+
+void FskxRxMainView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+
+    ui::Rect waterfall_rect{0, 0, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    view_stream.waterfall.set_parent_rect(waterfall_rect);
+}
+
+FskxRxMainView::~FskxRxMainView() {
+    audio::output::stop();
+    receiver_model.disable();
+    baseband::shutdown();
+}
+} /* namespace ui */
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2018 Furrtek
+ * Copyright (C) 2023 gullradriel, Nilorea Studio Inc.
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_FSK_RX_H__
+#define __UI_FSK_RX_H__
+
+#include "ui_widget.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_receiver.hpp"
+#include "ui_record_view.hpp"
+#include "ui_rssi.hpp"
+#include "ui_spectrum.hpp"
+#include "ui_styles.hpp"
+#include "ui_tabview.hpp"
+
+#include "app_settings.hpp"
+#include "log_file.hpp"
+#include "radio_state.hpp"
+#include "pocsag_app.hpp"
+
+#include <functional>
+
+class FskRxLogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data, const uint32_t frequency);
+    void log_decoded(Timestamp timestamp, const std::string& text);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+class FskRxAppConsoleView : public View {
+   public:
+    FskRxAppConsoleView(NavigationView& nav, Rect parent_rec);
+    ~FskRxAppConsoleView();
+
+    std::string title() const override { return "FSK RX Data"; };
+
+    void on_packet(uint32_t value, bool is_data);
+
+    void on_show() override;
+    void on_hide() override;
+
+   private:
+    NavigationView& nav_;
+
+    Console console{
+        {0, 0, 240, 224}};
+};
+
+class FskRxAppView : public View {
+   public:
+    FskRxAppView(NavigationView& nav, Rect parent_rect);
+    ~FskRxAppView();
+
+    void focus() override;
+    void on_show() override;
+    void on_hide() override;
+
+    spectrum::WaterfallView waterfall{};
+
+    std::string title() const override { return "FSK RX Stream"; };
+
+   private:
+    NavigationView& nav_;
+    RxRadioState radio_state_{};
+};
+
+class FskxRxMainView : public View {
+   public:
+    FskxRxMainView(NavigationView& nav);
+    ~FskxRxMainView();
+
+    void focus() override;
+    void set_parent_rect(const Rect new_parent_rect) override;
+
+    std::string title() const override { return "FSK RX"; };
+
+   private:
+    static constexpr uint32_t initial_target_frequency = 902'075'000;
+    static constexpr ui::Dim header_height = (5 * 16);
+
+    uint32_t initial_deviation{3750};
+
+    bool logging() const { return false; };
+    bool logging_raw() const { return false; };
+
+    NavigationView& nav_;
+    Rect view_rect = {0, header_height, 240, 224};
+
+    FskRxAppView view_stream{nav_, view_rect};
+    FskRxAppConsoleView view_data{nav_, view_rect};
+
+    TabView tab_view{
+        {"Data", Color::yellow(), &view_data},
+        {"Stream", Color::cyan(), &view_stream}};
+
+    void refresh_ui(rf::Frequency f);
+    void on_packet(uint32_t value, bool is_data);
+    void handle_decoded(Timestamp timestamp, const std::string& prefix);
+
+    uint32_t last_address = 0;
+    FskRxLogger logger{};
+    uint16_t packet_count = 0;
+
+    RxFrequencyField field_frequency{
+        {0 * 8, 4 * 8},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {11 * 8, 2 * 16}};
+
+    LNAGainField field_lna{
+        {13 * 8, 2 * 16}};
+
+    VGAGainField field_vga{
+        {16 * 8, 2 * 16}};
+
+    RSSI rssi{
+        {19 * 8 - 4, 35, 6 * 8, 4}};
+
+    Channel channel{
+        {19 * 8 - 4, 40, 6 * 8, 4}};
+
+    Labels labels{
+        {{0 * 8, 3 * 16}, "Deviation:", Color::light_grey()},
+    };
+
+    FrequencyField deviation_frequency{
+        {10 * 8, 3 * 16},
+        {3750, 500000},
+    };
+
+    // DEBUG
+    RecordView record_view{
+        {0 * 8, 4 * 16, 30 * 8, 1 * 16},
+        u"FSKRX_????.C16",
+        u"FSKRX",
+        RecordView::FileType::RawS16,
+        16384,
+        3};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::AFSKData,
+        [this](Message* const p) {
+            const auto message = static_cast<const AFSKDataMessage*>(p);
+            this->view_data.on_packet(message->value, message->is_data);
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__POCSAG_APP_H__*/
@@ -30,41 +30,87 @@ namespace fs = std::filesystem;

 namespace ui {

-IQTrimView::IQTrimView(NavigationView& nav) {
+IQTrimView::IQTrimView(NavigationView& nav)
+    : nav_{nav} {
    add_children({
        &labels,
        &field_path,
-        &text_range,
+        &field_start,
+        &field_end,
+        &text_samples,
+        &text_max,
+        &field_cutoff,
+        &field_amplify,
        &button_trim,
    });

-    field_path.on_select = [this, &nav](TextField&) {
-        auto open_view = nav.push<FileLoadView>(".C*");
+    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) {
-            read_capture(path);
-            path_ = std::move(path);
-            refresh_ui();
+            open_file(path);
        };
    };

-    button_trim.on_select = [this, &nav](Button&) {
-        if (!path_.empty() && trim_range_.file_size > 0) {
-            progress_ui.show_trimming();
-            TrimFile(path_, trim_range_);
-            read_capture(path_);
+    text_samples.set_style(&Styles::light_grey);
+    text_max.set_style(&Styles::light_grey);
+
+    field_start.on_change = [this](int32_t v) {
+        if (field_end.value() < v)
+            field_end.set_value(v, false);
+        set_dirty();
+    };
+
+    field_end.on_change = [this](int32_t v) {
+        if (field_start.value() > v)
+            field_start.set_value(v, false);
+        set_dirty();
+    };
+
+    field_cutoff.set_value(7);  // 7% of max is a good default.
+    field_cutoff.on_change = [this](int32_t) {
+        compute_range();
+        refresh_ui();
+    };
+
+    field_amplify.set_value(1);  // 1X is default (no amplification)
+    field_amplify.on_change = [this](int32_t) {
+        refresh_ui();
+    };
+
+    button_trim.on_select = [this](Button&) {
+        if (trim_capture()) {
+            profile_capture();
+            compute_range();
            refresh_ui();
-        } else {
-            nav.display_modal("Error", "Select a file first.");
        }
    };
 }

+IQTrimView::IQTrimView(NavigationView& nav, const fs::path& path)
+    : IQTrimView(nav) {
+    open_file(path);
+}
+
+void IQTrimView::open_file(const std::filesystem::path& path) {
+    path_ = std::move(path);
+    profile_capture();
+    compute_range();
+    refresh_ui();
+}
+
 void IQTrimView::paint(Painter& painter) {
-    if (!path_.empty()) {
+    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 amp = power_buckets_[i].power;
+            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,
@@ -72,8 +118,8 @@ void IQTrimView::paint(Painter& painter) {
        }

        // Draw trim range edges.
-        int start_x = screen_width * trim_range_.start / trim_range_.file_size;
-        int end_x = screen_width * trim_range_.end / trim_range_.file_size;
+        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},
@@ -92,27 +138,83 @@ void IQTrimView::focus() {

 void IQTrimView::refresh_ui() {
    field_path.set_text(path_.filename().string());
-    text_range.set(to_string_dec_uint(trim_range_.start) + "-" + to_string_dec_uint(trim_range_.end));
+    text_samples.set(to_string_dec_uint(info_->sample_count));
+
+    // show max power after amplification applied
+    uint64_t power_amp = field_amplify.value() * field_amplify.value() * field_amplify.value() * field_amplify.value();
+    text_max.set(to_string_dec_uint(info_->max_power * power_amp));
+
+    // show max power in red if amplification is too high, causing clipping
+    uint32_t clipping_limit = (fs::capture_file_sample_size(path_) == sizeof(complex8_t)) ? 0x80 : 0x8000;
+    if ((field_amplify.value() * info_->max_iq) > clipping_limit)
+        text_max.set_style(&Styles::red);
+    else
+        text_max.set_style(&Styles::light_grey);
+
    set_dirty();
 }

-bool IQTrimView::read_capture(const fs::path& path) {
+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_ = {};
-    PowerBuckets buckets{
+    iq::PowerBuckets buckets{
        .p = power_buckets_.data(),
        .size = power_buckets_.size()};

    progress_ui.show_reading();
-    auto range = ComputeTrimRange(path, amp_threshold, &buckets, progress_ui.get_callback());
+    info_ = iq::profile_capture(path_, buckets);
    progress_ui.clear();
-
-    if (range) {
-        trim_range_ = *range;
-        return true;
-    } else {
-        trim_range_ = {};
-        return false;
-    }
 }

-}  // namespace ui
+void IQTrimView::compute_range() {
+    if (!info_)
+        return;
+
+    iq::PowerBuckets buckets{
+        .p = power_buckets_.data(),
+        .size = power_buckets_.size()};
+    auto trim_range = iq::compute_trim_range(*info_, buckets, field_cutoff.value());
+
+    update_range_controls(trim_range);
+}
+
+bool IQTrimView::trim_capture() {
+    if (!info_) {
+        nav_.display_modal("Error", "Open a file first.");
+        return false;
+    }
+
+    bool trimmed = false;
+    iq::TrimRange trim_range{
+        static_cast<uint32_t>(field_start.value()),
+        static_cast<uint32_t>(field_end.value()),
+        info_->sample_size};
+
+    if (trim_range.start_sample >= trim_range.end_sample) {
+        nav_.display_modal("Error", "Invalid trimming range.");
+        return false;
+    }
+
+    progress_ui.show_trimming();
+    trimmed = iq::trim_capture_with_range(path_, trim_range, progress_ui.get_callback(), field_amplify.value());
+    progress_ui.clear();
+
+    if (!trimmed)
+        nav_.display_modal("Error", "Trimming failed.");
+
+    return trimmed;
+}
+
+}  // namespace ui
@@ -24,6 +24,7 @@

 #include "file.hpp"
 #include "iq_trim.hpp"
+#include "optional.hpp"
 #include "ui.hpp"
 #include "ui_navigation.hpp"
 #include "ui_styles.hpp"
@@ -49,7 +50,7 @@ class TrimProgressUI {

    void show_progress(uint8_t percent) {
        auto width = percent * screen_width / 100;
-        p.draw_hline({0, 6 * 16}, width, Color::yellow());
+        p.draw_hline({0, 6 * 16 + 2}, width, Color::yellow());
    }

    void clear() {
@@ -67,24 +68,47 @@ class TrimProgressUI {
 class IQTrimView : public View {
   public:
    IQTrimView(NavigationView& nav);
+    IQTrimView(NavigationView& nav, const std::filesystem::path& path);

    std::string title() const override { return "IQ Trim"; }
    void paint(Painter& painter) override;
    void focus() override;

   private:
+    void open_file(const std::filesystem::path& path);
+
+    /* Update controls with latest values. */
    void refresh_ui();
-    bool read_capture(const std::filesystem::path& path);
+
+    /* 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_{};
-    TrimRange trim_range_{};
-    std::array<PowerBuckets::Bucket, screen_width> power_buckets_{};
-    uint8_t amp_threshold = 5;
+    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}, "Range:", Color::light_grey()},
+        {{0 * 8, 6 * 16}, "Start  :", Color::light_grey()},
+        {{0 * 8, 7 * 16}, "End    :", Color::light_grey()},
+        {{0 * 8, 8 * 16}, "Samples:", Color::light_grey()},
+        {{0 * 8, 9 * 16}, "Max Pwr:", Color::light_grey()},
+        {{0 * 8, 10 * 16}, "Cutoff :", Color::light_grey()},
+        {{12 * 8, 10 * 16}, "%", Color::light_grey()},
+        {{0 * 8, 12 * 16}, "Amplify:", Color::light_grey()},
+        {{10 * 8, 12 * 16}, "x", Color::light_grey()},
    };

    TextField field_path{
@@ -94,12 +118,44 @@ class IQTrimView : public View {
    Point pos_lines{0 * 8, 4 * 16};
    Dim height_lines{2 * 16};

-    Text text_range{
-        {7 * 8, 6 * 16, 20 * 8, 1 * 16},
-        {}};
+    NumberField field_start{
+        {9 * 8, 6 * 16},
+        10,
+        {0, 0},
+        1,
+        ' '};
+
+    NumberField field_end{
+        {9 * 8, 7 * 16},
+        10,
+        {0, 0},
+        1,
+        ' '};
+
+    Text text_samples{
+        {9 * 8, 8 * 16, 10 * 8, 1 * 16},
+        "0"};
+
+    Text text_max{
+        {9 * 8, 9 * 16, 20 * 8, 1 * 16},
+        "0"};
+
+    NumberField field_cutoff{
+        {9 * 8, 10 * 16},
+        3,
+        {1, 100},
+        1,
+        ' '};
+
+    NumberField field_amplify{
+        {9 * 8, 12 * 16},
+        1,
+        {1, 9},
+        1,
+        ' '};

    Button button_trim{
-        {11 * 8, 9 * 16, 8 * 8, 3 * 16},
+        {20 * 8, 16 * 16, 8 * 8, 2 * 16},
        "Trim"};
 };

@@ -261,6 +261,7 @@ void JammerView::start_tx() {

        transmitter_model.set_rf_amp(field_amp.value());
        transmitter_model.set_tx_gain(field_gain.value());
+        transmitter_model.set_baseband_bandwidth(28'000'000);  // Although tx is narrowband , let's use Max TX LPF .
        transmitter_model.enable();

        baseband::set_jammer(true, (JammerType)options_type.selected_index(), options_speed.selected_index_value());
@@ -288,7 +289,8 @@ void JammerView::on_timer() {
        mscounter = 0;
        if (jamming) {
            if (cooling) {
-                if (++seconds >= field_timepause.value()) {  // Re-start TX
+                if (++seconds >= field_timepause.value()) {                // Re-start TX
+                    transmitter_model.set_baseband_bandwidth(28'000'000);  // Although tx is narrowband , let's use Max TX LPF .
                    transmitter_model.enable();
                    button_transmit.set_text("STOP");
                    baseband::set_jammer(true, (JammerType)options_type.selected_index(), options_speed.selected_index_value());
@@ -101,6 +101,7 @@ class JammerView : public View {
   private:
    NavigationView& nav_;
    TxRadioState radio_state_{
+        0 /* frequency */,
        3500000 /* bandwidth */,
        3072000 /* sampling rate */
    };
@@ -222,8 +222,6 @@ KeyfobView::KeyfobView(

    options_make.set_selected_index(0);

-    transmitter_model.set_target_frequency(433920000);  // Fixed 433.92MHz
-
    tx_view.on_edit_frequency = [this, &nav]() {
        auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.target_frequency());
        new_view->on_changed = [this](rf::Frequency f) {
@@ -44,6 +44,7 @@ class KeyfobView : public View {
    NavigationView& nav_;

    TxRadioState radio_state_{
+        433920000 /* frequency */,
        1750000 /* bandwidth */,
        OOK_SAMPLERATE /* sampling rate */
    };
@@ -127,6 +127,8 @@ void LCRView::start_tx(const bool scan) {

    modems::generate_data(lcr::generate_message(rgsb, litterals_list, options_ec.selected_index()), lcr_message_data);

+    /* It is AFSK modulation , measuring original fw 1.7.4 spectrum BW is just around 30khz , NBFM */
+    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF 1M75, same spectrum as previous fw 1.7.4
    transmitter_model.enable();

    memcpy(shared_memory.bb_data.data, lcr_message_data, sizeof(lcr_message_data));
@@ -82,6 +82,7 @@ class LCRView : public View {
    };

    TxRadioState radio_state_{
+        0 /* frequency */,
        1750000 /* bandwidth */,
        AFSK_TX_SAMPLERATE /* sampling rate */
    };
@@ -51,7 +51,7 @@ void MicTXView::focus() {
            field_rxfrequency.focus();
            break;
        default:
-            field_va.focus();
+            check_va.focus();
            break;
    }
 }
@@ -60,24 +60,56 @@ void MicTXView::update_vumeter() {
    vumeter.set_value(audio_level);
 }

+void MicTXView::update_tx_icon() {
+    tx_icon.set_foreground(transmitting ? Color::red() : Color::black());
+    tx_icon.set_background(transmitting ? Color::yellow() : Color::black());
+}
+
 void MicTXView::on_tx_progress(const bool done) {
    // Roger beep played, stop transmitting
    if (done)
        set_tx(false);
 }

+uint8_t MicTXView::shift_bits(void) {
+    uint8_t shift_bits_s16{4};  // shift bits factor to the captured ADC S16 audio sample.
+
+    if (audio::debug::codec_name() == "WM8731") {
+        switch (ak4951_alc_and_wm8731_boost_GUI) {
+            case 0:                  // +12 dB’s respect reference level orig fw 1.5.x fw FM : when +20dB's boost ON) and shift bits (>>8),
+                shift_bits_s16 = 6;  // now mic-boost on (+20dBs) and shift bits (>>6), +20+12=32 dB’s (orig fw +20 dBs+ 0dBs)=> +12dB's respect ref.
+                break;
+            case 1:                  // +06 dB’s reference level, (when +20dB's boost ON)
+                shift_bits_s16 = 7;  // now mic-boost on (+20dBs) and shift bits (>>7), +20+06=26 dB’s (orig fw +20 dBs+ 0dBs) => +06dB's respect ref.
+                break;
+            case 2:
+                shift_bits_s16 = 4;  // +04 dB’s respect ref level, (when +20dB's boost OFF)
+                break;               // now mic-boost off (+00dBs) shift bits (4) (+0+24dB's)=24 dBs => +04dB's respect ref.
+            case 3:
+                shift_bits_s16 = 5;  // -02 dB’s respect ref level, (when +20dB's boost OFF)
+                break;               // now mic-boost off (+00dBs) shift bits (5) (+0+18dB's)=18 dBs => -02dB's respect ref.
+            case 4:
+                shift_bits_s16 = 6;  // -08 dB’s respect ref level, (when +20dB's boost OFF)
+                break;               // now mic-boost off (+00dBs) shift bits (6) (+0+12dB's)=12 dBs => -08dB's respect ref.
+        }
+    } else {
+        shift_bits_s16 = 8;  // Initialized default fixed >>8_FM for FM tx mod, shift audio data for AK4951, using top 8 bits s16 data (>>8)
+    }
+    return shift_bits_s16;
+}
+
 void MicTXView::configure_baseband() {
    // TODO: Can this use the transmitter model instead?
    baseband::set_audiotx_config(
        sampling_rate / 20,  // Update vu-meter at 20Hz
        transmitting ? transmitter_model.channel_bandwidth() : 0,
-        mic_gain,
-        shift_bits_s16,  // to be used in dsp_modulate
+        mic_gain_x10 / 10.0,
+        shift_bits(),  // to be used in dsp_modulate
        TONES_F2D(tone_key_frequency(tone_key_index), sampling_rate),
-        enable_am,
-        enable_dsb,
-        enable_usb,
-        enable_lsb);
+        (mic_mod_index == MIC_MOD_AM),
+        (mic_mod_index == MIC_MOD_DSB),
+        (mic_mod_index == MIC_MOD_USB),
+        (mic_mod_index == MIC_MOD_LSB));
 }

 void MicTXView::set_tx(bool enable) {
@@ -87,6 +119,10 @@ void MicTXView::set_tx(bool enable) {
        transmitting = true;
        configure_baseband();
        transmitter_model.set_target_frequency(tx_frequency);  // Now, no need: transmitter_model.set_tx_gain(tx_gain), nor (rf_amp);
+
+        /* The max. Power Spectrum Densitiy in WFM with High tone mod level (80%) and high 32kHZ subtone as fmod.  with max fdeviation 150k ,
+         BW aprox = 2 *(150K + 32K) = 364khz, then we just select the minimum TX  LPF 1M75. */
+        transmitter_model.set_baseband_bandwidth(1'750'000);
        transmitter_model.enable();
        portapack::pin_i2s0_rx_sda.mode(3);  // This is already done in audio::init but gets changed by the CPLD overlay reprogramming
    } else {
@@ -97,12 +133,24 @@ void MicTXView::set_tx(bool enable) {
            transmitting = false;
            configure_baseband();
            transmitter_model.disable();
-            if (rx_enabled)     // If audio RX is enabled and we've been transmitting
+
+            if (rx_enabled) {
                rxaudio(true);  // Turn back on audio RX
+
+                // TODO FIXME: this isn't working: vu meter isn't going to 0:
+                vumeter.set_value(0);  // Reset  vumeter
+                vumeter.dirty();       // Force to refresh vumeter.
+            }
        }
    }
+    update_tx_icon();
 }

+bool MicTXView::tx_button_held() {
+    const auto switches_state = get_switches_state();
+    return switches_state[(size_t)ui::KeyEvent::Select];
+};
+
 void MicTXView::do_timing() {
    if (va_enabled) {
        if (!transmitting) {
@@ -124,7 +172,8 @@ void MicTXView::do_timing() {
                if ((decay_timer >> 8) >= decay_ms) {
                    decay_timer = 0;
                    attack_timer = 0;
-                    set_tx(false);
+                    if (!button_touch && !tx_button_held())
+                        set_tx(false);
                } else {
                    decay_timer += lcd_frame_duration;
                }
@@ -134,42 +183,39 @@ void MicTXView::do_timing() {
        }
    } else {
        // Check for PTT release
-        const auto switches_state = get_switches_state();
-        if (!switches_state[4] && transmitting && !button_touch)  // Select button
+        if (transmitting && !button_touch && !tx_button_held())
            set_tx(false);
    }
 }

-void MicTXView::rxaudio(bool is_on) {
-    if (is_on) {
+void MicTXView::rxaudio(bool enable) {
+    if (enable) {
        audio::input::stop();
        baseband::shutdown();

-        if (enable_am || enable_usb || enable_lsb || enable_dsb) {  // "NFM/FM", 0, " WFM  ", 1,  "  AM  ", 2, " USB  ", 3, " LSB  ", 4, " DSB-SC", 5
-            baseband::run_image(portapack::spi_flash::image_tag_am_audio);
-            receiver_model.set_modulation(ReceiverModel::Mode::AMAudio);                 // that AM demodulation engine is common to all Amplitude mod : AM/USB/LSB/DSB (2,3,4,5)
-            if (options_mode.selected_index() < 5)                                       // We will be called here with 2,3,4,5. We treat here demod. filter 2,3,4; (excluding DSB-C case (5) it is treated more down).
-                receiver_model.set_am_configuration(options_mode.selected_index() - 1);  // selecting proper filter(2,3,4). 2-1=1=>6k-AM(1), 3-1=2=>+3k-USB(2), 4-1=3=>-3K-LSB(3),
-        } else {                                                                         // We are in NFM/FM or WFM (NFM BW:8k5 or 11k / FM BW 16k / WFM BW:200k)
-
-            if (enable_wfm) {  // WFM, BW 200Khz aprox, or the two new addional BW filters (180k, 40k)
+        switch (mic_mod_index) {
+            case MIC_MOD_NFM:  // NFM BW:8k5 or 11k / FM BW 16k
+                baseband::run_image(portapack::spi_flash::image_tag_nfm_audio);
+                receiver_model.set_modulation(ReceiverModel::Mode::NarrowbandFMAudio);
+                // receiver_model.set_nbfm_configuration(n); is called above, depending user's selection (8k5, 11k, 16k).
+                break;
+            case MIC_MOD_WFM:  // WFM, BW 200Khz aprox, or the two new addional BW filters (180k, 40k)
                baseband::run_image(portapack::spi_flash::image_tag_wfm_audio);
                receiver_model.set_modulation(ReceiverModel::Mode::WidebandFMAudio);
-                // receiver_model.set_wfm_configuration(n);  // it is called above, depending user's selection (200k, 180k, 0k).
-            } else {  // NFM BW:8k5 or 11k / FM BW 16k
-                baseband::run_image(portapack::spi_flash::image_tag_nfm_audio);
-                receiver_model.set_modulation(ReceiverModel::Mode::NarrowbandFMAudio);  //
-                                                                                        // receiver_model.set_nbfm_configuration(n); is called above, depending user's selection (8k5, 11k, 16k).
-            }
+                // receiver_model.set_wfm_configuration(n); is called above, depending user's selection (200k, 180k, 0k).
+                break;
+            case MIC_MOD_AM:
+            case MIC_MOD_DSB:
+            case MIC_MOD_USB:
+            case MIC_MOD_LSB:
+                baseband::run_image(portapack::spi_flash::image_tag_am_audio);
+                receiver_model.set_modulation(ReceiverModel::Mode::AMAudio);                 // that AM demodulation engine is common to all Amplitude mod : AM/USB/LSB/DSB (2,3,4,5)
+                if (options_mode.selected_index() < 5)                                       // We will be called here with 2,3,4,5. We treat here demod. filter 2,3,4; (excluding DSB-C case (5) it is treated more down).
+                    receiver_model.set_am_configuration(options_mode.selected_index() - 1);  // selecting proper filter(2,3,4). 2-1=1=>6k-AM(1), 3-1=2=>+3k-USB(2), 4-1=3=>-3K-LSB(3),
+                break;
        }

-        if (bool_same_F_tx_rx_enabled)                          // when stop TX, define to which freq RX we return
-            receiver_model.set_target_frequency(tx_frequency);  // Update freq also for RX = TX
-        else
-            receiver_model.set_target_frequency(rx_frequency);  // Now with separate freq controls!
-        receiver_model.set_lna(rx_lna);
-        receiver_model.set_vga(rx_vga);
-        receiver_model.set_rf_amp(rx_amp);
+        receiver_model.set_target_frequency(bool_same_F_tx_rx_enabled ? tx_frequency : rx_frequency);
        receiver_model.enable();
        audio::output::start();
    } else {                                                                    // These incredibly convoluted steps are required for the vumeter to reappear when stopping RX.
@@ -179,14 +225,82 @@ void MicTXView::rxaudio(bool is_on) {

        baseband::run_image(portapack::spi_flash::image_tag_mic_tx);
        audio::output::stop();
-        audio::input::start(ak4951_alc_and_wm8731_boost_GUI);  // When detected AK4951 => set up ALC mode; when detected WM8731 => set up mic_boost ON/OFF.
+        audio::input::start(ak4951_alc_and_wm8731_boost_GUI, mic_to_HP_enabled);  // set up ALC mode (AK4951) or set up mic_boost ON/OFF (WM8731). and the check box "Hear Mic"
        portapack::pin_i2s0_rx_sda.mode(3);
        configure_baseband();
    }
 }

-void MicTXView::set_ptt_visibility(bool v) {
-    tx_button.hidden(!v);
+void MicTXView::set_rxbw_options(void) {
+    using option_t = std::pair<std::string, int32_t>;
+    using options_t = std::vector<option_t>;
+    options_t rxbw;  // Aux structure to change dynamically field_rxbw contents
+
+    switch (mic_mod_index) {
+        case MIC_MOD_NFM:
+            freqman_set_bandwidth_option(NFM_MODULATION, field_rxbw);  // restore dynamic field_rxbw value with NFM options from freqman_db.cpp
+            field_rxbw.set_by_value(receiver_model.nbfm_configuration());
+            break;
+        case MIC_MOD_WFM:
+            freqman_set_bandwidth_option(WFM_MODULATION, field_rxbw);  // restore dynamic field_rxbw value with WFM options from freqman_db.cpp
+            field_rxbw.set_by_value(receiver_model.wfm_configuration());
+            break;
+        case MIC_MOD_AM:
+            rxbw.emplace_back("DSB 9k", 0);  // we offer in AM DSB two audio BW 9k / 6k.
+            rxbw.emplace_back("DSB 6k", 1);
+            field_rxbw.set_options(rxbw);  // store that aux GUI option to the field_rxbw.
+            break;
+        case MIC_MOD_DSB:
+            rxbw.emplace_back("USB+3k", 0);  // added dynamically two options (index 0,1) to that DSB-SC case to the field_rxbw value.
+            rxbw.emplace_back("LSB-3k", 1);
+            field_rxbw.set_options(rxbw);  // store that aux GUI option to the field_rxbw.
+            break;
+        case MIC_MOD_USB:
+            rxbw.emplace_back("USB+3k", 0);  // locked a fixed option, to display it.
+            field_rxbw.set_options(rxbw);    // store that aux GUI option to the field_rxbw.
+            break;
+        case MIC_MOD_LSB:
+            rxbw.emplace_back("LSB-3k", 0);  // locked a fixed option, to display it.
+            field_rxbw.set_options(rxbw);    // store that aux GUI option to the field_rxbw.
+            break;
+    }
+}
+
+void MicTXView::set_rxbw_defaults(bool use_app_settings) {
+    if (use_app_settings) {
+        field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);
+        field_rxbw.set_by_value(rxbw_index);
+    } else if (mic_mod_index == MIC_MOD_NFM) {
+        field_bw.set_value(10);  // NFM TX bw 10k, RX bw 16k (2) default
+        field_rxbw.set_by_value(2);
+    } else if (mic_mod_index == MIC_MOD_WFM) {
+        field_bw.set_value(75);  // WFM TX bw 75K, RX bw 200k (0) default
+        field_rxbw.set_by_value(0);
+    }
+    // field_bw is hidden in other modulation cases
+}
+
+void MicTXView::update_receiver_rxbw(void) {
+    // In Previous fw versions, that nbfm_configuration(n) was done in any mode (FM/AM/SSB/DSB)...strictly speaking only need it in (NFM/FM)
+    // In AM TX mode, we will allow both independent RX audio BW : AM 9K (9K00AE3 / AM 6K (6K00AE3). (In AM option v can be 0 (9k), 1 (6k)
+    // In DSB-SC TX mode, we will allow both independent RX SSB demodulation (USB / LSB side band). in that submenu, v is 0 (SSB1 USB) or 1 (SSB2 LSB)
+    switch (mic_mod_index) {
+        case MIC_MOD_NFM:
+            receiver_model.set_nbfm_configuration(rxbw_index);  // we are in NFM/FM case, we need to select proper NFM/FM RX channel filter, NFM BW 8K5(0), NFM BW 11K(1), FM BW 16K (2)
+            break;
+        case MIC_MOD_WFM:
+            receiver_model.set_wfm_configuration(rxbw_index);  // we are in WFM case, we need to select proper WFB RX BW filter, WFM BW 200K(0), WFM BW 180K(1), WFM BW 40K(2)
+            break;
+        case MIC_MOD_AM:
+            receiver_model.set_am_configuration(rxbw_index);  // we are in AM TX mode, we need to select proper AM full path config AM-9K filter. 0+0 =>AM-9K(0), 0+1=1 =>AM-6K(1),
+            break;
+        case MIC_MOD_USB:
+        case MIC_MOD_LSB:
+            break;  // change can't happen in these modes because there's only one BW choice
+        case MIC_MOD_DSB:
+            receiver_model.set_am_configuration(rxbw_index + 2);  // we are in DSB-SC TX mode, we need to select proper SSB filter. 0+2 =>usb(2), 1+2=3 =>lsb(3),
+            break;
+    }
 }

 MicTXView::MicTXView(
@@ -195,400 +309,260 @@ MicTXView::MicTXView(

    baseband::run_image(portapack::spi_flash::image_tag_mic_tx);

-    if (audio::debug::codec_name() == "WM8731") {
-        add_children({&labels_WM8731,  // we have audio codec WM8731, same MIC menu as original.
-                      &vumeter,
-                      &options_gain,  // MIC GAIN float factor on the GUI.
-                      &options_wm8731_boost_mode,
-                      //		&check_va,
-                      &field_va,
-                      &field_va_level,
-                      &field_va_attack,
-                      &field_va_decay,
-                      &field_bw,
-                      &tx_view,  // it already integrates previous rfgain, rfamp.
-                      &options_mode,
-                      &field_frequency,
-                      &options_tone_key,
-                      &check_rogerbeep,
-                      &check_common_freq_tx_rx,  // added to handle common or separate freq- TX/RX
-                      &check_rxactive,
-                      &field_volume,
-                      &field_rxbw,
-                      &field_squelch,
-                      &field_rxfrequency,
-                      &field_rxlna,
-                      &field_rxvga,
-                      &field_rxamp,
-                      &tx_button});
+    bool wm = (audio::debug::codec_name() == "WM8731");
+    add_children({&labels_both,
+                  wm ? &labels_WM8731 : &labels_AK4951,  // enable ALC if AK4951
+                  &vumeter,
+                  &options_gain,  // MIC GAIN float factor on the GUI.
+                  wm ? &options_wm8731_boost_mode : &options_ak4951_alc_mode,
+                  &check_va,
+                  &field_va_level,
+                  &field_va_attack,
+                  &field_va_decay,
+                  &field_bw,
+                  &tx_view,  // it already integrates previous rfgain, rfamp.
+                  &options_mode,
+                  &field_frequency,
+                  &options_tone_key,
+                  &check_rogerbeep,
+                  &check_mic_to_HP,          // check box to activate "hear mic"
+                  &check_common_freq_tx_rx,  // added to handle common or separate freq- TX/RX
+                  &check_rxactive,
+                  &field_volume,
+                  &field_rxbw,
+                  &field_squelch,
+                  &field_rxfrequency,
+                  &field_rxlna,
+                  &field_rxvga,
+                  &field_rxamp,
+                  &tx_button,
+                  &tx_icon});

-    } else {
-        add_children({&labels_AK4951,  // we have audio codec AK4951, enable Automatic Level Control
-                      &vumeter,
-                      &options_gain,
-                      &options_ak4951_alc_mode,
-                      //		&check_va,
-                      &field_va,
-                      &field_va_level,
-                      &field_va_attack,
-                      &field_va_decay,
-                      &field_bw,
-                      &tx_view,  // it already integrates previous rfgain, rfamp.
-                      &options_mode,
-                      &field_frequency,
-                      &options_tone_key,
-                      &check_rogerbeep,
-                      &check_common_freq_tx_rx,  // added to handle common or separate freq- TX/RX
-                      &check_rxactive,
-                      &field_volume,
-                      &field_rxbw,
-                      &field_squelch,
-                      &field_rxfrequency,
-                      &field_rxlna,
-                      &field_rxvga,
-                      &field_rxamp,
-                      &tx_button});
-    }
+    set_rxbw_options();
+    set_rxbw_defaults(settings_.loaded());

    tone_keys_populate(options_tone_key);
+    options_tone_key.set_selected_index(tone_key_index);
    options_tone_key.on_change = [this](size_t i, int32_t) {
        tone_key_index = i;
    };
-    options_tone_key.set_selected_index(0);
+
+    check_rogerbeep.set_value(rogerbeep_enabled);
+    check_rogerbeep.on_select = [this](Checkbox&, bool v) {
+        rogerbeep_enabled = v;
+    };
+
+    field_rxlna.set_value(receiver_model.lna());
+    field_rxlna.on_change = [this](int32_t v) {
+        receiver_model.set_lna(v);
+    };
+
+    field_rxvga.set_value(receiver_model.vga());
+    field_rxvga.on_change = [this](int32_t v) {
+        receiver_model.set_vga(v);
+    };
+
+    field_rxamp.set_value(receiver_model.rf_amp());
+    field_rxamp.on_change = [this](int32_t v) {
+        receiver_model.set_rf_amp(v);
+    };

    options_gain.on_change = [this](size_t, int32_t v) {
-        mic_gain = v / 10.0;
+        mic_gain_x10 = v;
        configure_baseband();
    };
-    options_gain.set_selected_index(1);  // x1.0 preselected default.
+    options_gain.set_by_value(mic_gain_x10);  // x1.0 preselected default.
+
+    field_rxbw.on_change = [this](size_t, int32_t v) {
+        rxbw_index = v;
+        update_receiver_rxbw();
+    };
+    field_rxbw.set_by_value(rxbw_index);
+
+    field_squelch.set_value(receiver_model.squelch_level());
+    field_squelch.on_change = [this](int32_t v) {
+        receiver_model.set_squelch_level(v);
+    };

    if (audio::debug::codec_name() == "WM8731") {
        options_wm8731_boost_mode.on_change = [this](size_t, int8_t v) {
-            switch (v) {
-                case 0:                  // +12 dB’s respect reference level orig fw 1.5.x fw FM : when +20dB's boost ON) and shift bits (>>8),
-                    shift_bits_s16 = 6;  // now mic-boost on (+20dBs) and shift bits (>>6), +20+12=32 dB’s (orig fw +20 dBs+ 0dBs)=> +12dB's respect ref.
-                    break;
-                case 1:                  // +06 dB’s reference level, (when +20dB's boost ON)
-                    shift_bits_s16 = 7;  // now mic-boost on (+20dBs) and shift bits (>>7), +20+06=26 dB’s (orig fw +20 dBs+ 0dBs) => +06dB's respect ref.
-                    break;
-                case 2:
-                    shift_bits_s16 = 4;  // +04 dB’s respect ref level, (when +20dB's boost OFF)
-                    break;               // now mic-boost off (+00dBs) shift bits (4) (+0+24dB's)=24 dBs => +04dB's respect ref.
-                case 3:
-                    shift_bits_s16 = 5;  // -02 dB’s respect ref level, (when +20dB's boost OFF)
-                    break;               // now mic-boost off (+00dBs) shift bits (5) (+0+18dB's)=18 dBs => -02dB's respect ref.
-                case 4:
-                    shift_bits_s16 = 6;  // -08 dB’s respect ref level, (when +20dB's boost OFF)
-                    break;               // now mic-boost off (+00dBs) shift bits (6) (+0+12dB's)=12 dBs => -08dB's respect ref.
-            }
-            ak4951_alc_and_wm8731_boost_GUI = v;                   // 0..4, WM8731_boost dB's options, (combination boost on/off, and effective gain in captured data >>x)
-            audio::input::start(ak4951_alc_and_wm8731_boost_GUI);  // Detected (WM8731), set up the proper wm_boost on/off, 0..4 (0,1) boost_on, (2,3,4) boost_off
-            configure_baseband();                                  // to update in real time, sending msg, var-parameters >>shift_bits FM msg, to audio_tx from M0 to M4 Proc -
+            ak4951_alc_and_wm8731_boost_GUI = v;                                      // 0..4, WM8731_boost dB's options, (combination boost on/off, and effective gain in captured data >>x)
+            audio::input::start(ak4951_alc_and_wm8731_boost_GUI, mic_to_HP_enabled);  // Detected (WM8731), set up the proper wm_boost on/off, 0..4 (0,1) boost_on, (2,3,4) boost_off,and the check box "Hear Mic"
+            configure_baseband();                                                     // to update in real time, sending msg, var-parameters >>shift_bits FM msg, to audio_tx from M0 to M4 Proc -
        };
-        options_wm8731_boost_mode.set_selected_index(3);  // preset GUI index 3 as default WM -> -02 dB's.
+        if (!settings_.loaded()) {
+            ak4951_alc_and_wm8731_boost_GUI = 3;  // preset GUI index 3 as default WM -> -02 dB's
+        }
+        options_wm8731_boost_mode.set_selected_index(ak4951_alc_and_wm8731_boost_GUI);
    } else {
-        shift_bits_s16 = 8;  // Initialized default fixed >>8_FM for FM tx mod, shift audio data for AK4951, using top 8 bits s16 data (>>8)
        options_ak4951_alc_mode.on_change = [this](size_t, int8_t v) {
-            ak4951_alc_and_wm8731_boost_GUI = v;                   // 0..11, AK4951 Mic -Automatic volume Level Control options,
-            audio::input::start(ak4951_alc_and_wm8731_boost_GUI);  // Detected (AK4951) ==> Set up proper ALC mode from 0..11 options
-            configure_baseband();                                  // sending fixed >>8_FM, var-parameters msg, to audiotx from this M0 to M4 process.
+            ak4951_alc_and_wm8731_boost_GUI = v;                                      // 0..11, AK4951 Mic -Automatic volume Level Control options,
+            audio::input::start(ak4951_alc_and_wm8731_boost_GUI, mic_to_HP_enabled);  // Detected (AK4951) ==> Set up proper ALC mode from 0..11 options, and the check box "Hear Mic"
+            configure_baseband();                                                     // sending fixed >>8_FM, var-parameters msg, to audiotx from this M0 to M4 process.
        };
+        if (!settings_.loaded())
+            ak4951_alc_and_wm8731_boost_GUI = 0;
+        options_ak4951_alc_mode.set_selected_index(ak4951_alc_and_wm8731_boost_GUI);
    }

-    // options_ak4951_alc_mode.set_selected_index(0);
-
+    // WARNING: transmitter_model.set_target_frequency() and receiver_model.set_target_frequency() both update the same tuning freq, but one has an offset!
    tx_frequency = transmitter_model.target_frequency();
-    field_frequency.set_value(transmitter_model.target_frequency());
-    field_frequency.set_step(receiver_model.frequency_step());
    field_frequency.on_change = [this](rf::Frequency f) {
        tx_frequency = f;
-        if (!rx_enabled) {  // not activated receiver. just update freq TX
+        if (!rx_enabled)
            transmitter_model.set_target_frequency(f);
-        } else {                                         // activated receiver.
-            if (bool_same_F_tx_rx_enabled)               // user selected common freq- TX = RX
-                receiver_model.set_target_frequency(f);  // Update common freq also for RX
-        }
+        else if (bool_same_F_tx_rx_enabled)
+            receiver_model.set_target_frequency(f);
+        // else tuning freq will be updated when rx is enabled, transmitting starts, or when rx_frequency is changed (if rx_enabled)
    };
    field_frequency.on_edit = [this, &nav]() {
        focused_ui = 0;
        // TODO: Provide separate modal method/scheme?
        auto new_view = nav.push<FrequencyKeypadView>(tx_frequency);
        new_view->on_changed = [this](rf::Frequency f) {
-            tx_frequency = f;
-            if (!rx_enabled) {
-                transmitter_model.set_target_frequency(f);
-            } else {
-                if (bool_same_F_tx_rx_enabled)
-                    receiver_model.set_target_frequency(f);  // Update freq also for RX
-            }
            this->field_frequency.set_value(f);
-            set_dirty();
        };
    };
+    field_frequency.set_value(tx_frequency);

-    field_bw.on_change = [this](uint32_t v) {
-        transmitter_model.set_channel_bandwidth(v * 1000);
-    };
-    field_bw.set_value(10);  // pre-default first time, TX deviation FM for NFM / FM
+    // TODO: would be nice if frequency step was configurable in this app
+    field_frequency.set_step(receiver_model.frequency_step());

-    // now, no need direct update, field_rfgain, field_rfamp (it is done in ui_transmitter.cpp)
-
-    options_mode.on_change = [this](size_t, int32_t v) {  // { "NFM/FM", 0 }, { " WFM  ", 1 }, { "AM", 2 }, { "USB", 3 }, { "LSB", 4 }, { "DSB", 5 }
-        enable_am = false;
-        enable_usb = false;
-        enable_lsb = false;
-        enable_dsb = false;
-        enable_wfm = false;
-
-        using option_t = std::pair<std::string, int32_t>;
-        using options_t = std::vector<option_t>;
-        options_t rxbw;  // Aux structure to change dynamically field_rxbw contents,
-
-        switch (v) {
-            case 0:  //{ "FM", 0 }
-                enable_am = false;
-                enable_usb = false;
-                enable_lsb = false;
-                enable_dsb = false;
-                field_bw.set_value(10);  // pre-default deviation FM for WFM
-                // field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);
-                // if (rx_enabled)
-                rxaudio(rx_enabled);         // Update now if we have RX audio on
-                options_tone_key.hidden(0);  // we are in FM mode, we should have active the Key-tones & CTCSS option.
-
-                freqman_set_bandwidth_option(NFM_MODULATION, field_rxbw);  // restore dynamic field_rxbw value with NFM options from freqman_db.cpp
-                field_rxbw.set_by_value(2);                                // // bw 16k (2) default
-                field_rxbw.hidden(0);                                      // we are in FM mode, we need to allow the user set up of the RX NFM BW selection (8K5, 11K, 16K)
-                field_bw.hidden(0);                                        // we are in FM mode, we need to allow FM deviation parameter, in non FM mode.
-                break;
-            case 1:  //{ "WFM", 1 }
-                enable_am = false;
-                enable_usb = false;
-                enable_lsb = false;
-                enable_dsb = false;
-                enable_wfm = true;
-                field_bw.set_value(75);  // pre-default deviation FM for WFM
-                // field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);
-                // if (rx_enabled)
-                rxaudio(rx_enabled);         // Update now if we have RX audio on
-                options_tone_key.hidden(0);  // we are in WFM mode, we should have active the Key-tones & CTCSS option.
-
-                freqman_set_bandwidth_option(WFM_MODULATION, field_rxbw);  // restore dynamic field_rxbw value with WFM options from freqman_db.cpp
-                field_rxbw.set_by_value(0);                                // bw 200k (0) default
-                field_rxbw.hidden(0);                                      // we are in WFM mode, we need to show to the user the selected BW WFM filter.
-                field_bw.hidden(0);                                        // we are in WFM mode, we need to allow WFM deviation parameter, in non FM mode.
-                break;
-            case 2:  //{ "AM", 2 }
-                enable_am = true;
-                rxaudio(rx_enabled);                     // Update now if we have RX audio on
-                options_tone_key.set_selected_index(0);  // we are NOT in FM mode, we reset the possible previous key-tones &CTCSS selection.
-                set_dirty();                             // Refresh display
-                options_tone_key.hidden(1);              // we hide that Key-tones & CTCSS input selecction, (no meaning in AM/DSB/SSB).
-
-                rxbw.emplace_back("DSB 9k", 0);  // we offer in AM DSB two audio BW 9k / 6k.
-                rxbw.emplace_back("DSB 6k", 1);
-                field_rxbw.set_options(rxbw);  // store that aux GUI option to the field_rxbw.
-
-                field_rxbw.hidden(0);       // we show fixed RX AM BW 6Khz
-                field_bw.hidden(1);         // we hide the FM TX deviation parameter, in non FM mode.
-                check_rogerbeep.hidden(0);  // make visible again the "rogerbeep" selection.
-                break;
-            case 3:  //{ "USB", 3 }
-                enable_usb = true;
-                rxaudio(rx_enabled);               // Update now if we have RX audio on
-                check_rogerbeep.set_value(false);  // reset the possible activation of roger beep, because it is not compatible with SSB, by now.
-                check_rogerbeep.hidden(1);         // hide that roger beep selection.
-
-                rxbw.emplace_back("USB+3k", 0);  // locked a fixed option, to display it.
-                field_rxbw.set_options(rxbw);    // store that aux GUI option to the field_rxbw.
-
-                set_dirty();  // Refresh display
-                break;
-            case 4:  //{ "LSB", 4 }
-                enable_lsb = true;
-                rxaudio(rx_enabled);               // Update now if we have RX audio on
-                check_rogerbeep.set_value(false);  // reset the possible activation of roger beep, because it is not compatible with SSB, by now.
-                check_rogerbeep.hidden(1);         // hide that roger beep selection.
-
-                rxbw.emplace_back("LSB-3k", 0);  // locked a fixed option, to display it.
-                field_rxbw.set_options(rxbw);    // store that aux GUI option to the field_rxbw.
-
-                set_dirty();  // Refresh display
-                break;
-            case 5:  //{ "DSB-SC", 5 }
-                enable_dsb = true;
-                rxaudio(rx_enabled);        // Update now if we have RX audio on
-                check_rogerbeep.hidden(0);  // make visible again the "rogerbeep" selection.
-
-                rxbw.emplace_back("USB+3k", 0);  // added dynamically two options (index 0,1) to that DSB-SC case to the field_rxbw value.
-                rxbw.emplace_back("LSB-3k", 1);
-
-                field_rxbw.set_options(rxbw);  // store that aux GUI option to the field_rxbw.
-
-                break;
-        }
-        // configure_baseband();
-    };
-
-    /*
-        check_va.on_select = [this](Checkbox&, bool v) {
-                va_enabled = v;
-                text_ptt.hidden(v);			//hide / show PTT text
-                check_rxactive.hidden(v); 	//hide / show the RX AUDIO
-                set_dirty();				//Refresh display
-        };
-        */
-    field_va.set_selected_index(1);
-    field_va.on_change = [this](size_t, int32_t v) {
-        switch (v) {
-            case 0:
-                va_enabled = 0;
-                this->set_ptt_visibility(0);
-                check_rxactive.hidden(0);
-                ptt_enabled = 0;
-                break;
-            case 1:
-                va_enabled = 0;
-                this->set_ptt_visibility(1);
-                check_rxactive.hidden(0);
-                ptt_enabled = 1;
-                break;
-            case 2:
-                if (!rx_enabled) {
-                    va_enabled = 1;
-                    this->set_ptt_visibility(0);
-                    check_rxactive.hidden(1);
-                    ptt_enabled = 0;
-                } else {
-                    field_va.set_selected_index(1);
-                }
-                break;
-        }
-        set_dirty();
-    };
-
-    check_rogerbeep.on_select = [this](Checkbox&, bool v) {
-        rogerbeep_enabled = v;
-    };
-
-    check_common_freq_tx_rx.on_select = [this](Checkbox&, bool v) {
-        bool_same_F_tx_rx_enabled = v;
-        field_rxfrequency.hidden(v);                                           // Hide or show separated freq RX field. (When no hide user can enter down indep. freq for RX)
-        set_dirty();                                                           // Refresh GUI interface
-        receiver_model.set_target_frequency(v ? tx_frequency : rx_frequency);  // To go to the proper tuned freq. when toggling it
-    };
-
-    field_va_level.on_change = [this](int32_t v) {
-        va_level = v;
-        vumeter.set_mark(v);
-    };
-    field_va_level.set_value(40);
-
-    field_va_attack.on_change = [this](int32_t v) {
-        attack_ms = v;
-    };
-    field_va_attack.set_value(500);
-
-    field_va_decay.on_change = [this](int32_t v) {
-        decay_ms = v;
-    };
-    field_va_decay.set_value(1000);
-
-    check_rxactive.on_select = [this](Checkbox&, bool v) {
-        //		vumeter.set_value(0);	//Start with a clean vumeter
-        rx_enabled = v;
-        //		check_va.hidden(v); 	//Hide or show voice activation
-        rxaudio(v);   // Activate-Deactivate audio rx accordingly
-        set_dirty();  // Refresh interface
-    };
-
-    field_rxbw.on_change = [this](size_t, int32_t v) {
-        if (!(enable_am || enable_usb || enable_lsb || enable_dsb || enable_wfm)) {
-            // In Previous fw versions, that nbfm_configuration(n) was done in any mode (FM/AM/SSB/DSB)...strictly speaking only need it in (NFM/FM)
-            receiver_model.set_nbfm_configuration(v);    // we are in NFM/FM case, we need to select proper NFM/FM RX channel filter, NFM BW 8K5(0), NFM BW 11K(1), FM BW 16K (2)
-        } else {                                         // we are not in NFM/FM mode. (we could be in any of the rest : AM /USB/LSB/DSB-SC)
-            if (enable_am) {                             // we are in AM TX mode, we will allow both independent RX audio BW : AM 9K (9K00AE3 / AM 6K (6K00AE3). (In AM option v can be 0 (9k), 1 (6k)
-                receiver_model.set_am_configuration(v);  // we are in AM TX mode, we need to select proper AM full path config AM-9K filter. 0+0 =>AM-9K(0), 0+1=1 =>AM-6K(1),
-            }
-            if (enable_dsb) {                                // we are in DSB-SC in TX mode, we will allow both independent RX SSB demodulation (USB / LSB side band). in that submenu, v is 0 (SSB1 USB) or 1 (SSB2 LSB)
-                receiver_model.set_am_configuration(v + 2);  // we are in DSB-SC TX mode, we need to select proper SSB filter. 0+2 =>usb(2), 1+2=3 =>lsb(3),
-            }
-            if (enable_wfm) {
-                receiver_model.set_wfm_configuration(v);  // we are in WFM case, we need to select proper WFB RX BW filter, WFM BW 200K(0), WFM BW 180K(1), WFM BW 40K(2)
-            }
-        }
-    };
-
-    field_squelch.on_change = [this](int32_t v) {
-        receiver_model.set_squelch_level(100 - v);
-    };
-    field_squelch.set_value(0);
-    receiver_model.set_squelch_level(0);
-
-    rx_frequency = receiver_model.target_frequency();
+    // WARNING: transmitter_model.set_target_frequency() and receiver_model.set_target_frequency() both update the same tuning freq, but one has an offset!
    field_rxfrequency.set_value(rx_frequency);
-    field_rxfrequency.set_step(receiver_model.frequency_step());
    field_rxfrequency.on_change = [this](rf::Frequency f) {  // available when field rxfrequency not hidden => user selected separated freq RX/TX-
        rx_frequency = f;
        if (rx_enabled)
-            receiver_model.set_target_frequency(f);
+            receiver_model.set_target_frequency(rx_frequency);
    };
    field_rxfrequency.on_edit = [this, &nav]() {  // available when field rxfrequency not hidden => user selected separated freq RX/TX-
        focused_ui = 1;
        // TODO: Provide separate modal method/scheme?
        auto new_view = nav.push<FrequencyKeypadView>(rx_frequency);
        new_view->on_changed = [this](rf::Frequency f) {
-            rx_frequency = f;
-            if (rx_enabled)
-                receiver_model.set_target_frequency(f);
            this->field_rxfrequency.set_value(f);
-            set_dirty();
        };
    };

-    rx_lna = receiver_model.lna();
-    field_rxlna.on_change = [this](int32_t v) {
-        rx_lna = v;
-        if (rx_enabled)
-            receiver_model.set_lna(v);
-    };
-    field_rxlna.set_value(rx_lna);
+    // TODO: would be nice if frequency step was configurable in this app
+    field_rxfrequency.set_step(receiver_model.frequency_step());

-    rx_vga = receiver_model.vga();
-    field_rxvga.on_change = [this](int32_t v) {
-        rx_vga = v;
-        if (rx_enabled)
-            receiver_model.set_vga(v);
+    check_common_freq_tx_rx.on_select = [this](Checkbox&, bool v) {
+        bool_same_F_tx_rx_enabled = v;
+        field_rxfrequency.hidden(v);
+        set_dirty();
+        receiver_model.set_target_frequency(bool_same_F_tx_rx_enabled ? tx_frequency : rx_frequency);  // To go to the proper tuned freq. when toggling it
    };
-    field_rxvga.set_value(rx_vga);
+    check_common_freq_tx_rx.set_value(bool_same_F_tx_rx_enabled);

-    rx_amp = receiver_model.rf_amp();
-    field_rxamp.on_change = [this](int32_t v) {
-        rx_amp = v;
-        if (rx_enabled)
-            receiver_model.set_rf_amp(rx_amp);
+    field_bw.on_change = [this](uint32_t v) {
+        transmitter_model.set_channel_bandwidth(v * 1000);
    };
-    field_rxamp.set_value(rx_amp);
+    field_bw.set_value(transmitter_model.channel_bandwidth() / 1000);  // pre-default first time, TX deviation FM for NFM / FM
+
+    // now, no need direct update, field_rfgain, field_rfamp (it is done in ui_transmitter.cpp)
+
+    options_mode.on_change = [this](size_t, int32_t v) {
+        mic_mod_index = v;
+
+        // update bw & tone key visibility - only visible in NFM/WFM modes
+        if ((mic_mod_index == MIC_MOD_NFM) || (mic_mod_index == MIC_MOD_WFM)) {
+            field_bw.hidden(false);
+            options_tone_key.hidden(false);
+        } else {
+            field_bw.hidden(true);
+            options_tone_key.set_selected_index(0);
+            options_tone_key.hidden(true);
+        }
+
+        // update rogerbeep visibility - disable in USB/LSB modes
+        if ((mic_mod_index == MIC_MOD_USB) || (mic_mod_index == MIC_MOD_LSB)) {
+            check_rogerbeep.set_value(false);
+            check_rogerbeep.hidden(true);
+        } else {
+            check_rogerbeep.hidden(false);
+        }
+
+        // update squelch visibility - only visible in NFM mode
+        field_squelch.hidden(mic_mod_index != MIC_MOD_NFM);
+
+        // update bandwidth
+        set_rxbw_options();
+        set_rxbw_defaults(false);
+        field_rxbw.hidden(false);
+        set_dirty();  // Refresh display
+
+        rxaudio(rx_enabled);  // Update now if we have RX audio on
+        // configure_baseband();
+    };
+    options_mode.set_selected_index(mic_mod_index);
+
+    check_mic_to_HP.on_select = [this](Checkbox&, bool v) {
+        mic_to_HP_enabled = v;
+        if (mic_to_HP_enabled) {  // When user click to "hear mic to HP", we will select the higher acoustic sound Option MODE  ALC or BOOST-
+            audio::input::loopback_mic_to_hp_enable();
+            if (audio::debug::codec_name() == "WM8731") {
+                options_wm8731_boost_mode.set_selected_index(0);  // In WM we always go to Boost +12 dB’s respect reference level
+            } else if (ak4951_alc_and_wm8731_boost_GUI == 0)      // In AK we are changing only that ALC index =0, because in that option, there is no sound.
+                options_ak4951_alc_mode.set_selected_index(1);    // alc_mode =0 , means no ALC,no DIGITAL filter block (by passed), and that mode has no loopback mode.
+        } else {
+            audio::input::loopback_mic_to_hp_disable();
+        }
+    };
+    check_mic_to_HP.set_value(mic_to_HP_enabled);
+
+    check_rxactive.on_select = [this](Checkbox&, bool v) {
+        //		vumeter.set_value(0);	//Start with a clean vumeter
+        rx_enabled = v;
+        check_mic_to_HP.hidden(rx_enabled);  // Toggle Hide / show "Hear Mic" checkbox depending if we activate or not the receiver. (if RX on => no visible "Mic Hear" option)
+        if ((rx_enabled) && (transmitting))
+            check_mic_to_HP.set_value(transmitting);  // Once we activate the "Rx audio" in reception time we disable "Hear Mic", but we allow it again in TX time.
+
+        if (rx_enabled)
+            check_va.set_value(false);  // Disallow voice activation during RX audio (for now) - Future TODO: Should allow VOX during RX audio
+
+        rxaudio(v);   // Activate-Deactivate audio RX (receiver) accordingly
+        set_dirty();  // Refresh interface
+    };
+    check_rxactive.set_value(rx_enabled);

    tx_button.on_select = [this](Button&) {
-        if (ptt_enabled && !transmitting) {
+        if (!transmitting) {
            set_tx(true);
        }
    };

    tx_button.on_touch_release = [this](Button&) {
-        if (button_touch) {
-            button_touch = false;
-            set_tx(false);
-        }
+        button_touch = false;
    };

    tx_button.on_touch_press = [this](Button&) {
-        if (!transmitting) {
-            button_touch = true;
-        }
+        button_touch = true;
    };

+    field_va_level.on_change = [this](int32_t v) {
+        va_level = v;
+        vumeter.set_mark(v);
+    };
+    field_va_level.set_value(va_level);
+
+    field_va_attack.set_value(attack_ms);
+    field_va_attack.on_change = [this](int32_t v) {
+        attack_ms = v;
+    };
+
+    field_va_decay.set_value(decay_ms);
+    field_va_decay.on_change = [this](int32_t v) {
+        decay_ms = v;
+    };
+
+    check_va.on_select = [this](Checkbox&, bool v) {
+        va_enabled = v;
+        if (va_enabled)
+            check_rxactive.set_value(false);  // Disallow RX-audio in VOX mode (for now) - Future TODO: Should allow VOX during RX audio
+    };
+    check_va.set_value(va_enabled);
+
    // These shouldn't be necessary, but because
    // this app uses both transmitter_model and directly
    // configures the baseband, these end up being required.
@@ -598,7 +572,12 @@ MicTXView::MicTXView(
    set_tx(false);

    audio::set_rate(audio::Rate::Hz_24000);
-    audio::input::start(ak4951_alc_and_wm8731_boost_GUI);  // When detected AK4951 => set up ALC mode; when detected WM8731 => set up mic_boost ON/OFF.
+    audio::input::start(ak4951_alc_and_wm8731_boost_GUI, mic_to_HP_enabled);  // set up ALC mode (AK4951) or set up mic_boost ON/OFF (WM8731). and the check box "Hear Mic"
+
+    // Workaround for bad RX reception when app first started -- shouldn't be necessary:
+    // Trigger receiver to update modulation.
+    if (rx_enabled)
+        receiver_model.set_squelch_level(receiver_model.squelch_level());
 }

 MicTXView::MicTXView(
@@ -607,16 +586,15 @@ MicTXView::MicTXView(
    : MicTXView(nav) {
    // Try to use the modulation/bandwidth from RX settings.
    // TODO: These concepts should be merged so there's only one.
-    // TODO: enums/constants for these indexes.
    switch (override.mode) {
        case ReceiverModel::Mode::AMAudio:
-            options_mode.set_selected_index(2);
+            options_mode.set_selected_index(MIC_MOD_AM);
            break;
        case ReceiverModel::Mode::NarrowbandFMAudio:
-            options_mode.set_selected_index(0);
+            options_mode.set_selected_index(MIC_MOD_NFM);
            break;
        case ReceiverModel::Mode::WidebandFMAudio:
-            options_mode.set_selected_index(1);
+            options_mode.set_selected_index(MIC_MOD_WFM);
            break;

        // Unsupported modulations.
@@ -626,6 +604,8 @@ MicTXView::MicTXView(
            break;
    }

+    check_common_freq_tx_rx.set_value(true);  // freq passed from other app is in tx_frequency, so set rx_frequency=tx_frequency
+
    // TODO: bandwidth selection is tied too tightly to the UI
    // controls. It's not possible to set the bandwidth here without
    // refactoring. Also options_mode seems to have a category error.
@@ -633,10 +613,12 @@ MicTXView::MicTXView(

 MicTXView::~MicTXView() {
    audio::input::stop();
-    transmitter_model.set_target_frequency(tx_frequency);
-    transmitter_model.disable();
-    if (rx_enabled)  // Also turn off audio rx if enabled
+    if (rx_enabled) {  // Also turn off both (audio rx if enabled, and disable  mic_loop to HP)
        rxaudio(false);
+        audio::input::loopback_mic_to_hp_disable();  // Leave Mic audio off in the main menu (as original audio path, otherwise we had No audio in next "Audio App")
+    }
+    transmitter_model.set_target_frequency(tx_frequency);  // Set tx_frequency here to be saved in app_settings (might not match rx_frequency)
+    transmitter_model.disable();
    baseband::shutdown();
 }

@@ -70,66 +70,85 @@ class MicTXView : public View {
    static constexpr uint32_t lcd_frame_duration = (256 * 1000UL) / 60;  // 1 frame @ 60fps in ms .8 fixed point  /60

    void update_vumeter();
+    bool tx_button_held();
    void do_timing();
    void set_tx(bool enable);
-    //	void on_target_frequency_changed(rf::Frequency f);
    void on_tx_progress(const bool done);
+    void update_tx_icon();
+    uint8_t shift_bits(void);
    void configure_baseband();
-
+    void set_rxbw_options(void);
+    void set_rxbw_defaults(bool use_app_settings);
+    void update_receiver_rxbw(void);
    void rxaudio(bool is_on);

-    void set_ptt_visibility(bool v);
-
    RxRadioState rx_radio_state_{};
    TxRadioState tx_radio_state_{
+        0 /* frequency */,
        1750000 /* bandwidth */,
        sampling_rate /* sampling rate */
    };
-    app_settings::SettingsManager settings_{
-        "tx_mic", app_settings::Mode::RX_TX,
-        app_settings::Options::UseGlobalTargetFrequency};

-    bool transmitting{false};
+    enum Mic_Modulation : uint32_t {
+        MIC_MOD_NFM = 0,
+        MIC_MOD_WFM = 1,
+        MIC_MOD_AM = 2,
+        MIC_MOD_USB = 3,
+        MIC_MOD_LSB = 4,
+        MIC_MOD_DSB = 5,
+    };
+
+    // Settings
+    uint32_t mic_mod_index{0};
+    uint32_t rxbw_index{0};
    bool va_enabled{false};
-    bool ptt_enabled{true};
    bool rogerbeep_enabled{false};
+    bool mic_to_HP_enabled{false};
    bool bool_same_F_tx_rx_enabled{false};
+    rf::Frequency rx_frequency{0};
    bool rx_enabled{false};
-    uint32_t tone_key_index{};
-    float mic_gain{1.0};
+    uint32_t tone_key_index{0};
+    uint32_t mic_gain_x10{1};
    uint8_t ak4951_alc_and_wm8731_boost_GUI{0};
+    uint32_t va_level{40};
+    uint32_t attack_ms{500};
+    uint32_t decay_ms{1000};
+    app_settings::SettingsManager settings_{
+        "tx_mic",
+        app_settings::Mode::RX_TX,
+        app_settings::Options::UseGlobalTargetFrequency,
+        {
+            {"mic_mod_index"sv, &mic_mod_index},
+            {"rxbw_index"sv, &rxbw_index},
+            {"same_F_tx_rx"sv, &bool_same_F_tx_rx_enabled},
+            {"mic_rx_frequency"sv, &rx_frequency},
+            {"rx_enabled"sv, &rx_enabled},
+            {"mic_gain_x10"sv, &mic_gain_x10},
+            {"mic_to_HP"sv, &mic_to_HP_enabled},
+            {"alc_and_boost"sv, &ak4951_alc_and_wm8731_boost_GUI},
+            {"va_level"sv, &va_level},
+            {"attack_ms"sv, &attack_ms},
+            {"decay_ms"sv, &decay_ms},
+            {"vox"sv, &va_enabled},
+            {"rogerbeep"sv, &rogerbeep_enabled},
+            {"tone_key_index"sv, &tone_key_index},
+        }};
+
+    rf::Frequency tx_frequency{0};
+    bool transmitting{false};
    uint32_t audio_level{0};
-    uint32_t va_level{};
-    uint32_t attack_ms{};
-    uint32_t decay_ms{};
    uint32_t attack_timer{0};
    uint32_t decay_timer{0};
    int32_t tx_gain{47};
    bool rf_amp{false};
-    int32_t rx_lna{32};
-    int32_t rx_vga{32};
-    bool rx_amp{false};
-    rf::Frequency tx_frequency{0};
-    rf::Frequency rx_frequency{0};
    int32_t focused_ui{2};
    bool button_touch{false};
-    uint8_t shift_bits_s16{4};  // shift bits factor to the captured ADC S16 audio sample.

-    // AM TX Stuff
-    // TODO: Some of this stuff is mutually exclusive. Need a better representation.
-    bool enable_am{false};
-    bool enable_dsb{false};
-    bool enable_usb{false};
-    bool enable_lsb{false};
-    bool enable_wfm{false};  // added to distinguish in the FM mode, RX BW : NFM (8K5, 11K), FM (16K), WFM(200K)
-
-    Labels labels_WM8731{
+    Labels labels_both{
        {{3 * 8, 1 * 8}, "MIC-GAIN:", Color::light_grey()},
-        {{17 * 8, 1 * 8}, "Boost", Color::light_grey()},
        {{3 * 8, 3 * 8}, "F:", Color::light_grey()},
        {{15 * 8, 3 * 8}, "FM TXBW:    kHz", Color::light_grey()},  // to be more symetric and consistent to the below FM RXBW
        {{18 * 8, (5 * 8)}, "Mode:", Color::light_grey()},          // now, no need to handle GAIN, Amp here It is handled by ui_transmitter.cpp
-        {{3 * 8, 8 * 8}, "TX Activation:", Color::light_grey()},    // we delete  { { 3 * 8, 5 * 8 }, "GAIN:", Color::light_grey() },
        {{4 * 8, 10 * 8}, "LVL:", Color::light_grey()},             // we delete  { {11 * 8, 5 * 8 }, "Amp:", Color::light_grey() },
        {{12 * 8, 10 * 8}, "ATT:", Color::light_grey()},
        {{20 * 8, 10 * 8}, "DEC:", Color::light_grey()},
@@ -142,25 +161,10 @@ class MicTXView : public View {
        {{5 * 8, (27 * 8) + 2}, "LNA:", Color::light_grey()},
        {{12 * 8, (27 * 8) + 2}, "VGA:", Color::light_grey()},
        {{19 * 8, (27 * 8) + 2}, "AMP:", Color::light_grey()}};
+    Labels labels_WM8731{
+        {{17 * 8, 1 * 8}, "Boost", Color::light_grey()}};
    Labels labels_AK4951{
-        {{3 * 8, 1 * 8}, "MIC-GAIN:", Color::light_grey()},
-        {{17 * 8, 1 * 8}, "ALC", Color::light_grey()},
-        {{3 * 8, 3 * 8}, "F:", Color::light_grey()},
-        {{15 * 8, 3 * 8}, "FM TXBW:    kHz", Color::light_grey()},
-        {{18 * 8, (5 * 8)}, "Mode:", Color::light_grey()},        // now, no need to handle GAIN, Amp here It is handled by ui_transmitter.cpp
-        {{3 * 8, 8 * 8}, "TX Activation:", Color::light_grey()},  // we delete  { { 3 * 8, 5 * 8 }, "GAIN:", Color::light_grey() },
-        {{4 * 8, 10 * 8}, "LVL:", Color::light_grey()},           // we delete  { {11 * 8, 5 * 8 }, "Amp:", Color::light_grey() },
-        {{12 * 8, 10 * 8}, "ATT:", Color::light_grey()},
-        {{20 * 8, 10 * 8}, "DEC:", Color::light_grey()},
-        {{3 * 8, (13 * 8) - 5}, "TONE KEY:", Color::light_grey()},
-        {{3 * 8, (18 * 8) - 1}, "======== Receiver ========", Color::green()},
-        {{(5 * 8), (23 * 8) + 2}, "VOL:", Color::light_grey()},
-        {{14 * 8, (23 * 8) + 2}, "RXBW:", Color::light_grey()},  // we remove the label "FM" because we will display all MOD types RX_BW.
-        {{20 * 8, (25 * 8) + 2}, "SQ:", Color::light_grey()},
-        {{5 * 8, (25 * 8) + 2}, "F_RX:", Color::light_grey()},
-        {{5 * 8, (27 * 8) + 2}, "LNA:", Color::light_grey()},
-        {{12 * 8, (27 * 8) + 2}, "VGA:", Color::light_grey()},
-        {{19 * 8, (27 * 8) + 2}, "AMP:", Color::light_grey()}};
+        {{17 * 8, 1 * 8}, "ALC", Color::light_grey()}};

    VuMeter vumeter{
        {0 * 8, 1 * 8, 2 * 8, 33 * 8},
@@ -223,28 +227,19 @@ class MicTXView : public View {
        {24 * 8, 5 * 8},
        6,
        {
-            {"NFM/FM", 0},
-            {" WFM  ", 1},
-            {"  AM  ", 2},  // in fact that TX mode = AM -DSB with carrier.
-            {" USB  ", 3},
-            {" LSB  ", 4},
-            {"DSB-SC", 5}  // We are TX Double Side AM Band with suppressed carrier, and allowing in RX both indep SSB lateral band (USB/LSB).
+            {"NFM/FM", MIC_MOD_NFM},
+            {" WFM  ", MIC_MOD_WFM},
+            {"  AM  ", MIC_MOD_AM},  // in fact that TX mode = AM -DSB with carrier.
+            {" USB  ", MIC_MOD_USB},
+            {" LSB  ", MIC_MOD_LSB},
+            {"DSB-SC", MIC_MOD_DSB}  // We are TX Double Side AM Band with suppressed carrier, and allowing in RX both indep SSB lateral band (USB/LSB).
        }};
-    /*
-        Checkbox check_va {
-                { 3 * 8, (10 * 8) - 4 },
-                7,
-                "Voice activation",
-                false
-        };
-        */

-    OptionsField field_va{
-        {17 * 8, 8 * 8},
-        4,
-        {{" OFF", 0},
-         {" PTT", 1},
-         {"AUTO", 2}}};
+    Checkbox check_va{
+        {3 * 8, 8 * 7},
+        10,
+        "VOX enable",
+        false};

    NumberField field_va_level{
        {8 * 8, 10 * 8},
@@ -276,6 +271,12 @@ class MicTXView : public View {
        "Roger beep",
        false};

+    Checkbox check_mic_to_HP{
+        {18 * 8, (14 * 8) + 4},
+        10,
+        "Hear Mic",
+        false};
+
    Checkbox check_rxactive{
        {3 * 8, (21 * 8) - 7},
        8,  // it was 18, but if it is string size should be 8
@@ -285,7 +286,7 @@ class MicTXView : public View {
    Checkbox check_common_freq_tx_rx{
        {18 * 8, (21 * 8) - 7},
        8,
-        "F  TX=RX",
+        "F  RX=TX",
        false};

    AudioVolumeField field_volume{
@@ -339,9 +340,15 @@ class MicTXView : public View {

    Button tx_button{
        {10 * 8, 30 * 8, 10 * 8, 5 * 8},
-        "TX",
+        "PTT TX",
        true};

+    Image tx_icon{
+        {6 * 8, 31 * 8 + 4, 16, 16},
+        &bitmap_icon_microphone,
+        Color::black(),
+        Color::black()};
+
    MessageHandlerRegistration message_handler_lcd_sync{
        Message::ID::DisplayFrameSync,
        [this](const Message* const) {
@@ -117,6 +117,8 @@ bool MorseView::start_tx() {
    }

    progressbar.set_max(symbol_count);
+    // By experimental spectrum measurment, we left exactly same TX LPF settings as previous fw 1.7.4,  TX LPF= 1M75 (min).
+    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF .already tested in FM morse max tone 9,999k , max dev 150khz
    transmitter_model.enable();

    if (modulation == CW) {
@@ -70,6 +70,7 @@ class MorseView : public View {
    uint32_t time_units{0};

    TxRadioState radio_state_{
+        0 /* frequency */,
        1750000 /* bandwidth */,
        1536000 /* sampling rate */
    };
@@ -54,7 +54,6 @@ NRFRxView::NRFRxView(NavigationView& nav)
                  &console});

    // Auto-configure modem for LCR RX (will be removed later)
-    field_frequency.set_value(2480000000);
    auto def_bell202 = &modem_defs[0];
    persistent_memory::set_modem_baudrate(def_bell202->baudrate);
    serial_format_t serial_format;
@@ -50,6 +50,7 @@ class NRFRxView : public View {

    NavigationView& nav_;
    RxRadioState radio_state_{
+        2480000000 /* frequency */,
        4000000 /* bandwidth */,
        4000000 /* sampling rate */,
        ReceiverModel::Mode::WidebandFMAudio};
@@ -39,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();
 }
@@ -56,6 +56,7 @@ class NumbersStationView : public View {
    NavigationView& nav_;

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

    TxRadioState radio_state_{
+        0 /* frequency */,
        1750000 /* bandwidth */,
        1536000 /* sampling rate */
    };
@@ -273,7 +273,7 @@ void PlaylistView::send_current_track() {
    // ReplayThread starts immediately on construction; must be set before creating.
    transmitter_model.set_target_frequency(current()->metadata.center_frequency);
    transmitter_model.set_sampling_rate(get_actual_sample_rate(current()->metadata.sample_rate));
-    transmitter_model.set_baseband_bandwidth(baseband_bandwidth);
+    transmitter_model.set_baseband_bandwidth(current()->metadata.sample_rate <= 500'000 ? 1'750'000 : 2'500'000);  // TX LPF min 1M75 for SR <=500K, and  2M5 (by experimental test) for SR >500K
    transmitter_model.enable();

    // Reset the transmit progress bar.
@@ -60,7 +60,6 @@ class PlaylistView : public View {

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

    struct playlist_entry {
        std::filesystem::path path{};
@@ -81,6 +81,8 @@ bool POCSAGTXView::start_tx() {

    transmitter_model.set_rf_amp(true);
    transmitter_model.set_tx_gain(40);
+    // We left exactly same TX LPF settings as previous fw 1.7.4,  TX LPF= 1M75 (min). It is fine even in max FM dev. 150khz and 2400 bauds.
+    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF . Pocsag is NBFM , using BW channel 25khz or 12khz
    transmitter_model.enable();

    uint8_t* data_ptr = shared_memory.bb_data.data;
@@ -60,6 +60,7 @@ class POCSAGTXView : public View {
    NavigationView& nav_;

    TxRadioState radio_state_{
+        466175000 /* frequency */,
        1750000 /* bandwidth */,
        2280000 /* sampling rate */
    };
@@ -142,6 +142,7 @@ class RDSView : public View {
    RDS_flags rds_flags{};

    TxRadioState radio_state_{
+        0 /* frequency */,
        1750000 /* bandwidth */,
        2280000 /* sampling rate */
    };
@@ -103,7 +103,6 @@ void ReconView::reset_indexes() {
 void ReconView::update_description() {
    if (frequency_list.empty() || current_entry().description.empty()) {
        description = "...no description...";
-        return;
    } else {
        switch (current_entry().type) {
            case freqman_type::Range:
@@ -117,7 +116,6 @@ void ReconView::update_description() {
        }
        description += current_entry().description;
    }
-
    desc_cycle.set(description);
 }

@@ -459,8 +457,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.
@@ -497,6 +494,7 @@ ReconView::ReconView(NavigationView& nav)

    button_manual_recon.on_select = [this](Button&) {
        button_remove.set_text("DELETE");
+        button_add.hidden(false);
        scanner_mode = false;
        manual_mode = true;
        recon_pause();
@@ -540,7 +538,7 @@ ReconView::ReconView(NavigationView& nav)
            button_scanner_mode.set_style(&Styles::white);
            button_scanner_mode.set_text("MANUAL");
            file_name.set_style(&Styles::white);
-            file_name.set("MANUAL RANGE RECON");
+            file_name.set("MANUAL => " + output_file);
            desc_cycle.set_style(&Styles::white);

            last_entry.modulation = freqman_invalid_index;
@@ -609,12 +607,12 @@ ReconView::ReconView(NavigationView& nav)
            scanner_mode = false;
            button_scanner_mode.set_style(&Styles::blue);
            button_scanner_mode.set_text("RECON");
-            button_remove.set_text("DELETE");
+            button_remove.set_text("REMOVE");
        } else {
            scanner_mode = true;
            button_scanner_mode.set_style(&Styles::red);
            button_scanner_mode.set_text("SCAN");
-            button_scanner_mode.set_text("REMOVE");
+            button_remove.set_text("DELETE");
        }
        frequency_file_load(true);
        if (autostart) {
@@ -622,12 +620,17 @@ ReconView::ReconView(NavigationView& nav)
        } else {
            recon_pause();
        }
+        button_add.hidden(scanner_mode);
+        if (scanner_mode)  // only needed when hiding, UI mayhem
+            set_dirty();
    };

    button_config.on_select = [this, &nav](Button&) {
        if (is_recording)  // disabling config while recording
            return;
+
        clear_freqlist_for_ui_action();
+
        freq_lock = 0;
        timer = 0;
        auto open_view = nav.push<ReconSetupView>(input_file, output_file);
@@ -734,30 +737,22 @@ void ReconView::frequency_file_load(bool) {
        button_scanner_mode.set_text("RECON");
    }

+    file_name.set(file_input + "=>" + output_file);
+
    freqman_load_options options{
        .load_freqs = load_freqs,
        .load_ranges = load_ranges,
        .load_hamradios = load_hamradios};
-    if (!load_freqman_file(file_input, frequency_list, options)) {
+    if (!load_freqman_file(file_input, frequency_list, options) || frequency_list.empty()) {
        file_name.set_style(&Styles::red);
-        desc_cycle.set(" NO " + file_input + ".TXT FILE ...");
-        file_name.set("=> NO DATA");
-    } else {
-        file_name.set(file_input + "=>" + output_file);
-        if (frequency_list.size() == 0) {
-            file_name.set_style(&Styles::red);
-            desc_cycle.set("/0 no entries in list");
-            file_name.set("BadOrEmpty " + file_input);
-        } else {
-            if (frequency_list.size() > FREQMAN_MAX_PER_FILE) {
-                file_name.set_style(&Styles::yellow);
-            }
-        }
+        desc_cycle.set("...empty file...");
+        frequency_list.clear();
+        text_cycle.set_text(" ");
+        return;
    }

-    if (frequency_list.empty()) {
-        text_cycle.set_text(" ");
-        return;  // Can't really do much.
+    if (frequency_list.size() > FREQMAN_MAX_PER_FILE) {
+        file_name.set_style(&Styles::yellow);
    }

    reset_indexes();
@@ -782,19 +777,8 @@ void ReconView::frequency_file_load(bool) {
 }

 void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
-    systime_t time_interval = 100;
-    uint32_t local_recon_lock_duration = recon_lock_duration;
-
    chrono_end = chTimeNow();
-    if (field_mode.selected_index_value() == SPEC_MODULATION) {
-        time_interval = chrono_end - chrono_start;
-        if (field_lock_wait.value() == 0) {
-            if (time_interval <= 1)             // capping here to avoid freeze because too quick
-                local_recon_lock_duration = 2;  // minimum working tested value
-            else
-                local_recon_lock_duration = time_interval;
-        }
-    }
+    systime_t time_interval = chrono_end - chrono_start;
    chrono_start = chrono_end;

    // hack to reload the list if it was cleared by going into CONFIG
@@ -814,7 +798,7 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
        if (!timer) {
            status = 0;
            freq_lock = 0;
-            timer = local_recon_lock_duration;
+            timer = recon_lock_duration;
        }
        if (freq_lock < recon_lock_nb_match)  // LOCKING
        {
@@ -1215,14 +1199,6 @@ void ReconView::handle_remove_current_item() {
        if (current_is_valid()) {
            frequency_list.erase(frequency_list.begin() + current_index);
        }
-
-        if (frequency_list.size() > 0) {
-            current_index = clip<int32_t>(current_index, 0u, frequency_list.size() - 1);
-            text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
-            update_description();
-        } else {
-            current_index = 0;
-        }
    }

    // In Scanner or Manual mode, remove the entry from the output file.
@@ -1233,6 +1209,17 @@ void ReconView::handle_remove_current_item() {

        freq_db.delete_entry(entry);
    }
+
+    // Clip
+    if (frequency_list.size() > 0) {
+        current_index = clip<int32_t>(current_index, 0u, frequency_list.size() - 1);
+        text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
+    } else {
+        current_index = 0;
+        text_cycle.set_text(" ");
+    }
+
+    update_description();
 }

 } /* namespace ui */
@@ -303,7 +303,7 @@ class ReconView : public View {
    NumberField field_lock_wait{
        {25 * 8, 24 * 8 + 4},
        4,
-        {0, RECON_MAX_LOCK_DURATION},
+        {STATS_UPDATE_INTERVAL, RECON_MAX_LOCK_DURATION},
        STATS_UPDATE_INTERVAL,
        ' ',
    };
@@ -39,10 +39,10 @@ namespace ui {
 ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, std::string input_file, std::string output_file)
    : View(parent_rect), _input_file{input_file}, _output_file{output_file} {
    hidden(true);
-    add_children({&button_load_freqs,
+    add_children({&button_input_file,
                  &text_input_file,
-                  &button_save_freqs,
-                  &button_output_file,
+                  &button_choose_output_file,
+                  &button_choose_output_name,
                  &checkbox_autosave_freqs,
                  &checkbox_autostart_recon,
                  &checkbox_clear_output});
@@ -52,9 +52,9 @@ ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, st
    checkbox_clear_output.set_value(persistent_memory::recon_clear_output());

    text_input_file.set(_input_file);
-    button_output_file.set_text(_output_file);
+    button_choose_output_name.set_text(_output_file);

-    button_load_freqs.on_select = [this, &nav](Button&) {
+    button_input_file.on_select = [this, &nav](Button&) {
        auto open_view = nav.push<FileLoadView>(".TXT");
        open_view->push_dir(freqman_dir);
        open_view->on_changed = [this, &nav](std::filesystem::path new_file_path) {
@@ -67,25 +67,24 @@ ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, st
        };
    };

-    button_save_freqs.on_select = [this, &nav](Button&) {
+    button_choose_output_file.on_select = [this, &nav](Button&) {
        auto open_view = nav.push<FileLoadView>(".TXT");
        open_view->push_dir(freqman_dir);
        open_view->on_changed = [this, &nav](std::filesystem::path new_file_path) {
            if (new_file_path.native().find(freqman_dir.native()) == 0) {
                _output_file = new_file_path.stem().string();
-                button_output_file.set_text(_output_file);
+                button_choose_output_name.set_text(_output_file);
            } else {
-                nav.display_modal("LOAD ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
+                nav.display_modal("SAVE ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
            }
        };
    };

-    button_output_file.on_select = [this, &nav](Button&) {
-        text_prompt(nav, _output_file, 28,
-                    [this](std::string& buffer) {
-                        _output_file = std::move(buffer);
-                        button_output_file.set_text(_output_file);
-                    });
+    button_choose_output_name.on_select = [this, &nav](Button&) {
+        text_prompt(nav, _output_file, 28, [this](std::string& buffer) {
+            _output_file = buffer;
+            button_choose_output_name.set_text(_output_file);
+        });
    };
 };

@@ -105,7 +104,7 @@ void ReconSetupViewMore::save() {
 };

 void ReconSetupViewMain::focus() {
-    button_load_freqs.focus();
+    button_input_file.focus();
 }

 ReconSetupViewMore::ReconSetupViewMore(NavigationView& nav, Rect parent_rect)
@@ -73,17 +73,18 @@ class ReconSetupViewMain : public View {
    std::string _input_file{"RECON"};
    std::string _output_file{"RECON_RESULTS"};

-    Button button_load_freqs{
+    Button button_input_file{
        {1 * 8, 12, 18 * 8, 22},
        "select input file"};
    Text text_input_file{
        {1 * 8, 4 + 2 * 16, 18 * 8, 22},
        "RECON"};

-    Button button_save_freqs{
+    Button button_choose_output_file{
        {1 * 8, 4 * 16 - 8, 18 * 8, 22},
        "select output file"};
-    Button button_output_file{
+
+    Button button_choose_output_name{
        {1 * 8, 5 * 16 - 2, 18 * 8, 22},
        "RECON_RESULTS"};

@@ -21,6 +21,7 @@

 #include "ui_remote.hpp"

+#include "binder.hpp"
 #include "convert.hpp"
 #include "file_reader.hpp"
 #include "io_convert.hpp"
@@ -239,19 +240,9 @@ RemoteEntryEditView::RemoteEntryEditView(
        &button_done,
    });

-    // TODO: It's time to make field bindings and clean this mess up.
-    field_name.on_change = [this](TextField& tf) {
-        entry_.name = tf.get_text();
-        button_preview.set_text(entry_.name);
-    };
-    field_name.on_select = [this, &nav](TextField& tf) {
-        temp_buffer_ = tf.get_text();
-        text_prompt(nav, temp_buffer_, text_edit_max,
-                    [this, &tf](std::string& str) {
-                        tf.set_text(str);
-                    });
-    };
-    field_name.set_text(entry_.name);
+    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*");
@@ -262,31 +253,16 @@ RemoteEntryEditView::RemoteEntryEditView(
        };
    };

-    field_freq.on_edit = [this, &nav]() {
-        auto freq_view = nav.push<FrequencyKeypadView>(entry_.metadata.center_frequency);
-        freq_view->on_changed = [this](rf::Frequency f) {
-            entry_.metadata.center_frequency = f;
-            field_freq.set_value(f);
-        };
-    };
-
-    field_icon_index.on_change = [this](int32_t v) {
-        entry_.icon = v;
+    bind(field_freq, entry_.metadata.center_frequency, nav);
+    bind(field_icon_index, entry_.icon, [this](auto v) {
        button_preview.set_bitmap(RemoteIcons::get(v));
-    };
-    field_icon_index.set_value(entry.icon);
-
-    field_fg_color_index.on_change = [this](int32_t v) {
-        entry_.fg_color = v;
+    });
+    bind(field_fg_color_index, entry_.fg_color, [this](auto v) {
        button_preview.set_color(RemoteColors::get(v));
-    };
-    field_fg_color_index.set_value(entry_.fg_color);
-
-    field_bg_color_index.on_change = [this](int32_t v) {
-        entry_.bg_color = v;
+    });
+    bind(field_bg_color_index, entry_.bg_color, [this](auto) {
        button_preview.set_dirty();
-    };
-    field_bg_color_index.set_value(entry_.bg_color);
+    });

    button_delete.on_select = [this, &nav]() {
        nav.display_modal(
@@ -485,6 +461,7 @@ void RemoteView::edit_button(RemoteButton& btn) {
    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) {
@@ -555,7 +532,6 @@ void RemoteView::open_remote() {
        save_remote();
        load_remote(std::move(path));
        refresh_ui();
-        ;
    };
 }

@@ -195,7 +195,6 @@ class RemoteEntryEditView : public View {

   private:
    RemoteEntryModel& entry_;
-    std::string temp_buffer_{};

    void refresh_ui();
    void load_path(std::filesystem::path&& path);
@@ -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 {

@@ -91,10 +90,31 @@ class SearchView : public View {
   private:
    NavigationView& nav_;
    RxRadioState radio_state_{
+        100'000'000 /* frequency */,
        2500000 /* bandwidth */,
        SEARCH_SLICE_WIDTH /* sampling rate */,
        ReceiverModel::Mode::SpectrumAnalysis};

+    // Settings
+    struct SearchSettings {
+        uint32_t power_threshold = 80;
+        rf::Frequency freq_min = 100'000'000;
+        rf::Frequency freq_max = 400'000'000;
+        bool snap_search = true;
+        uint32_t snap_step = 12'500;
+    };
+    SearchSettings settings_{};
+    app_settings::SettingsManager app_settings_{
+        "rx_search"sv,
+        app_settings::Mode::RX,
+        {
+            {"power_threshold"sv, &settings_.power_threshold},
+            {"freq_min"sv, &settings_.freq_min},
+            {"freq_max"sv, &settings_.freq_max},
+            {"snap_search"sv, &settings_.snap_search},
+            {"snap_step"sv, &settings_.snap_step},
+        }};
+
    struct slice_t {
        rf::Frequency center_frequency;
        uint8_t max_power;
@@ -103,33 +123,36 @@ class SearchView : public View {
        int16_t index;
    } slices[32];

-    uint32_t bin_skip_acc{0}, bin_skip_frac{};
-    uint32_t pixel_index{0};
-    std::array<Color, 240> spectrum_row = {0};
-    ChannelSpectrumFIFO* fifo{nullptr};
-    rf::Frequency f_min{0}, f_max{0};
-    uint8_t detect_timer{0}, release_timer{0}, timing_div{0};
-    uint8_t overall_power_max{0};
-    uint32_t mean_power{0}, mean_acc{0};
-    uint32_t duration{0};
-    uint32_t power_threshold{80};  // Todo: Put this in persistent / settings
-    rf::Frequency slice_start{0};
-    uint8_t slices_nb{0};
-    uint8_t slice_counter{0};
-    int16_t last_bin{0};
-    uint32_t last_slice{0};
-    Coord last_tick_pos{0};
-    rf::Frequency search_span{0}, resolved_frequency{0};
-    uint16_t locked_bin{0};
-    uint8_t search_counter{0};
-    bool locked{false};
+    uint32_t bin_skip_acc = 0;
+    uint32_t bin_skip_frac = 0;
+    uint32_t pixel_index = 0;
+    std::array<Color, 240> spectrum_row{};
+    ChannelSpectrumFIFO* fifo = nullptr;

+    uint8_t detect_timer = 0;
+    uint8_t release_timer = 0;
+    uint8_t timing_div = 0;
+    uint8_t overall_power_max{0};
+    uint32_t mean_power = 0;
+    uint32_t mean_acc = 0;
+    uint32_t duration = 0;
+
+    rf::Frequency slice_start = 0;
+    uint8_t slices_nb = 0;
+    uint8_t slice_counter = 0;
+    int16_t last_bin = 0;
+    uint32_t last_slice = 0;
+    Coord last_tick_pos = 0;
+    rf::Frequency search_span = 0;
+    rf::Frequency resolved_frequency = 0;
+    uint16_t locked_bin = 0;
+    uint8_t search_counter = 0;
+    bool locked = false;
+
+    void do_detection();
+    void do_timers();
    void on_channel_spectrum(const ChannelSpectrum& spectrum);
    void on_range_changed();
-    void do_detection();
-    void on_lna_changed(int32_t v_db);
-    void on_vga_changed(int32_t v_db);
-    void do_timers();
    void add_spectrum_pixel(Color color);

    const RecentEntriesColumns columns{{{"Frequency", 9},
@@ -150,6 +173,7 @@ class SearchView : public View {
        {1 * 8, 1 * 16}};
    FrequencyField field_frequency_max{
        {11 * 8, 1 * 16}};
+
    LNAGainField field_lna{
        {22 * 8, 1 * 16}};
    VGAGainField field_vga{
@@ -191,10 +215,10 @@ class SearchView : public View {
        {17 * 8, 15 * 8},  // Position
        7,                 // Length
        {                  // Options
-         {"25kHz  ", 25000},
-         {"12.5kHz", 12500},
-         {"8.33kHz", 8333},
-         {"2.5kHz", 2500},
+         {"25kHz  ", 25'000},
+         {"12.5kHz", 12'500},
+         {"8.33kHz", 8'333},
+         {"2.5kHz", 2'500},
         {"500Hz", 500}}};

    BigFrequency big_display{
@@ -207,6 +231,7 @@ class SearchView : public View {
            const auto message = *reinterpret_cast<const ChannelSpectrumConfigMessage*>(p);
            this->fifo = message.fifo;
        }};
+
    MessageHandlerRegistration message_handler_frame_sync{
        Message::ID::DisplayFrameSync,
        [this](const Message* const) {
@@ -343,34 +343,6 @@ void SetUIView::focus() {
    button_save.focus();
 }

-/* SetAppSettingsView ************************************/
-
-SetAppSettingsView::SetAppSettingsView(NavigationView& nav) {
-    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());
-
-    button_save.on_select = [&nav, this](Button&) {
-        pmem::set_load_app_settings(checkbox_load_app_settings.value());
-        pmem::set_save_app_settings(checkbox_save_app_settings.value());
-        nav.pop();
-    };
-    button_cancel.on_select = [&nav, this](Button&) {
-        nav.pop();
-    };
-}
-
-void SetAppSettingsView::focus() {
-    button_save.focus();
-}
-
 /* SetConverterSettingsView ******************************/

 SetConverterSettingsView::SetConverterSettingsView(NavigationView& nav) {
@@ -654,7 +626,6 @@ 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>(); }},
@@ -310,41 +310,6 @@ class SetUIView : public View {
    };
 };

-class SetAppSettingsView : public View {
-   public:
-    SetAppSettingsView(NavigationView& nav);
-
-    void focus() override;
-    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, 6 * 16},
-        25,
-        "Load radio settings"};
-
-    Checkbox checkbox_save_app_settings{
-        {3 * 8, 8 * 16},
-        25,
-        "Save radio settings"};
-
-    Button button_save{
-        {2 * 8, 16 * 16, 12 * 8, 32},
-        "Save"};
-
-    Button button_cancel{
-        {16 * 8, 16 * 16, 12 * 8, 32},
-        "Cancel",
-    };
-};
-
 class SetConverterSettingsView : public View {
   public:
    SetConverterSettingsView(NavigationView& nav);
@@ -87,10 +87,18 @@ SigGenView::SigGenView(
                  &field_stop,
                  &tx_view});

+    symfield_tone.hidden(1);        // At first launch , by default we are in CW Shape has NO MOD , we are not using Tone modulation.
+    symfield_tone.set_value(1000);  // Default: 1000 Hz
    options_shape.on_change = [this](size_t, OptionsField::value_t v) {
        text_shape.set(shape_strings[v]);
        if (auto_update)
            update_config();
+        if ((v == 0) || (v == 6)) {  // In Shapes Options (CW & Pseudo Random Noise) we are not using Tone modulation freq.
+            symfield_tone.hidden(1);
+        } else {
+            symfield_tone.hidden(0);
+        }
+        set_dirty();
    };
    options_shape.set_selected_index(0);
    text_shape.set(shape_strings[0]);
@@ -51,21 +51,23 @@ class SigGenView : public View {
    void on_tx_progress(const uint32_t progress, const bool done);

    TxRadioState radio_state_{
+        0 /* frequency */,
        1750000 /* bandwidth */,
        1536000 /* sampling rate */
    };
    app_settings::SettingsManager settings_{
        "tx_siggen", app_settings::Mode::TX};

-    const std::string shape_strings[7] = {
-        "CW-just carrier",
-        "Sine signal    ",
-        "Triangle signal",
-        "Saw up signal  ",
-        "Saw down signal",
-        "Square signal  ",
-        "Noise signal   "  // using 16 bits LFSR register, 16 order polynomial feedback.
-    };
+    const std::string shape_strings[9] = {
+        "CW  (No mod.) ",
+        "Sine mod. FM",
+        "Triangle mod.FM",  // max 15 character text space.
+        "Saw up mod. FM",
+        "Saw down mod.FM",
+        "Square mod. FM",
+        "Pseudo Noise FM",  // using 16 bits LFSR register, 16 order polynomial feedback.
+        "BPSK 0,1,0,1...",
+        "QPSK 00-01-10.."};

    bool auto_update{false};

@@ -85,10 +87,12 @@ class SigGenView : public View {
         {&bitmap_sig_saw_up, 3},
         {&bitmap_sig_saw_down, 4},
         {&bitmap_sig_square, 5},
-         {&bitmap_sig_noise, 6}}};
+         {&bitmap_sig_noise, 6},
+         {&bitmap_sig_noise, 7},    // Pending to add a correct BPSK icon.
+         {&bitmap_sig_noise, 8}}};  // Pending to add a correct QPSK icon.

    Text text_shape{
-        {15 * 8, 4 + 10, 8 * 8, 16},
+        {15 * 8, 4 + 10, 15 * 8, 16},
        ""};

    SymField symfield_tone{
@@ -66,9 +66,6 @@ SondeView::SondeView(NavigationView& nav)
                  &button_see_qr,
                  &button_see_map});

-    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

    geopos.set_read_only(true);
@@ -68,6 +68,7 @@ class SondeView : public View {
   private:
    NavigationView& nav_;
    RxRadioState radio_state_{
+        402700000 /* frequency */,
        1750000 /* bandwidth */,
        2457600 /* sampling rate */
    };
@@ -75,7 +76,6 @@ class SondeView : public View {
        "rx_sonde", app_settings::Mode::RX};

    std::unique_ptr<SondeLogger> logger{};
-    uint32_t target_frequency_{402700000};
    bool logging{false};
    bool use_crc{false};
    bool beep{false};
@@ -85,7 +85,11 @@ SpectrumPainterView::SpectrumPainterView(

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

            if (persistent_memory::stealth_mode()) {
@@ -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();
 }
@@ -160,6 +160,7 @@ void SSTVTXView::start_tx() {
    scanline_counter = 0;
    prepare_scanline();  // Preload one scanline

+    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF 1M75, same spectrum as previous fw 1.7.4
    transmitter_model.enable();

    baseband::set_sstv_data(
@@ -62,6 +62,7 @@ class TestView : public View {
   private:
    NavigationView& nav_;
    RxRadioState radio_state_{
+        0 /* frequency */,
        1750000 /* bandwidth */,
        2457600 * 2 /* sampling rate */
    };
@@ -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 *******************************************************/
@@ -413,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]() {
@@ -530,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__

@@ -238,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);

@@ -252,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{};

@@ -85,7 +85,6 @@ void TouchTunesView::on_tx_progress(const uint32_t progress, const bool done) {
 // transmission events.
 void TouchTunesView::start_ew() {
    // Radio
-    transmitter_model.set_target_frequency(433920000);
    transmitter_model.set_rf_amp(true);
    transmitter_model.set_tx_gain(47);
    transmitter_model.enable();
@@ -151,10 +150,7 @@ void TouchTunesView::start_tx(const uint32_t button_index) {

    size_t bitstream_length = make_bitstream(fragments);

-    transmitter_model.set_target_frequency(433920000);
-    transmitter_model.set_sampling_rate(OOK_SAMPLERATE);
    transmitter_model.set_rf_amp(true);
-    transmitter_model.set_baseband_bandwidth(1750000);
    transmitter_model.enable();

    baseband::set_ook_data(
@@ -25,6 +25,7 @@
 #include "ui_transmitter.hpp"
 #include "transmitter_model.hpp"
 #include "radio_state.hpp"
+#include "encoders.hpp"

 // The coding in notpike's script is quite complex, using multiple LUTs to form the data sent to the YSO.
 // The format is actually very simple if it is rather seen as short and long gaps between pulses (as seen in many OOK remotes).
@@ -115,8 +116,9 @@ class TouchTunesView : public View {

   private:
    TxRadioState radio_state_{
-        3500000 /* bandwidth */,
-        3072000 /* sampling rate */
+        433920000 /* frequency */,
+        1750000 /* bandwidth */,
+        OOK_SAMPLERATE /* sampling rate */
    };

    uint32_t scan_button_index{};
@@ -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();
+            });
        };
    };

@@ -198,8 +198,8 @@ void update_audio_mute() {

 namespace input {

-void start(int8_t alc_mode) {
-    audio_codec->microphone_enable(alc_mode);  // added user-GUI selection for AK4951, ALC mode parameter.
+void start(int8_t alc_mode, bool mic_to_HP_enabled) {
+    audio_codec->microphone_enable(alc_mode, mic_to_HP_enabled);  // added user-GUI selection for AK4951, ALC mode parameter. and the check box "Hear Mic"
    i2s::i2s0::rx_start();
 }

@@ -208,6 +208,14 @@ void stop() {
    audio_codec->microphone_disable();
 }

+void loopback_mic_to_hp_enable() {
+    audio_codec->microphone_to_HP_enable();
+}
+
+void loopback_mic_to_hp_disable() {
+    audio_codec->microphone_to_HP_disable();
+}
+
 } /* namespace input */

 namespace headphone {
@@ -50,9 +50,12 @@ class Codec {
    virtual volume_range_t headphone_gain_range() const = 0;
    virtual void set_headphone_volume(const volume_t volume) = 0;

-    virtual void microphone_enable(int8_t alc_mode) = 0;  // added user-GUI  AK4951 ,selected ALC mode.
+    virtual void microphone_enable(int8_t alc_mode, bool mic_to_HP_enabled) = 0;  // added user-GUI  AK4951 ,selected ALC mode.
    virtual void microphone_disable() = 0;

+    virtual void microphone_to_HP_enable() = 0;
+    virtual void microphone_to_HP_disable() = 0;
+
    virtual size_t reg_count() const = 0;
    virtual size_t reg_bits() const = 0;
    virtual uint32_t reg_read(const size_t register_number) = 0;
@@ -76,9 +79,12 @@ void update_audio_mute();

 namespace input {

-void start(int8_t alc_mode);  // added parameter user-GUI select AK4951-ALC mode for config mic path,(recording mode in datasheet),
+void start(int8_t alc_mode, bool mic_to_HP_enabled);  // added parameters -GUI select AK4951-ALC mode for config mic path,(recording mode),and the check box "Hear Mic"
 void stop();

+void loopback_mic_to_hp_enable();
+void loopback_mic_to_hp_disable();
+
 } /* namespace input */

 namespace headphone {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
gullradriel	645f02e2f3	updated submodule (#1551 ) Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-04 22:41:38 -05:00
Netro	b178462e47	BLE Rx improvements. (#1550 ) * Added parsing for ble name added focus for ble tx play button. * Added sort by name * Fixed issue where we were pushing too early before pop was finished. * Fix ordering * Fix field location. * truncating entries to stop memory overflow * Added Number of Hits. * Limiting number of hits to uint16_t, as any higher would overflow screen * Limiting number of hits to uint16_t due to possible screen overflow. * Stop creating a log every time app starts. Cluttering log folder.	2023-11-04 08:29:48 +01:00
Netro	1639348b94	More btle improvements (#1549 ) * Cleanup of BLE Rx naming and added switching between the two. Fixed bug in packet count not resetting when opening new file in BLE Tx * Bug fix and color change.	2023-11-03 08:08:49 +01:00
Netro	f67fe262bb	Add open file focus and changing the way send and loop works (#1548 )	2023-11-02 19:47:34 +01:00
Netro	0681117af6	Bletx multi packet (#1547 ) * Added multiple packet support * Fixed Issue where default was RAW and discovery needed toggle to work on init * Added random MAC toggle	2023-11-02 17:32:29 +01:00
Netro	b5c244a09b	Ble tx improvements (#1546 )	2023-11-01 23:24:55 +01:00
Netro	dceb7255b0	BLE Tx App / BLE Rx Filtering. (#1543 ) BLE TX app creation BLE RX and TX app improvements	2023-11-01 11:46:41 +01:00
Brumi-2021	62307b93d7	Clean compile warning (#1545 )	2023-11-01 00:25:11 +01:00
Mark Thompson	61ce8b11a6	Mic app enhancements - "Transmitting" icon, PTT TX button always enabled, and persistent settings (#1531 ) * Add files via upload * Clang * Clang * Persist mic settings * Preserve mode setting * Clang * Add files via upload * Add files via upload * Clang * Clang * Adjusted Transmitting icon position * Clang * Changed common freq checkbox description * Fix swizzled USB/LSB/DSB modulation values in widget	2023-10-31 23:31:10 +01:00
gullradriel	211f40ddf3	Recon: fix output when typing name (#1538 ) * Changed some buttons name and fixed blank output if typed * code format --------- Co-authored-by: Gull Ra Driel <gull@NiloreaDevLaptop.home> Co-authored-by: gullradriel <gull@nomail.net>	2023-10-30 16:54:37 -05:00
pathetic nihilist	01dd0c79ed	tiny fix: fix for wrong wav (#1540 ) * fix_for_wrong_wav * correct_wrong_file	2023-10-30 11:15:09 -05:00
Brumi-2021	be7b402c95	Adding raw data stream BPSK - QPSK (#1534 ) * Adding raw data stream BPSK - QPSK * minor code compact	2023-10-30 11:32:34 +01:00
Mark Thompson	a11929d2ca	Preallocate enough vectors for common app settings #1535	2023-10-30 11:32:01 +01:00
Mark Thompson	0bacb31d17	Improve blacklist to require precise app name matches (#1532 ) * Add files via upload * Add files via upload * Add files via upload * Clang * Update ui_btngrid.cpp * Update comment	2023-10-28 21:32:59 +02:00
Mark Thompson	cc7e4aec8a	Add files via upload (#1533 )	2023-10-28 08:28:17 +02:00
Netro	15c338e5b3	Added Sorting to BLE app (#1527 ) * First BLE work * Adding new fsk proc WIP * Reverting ble stuff * Initial compile working * more work. * Adding waterfall for debug * more edits to debug * Work to get widgets to show. * cleanup before attempting diff fsk modulation method * Temporary debug to learn how decimation scales. * Tab view for console and spectrum. Spectrum still not working right. * Fixed spectrum offset. * Added audio sampling rate increments to freqman * Added overriding range for frequency field and working off deviation * BLE cleanup. Got PDU parsing. * Parsing CRC * forgot : * Removing AA again because cluttering UI * fix compile * attempt at throttling. * WIP changes. * Decimating by 4 to handle issue with overloading. * Attempt to parse MAC still needs work. * Small fixes. MAC still wrong. * Fixed invalid indexing on Symbols. * List view of BLE Mac Addresses * Added Channel Option and improved GUI header. * renaming to dB and fixing some warnings. * Advertisements only. * Initial cut of BLE Advertisement scan app. * Copyrights * formatting correctly in association to clang13 * Fixing warning and hiding fsk rx. * spacing * Removing some cmake install files that weren't suppose to be there. * missed some. * Added name to about. * Edits for PR review pt.1 * Refactor ORing with 0 doesn't make sense. * remove parenthesis * More PR Review changes. * Fix compiler error. * PR Review edits. * PR review changes. * Fixes. * Unneeded ; * Update ui_about_simple.cpp * Disabling frequency stepping. * removing unused label * Fixing something that got messed up in merge? * removing file that got added. * editing labels. * Added sort functionality. * removed unused code. --------- Co-authored-by: jLynx <admin@jlynx.net>	2023-10-24 17:08:45 -05:00
Netro	80bfcd5eb1	Restricting Frequency change to only Channel Options Toggle. (#1526 ) * First BLE work	2023-10-23 20:54:04 +02:00
Netro	b96f14762f	New and Improved BLE App. (#1524 ) * First BLE work * Adding new fsk proc WIP * Reverting ble stuff * Initial compile working * more work. * Adding waterfall for debug * more edits to debug * Work to get widgets to show. * cleanup before attempting diff fsk modulation method * Temporary debug to learn how decimation scales. * Tab view for console and spectrum. Spectrum still not working right. * Fixed spectrum offset. * Added audio sampling rate increments to freqman * Added overriding range for frequency field and working off deviation * BLE cleanup. Got PDU parsing. * Parsing CRC * forgot : * Removing AA again because cluttering UI * fix compile * attempt at throttling. * WIP changes. * Decimating by 4 to handle issue with overloading. * Attempt to parse MAC still needs work. * Small fixes. MAC still wrong. * Fixed invalid indexing on Symbols. * List view of BLE Mac Addresses * Added Channel Option and improved GUI header. * renaming to dB and fixing some warnings. * Advertisements only. * Initial cut of BLE Advertisement scan app. * Copyrights * formatting correctly in association to clang13 * Fixing warning and hiding fsk rx. * spacing * Removing some cmake install files that weren't suppose to be there. * missed some. * Added name to about. * Edits for PR review pt.1 * Refactor ORing with 0 doesn't make sense. * remove parenthesis * More PR Review changes. * Fix compiler error. * PR Review edits. * PR review changes. * Fixes. * Unneeded ; * Update ui_about_simple.cpp --------- Co-authored-by: jLynx <admin@jlynx.net>	2023-10-22 22:58:14 -07:00
Brumi-2021	0feacfa102	Solve mic to hp small side effect (#1523 ) * Allowing to hear Mic at TX time with Receiver ON * Solve small side effect to Audio RX App	2023-10-22 19:10:26 +02:00
Brumi-2021	a1496c1b79	Allowing to hear Mic at TX time with Receiver ON (#1522 )	2023-10-22 01:13:32 +02:00
Brumi-2021	1b73a138b6	Mic to hp refactoring (#1521 ) * Refactoring previous "Hear Mic" PR * Missed file	2023-10-21 17:31:17 +02:00
Brumi-2021	efcedd9005	Add "Hear Mic" feature to the Mic App (#1518 ) * Add "Hear Mic" feature to the Mic App * Following consensus change about ternary operators	2023-10-20 18:43:22 -05:00
Mark Thompson	86d4b17257	Simple amplification option in IQ Trim app (#1506 ) * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload	2023-10-19 20:14:25 +02:00
Mark Thompson	f6a437f7fb	Create SETTINGS folder if one does not exist (#1512 ) * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload	2023-10-19 20:09:49 +02:00
jLynx	3db8a5ac5b	Stable v1.8.0 release (#1504 ) * Update version.txt * Update past_version.txt	2023-10-17 15:20:40 +13:00
Mark Thompson	266a626acf	POCSAG TX default freq (#1503 ) * Changed name for blacklist * Set default POCSAG TX freq to same as in POCSAG RX	2023-10-16 21:32:07 +02:00
Mark Thompson	411e2fb93a	Hide unwanted apps by naming them in SETTINGS/blacklist file (#1502 ) * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Changed some app name strings for blacklist	2023-10-15 18:04:26 -05:00
Mark Thompson	6ed83c08e3	Renamed .ini file for Burger Pager app (#1500 )	2023-10-14 21:08:39 +02:00
Mark Thompson	9929376acf	Added Freq to Radio State, only update specified App Settings, always Load/Save Settings (#1498 ) * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload	2023-10-14 11:33:52 -05:00
Mark Thompson	5135b6404d	Prevent unnecessary CPLD SRAM load on first RX operation (#1494 )	2023-10-14 10:28:44 +02:00
Mark Thompson	790669c242	Added Transmitter settings to 2nd DFU overlay screen (#1497 ) * Added Transmitter settings to 2nd DFU overlay	2023-10-14 10:25:40 +02:00
Brumi-2021	4bb8b1882c	Error correction. Now comments matching with value (#1496 )	2023-10-12 19:56:27 +02:00
Brumi-2021	56702ca7c2	Applying a proper TX_LPF to all remaining TX App (#1495 )	2023-10-12 18:02:38 +02:00
Erwin Ried	9be4b9596d	Update README.md (#1491 ) Changing the introductory video with a newer one with a guy with weird danish accented english	2023-10-12 07:57:34 +02:00
Mark Thompson	37c6b35fb7	Moved external Font Viewer app to DEBUG menu (#1485 ) * Updated icon * Support external apps on DEBUG menu screen	2023-10-11 18:32:01 +02:00
Mark Thompson	5cd7a09797	Disable display scroll before showing fault debug message (#1482 )	2023-10-11 07:45:45 +02:00
Mark Thompson	a1856b9bb0	Fix some Guru Meditation Faults in ADSB-RX app (#1483 ) * Don't use screen_rect in functions called from rtc_timer_tick * Pause AircraftRecentEntry list changes when AC Details screen is displayed	2023-10-11 07:44:56 +02:00
Mark Thompson	29a36c8658	Revived Fonts Viewer as an External app (in Utilities menu) (#1484 ) * Add files via upload * Moved Font Viewer to external app	2023-10-11 07:43:56 +02:00
gullradriel	264b1b38ba	fix complicated timing logic (#1480 )	2023-10-09 20:01:40 +02:00
Mark Thompson	65e71508ac	Incrementing date workaround for dead RTC battery (#1479 ) * Enable f_utime function * Added file_update_date() function * Added rtc_battery_workaround() function * Update ui_navigation.cpp	2023-10-09 12:04:46 +02:00
Mark Thompson	e5546159c5	Kludge fix for null parent() (#1477 )	2023-10-09 12:03:11 +02:00
gullradriel	d7c961ea4f	Fixing empty output file/store button/text display (#1475 )	2023-10-08 22:21:00 +02:00
Mark Thompson	ad987f2b5e	Added new icon for IQ Trim, and IQ Trim Button in FileMan (#1476 ) * Add files via upload * Added trim icon * Added trim icon * Added Trim button to FileMan * Added Trim button to FileMan * Added Trim button to FileMan * Added Trim button to FileMan	2023-10-08 14:57:59 -05:00
Brumi-2021	defb934c3f	Activating TX Low Pass Filter in Second IF IC (#1470 ) * Activating TX Low Pass Filter in Second IF IC * solving PR conversation revisions * Final TX LPF decision for ADSB_TX * Small comments correction. * Added set TX LPF also in APRS, BurgerPgr,Jammer	2023-10-08 17:50:31 +02:00
Bernd Herzog	5a850984b9	Calculator app (#1474 ) * implemented calculator app * improved output * refactoring	2023-10-08 16:24:02 +02:00
Bernd Herzog	1185b67b28	changed alignment for text sections (#1473 )	2023-10-07 15:30:43 +02:00
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