V1.9.0 (#1660)

* Update version.txt

* Update past_version.txt

.github/workflows/past_version.txt

@@ -1 +1 @@
-v1.7.3
+v1.8.0

.github/workflows/version.txt

@@ -1 +1 @@
-v1.7.4
+v1.9.0

.gitignore

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

README.md

@@ -1,6 +1,6 @@
 # PortaPack Mayhem
 
-[![Build Status](https://travis-ci.com/eried/portapack-mayhem.svg?branch=master)](https://travis-ci.com/eried/portapack-mayhem) [![Nightly Release](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml/badge.svg?branch=next)](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml) [![CodeScene Code Health](https://codescene.io/projects/8381/status-badges/code-health)](https://codescene.io/projects/8381) [![GitHub All Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/total)](https://github.com/eried/portapack-mayhem/releases) [![GitHub Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/latest/total)](https://github.com/eried/portapack-mayhem/releases/latest) [![Docker Hub Pulls](https://img.shields.io/docker/pulls/eried/portapack.svg)](https://hub.docker.com/r/eried/portapack) [![Discord Chat](https://img.shields.io/discord/719669764804444213.svg)](https://discord.gg/tuwVMv3)  [![Check bounties!](https://img.shields.io/bountysource/team/portapack-mayhem/activity?color=%2333ccff&label=bountysource%20%28USD%29&style=plastic)](https://www.bountysource.com/teams/portapack-mayhem/issues)
+[![Build Status](https://travis-ci.com/eried/portapack-mayhem.svg?branch=master)](https://travis-ci.com/eried/portapack-mayhem) [![Nightly Release](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml/badge.svg?branch=next)](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml) [![CodeScene Code Health](https://codescene.io/projects/8381/status-badges/code-health)](https://codescene.io/projects/8381) [![GitHub All Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/total)](https://github.com/eried/portapack-mayhem/releases) [![GitHub Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/latest/total)](https://github.com/eried/portapack-mayhem/releases/latest) [![Docker Hub Pulls](https://img.shields.io/docker/pulls/eried/portapack.svg)](https://hub.docker.com/r/eried/portapack) [![Discord Chat](https://dcbadge.vercel.app/api/server/tuwVMv3?style=flat)](https://discord.gg/tuwVMv3)
 
 This is a fork of the [Havoc](https://github.com/furrtek/portapack-havoc/) firmware, which itself was a fork of the [PortaPack](https://github.com/sharebrained/portapack-hackrf) firmware, an add-on for the [HackRF](http://greatscottgadgets.com/hackrf/). A fork is a derivate, in this case one that has extra features and fixes when compared to the older versions.
 
@@ -8,11 +8,11 @@ This is a fork of the [Havoc](https://github.com/furrtek/portapack-havoc/) firmw
 
 *[PortaPack H2+HackRF+battery](https://s.click.aliexpress.com/e/_DmU7GQX) (clone) with a custom [3d printed case](https://github.com/eried/portapack-mayhem/wiki/H2-Enclosure)*
 
-# Quick overview
+# What is this?
 
-If you are new to *HackRF+PortaPack+Mayhem*, there is an awesome introductory video by [Tech Minds](https://www.youtube.com/channel/UC9a8Z6Sp6eb2s3O79pX5Zvg) available:
+If you are new to *HackRF+PortaPack+Mayhem*, check this video:
 
-[![Setup and overview](https://img.youtube.com/vi/kjFB58Y1TAo/0.jpg)](https://www.youtube.com/watch?v=kjFB58Y1TAo)
+[![What is?](https://img.youtube.com/vi/alrFbY5vxt4/0.jpg)](https://www.youtube.com/watch?v=alrFbY5vxt4)
 
 # Frequently Asked Questions
 
@@ -20,7 +20,9 @@ This repository expands upon the previous work by many people and aims to consta
 
 ## What to buy?
 
-:heavy_check_mark: A recommended one is this [PortaPack H2](https://s.click.aliexpress.com/e/_DmU7GQX) pack, that includes everything you need. Sadly, the people making the H2 never made the updated schematics available (against the terms of the license). 
+:heavy_check_mark: A recommended one is this [PortaPack H2](https://s.click.aliexpress.com/e/_DmU7GQX), that includes everything you need with the plastic case "inspired" on [this](https://github.com/eried/portapack-mayhem/wiki/H2-Enclosure).
+
+:heavy_check_mark: Our friends at OpenSourceSDRLab give away five units every three months in our discord (check the badge on top) of their [PortaPack H2](https://www.aliexpress.com/item/4000247041639.html?gatewayAdapt=4itemAdapt), you can support them too by ordering.
 
 :heavy_check_mark: Another popular option is the clone of the [PortaPack H1](https://s.click.aliexpress.com/e/_Dkbqs2X).
 
@@ -48,9 +50,11 @@ To support the people behind the hardware, please buy a genuine [HackRF](https:/
 ## What if I really want something specific?
 If what you need can be relevant in general, you can [request a feature](https://github.com/eried/portapack-mayhem/issues/new?labels=enhancement&template=feature_request.md).
 
-You can create a bounty and invite people to your own bounty. This will incentivize coders to work on a new feature, solving a bug or even writting documentation. Start a bounty by [creating](https://github.com/eried/portapack-mayhem/issues/new/choose) or [choosing](https://github.com/eried/portapack-mayhem/issues/) an existing issue. Then, go to [Bountysource](https://www.bountysource.com/) and post a bounty using the link to that specific [issue](https://www.bountysource.com/teams/portapack-mayhem/issues).
+<del>You can create a bounty and invite people to your own bounty. This will incentivize coders to work on a new feature, solving a bug or even writting documentation. Start a bounty by [creating](https://github.com/eried/portapack-mayhem/issues/new/choose) or [choosing](https://github.com/eried/portapack-mayhem/issues/) an existing issue. Then, go to [Bountysource](https://www.bountysource.com/) and post a bounty using the link to that specific [issue](https://www.bountysource.com/teams/portapack-mayhem/issues).</del>
 
-Promote your bounty over our Discord by clicking the chat badge on [top](#portapack-mayhem).
+<del>Promote your bounty over our Discord by clicking the chat badge on [top](#portapack-mayhem).</del>
+
+Bountysource has not been reliable lately, so until this changes, please **DO NOT** post a bounty there. Go to our Discord by clicking the chat badge on [top](#portapack-mayhem) and discuss there.
 
 ## What if I need help?
 First, check the [documentation](https://github.com/eried/portapack-mayhem/wiki). If you find a bug or you think the problem is related to the current repository, please open an [issue](https://github.com/eried/portapack-mayhem/issues/new/choose).

firmware/CMakeLists.txt

@@ -54,6 +54,7 @@ add_custom_target(
 
 add_custom_target(
 	program
+	COMMAND ${PROJECT_SOURCE_DIR}/tools/enter_mode.sh hackrf
 	COMMAND dfu-util --device 1fc9:000c --download ${HACKRF_FIRMWARE_DFU_IMAGE} || (exit 0) # We need to add it for dfu-utils v.011 , (in v.09 it is not necessary)
 	COMMAND sleep 3s
 	COMMAND hackrf_spiflash -i -R -w ${FIRMWARE_FILENAME}

firmware/application/CMakeLists.txt

@@ -113,6 +113,17 @@ set(CSRC
 	${BOARDSRC}
 	${FATFSSRC}
 	firmware_info.c
+	usb_serial_cdc.c
+	usb_serial_descriptor.c
+	usb_serial_endpoints.c
+	usb_serial_io.c
+	${HACKRF_PATH}/firmware/common/usb.c
+	${HACKRF_PATH}/firmware/common/usb_queue.c
+	${HACKRF_PATH}/firmware/hackrf_usb/usb_device.c
+	${HACKRF_PATH}/firmware/common/usb_request.c
+	${HACKRF_PATH}/firmware/common/usb_standard_request.c
+	${CHIBIOS}/os/various/shell.c
+	${CHIBIOS}/os/various/chprintf.c
 )
 
 # C++ sources that can be compiled in ARM or THUMB mode depending on the global
@@ -162,6 +173,7 @@ set(CPPSRC
 	${COMMON}/ui_painter.cpp
 	${COMMON}/ui_text.cpp
 	${COMMON}/ui_widget.cpp
+	${COMMON}/ui_language.cpp
 	${COMMON}/utility.cpp
 	${COMMON}/wm8731.cpp
 	${COMMON}/performance_counter.cpp
@@ -190,6 +202,10 @@ set(CPPSRC
 	log_file.cpp
 	metadata_file.cpp
 	portapack.cpp
+	usb_serial_shell.cpp
+	usb_serial_event.cpp
+	usb_serial_thread.cpp
+	usb_serial.cpp
 	qrcodegen.cpp
 	radio.cpp
 	receiver_model.cpp
@@ -243,12 +259,14 @@ set(CPPSRC
 	apps/acars_app.cpp
 	apps/ais_app.cpp
 	apps/analog_audio_app.cpp
-	apps/analog_tv_app.cpp
+	# apps/analog_tv_app.cpp
+	apps/ble_comm_app.cpp
+	apps/ble_rx_app.cpp
+	apps/ble_tx_app.cpp
 	apps/capture_app.cpp
 	apps/ert_app.cpp
 	apps/gps_sim_app.cpp
-	apps/lge_app.cpp
-	apps/lge_app.cpp
+	# apps/lge_app.cpp
 	apps/pocsag_app.cpp
 	# apps/replay_app.cpp
 	apps/soundboard_app.cpp
@@ -261,23 +279,24 @@ set(CPPSRC
 	apps/ui_aprs_tx.cpp
 	apps/ui_bht_tx.cpp
 	apps/ui_btle_rx.cpp
-	apps/ui_coasterp.cpp
+	# apps/ui_coasterp.cpp
 	apps/ui_debug.cpp
 	apps/ui_dfu_menu.cpp
 	apps/ui_encoders.cpp
 	apps/ui_fileman.cpp
 	apps/ui_flash_utility.cpp
 	apps/ui_freqman.cpp
+	apps/ui_fsk_rx.cpp
 	apps/ui_iq_trim.cpp
-	apps/ui_jammer.cpp
+	# apps/ui_jammer.cpp
     # apps/ui_keyfob.cpp
-	apps/ui_lcr.cpp
+	# apps/ui_lcr.cpp
 	apps/ui_level.cpp  
 	apps/ui_looking_glass_app.cpp
 	apps/ui_mictx.cpp
 	apps/ui_modemsetup.cpp
 	apps/ui_morse.cpp
-	apps/ui_nrf_rx.cpp
+	# apps/ui_nrf_rx.cpp
 	# apps/ui_nuoptix.cpp
 	apps/ui_playlist.cpp
 	apps/ui_pocsag_tx.cpp
@@ -297,19 +316,21 @@ set(CPPSRC
 	apps/ui_spectrum_painter.cpp
 	apps/ui_ss_viewer.cpp
 	apps/ui_sstvtx.cpp
+	apps/ui_subghzd.cpp
 	# apps/ui_test.cpp
 	apps/ui_text_editor.cpp
 	apps/ui_tone_search.cpp
 	apps/ui_touch_calibration.cpp
 	apps/ui_touchtunes.cpp
 	apps/ui_view_wav.cpp
+	apps/ui_weatherstation.cpp
 	apps/ui_whipcalc.cpp
 	protocols/aprs.cpp
 	protocols/ax25.cpp
 	protocols/bht.cpp
 	protocols/dcs.cpp
 	protocols/encoders.cpp
-	protocols/lcr.cpp
+	# protocols/lcr.cpp
 	protocols/modems.cpp
 	protocols/rds.cpp
 	# ui_handwrite.cpp
@@ -357,6 +378,9 @@ set(INCDIR ${CMAKE_CURRENT_BINARY_DIR} ${COMMON} ${PORTINC} ${KERNINC} ${TESTINC
 	${HALINC} ${PLATFORMINC} ${BOARDINC}
 	${FATFSINC}
 	${CHIBIOS}/os/various
+	${HACKRF_PATH}/firmware/libopencm3/include
+	${HACKRF_PATH}/firmware/common
+	${HACKRF_PATH}/firmware
 	ui
 	hw
 	apps

firmware/application/app_settings.cpp

@@ -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_);
 }

firmware/application/app_settings.hpp

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

firmware/application/apps/acars_app.hpp

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

firmware/application/apps/ais_app.cpp

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

firmware/application/apps/ais_app.hpp

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

firmware/application/apps/ble_comm_app.cpp

@@ -0,0 +1,331 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ble_comm_app.hpp"
+
+#include "ui_modemsetup.hpp"
+
+#include "modems.hpp"
+#include "audio.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "ui_text.hpp"
+
+using namespace portapack;
+using namespace modems;
+
+void BLECommLogger::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+namespace ui {
+static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
+    uint64_t freq_hz;
+
+    switch (channel_number) {
+        case 37:
+            freq_hz = 2'402'000'000ull;
+            break;
+        case 38:
+            freq_hz = 2'426'000'000ull;
+            break;
+        case 39:
+            freq_hz = 2'480'000'000ull;
+            break;
+        case 0 ... 10:
+            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
+            break;
+        case 11 ... 36:
+            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
+            break;
+        default:
+            freq_hz = UINT64_MAX;
+    }
+
+    return freq_hz;
+}
+
+void BLECommView::focus() {
+    options_channel.focus();
+}
+
+BLECommView::BLECommView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &options_channel,
+                  &field_frequency,
+                  &label_send_adv,
+                  &button_send_adv,
+                  &check_log,
+                  &label_packets_sent,
+                  &text_packets_sent,
+                  &console});
+
+    field_frequency.set_step(0);
+
+    button_send_adv.on_select = [this](ImageButton&) {
+        this->toggle();
+    };
+
+    check_log.set_value(logging);
+
+    check_log.on_select = [this](Checkbox&, bool v) {
+        str_log = "";
+        logging = v;
+
+        if (logger && logging)
+            logger->append(LOG_ROOT_DIR "/BLELOG_" + to_string_timestamp(rtc_time::now()) + ".TXT");
+    };
+
+    options_channel.on_change = [this](size_t, int32_t i) {
+        // If we selected Auto don't do anything and Auto will handle changing.
+        if (i == 40) {
+            auto_channel = true;
+            return;
+        } else {
+            auto_channel = false;
+        }
+
+        field_frequency.set_value(get_freq_by_channel_number(i));
+        channel_number_rx = i;
+        channel_number_tx = i;
+    };
+
+    options_channel.set_selected_index(3, true);
+
+    logger = std::make_unique<BLECommLogger>();
+
+    // Generate new random Mac Address upon each new startup.
+    generateRandomMacAddress(randomMac);
+
+    // Setup Initial Advertise Packet.
+    advertisePacket = build_adv_packet();
+}
+
+void BLECommView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    console.set_parent_rect(content_rect);
+}
+
+BLECommView::~BLECommView() {
+    receiver_model.disable();
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+bool BLECommView::in_tx_mode() const {
+    return (bool)is_running_tx;
+}
+
+void BLECommView::toggle() {
+    if (in_tx_mode()) {
+        sendAdvertisement(false);
+    } else {
+        sendAdvertisement(true);
+    }
+}
+
+BLETxPacket BLECommView::build_adv_packet() {
+    BLETxPacket bleTxPacket;
+    memset(&bleTxPacket, 0, sizeof(BLETxPacket));
+
+    std::string dataString = "11094861636b524620506f7274617061636b";
+
+    strncpy(bleTxPacket.macAddress, randomMac, 12);
+    strncpy(bleTxPacket.advertisementData, dataString.c_str(), dataString.length());
+
+    // Duty cycle of 40% per 100ms advertisment periods.
+    strncpy(bleTxPacket.packetCount, "80", 3);
+    bleTxPacket.packet_count = 80;
+
+    bleTxPacket.packetType = PKT_TYPE_DISCOVERY;
+
+    return bleTxPacket;
+}
+
+void BLECommView::sendAdvertisement(bool enable) {
+    if (enable) {
+        startTx(advertisePacket);
+        is_adv = true;
+    } else {
+        is_adv = false;
+        stopTx();
+    }
+}
+
+void BLECommView::startTx(BLETxPacket packetToSend) {
+    int randomChannel = channel_number_tx;
+
+    if (auto_channel) {
+        int min = 37;
+        int max = 39;
+
+        randomChannel = min + std::rand() % (max - min + 1);
+
+        field_frequency.set_value(get_freq_by_channel_number(randomChannel));
+    }
+
+    if (!in_tx_mode()) {
+        switch_rx_tx(false);
+
+        currentPacket = packetToSend;
+        packet_counter = currentPacket.packet_count;
+
+        button_send_adv.set_bitmap(&bitmap_stop);
+        baseband::set_btletx(randomChannel, currentPacket.macAddress, currentPacket.advertisementData, currentPacket.packetType);
+        transmitter_model.set_tx_gain(47);
+        transmitter_model.enable();
+
+        is_running_tx = true;
+    } else {
+        baseband::set_btletx(randomChannel, currentPacket.macAddress, currentPacket.advertisementData, currentPacket.packetType);
+    }
+
+    if ((packet_counter % 10) == 0) {
+        text_packets_sent.set(to_string_dec_uint(packet_counter));
+    }
+
+    is_sending = true;
+
+    packet_counter--;
+}
+
+void BLECommView::stopTx() {
+    button_send_adv.set_bitmap(&bitmap_play);
+    text_packets_sent.set(to_string_dec_uint(packet_counter));
+
+    switch_rx_tx(true);
+
+    baseband::set_btlerx(channel_number_rx);
+    receiver_model.enable();
+
+    is_running_tx = false;
+}
+
+void BLECommView::switch_rx_tx(bool inRxMode) {
+    if (inRxMode) {
+        // Start Rx
+        transmitter_model.disable();
+        baseband::shutdown();
+        baseband::run_image(portapack::spi_flash::image_tag_btle_rx);
+    } else {
+        // Start Tx
+        receiver_model.disable();
+        baseband::shutdown();
+        baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+    }
+}
+
+void BLECommView::on_data(BlePacketData* packet) {
+    parse_received_packet(packet, (ADV_PDU_TYPE)packet->type);
+}
+
+// called each 1/60th of second, so 6 = 100ms
+void BLECommView::on_timer() {
+    // Send advertise burst only once every 100ms
+    if (++timer_counter == timer_period) {
+        timer_counter = 0;
+
+        if (!is_adv) {
+            sendAdvertisement(true);
+        }
+    }
+}
+
+void BLECommView::on_tx_progress(const bool done) {
+    if (done) {
+        if (in_tx_mode()) {
+            is_sending = false;
+
+            if (packet_counter == 0) {
+                if (is_adv) {
+                    sendAdvertisement(false);
+                } else {
+                    stopTx();
+                }
+            } else {
+                startTx(currentPacket);
+            }
+        }
+    }
+}
+
+void BLECommView::parse_received_packet(const BlePacketData* packet, ADV_PDU_TYPE pdu_type) {
+    std::string data_string;
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        data_string += to_string_hex(packet->data[i], 2);
+    }
+
+    receivedPacket.dbValue = packet->max_dB;
+    receivedPacket.timestamp = to_string_timestamp(rtc_time::now());
+    receivedPacket.dataString = data_string;
+
+    receivedPacket.packetData.type = packet->type;
+    receivedPacket.packetData.size = packet->size;
+    receivedPacket.packetData.dataLen = packet->dataLen;
+
+    receivedPacket.packetData.macAddress[0] = packet->macAddress[0];
+    receivedPacket.packetData.macAddress[1] = packet->macAddress[1];
+    receivedPacket.packetData.macAddress[2] = packet->macAddress[2];
+    receivedPacket.packetData.macAddress[3] = packet->macAddress[3];
+    receivedPacket.packetData.macAddress[4] = packet->macAddress[4];
+    receivedPacket.packetData.macAddress[5] = packet->macAddress[5];
+
+    receivedPacket.numHits++;
+
+    for (int i = 0; i < packet->dataLen; i++) {
+        receivedPacket.packetData.data[i] = packet->data[i];
+    }
+
+    if (pdu_type == SCAN_REQ || pdu_type == CONNECT_REQ) {
+        ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)packet->data;
+
+        std::reverse(directed_mac_data->A1, directed_mac_data->A1 + 6);
+        console.clear(true);
+        std::string str_console = "";
+        std::string pduTypeStr = "";
+
+        if (pdu_type == SCAN_REQ) {
+            pduTypeStr += "SCAN_REQ";
+        } else if (pdu_type == CONNECT_REQ) {
+            pduTypeStr += "CONNECT_REQ";
+        }
+
+        str_console += "PACKET TYPE:" + pduTypeStr + "\n";
+        str_console += "MY MAC:" + to_string_formatted_mac_address(randomMac) + "\n";
+        str_console += "SCAN MAC:" + to_string_mac_address(directed_mac_data->A1, 6, false) + "\n";
+        console.write(str_console);
+    }
+}
+
+} /* namespace ui */

firmware/application/apps/ble_comm_app.hpp

@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLE_COMM_APP_H__
+#define __BLE_COMM_APP_H__
+
+#include "ble_rx_app.hpp"
+#include "ble_tx_app.hpp"
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+#include "recent_entries.hpp"
+
+class BLECommLogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+class BLECommView : public View {
+   public:
+    BLECommView(NavigationView& nav);
+    ~BLECommView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    std::string title() const override { return "BLE Comm"; };
+
+   private:
+    BLETxPacket build_adv_packet();
+    void switch_rx_tx(bool inRxMode);
+    void startTx(BLETxPacket packetToSend);
+    void stopTx();
+    void toggle();
+    bool in_tx_mode() const;
+    void on_timer();
+    void on_data(BlePacketData* packetData);
+    void on_tx_progress(const bool done);
+    void parse_received_packet(const BlePacketData* packet, ADV_PDU_TYPE pdu_type);
+    void sendAdvertisement(bool enable);
+
+    NavigationView& nav_;
+
+    RxRadioState radio_state_rx_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */,
+        ReceiverModel::Mode::WidebandFMAudio};
+
+    TxRadioState radio_state_tx_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */
+    };
+
+    app_settings::SettingsManager settings_{
+        "BLE Comm Tx", app_settings::Mode::RX_TX};
+
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+
+    uint8_t channel_number_tx = 37;
+    uint8_t channel_number_rx = 37;
+    bool auto_channel = false;
+
+    char randomMac[13] = "010203040506";
+
+    bool is_running_tx = false;
+    bool is_sending = false;
+    bool is_adv = false;
+
+    int16_t timer_period{6};  // Delay each packet by 16ms.
+    int16_t timer_counter = 0;
+    int16_t timer_rx_counter = 0;
+    int16_t timer_rx_period{12};  // Poll Rx for at least 200ms. (TBD)
+
+    uint32_t packet_counter{0};
+    BLETxPacket advertisePacket{};
+    BLETxPacket currentPacket{};
+    BleRecentEntry receivedPacket{};
+
+    static constexpr auto header_height = 5 * 16;
+
+    OptionsField options_channel{
+        {0 * 8, 0 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39},
+         {"Auto", 40}}};
+
+    RxFrequencyField field_frequency{
+        {6 * 8, 0 * 16},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {16 * 8, 0 * 16}};
+
+    LNAGainField field_lna{
+        {18 * 8, 0 * 16}};
+
+    VGAGainField field_vga{
+        {21 * 8, 0 * 16}};
+
+    RSSI rssi{
+        {24 * 8, 0, 6 * 8, 4}};
+
+    Channel channel{
+        {24 * 8, 5, 6 * 8, 4}};
+
+    Labels label_send_adv{
+        {{0 * 8, 2 * 8}, "Send Advertisement:", Color::light_grey()}};
+
+    ImageButton button_send_adv{
+        {21 * 8, 1 * 16, 10 * 8, 2 * 16},
+        &bitmap_play,
+        Color::green(),
+        Color::black()};
+
+    Checkbox check_log{
+        {24 * 8, 2 * 8},
+        3,
+        "Log",
+        true};
+
+    Labels label_packets_sent{
+        {{0 * 8, 4 * 8}, "Packets Left:", Color::light_grey()}};
+
+    Text text_packets_sent{
+        {13 * 8, 2 * 16, 12 * 8, 16},
+        "-"};
+
+    Console console{
+        {0, 4 * 16, 240, 240}};
+
+    std::string str_log{""};
+    bool logging{false};
+
+    std::unique_ptr<BLECommLogger> logger{};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::BlePacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const BLEPacketMessage*>(p);
+            this->on_data(message->packet);
+        }};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.done);
+        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/

firmware/application/apps/ble_rx_app.cpp

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

firmware/application/apps/ble_rx_app.hpp

@@ -0,0 +1,368 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLE_RX_APP_H__
+#define __BLE_RX_APP_H__
+
+#include "ble_tx_app.hpp"
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+#include "usb_serial_thread.hpp"
+
+#include "recent_entries.hpp"
+
+class BLELogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+typedef enum {
+    ADV_IND = 0,
+    ADV_DIRECT_IND = 1,
+    ADV_NONCONN_IND = 2,
+    SCAN_REQ = 3,
+    SCAN_RSP = 4,
+    CONNECT_REQ = 5,
+    ADV_SCAN_IND = 6,
+    RESERVED0 = 7,
+    RESERVED1 = 8,
+    RESERVED2 = 9,
+    RESERVED3 = 10,
+    RESERVED4 = 11,
+    RESERVED5 = 12,
+    RESERVED6 = 13,
+    RESERVED7 = 14,
+    RESERVED8 = 15
+} ADV_PDU_TYPE;
+
+struct BleRecentEntry {
+    using Key = uint64_t;
+
+    static constexpr Key invalid_key = 0xffffffff;
+
+    uint64_t macAddress;
+    int dbValue;
+    BlePacketData packetData;
+    std::string timestamp;
+    std::string dataString;
+    std::string nameString;
+    bool include_name;
+    uint16_t numHits;
+    ADV_PDU_TYPE pduType;
+    uint8_t channelNumber;
+    bool entryFound;
+
+    BleRecentEntry()
+        : BleRecentEntry{0} {
+    }
+
+    BleRecentEntry(
+        const uint64_t macAddress)
+        : macAddress{macAddress},
+          dbValue{},
+          packetData{},
+          timestamp{},
+          dataString{},
+          nameString{},
+          include_name{},
+          numHits{},
+          pduType{},
+          channelNumber{},
+          entryFound{} {
+    }
+
+    Key key() const {
+        return macAddress;
+    }
+};
+
+using BleRecentEntries = RecentEntries<BleRecentEntry>;
+using BleRecentEntriesView = RecentEntriesView<BleRecentEntries>;
+
+class BleRecentEntryDetailView : public View {
+   public:
+    BleRecentEntryDetailView(NavigationView& nav, const BleRecentEntry& entry);
+
+    void set_entry(const BleRecentEntry& new_entry);
+    const BleRecentEntry& entry() const { return entry_; };
+
+    void update_data();
+    void focus() override;
+    void paint(Painter&) override;
+
+   private:
+    NavigationView& nav_;
+    BleRecentEntry entry_{};
+    BLETxPacket build_packet();
+    void on_save_file(const std::string value, BLETxPacket packetToSave);
+    bool saveFile(const std::filesystem::path& path, BLETxPacket packetToSave);
+    std::string packetFileBuffer{};
+    std::filesystem::path packet_save_path{u"BLERX/Lists/????.csv"};
+
+    static constexpr uint8_t total_data_lines{5};
+
+    Labels label_mac_address{
+        {{0 * 8, 0 * 16}, "Mac Address:", Color::light_grey()}};
+
+    Text text_mac_address{
+        {12 * 8, 0 * 16, 17 * 8, 16},
+        "-"};
+
+    Labels label_pdu_type{
+        {{0 * 8, 1 * 16}, "PDU Type:", Color::light_grey()}};
+
+    Text text_pdu_type{
+        {9 * 8, 1 * 16, 17 * 8, 16},
+        "-"};
+
+    Labels labels{
+        {{0 * 8, 3 * 16}, "Len", Color::light_grey()},
+        {{5 * 8, 3 * 16}, "Type", Color::light_grey()},
+        {{10 * 8, 3 * 16}, "Value", Color::light_grey()},
+    };
+
+    Button button_send{
+        {19, 224, 96, 24},
+        "Send"};
+
+    Button button_done{
+        {125, 224, 96, 24},
+        "Done"};
+
+    Button button_save{
+        {72, 264, 96, 24},
+        "Save"};
+
+    bool send_updates{false};
+
+    Rect draw_field(
+        Painter& painter,
+        const Rect& draw_rect,
+        const Style& style,
+        const std::string& label,
+        const std::string& value);
+};
+
+class BLERxView : public View {
+   public:
+    BLERxView(NavigationView& nav);
+    ~BLERxView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    std::string title() const override { return "BLE RX"; };
+
+   private:
+    std::string build_line_str(BleRecentEntry entry);
+    void on_save_file(const std::string value);
+    bool saveFile(const std::filesystem::path& path);
+    std::unique_ptr<UsbSerialThread> usb_serial_thread{};
+    void on_data(BlePacketData* packetData);
+    void on_filter_change(std::string value);
+    void on_file_changed(const std::filesystem::path& new_file_path);
+    void file_error();
+    void on_timer();
+    void handle_entries_sort(uint8_t index);
+    void updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type);
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{
+        2402000000 /* frequency */,
+        4000000 /* bandwidth */,
+        4000000 /* sampling rate */,
+        ReceiverModel::Mode::WidebandFMAudio};
+
+    uint8_t channel_index{0};
+    uint8_t sort_index{0};
+    std::string filter{};
+    bool logging{false};
+
+    bool name_enable{true};
+    app_settings::SettingsManager settings_{
+        "rx_ble",
+        app_settings::Mode::RX,
+        {
+            {"channel_index"sv, &channel_index},
+            {"sort_index"sv, &sort_index},
+            {"filter"sv, &filter},
+            {"log"sv, &logging},
+            {"name"sv, &name_enable},
+        }};
+
+    std::string str_console = "";
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+    uint8_t channel_number = 37;
+    bool auto_channel = false;
+
+    int16_t timer_count{0};
+    int16_t timer_period{6};  // 100ms
+
+    std::string filterBuffer{};
+    std::string listFileBuffer{};
+    std::string headerStr = "Timestamp, MAC Address, Name, Packet Type, Data, Hits, dB, Channel";
+    uint16_t maxLineLength = 140;
+
+    std::filesystem::path file_path{};
+    uint64_t found_count = 0;
+    uint64_t total_count = 0;
+    std::vector<std::string> searchList{};
+
+    std::filesystem::path find_packet_path{u"BLERX/Find/????.TXT"};
+    std::filesystem::path log_packets_path{u"BLERX/Logs/????.TXT"};
+    std::filesystem::path packet_save_path{u"BLERX/Lists/????.csv"};
+
+    static constexpr auto header_height = 4 * 16;
+    static constexpr auto switch_button_height = 3 * 16;
+
+    OptionsField options_channel{
+        {0 * 8, 0 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39},
+         {"Auto", 40}}};
+
+    RxFrequencyField field_frequency{
+        {6 * 8, 0 * 16},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {16 * 8, 0 * 16}};
+
+    LNAGainField field_lna{
+        {18 * 8, 0 * 16}};
+
+    VGAGainField field_vga{
+        {21 * 8, 0 * 16}};
+
+    RSSI rssi{
+        {24 * 8, 0, 6 * 8, 4}};
+
+    Channel channel{
+        {24 * 8, 5, 6 * 8, 4}};
+
+    Labels label_sort{
+        {{0 * 8, 3 * 8}, "Sort:", Color::light_grey()}};
+
+    OptionsField options_sort{
+        {5 * 8, 3 * 8},
+        4,
+        {{"MAC", 0},
+         {"Hits", 1},
+         {"dB", 2},
+         {"Time", 3},
+         {"Name", 4}}};
+
+    Button button_filter{
+        {11 * 8, 3 * 8, 4 * 8, 16},
+        "Filter"};
+
+    Checkbox check_log{
+        {17 * 8, 3 * 8},
+        3,
+        "Log",
+        true};
+
+    Checkbox check_name{
+        {23 * 8, 3 * 8},
+        3,
+        "Name",
+        true};
+
+    Button button_find{
+        {0 * 8, 6 * 8, 4 * 8, 16},
+        "Find"};
+
+    Labels label_found{
+        {{5 * 8, 6 * 8}, "Found:", Color::light_grey()}};
+
+    Text text_found_count{
+        {11 * 8, 3 * 16, 20 * 8, 16},
+        "0/0"};
+
+    Console console{
+        {0, 4 * 16, 240, 240}};
+
+    Button button_clear_list{
+        {2 * 8, 320 - (16 + 32), 7 * 8, 32},
+        "Clear"};
+
+    Button button_save_list{
+        {11 * 8, 320 - (16 + 32), 11 * 8, 32},
+        "Export CSV"};
+
+    Button button_switch{
+        {240 - 6 * 8, 320 - (16 + 32), 4 * 8, 32},
+        "Tx"};
+
+    std::string str_log{""};
+    std::unique_ptr<BLELogger> logger{};
+
+    BleRecentEntries recent{};
+    BleRecentEntries tempList{};
+
+    const RecentEntriesColumns columns{{
+        {"Mac Address", 17},
+        {"Hits", 7},
+        {"dB", 4},
+    }};
+
+    BleRecentEntriesView recent_entries_view{columns, recent};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::BlePacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const BLEPacketMessage*>(p);
+            this->on_data(message->packet);
+        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/

firmware/application/apps/ble_tx_app.cpp

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

firmware/application/apps/ble_tx_app.hpp

@@ -0,0 +1,337 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLE_TX_APP_H__
+#define __BLE_TX_APP_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_text_editor.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "replay_thread.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+#include "recent_entries.hpp"
+
+#include <string>
+#include <memory>
+
+class BLELoggerTx {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+
+enum PKT_TYPE {
+    PKT_TYPE_INVALID_TYPE,
+    PKT_TYPE_RAW,
+    PKT_TYPE_DISCOVERY,
+    PKT_TYPE_IBEACON,
+    PKT_TYPE_ADV_IND,
+    PKT_TYPE_ADV_DIRECT_IND,
+    PKT_TYPE_ADV_NONCONN_IND,
+    PKT_TYPE_ADV_SCAN_IND,
+    PKT_TYPE_SCAN_REQ,
+    PKT_TYPE_SCAN_RSP,
+    PKT_TYPE_CONNECT_REQ,
+    PKT_TYPE_LL_DATA,
+    PKT_TYPE_LL_CONNECTION_UPDATE_REQ,
+    PKT_TYPE_LL_CHANNEL_MAP_REQ,
+    PKT_TYPE_LL_TERMINATE_IND,
+    PKT_TYPE_LL_ENC_REQ,
+    PKT_TYPE_LL_ENC_RSP,
+    PKT_TYPE_LL_START_ENC_REQ,
+    PKT_TYPE_LL_START_ENC_RSP,
+    PKT_TYPE_LL_UNKNOWN_RSP,
+    PKT_TYPE_LL_FEATURE_REQ,
+    PKT_TYPE_LL_FEATURE_RSP,
+    PKT_TYPE_LL_PAUSE_ENC_REQ,
+    PKT_TYPE_LL_PAUSE_ENC_RSP,
+    PKT_TYPE_LL_VERSION_IND,
+    PKT_TYPE_LL_REJECT_IND,
+    PKT_TYPE_NUM_PKT_TYPE
+};
+
+struct BLETxPacket {
+    char macAddress[13];
+    char advertisementData[63];
+    char packetCount[11];
+    uint32_t packet_count;
+    PKT_TYPE packetType;
+};
+
+class BLETxView : public View {
+   public:
+    BLETxView(NavigationView& nav);
+    BLETxView(NavigationView& nav, BLETxPacket packet);
+    ~BLETxView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    bool is_active() const;
+    void toggle();
+    void start();
+    void stop();
+    void reset();
+    void handle_replay_thread_done(const uint32_t return_code);
+    void file_error();
+    bool saveFile(const std::filesystem::path& path);
+
+    std::string title() const override { return "BLE TX"; };
+
+   private:
+    void on_timer();
+    void on_data(uint32_t value, bool is_data);
+    void on_file_changed(const std::filesystem::path& new_file_path);
+    void on_save_file(const std::string value);
+    void on_tx_progress(const bool done);
+    void on_random_data_change(std::string value);
+    void update_current_packet(BLETxPacket packet, uint32_t currentIndex);
+
+    NavigationView& nav_;
+    TxRadioState radio_state_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */
+    };
+    app_settings::SettingsManager settings_{
+        "tx_ble", app_settings::Mode::TX};
+
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+
+    std::filesystem::path file_path{};
+    std::filesystem::path packet_save_path{u"BLETX/BLETX_????.TXT"};
+    uint8_t channel_number = 37;
+    bool auto_channel = false;
+
+    char randomMac[13] = "010203040506";
+
+    bool is_running = false;
+
+    int16_t timer_count{0};
+    int16_t timer_period{1};
+    int16_t auto_channel_counter = 0;
+    int16_t auto_channel_period{6};
+
+    bool repeatLoop = false;
+    uint32_t packet_counter{0};
+    uint32_t num_packets{0};
+    uint32_t current_packet{0};
+    bool random_mac = false;
+    bool file_override = false;
+
+    typedef struct {
+        uint16_t line;
+        uint16_t col;
+    } CursorPos;
+
+    std::unique_ptr<FileWrapper> dataFileWrapper{};
+    File dataFile{};
+    std::filesystem::path dataTempFilePath{u"BLETX/dataFileTemp.TXT"};
+    std::vector<uint16_t> markedBytes{};
+    CursorPos cursor_pos{};
+    uint8_t marked_counter = 0;
+
+    static constexpr uint8_t mac_address_size_str{12};
+    static constexpr uint8_t max_packet_size_str{62};
+    static constexpr uint8_t max_packet_repeat_str{10};
+    static constexpr uint32_t max_packet_repeat_count{UINT32_MAX};
+    static constexpr uint32_t max_num_packets{32};
+
+    BLETxPacket packets[max_num_packets];
+
+    PKT_TYPE pduType = {PKT_TYPE_DISCOVERY};
+
+    static constexpr auto header_height = 10 * 16;
+    static constexpr auto switch_button_height = 6 * 16;
+
+    Button button_open{
+        {0 * 8, 0 * 16, 10 * 8, 2 * 16},
+        "Open file"};
+
+    Text text_filename{
+        {11 * 8, 0 * 16, 12 * 8, 16},
+        "-"};
+
+    ProgressBar progressbar{
+        {11 * 8, 1 * 16, 9 * 8, 16}};
+
+    Checkbox check_rand_mac{
+        {21 * 8, 1 * 16},
+        6,
+        "?? Mac",
+        true};
+
+    TxFrequencyField field_frequency{
+        {0 * 8, 2 * 16},
+        nav_};
+
+    TransmitterView2 tx_view{
+        {11 * 8, 2 * 16},
+        /*short_ui*/ true};
+
+    Checkbox check_loop{
+        {21 * 8, 2 * 16},
+        4,
+        "Loop",
+        true};
+
+    ImageButton button_play{
+        {28 * 8, 2 * 16, 2 * 8, 1 * 16},
+        &bitmap_play,
+        Color::green(),
+        Color::black()};
+
+    Labels label_speed{
+        {{0 * 8, 6 * 8}, "Speed:", Color::light_grey()}};
+
+    OptionsField options_speed{
+        {7 * 8, 6 * 8},
+        3,
+        {{"1 ", 1},     // 16ms
+         {"2 ", 2},     // 32ms
+         {"3 ", 3},     // 48ms
+         {"4 ", 6},     // 100ms
+         {"5 ", 12}}};  // 200ms
+
+    OptionsField options_channel{
+        {11 * 8, 6 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39},
+         {"Auto", 40}}};
+
+    OptionsField options_adv_type{
+        {17 * 8, 6 * 8},
+        14,
+        {{"DISCOVERY ", PKT_TYPE_DISCOVERY},
+         {"ADV_IND", PKT_TYPE_ADV_IND},
+         {"ADV_DIRECT", PKT_TYPE_ADV_DIRECT_IND},
+         {"ADV_NONCONN", PKT_TYPE_ADV_NONCONN_IND},
+         {"ADV_SCAN_IND", PKT_TYPE_ADV_SCAN_IND},
+         {"SCAN_REQ", PKT_TYPE_SCAN_REQ},
+         {"SCAN_RSP", PKT_TYPE_SCAN_RSP},
+         {"CONNECT_REQ", PKT_TYPE_CONNECT_REQ}}};
+
+    Labels label_marked_data{
+        {{0 * 8, 4 * 16}, "Marked Data:", Color::light_grey()}};
+
+    OptionsField marked_data_sequence{
+        {12 * 8, 8 * 8},
+        8,
+        {{"Ascend", 0},
+         {"Descend", 1},
+         {"Random", 2}}};
+
+    Labels label_packet_index{
+        {{0 * 8, 12 * 8}, "Packet Index:", Color::light_grey()}};
+
+    Text text_packet_index{
+        {13 * 8, 6 * 16, 12 * 8, 16},
+        "-"};
+
+    Labels label_packets_sent{
+        {{0 * 8, 14 * 8}, "Repeat Count:", Color::light_grey()}};
+
+    Text text_packets_sent{
+        {13 * 8, 7 * 16, 12 * 8, 16},
+        "-"};
+
+    Labels label_mac_address{
+        {{0 * 8, 16 * 8}, "Mac Address:", Color::light_grey()}};
+
+    Text text_mac_address{
+        {12 * 8, 8 * 16, 20 * 8, 16},
+        "-"};
+
+    Labels label_data_packet{
+        {{0 * 8, 9 * 16}, "Packet Data:", Color::light_grey()}};
+
+    Console console{
+        {0, 9 * 18, 240, 240}};
+
+    TextViewer dataEditView{
+        {0, 9 * 18, 240, 240}};
+
+    Button button_clear_marked{
+        {1 * 8, 14 * 16, 13 * 8, 3 * 8},
+        "Clear Marked"};
+
+    Button button_save_packet{
+        {1 * 8, 16 * 16, 13 * 8, 2 * 16},
+        "Save Packet"};
+
+    Button button_switch{
+        {16 * 8, 16 * 16, 13 * 8, 2 * 16},
+        "Switch to Rx"};
+
+    std::string str_log{""};
+    bool logging{true};
+    bool logging_done{false};
+    std::string packetFileBuffer{};
+
+    std::unique_ptr<BLELoggerTx> logger{};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::AFSKData,
+        [this](Message* const p) {
+            const auto message = static_cast<const AFSKDataMessage*>(p);
+            this->on_data(message->value, message->is_data);
+        }};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.done);
+        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/

firmware/application/apps/ert_app.cpp

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

firmware/application/apps/ert_app.hpp

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

firmware/application/apps/gps_sim_app.cpp

@@ -74,7 +74,10 @@ void GpsSimAppView::on_file_changed(const fs::path& new_file_path) {
     auto duration = ms_duration(file_size, transmitter_model.sampling_rate(), 2);
     text_duration.set(to_string_time_ms(duration));
 
-    button_play.focus();
+    // TODO: fix in UI framework with 'try_focus()'?
+    // Hack around focus getting called by ctor before parent is set.
+    if (parent())
+        button_play.focus();
 }
 
 void GpsSimAppView::on_tx_progress(const uint32_t progress) {
@@ -173,11 +176,6 @@ GpsSimAppView::GpsSimAppView(
         &waterfall,
     });
 
-    if (!settings_.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&) {

firmware/application/apps/gps_sim_app.hpp

@@ -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};
 

firmware/application/apps/pocsag_app.cpp

@@ -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");
 

firmware/application/apps/pocsag_app.hpp

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

firmware/application/apps/soundboard_app.hpp

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

firmware/application/apps/tpms_app.cpp

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

firmware/application/apps/tpms_app.hpp

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

firmware/application/apps/ui_about_simple.cpp

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

firmware/application/apps/ui_adsb_rx.cpp

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

firmware/application/apps/ui_adsb_rx.hpp

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

firmware/application/apps/ui_adsb_tx.cpp

@@ -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();

firmware/application/apps/ui_adsb_tx.hpp

@@ -203,7 +203,8 @@ class ADSBTxView : public View {
         };*/
 
     TxRadioState radio_state_{
-        10000000 /* bandwidth */,
+        1090000000 /* frequency */,
+        6000000 /* bandwidth */,
         4000000 /* sampling rate */
     };
     app_settings::SettingsManager settings_{

firmware/application/apps/ui_aprs_rx.hpp

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

firmware/application/apps/ui_aprs_tx.hpp

@@ -46,6 +46,7 @@ class APRSTXView : public View {
 
    private:
     TxRadioState radio_state_{
+        144390000 /* frequency */,
         1750000 /* bandwidth */,
         AFSK_TX_SAMPLERATE /* sampling rate */
     };

firmware/application/apps/ui_btle_rx.cpp

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

firmware/application/apps/ui_btle_rx.hpp

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

firmware/application/apps/ui_debug.cpp

@@ -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"
@@ -123,8 +124,8 @@ void TemperatureWidget::paint(Painter& painter) {
 }
 
 TemperatureWidget::temperature_t TemperatureWidget::temperature(const sample_t sensor_value) const {
-    /*It seems to be a temperature difference of 25C*/
-    return -40 + (sensor_value * 4.31) + 25;  // max2837 datasheet temp 25ºC has sensor value: 15
+    // Scaling is different for MAX2837 vs MAX2839 so it's now done in the respective chip-specific module
+    return sensor_value;
 }
 
 std::string TemperatureWidget::temperature_str(const temperature_t temperature) const {
@@ -158,11 +159,8 @@ void TemperatureView::focus() {
 /* RegistersWidget *******************************************************/
 
 RegistersWidget::RegistersWidget(
-    RegistersWidgetConfig&& config,
-    std::function<uint32_t(const size_t register_number)>&& reader)
-    : Widget{},
-      config(std::move(config)),
-      reader(std::move(reader)) {
+    RegistersWidgetConfig&& config)
+    : Widget{}, config(std::move(config)), page_number(0) {
 }
 
 void RegistersWidget::update() {
@@ -179,7 +177,7 @@ void RegistersWidget::paint(Painter& painter) {
 void RegistersWidget::draw_legend(const Coord left, Painter& painter) {
     const auto pos = screen_pos();
 
-    for (size_t i = 0; i < config.registers_count; i += config.registers_per_row()) {
+    for (uint32_t i = 0; i < config.registers_count; i += config.registers_per_row()) {
         const Point offset{
             left, static_cast<int>((i / config.registers_per_row()) * row_height)};
 
@@ -196,12 +194,12 @@ void RegistersWidget::draw_values(
     Painter& painter) {
     const auto pos = screen_pos();
 
-    for (size_t i = 0; i < config.registers_count; i++) {
+    for (uint32_t i = 0; i < config.registers_count; i++) {
         const Point offset = {
             static_cast<int>(left + config.legend_width() + 8 + (i % config.registers_per_row()) * (config.value_width() + 8)),
             static_cast<int>((i / config.registers_per_row()) * row_height)};
 
-        const auto value = reader(i);
+        const auto value = reg_read(i);
 
         const auto text = to_string_hex(value, config.value_length());
         painter.draw_string(
@@ -211,19 +209,61 @@ void RegistersWidget::draw_values(
     }
 }
 
+uint32_t RegistersWidget::reg_read(const uint32_t register_number) {
+    if (register_number < config.registers_count) {
+        switch (config.chip_type) {
+            case CT_PMEM:
+                return portapack::persistent_memory::pmem_data_word((page_number * config.registers_count + register_number) / 4) >> (register_number % 4 * 8);
+            case CT_RFFC5072:
+                return radio::debug::first_if::register_read(register_number);
+            case CT_MAX283X:
+                return radio::debug::second_if::register_read(register_number);
+            case CT_SI5351:
+                return portapack::clock_generator.read_register(register_number);
+            case CT_AUDIO:
+                return audio::debug::reg_read(register_number);
+        }
+    }
+    return 0xFFFF;
+}
+
+void RegistersWidget::reg_write(const uint32_t register_number, const uint32_t value) {
+    if (register_number < config.registers_count) {
+        switch (config.chip_type) {
+            case CT_PMEM:
+                break;
+            case CT_RFFC5072:
+                radio::debug::first_if::register_write(register_number, value);
+                break;
+            case CT_MAX283X:
+                radio::debug::second_if::register_write(register_number, value);
+                break;
+            case CT_SI5351:
+                portapack::clock_generator.write_register(register_number, value);
+                break;
+            case CT_AUDIO:
+                audio::debug::reg_write(register_number, value);
+                break;
+        }
+    }
+}
+
 /* RegistersView *********************************************************/
 
 RegistersView::RegistersView(
     NavigationView& nav,
     const std::string& title,
-    RegistersWidgetConfig&& config,
-    std::function<uint32_t(const size_t register_number)>&& reader)
-    : registers_widget{std::move(config), std::move(reader)} {
+    RegistersWidgetConfig&& config)
+    : registers_widget{std::move(config)} {
     add_children({
         &text_title,
         &registers_widget,
         &button_update,
         &button_done,
+        &labels,
+        &field_write_reg_num,
+        &field_write_data_val,
+        &button_write,
     });
 
     button_update.on_select = [this](Button&) {
@@ -236,6 +276,20 @@ RegistersView::RegistersView(
     text_title.set_parent_rect({(240 - static_cast<int>(title.size()) * 8) / 2, 16,
                                 static_cast<int>(title.size()) * 8, 16});
     text_title.set(title);
+
+    field_write_reg_num.on_change = [this](SymField&) {
+        field_write_data_val.set_value(this->registers_widget.reg_read(field_write_reg_num.to_integer()));
+        field_write_data_val.set_dirty();
+    };
+
+    const auto value = registers_widget.reg_read(0);
+    field_write_data_val.set_value(value);
+
+    button_write.set_style(&Styles::red);
+    button_write.on_select = [this](Button&) {
+        this->registers_widget.reg_write(field_write_reg_num.to_integer(), field_write_data_val.to_integer());
+        this->registers_widget.update();
+    };
 }
 
 void RegistersView::focus() {
@@ -375,18 +429,10 @@ DebugPeripheralsMenuView::DebugPeripheralsMenuView(NavigationView& nav) {
     const char* max283x = hackrf_r9 ? "MAX2839" : "MAX2837";
     const char* si5351x = hackrf_r9 ? "Si5351A" : "Si5351C";
     add_items({
-        {"RFFC5072", ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>(
-                                                                                              "RFFC5072", RegistersWidgetConfig{31, 16},
-                                                                                              [](const size_t register_number) { return radio::debug::first_if::register_read(register_number); }); }},
-        {max283x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, max283x]() { nav.push<RegistersView>(
-                                                                                                    max283x, RegistersWidgetConfig{32, 10},
-                                                                                                    [](const size_t register_number) { return radio::debug::second_if::register_read(register_number); }); }},
-        {si5351x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, si5351x]() { nav.push<RegistersView>(
-                                                                                                    si5351x, RegistersWidgetConfig{96, 8},
-                                                                                                    [](const size_t register_number) { return portapack::clock_generator.read_register(register_number); }); }},
-        {audio::debug::codec_name(), ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>(
-                                                                                                              audio::debug::codec_name(), RegistersWidgetConfig{audio::debug::reg_count(), audio::debug::reg_bits()},
-                                                                                                              [](const size_t register_number) { return audio::debug::reg_read(register_number); }); }},
+        {"RFFC5072", ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>("RFFC5072", RegistersWidgetConfig{CT_RFFC5072, 31, 16}); }},
+        {max283x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, max283x]() { nav.push<RegistersView>(max283x, RegistersWidgetConfig{CT_MAX283X, 32, 10}); }},
+        {si5351x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, si5351x]() { nav.push<RegistersView>(si5351x, RegistersWidgetConfig{CT_SI5351, 96, 8}); }},
+        {audio::debug::codec_name(), ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>(audio::debug::codec_name(), RegistersWidgetConfig{CT_AUDIO, audio::debug::reg_count(), audio::debug::reg_bits()}); }},
     });
     set_max_rows(2);  // allow wider buttons
 }
@@ -400,43 +446,71 @@ 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>(); }},
+        {"Memory Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryDumpView>(); }},
+        {"Memory Usage", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryView>(); }},
         {"Peripherals", ui::Color::dark_cyan(), &bitmap_icon_peripherals, [&nav]() { nav.push<DebugPeripheralsMenuView>(); }},
+        {"Pers. Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugPmemView>(); }},
         //{ "Radio State",	ui::Color::white(),	nullptr,	[&nav](){ nav.push<NotImplementedView>(); } },
         {"SD Card", ui::Color::dark_cyan(), &bitmap_icon_sdcard, [&nav]() { nav.push<SDCardDebugView>(); }},
         {"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
 }
 
+/* DebugMemoryDumpView *********************************************************/
+
+DebugMemoryDumpView::DebugMemoryDumpView(NavigationView& nav) {
+    add_children({
+        &button_dump,
+        &button_read,
+        &button_write,
+        &button_done,
+        &labels,
+        &field_starting_address,
+        &field_byte_count,
+        &field_rw_address,
+        &field_data_value,
+    });
+
+    button_done.on_select = [&nav](Button&) { nav.pop(); };
+
+    button_dump.on_select = [this](Button&) {
+        if (field_byte_count.to_integer() != 0)
+            memory_dump((uint32_t*)field_starting_address.to_integer(), ((uint32_t)field_byte_count.to_integer() + 3) / 4, false);
+    };
+
+    button_read.on_select = [this](Button&) {
+        field_data_value.set_value(*(uint32_t*)field_rw_address.to_integer());
+        field_data_value.set_dirty();
+    };
+
+    button_write.set_style(&Styles::red);
+    button_write.on_select = [this](Button&) {
+        *(uint32_t*)field_rw_address.to_integer() = (uint32_t)field_data_value.to_integer();
+    };
+}
+
+void DebugMemoryDumpView::focus() {
+    button_done.focus();
+}
+
 /* DebugPmemView *********************************************************/
 
-uint32_t pmem_checksum(volatile const uint32_t data[63]) {
-    CRC<32> crc{0x04c11db7, 0xffffffff, 0xffffffff};
-    for (size_t i = 0; i < 63; i++) {
-        const auto word = data[i];
-        crc.process_byte((word >> 0) & 0xff);
-        crc.process_byte((word >> 8) & 0xff);
-        crc.process_byte((word >> 16) & 0xff);
-        crc.process_byte((word >> 24) & 0xff);
-    }
-    return crc.checksum();
-}
-
 DebugPmemView::DebugPmemView(NavigationView& nav)
-    : data{*reinterpret_cast<pmem_data*>(memory::map::backup_ram.base())}, registers_widget(RegistersWidgetConfig{page_size, 8}, std::bind(&DebugPmemView::registers_widget_feed, this, std::placeholders::_1)) {
-    static_assert(sizeof(pmem_data) == memory::map::backup_ram.size());
-
+    : registers_widget(RegistersWidgetConfig{CT_PMEM, page_size, 8}) {
     add_children({&text_page, &registers_widget, &text_checksum, &text_checksum2, &button_ok});
 
     registers_widget.set_parent_rect({0, 32, 240, 192});
 
-    text_checksum.set("Size: " + to_string_dec_uint(portapack::persistent_memory::data_size(), 3) + "  CRC: " + to_string_hex(data.check_value, 8));
-    text_checksum2.set("Calculated CRC: " + to_string_hex(pmem_checksum(data.regfile), 8));
+    text_checksum.set("Size: " + to_string_dec_uint(portapack::persistent_memory::data_size(), 3) + "  CRC: " + to_string_hex(portapack::persistent_memory::pmem_stored_checksum(), 8));
+    text_checksum2.set("Calculated CRC: " + to_string_hex(portapack::persistent_memory::pmem_calculated_checksum(), 8));
 
     button_ok.on_select = [&nav](Button&) {
         nav.pop();
@@ -446,7 +520,7 @@ DebugPmemView::DebugPmemView(NavigationView& nav)
 }
 
 bool DebugPmemView::on_encoder(const EncoderEvent delta) {
-    page = std::max(0l, std::min((int32_t)page_max, page + delta));
+    registers_widget.set_page(std::max(0ul, std::min((uint32_t)page_count - 1, registers_widget.page() + delta)));
 
     update();
 
@@ -458,52 +532,10 @@ void DebugPmemView::focus() {
 }
 
 void DebugPmemView::update() {
-    text_page.set(to_string_hex(page_size * page, 2) + "+");
+    text_page.set(to_string_hex(registers_widget.page() * page_size, 2) + "+");
     registers_widget.update();
 }
 
-uint32_t DebugPmemView::registers_widget_feed(const size_t register_number) {
-    if (page_size * page + register_number >= memory::map::backup_ram.size()) {
-        return 0xff;
-    }
-    return data.regfile[(page_size * page + register_number) / 4] >> (register_number % 4 * 8);
-}
-
-/* DebugFontsView *******************************************************/
-
-uint16_t DebugFontsView::display_font(Painter& painter, uint16_t y_offset, const Style* font_style, std::string_view font_name) {
-    auto char_width{font_style->font.char_width()};
-    auto char_height{font_style->font.line_height()};
-    auto cpl{((screen_width / char_width) - 6) & 0xF8};  // Display a multiple of 8 characters per line
-    uint16_t line_pos{y_offset};
-
-    painter.draw_string({0, y_offset}, *font_style, font_name);
-
-    // Displaying ASCII+extended characters from 0x20 to 0xFF
-    for (uint8_t c = 0; c <= 0xDF; c++) {
-        line_pos = y_offset + ((c / cpl) + 2) * char_height;
-
-        if ((c % cpl) == 0)
-            painter.draw_string({0, line_pos}, *font_style, "Ox" + to_string_hex(c + 0x20, 2));
-
-        painter.draw_char({((c % cpl) + 5) * char_width, line_pos}, *font_style, (char)(c + 0x20));
-    }
-
-    return line_pos + char_height;
-}
-
-void DebugFontsView::paint(Painter& painter) {
-    int16_t line_pos;
-
-    line_pos = display_font(painter, 32, &Styles::white, "Fixed 8x16");
-    display_font(painter, line_pos + 16, &Styles::white_small, "Fixed 5x8");
-}
-
-DebugFontsView::DebugFontsView(NavigationView& nav)
-    : nav_{nav} {
-    set_focusable(true);
-}
-
 /* DebugScreenTest ****************************************************/
 
 DebugScreenTest::DebugScreenTest(NavigationView& nav)

firmware/application/apps/ui_debug.hpp

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

firmware/application/apps/ui_dfu_menu.cpp

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

firmware/application/apps/ui_dfu_menu.hpp

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

firmware/application/apps/ui_encoders.cpp

@@ -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(

firmware/application/apps/ui_encoders.hpp

@@ -185,6 +185,7 @@ class EncodersView : public View {
     };
 
     TxRadioState radio_state_{
+        433920000 /* frequency */,
         1750000 /* bandwidth */,
         OOK_SAMPLERATE /* sampling rate */
     };

firmware/application/apps/ui_fileman.cpp

@@ -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"
@@ -155,7 +156,7 @@ void FileManBaseView::load_directory_contents(const fs::path& dir_path) {
 
     for (const auto& entry : fs::directory_iterator(dir_path, u"*")) {
         // Hide files starting with '.' (hidden / tmp).
-        if (is_hidden_file(entry.path()))
+        if (!show_hidden_files && is_hidden_file(entry.path()))
             continue;
 
         if (fs::is_regular_file(entry.status())) {
@@ -566,6 +567,8 @@ FileManagerView::FileManagerView(
         &button_new_file,
         &button_open_notepad,
         &button_rename_timestamp,
+        &button_open_iq_trim,
+        &button_show_hidden_files,
     });
 
     menu_view.on_highlight = [this]() {
@@ -648,6 +651,20 @@ FileManagerView::FileManagerView(
         } else
             nav_.display_modal("Timestamp Rename", "Can't rename that.");
     };
+
+    button_open_iq_trim.on_select = [this]() {
+        auto path = get_selected_full_path();
+        if (selected_is_valid() && !get_selected_entry().is_directory && is_cxx_capture_file(path)) {
+            nav_.push<IQTrimView>(path);
+        } else
+            nav_.display_modal("IQ Trim", "Not a capture file.");
+    };
+
+    button_show_hidden_files.on_select = [this]() {
+        show_hidden_files = !show_hidden_files;
+        button_show_hidden_files.set_color(show_hidden_files ? Color::green() : Color::dark_grey());
+        reload_current();
+    };
 }
 
 }  // namespace ui

firmware/application/apps/ui_fileman.hpp

@@ -104,6 +104,8 @@ class FileManBaseView : public View {
     std::vector<fileman_entry> entry_list{};
     std::vector<uint32_t> saved_index_stack{};
 
+    bool show_hidden_files{false};
+
     Labels labels{
         {{0, 0}, "Path:", Color::light_grey()}};
 
@@ -272,6 +274,18 @@ 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()};
+
+    NewButton button_show_hidden_files{
+        {13 * 8, 34 * 8, 4 * 8, 32},
+        {},
+        &bitmap_icon_hide,
+        Color::dark_grey()};
 };
 
 } /* namespace ui */

firmware/application/apps/ui_fsk_rx.cpp

@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_fsk_rx.hpp"
+
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "string_format.hpp"
+#include "utility.hpp"
+
+#include "ui_freqman.hpp"
+
+using namespace portapack;
+namespace pmem = portapack::persistent_memory;
+
+void FskRxLogger::log_raw_data(const std::string& data, const uint32_t frequency) {
+    std::string entry = "Raw: F:" + to_string_dec_uint(frequency) + "Hz";
+
+    // // Raw hex dump of all the codewords
+    // for (size_t c = 0; c < 16; c++)
+    //     entry += to_string_hex(packet[c], 8) + " ";
+
+    log_file.write_entry(data + entry);
+}
+
+void FskRxLogger::log_decoded(Timestamp timestamp, const std::string& text) {
+    log_file.write_entry(timestamp, text);
+}
+
+namespace ui {
+//---------------------------------------------------------------------------------------------------------------
+//  Console View
+//---------------------------------------------------------------------------------------------------------------
+FskRxAppConsoleView::FskRxAppConsoleView(NavigationView& nav, Rect parent_rect)
+    : View(parent_rect), nav_{nav} {
+    add_child(&console);
+};
+
+void FskRxAppConsoleView::on_packet(uint32_t value, bool is_data) {
+    if (is_data) {
+        console.write(to_string_dec_uint(value) + " ");
+    }
+}
+
+void FskRxAppConsoleView::on_show() {
+    hidden(false);
+}
+
+void FskRxAppConsoleView::on_hide() {
+    hidden(true);
+}
+
+FskRxAppConsoleView::~FskRxAppConsoleView() {
+}
+
+//---------------------------------------------------------------------------------------------------------------
+//  Spectrum View
+//---------------------------------------------------------------------------------------------------------------
+FskRxAppView::FskRxAppView(NavigationView& nav, Rect parent_rect)
+    : View(parent_rect), nav_{nav} {
+    add_child(&waterfall);
+    hidden(true);
+}
+
+FskRxAppView::~FskRxAppView() {
+}
+
+void FskRxAppView::focus() {
+}
+
+void FskRxAppView::on_show() {
+    hidden(false);
+    waterfall.start();
+}
+
+void FskRxAppView::on_hide() {
+    hidden(true);
+    waterfall.stop();
+}
+
+//---------------------------------------------------------------------------------------------------------------
+//  Base View
+//---------------------------------------------------------------------------------------------------------------
+FskxRxMainView::FskxRxMainView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&tab_view,
+                  &view_data,
+                  &view_stream,
+                  &labels,
+                  &rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_frequency,
+                  &deviation_frequency,
+                  &record_view});
+
+    baseband::run_image(portapack::spi_flash::image_tag_fskrx);
+
+    // DEBUG
+    record_view.on_error = [&nav](std::string message) {
+        nav.display_modal("Error", message);
+    };
+
+    deviation_frequency.on_change = [this](rf::Frequency f) {
+        refresh_ui(f);
+    };
+
+    // Set initial sampling rate
+    /* Bandwidth of 2FSK is 2 * Deviation */
+    record_view.set_sampling_rate(initial_deviation * 2);
+
+    field_frequency.set_value(initial_target_frequency);
+    deviation_frequency.set_value(initial_deviation);
+
+    logger.append(LOG_ROOT_DIR "/FSKRX.TXT");
+
+    baseband::set_fsk(initial_deviation);
+
+    audio::output::start();
+    receiver_model.enable();
+}
+
+void FskxRxMainView::handle_decoded(Timestamp timestamp, const std::string& prefix) {
+    if (logging()) {
+        logger.log_decoded(timestamp, prefix);
+    }
+}
+
+void FskxRxMainView::refresh_ui(rf::Frequency deviationHz) {
+    /* Nyquist would imply a sample rate of 2x bandwidth, but because the ADC
+     * provides 2 values (I,Q), the sample_rate is equal to bandwidth here. */
+    /* Bandwidth of 2FSK is 2 * Deviation */
+    auto sample_rate = deviationHz * 2;
+
+    /* base_rate (bandwidth) is used for FFT calculation and display LCD, and also in recording writing SD Card rate. */
+    /* ex. sampling_rate values, 4Mhz, when recording 500 kHz (BW) and fs 8 Mhz, when selected 1 Mhz BW ... */
+    /* ex. recording 500kHz BW to .C16 file, base_rate clock 500kHz x2(I,Q) x 2 bytes (int signed) =2MB/sec rate SD Card. */
+
+    if (!view_stream.hidden()) {
+        view_stream.waterfall.stop();
+    }
+
+    // record_view determines the correct oversampling to apply and returns the actual sample rate.
+    // NB: record_view is what actually updates proc_capture baseband settings.
+    auto actual_sample_rate = record_view.set_sampling_rate(sample_rate);
+
+    // Update the radio model with the actual sampling rate.
+    receiver_model.set_sampling_rate(actual_sample_rate);
+
+    // Get suitable anti-aliasing BPF bandwidth for MAX2837 given the actual sample rate.
+    auto anti_alias_filter_bandwidth = filter_bandwidth_for_sampling_rate(actual_sample_rate);
+    receiver_model.set_baseband_bandwidth(anti_alias_filter_bandwidth);
+
+    if (!view_stream.hidden()) {
+        view_stream.waterfall.start();
+    }
+}
+
+void FskxRxMainView::focus() {
+    field_frequency.focus();
+}
+
+void FskxRxMainView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+
+    ui::Rect waterfall_rect{0, 0, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    view_stream.waterfall.set_parent_rect(waterfall_rect);
+}
+
+FskxRxMainView::~FskxRxMainView() {
+    audio::output::stop();
+    receiver_model.disable();
+    baseband::shutdown();
+}
+} /* namespace ui */

firmware/application/apps/ui_fsk_rx.hpp

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2018 Furrtek
+ * Copyright (C) 2023 gullradriel, Nilorea Studio Inc.
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_FSK_RX_H__
+#define __UI_FSK_RX_H__
+
+#include "ui_widget.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_receiver.hpp"
+#include "ui_record_view.hpp"
+#include "ui_rssi.hpp"
+#include "ui_spectrum.hpp"
+#include "ui_styles.hpp"
+#include "ui_tabview.hpp"
+
+#include "app_settings.hpp"
+#include "log_file.hpp"
+#include "radio_state.hpp"
+#include "pocsag_app.hpp"
+
+#include <functional>
+
+class FskRxLogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data, const uint32_t frequency);
+    void log_decoded(Timestamp timestamp, const std::string& text);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+class FskRxAppConsoleView : public View {
+   public:
+    FskRxAppConsoleView(NavigationView& nav, Rect parent_rec);
+    ~FskRxAppConsoleView();
+
+    std::string title() const override { return "FSK RX Data"; };
+
+    void on_packet(uint32_t value, bool is_data);
+
+    void on_show() override;
+    void on_hide() override;
+
+   private:
+    NavigationView& nav_;
+
+    Console console{
+        {0, 0, 240, 224}};
+};
+
+class FskRxAppView : public View {
+   public:
+    FskRxAppView(NavigationView& nav, Rect parent_rect);
+    ~FskRxAppView();
+
+    void focus() override;
+    void on_show() override;
+    void on_hide() override;
+
+    spectrum::WaterfallView waterfall{};
+
+    std::string title() const override { return "FSK RX Stream"; };
+
+   private:
+    NavigationView& nav_;
+    RxRadioState radio_state_{};
+};
+
+class FskxRxMainView : public View {
+   public:
+    FskxRxMainView(NavigationView& nav);
+    ~FskxRxMainView();
+
+    void focus() override;
+    void set_parent_rect(const Rect new_parent_rect) override;
+
+    std::string title() const override { return "FSK RX"; };
+
+   private:
+    static constexpr uint32_t initial_target_frequency = 902'075'000;
+    static constexpr ui::Dim header_height = (5 * 16);
+
+    uint32_t initial_deviation{3750};
+
+    bool logging() const { return false; };
+    bool logging_raw() const { return false; };
+
+    NavigationView& nav_;
+    Rect view_rect = {0, header_height, 240, 224};
+
+    FskRxAppView view_stream{nav_, view_rect};
+    FskRxAppConsoleView view_data{nav_, view_rect};
+
+    TabView tab_view{
+        {"Data", Color::yellow(), &view_data},
+        {"Stream", Color::cyan(), &view_stream}};
+
+    void refresh_ui(rf::Frequency f);
+    void on_packet(uint32_t value, bool is_data);
+    void handle_decoded(Timestamp timestamp, const std::string& prefix);
+
+    uint32_t last_address = 0;
+    FskRxLogger logger{};
+    uint16_t packet_count = 0;
+
+    RxFrequencyField field_frequency{
+        {0 * 8, 4 * 8},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {11 * 8, 2 * 16}};
+
+    LNAGainField field_lna{
+        {13 * 8, 2 * 16}};
+
+    VGAGainField field_vga{
+        {16 * 8, 2 * 16}};
+
+    RSSI rssi{
+        {19 * 8 - 4, 35, 6 * 8, 4}};
+
+    Channel channel{
+        {19 * 8 - 4, 40, 6 * 8, 4}};
+
+    Labels labels{
+        {{0 * 8, 3 * 16}, "Deviation:", Color::light_grey()},
+    };
+
+    FrequencyField deviation_frequency{
+        {10 * 8, 3 * 16},
+        {3750, 500000},
+    };
+
+    // DEBUG
+    RecordView record_view{
+        {0 * 8, 4 * 16, 30 * 8, 1 * 16},
+        u"FSKRX_????.C16",
+        u"FSKRX",
+        RecordView::FileType::RawS16,
+        16384,
+        3};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::AFSKData,
+        [this](Message* const p) {
+            const auto message = static_cast<const AFSKDataMessage*>(p);
+            this->view_data.on_packet(message->value, message->is_data);
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__POCSAG_APP_H__*/

firmware/application/apps/ui_iq_trim.cpp

@@ -40,6 +40,7 @@ IQTrimView::IQTrimView(NavigationView& nav)
         &text_samples,
         &text_max,
         &field_cutoff,
+        &field_amplify,
         &button_trim,
     });
 
@@ -47,10 +48,7 @@ IQTrimView::IQTrimView(NavigationView& nav)
         auto open_view = nav_.push<FileLoadView>(".C*");
         open_view->push_dir(u"CAPTURES");
         open_view->on_changed = [this](fs::path path) {
-            path_ = std::move(path);
-            profile_capture();
-            compute_range();
-            refresh_ui();
+            open_file(path);
         };
     };
 
@@ -75,6 +73,11 @@ IQTrimView::IQTrimView(NavigationView& nav)
         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();
@@ -84,6 +87,18 @@ IQTrimView::IQTrimView(NavigationView& nav)
     };
 }
 
+IQTrimView::IQTrimView(NavigationView& nav, const fs::path& path)
+    : IQTrimView(nav) {
+    open_file(path);
+}
+
+void IQTrimView::open_file(const std::filesystem::path& path) {
+    path_ = std::move(path);
+    profile_capture();
+    compute_range();
+    refresh_ui();
+}
+
 void IQTrimView::paint(Painter& painter) {
     if (info_) {
         uint32_t power_cutoff = field_cutoff.value() * static_cast<uint64_t>(info_->max_power) / 100;
@@ -124,7 +139,18 @@ void IQTrimView::focus() {
 void IQTrimView::refresh_ui() {
     field_path.set_text(path_.filename().string());
     text_samples.set(to_string_dec_uint(info_->sample_count));
-    text_max.set(to_string_dec_uint(info_->max_power));
+
+    // 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();
 }
 
@@ -182,7 +208,7 @@ bool IQTrimView::trim_capture() {
     }
 
     progress_ui.show_trimming();
-    trimmed = iq::trim_capture_with_range(path_, trim_range, progress_ui.get_callback());
+    trimmed = iq::trim_capture_with_range(path_, trim_range, progress_ui.get_callback(), field_amplify.value());
     progress_ui.clear();
 
     if (!trimmed)

firmware/application/apps/ui_iq_trim.hpp

@@ -68,12 +68,15 @@ 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();
 
@@ -104,6 +107,8 @@ class IQTrimView : public View {
         {{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{
@@ -132,7 +137,7 @@ class IQTrimView : public View {
         "0"};
 
     Text text_max{
-        {9 * 8, 9 * 16, 10 * 8, 1 * 16},
+        {9 * 8, 9 * 16, 20 * 8, 1 * 16},
         "0"};
 
     NumberField field_cutoff{
@@ -142,6 +147,13 @@ class IQTrimView : public View {
         1,
         ' '};
 
+    NumberField field_amplify{
+        {9 * 8, 12 * 16},
+        1,
+        {1, 9},
+        1,
+        ' '};
+
     Button button_trim{
         {20 * 8, 16 * 16, 8 * 8, 2 * 16},
         "Trim"};

firmware/application/apps/ui_keyfob.cpp

@@ -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) {

firmware/application/apps/ui_keyfob.hpp

@@ -44,6 +44,7 @@ class KeyfobView : public View {
     NavigationView& nav_;
 
     TxRadioState radio_state_{
+        433920000 /* frequency */,
         1750000 /* bandwidth */,
         OOK_SAMPLERATE /* sampling rate */
     };

firmware/application/apps/ui_level.cpp

@@ -142,31 +142,24 @@ LevelView::LevelView(NavigationView& nav)
 }
 
 void LevelView::on_statistics_update(const ChannelStatistics& statistics) {
-    static int last_max_db = -1000;
-    static int last_min_rssi = -1000;
-    static int last_avg_rssi = -1000;
-    static int last_max_rssi = -1000;
+    static int16_t last_max_db = -1000;
+    static int16_t last_min_rssi = -1000;
+    static int16_t last_avg_rssi = -1000;
+    static int16_t last_max_rssi = -1000;
 
     rssi_graph.add_values(rssi.get_min(), rssi.get_avg(), rssi.get_max(), statistics.max_db);
 
-    bool refresh_db = false;
-    bool refresh_rssi = false;
-
+    // refresh db
     if (last_max_db != statistics.max_db) {
-        refresh_db = true;
-    }
-    if (last_min_rssi != rssi.get_min() || last_avg_rssi != rssi.get_avg() || last_max_rssi != rssi.get_max()) {
-        refresh_rssi = true;
-    }
-    if (refresh_db) {
         last_max_db = statistics.max_db;
         freq_stats_db.set("Power: " + to_string_dec_int(statistics.max_db) + " db");
     }
-    if (refresh_rssi) {
-        last_min_rssi = rssi.get_min();
-        last_avg_rssi = rssi.get_avg();
-        last_max_rssi = rssi.get_max();
-        freq_stats_rssi.set("RSSI: " + to_string_dec_int(rssi.get_min()) + "/" + to_string_dec_int(rssi.get_avg()) + "/" + to_string_dec_int(rssi.get_max()) + ",dt: " + to_string_dec_int(rssi.get_delta()));
+    // refresh rssi
+    if (last_min_rssi != rssi_graph.get_graph_min() || last_avg_rssi != rssi_graph.get_graph_avg() || last_max_rssi != rssi_graph.get_graph_max()) {
+        last_min_rssi = rssi_graph.get_graph_min();
+        last_avg_rssi = rssi_graph.get_graph_avg();
+        last_max_rssi = rssi_graph.get_graph_max();
+        freq_stats_rssi.set("RSSI: " + to_string_dec_int(last_min_rssi) + "/" + to_string_dec_int(last_avg_rssi) + "/" + to_string_dec_int(last_max_rssi) + ",dt: " + to_string_dec_int(rssi_graph.get_graph_delta()));
     }
 } /* on_statistic_updates */
 

firmware/application/apps/ui_mictx.cpp

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

firmware/application/apps/ui_mictx.hpp

@@ -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) {

firmware/application/apps/ui_morse.cpp

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

firmware/application/apps/ui_morse.hpp

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

firmware/application/apps/ui_numbers.hpp

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

firmware/application/apps/ui_nuoptix.hpp

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

firmware/application/apps/ui_playlist.cpp

@@ -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.

firmware/application/apps/ui_playlist.hpp

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

firmware/application/apps/ui_pocsag_tx.cpp

@@ -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;

firmware/application/apps/ui_pocsag_tx.hpp

@@ -60,6 +60,7 @@ class POCSAGTXView : public View {
     NavigationView& nav_;
 
     TxRadioState radio_state_{
+        466175000 /* frequency */,
         1750000 /* bandwidth */,
         2280000 /* sampling rate */
     };

firmware/application/apps/ui_rds.hpp

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

firmware/application/apps/ui_recon.cpp

@@ -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);
 }
 
@@ -483,10 +481,9 @@ ReconView::ReconView(NavigationView& nav)
 
     button_remove.on_select = [this](ButtonWithEncoder&) {
         handle_remove_current_item();
-
-        // TODO: refresh UI.
         timer = 0;
         freq_lock = 0;
+        recon_redraw();
     };
 
     button_remove.on_change = [this]() {
@@ -496,6 +493,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();
@@ -539,7 +537,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;
@@ -568,7 +566,7 @@ ReconView::ReconView(NavigationView& nav)
     };
 
     button_restart.on_select = [this](Button&) {
-        frequency_file_load(true);
+        frequency_file_load();
         if (frequency_list.size() > 0) {
             if (fwd) {
                 button_dir.set_text("FW>");
@@ -608,25 +606,30 @@ ReconView::ReconView(NavigationView& nav)
             scanner_mode = false;
             button_scanner_mode.set_style(&Styles::blue);
             button_scanner_mode.set_text("RECON");
-            button_remove.set_text("DELETE");
+            button_remove.set_text("REMOVE");
         } else {
             scanner_mode = true;
             button_scanner_mode.set_style(&Styles::red);
             button_scanner_mode.set_text("SCAN");
-            button_scanner_mode.set_text("REMOVE");
+            button_remove.set_text("DELETE");
         }
-        frequency_file_load(true);
+        frequency_file_load();
         if (autostart) {
             recon_resume();
         } else {
             recon_pause();
         }
+        button_add.hidden(scanner_mode);
+        if (scanner_mode)  // only needed when hiding, UI mayhem
+            set_dirty();
     };
 
     button_config.on_select = [this, &nav](Button&) {
         if (is_recording)  // disabling config while recording
             return;
+
         clear_freqlist_for_ui_action();
+
         freq_lock = 0;
         timer = 0;
         auto open_view = nav.push<ReconSetupView>(input_file, output_file);
@@ -638,7 +641,7 @@ ReconView::ReconView(NavigationView& nav)
             load_persisted_settings();
             ui_settings.save();
 
-            frequency_file_load(false);
+            frequency_file_load();
             freqlist_cleared_for_ui_action = false;
 
             if (autostart) {
@@ -705,7 +708,7 @@ ReconView::ReconView(NavigationView& nav)
         delete_file(freq_file_path);
     }
 
-    frequency_file_load(false); /* do not stop all at start */
+    frequency_file_load(); /* do not stop all at start */
     if (autostart) {
         recon_resume();
     } else {
@@ -714,7 +717,7 @@ ReconView::ReconView(NavigationView& nav)
     recon_redraw();
 }
 
-void ReconView::frequency_file_load(bool) {
+void ReconView::frequency_file_load() {
     if (field_mode.selected_index_value() != SPEC_MODULATION)
         audio::output::stop();
 
@@ -733,30 +736,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();
@@ -781,25 +776,14 @@ 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
     if (freqlist_cleared_for_ui_action) {
         if (!manual_mode) {
-            frequency_file_load(false);
+            frequency_file_load();
         }
         if (autostart && !user_pause) {
             recon_resume();
@@ -813,7 +797,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
         {
@@ -1214,14 +1198,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.
@@ -1232,6 +1208,18 @@ void ReconView::handle_remove_current_item() {
 
         freq_db.delete_entry(entry);
     }
+
+    // Clip
+    if (frequency_list.size() > 0) {
+        current_index = clip<int32_t>(current_index, 0u, frequency_list.size() - 1);
+        text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
+        entry = current_entry();
+        freq = entry.frequency_a;
+    } else {
+        current_index = 0;
+        text_cycle.set_text(" ");
+    }
+    update_description();
 }
 
 } /* namespace ui */

firmware/application/apps/ui_recon.hpp

@@ -81,7 +81,7 @@ class ReconView : public View {
     void show_max(bool refresh_display = false);
     void recon_pause();
     void recon_resume();
-    void frequency_file_load(bool stop_all_before = false);
+    void frequency_file_load();
     void on_statistics_update(const ChannelStatistics& statistics);
     void on_index_delta(int32_t v);
     void on_stepper_delta(int32_t v);
@@ -154,8 +154,8 @@ class ReconView : public View {
     uint16_t last_nb_match{999};
     uint16_t last_freq_lock{999};
     size_t last_list_size{0};
-    int8_t last_rssi_min{-127};
-    int8_t last_rssi_med{-127};
+    int8_t last_rssi_min{127};
+    int8_t last_rssi_med{0};
     int8_t last_rssi_max{-127};
     int32_t last_index{-1};
     int64_t last_freq{0};
@@ -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,
         ' ',
     };

firmware/application/apps/ui_recon_settings.cpp

@@ -39,10 +39,10 @@ namespace ui {
 ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, std::string input_file, std::string output_file)
     : View(parent_rect), _input_file{input_file}, _output_file{output_file} {
     hidden(true);
-    add_children({&button_load_freqs,
+    add_children({&button_input_file,
                   &text_input_file,
-                  &button_save_freqs,
-                  &button_output_file,
+                  &button_choose_output_file,
+                  &button_choose_output_name,
                   &checkbox_autosave_freqs,
                   &checkbox_autostart_recon,
                   &checkbox_clear_output});
@@ -52,9 +52,9 @@ ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, st
     checkbox_clear_output.set_value(persistent_memory::recon_clear_output());
 
     text_input_file.set(_input_file);
-    button_output_file.set_text(_output_file);
+    button_choose_output_name.set_text(_output_file);
 
-    button_load_freqs.on_select = [this, &nav](Button&) {
+    button_input_file.on_select = [this, &nav](Button&) {
         auto open_view = nav.push<FileLoadView>(".TXT");
         open_view->push_dir(freqman_dir);
         open_view->on_changed = [this, &nav](std::filesystem::path new_file_path) {
@@ -67,25 +67,24 @@ ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, st
         };
     };
 
-    button_save_freqs.on_select = [this, &nav](Button&) {
+    button_choose_output_file.on_select = [this, &nav](Button&) {
         auto open_view = nav.push<FileLoadView>(".TXT");
         open_view->push_dir(freqman_dir);
         open_view->on_changed = [this, &nav](std::filesystem::path new_file_path) {
             if (new_file_path.native().find(freqman_dir.native()) == 0) {
                 _output_file = new_file_path.stem().string();
-                button_output_file.set_text(_output_file);
+                button_choose_output_name.set_text(_output_file);
             } else {
-                nav.display_modal("LOAD ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
+                nav.display_modal("SAVE ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
             }
         };
     };
 
-    button_output_file.on_select = [this, &nav](Button&) {
-        text_prompt(nav, _output_file, 28,
-                    [this](std::string& buffer) {
-                        _output_file = std::move(buffer);
-                        button_output_file.set_text(_output_file);
-                    });
+    button_choose_output_name.on_select = [this, &nav](Button&) {
+        text_prompt(nav, _output_file, 28, [this](std::string& buffer) {
+            _output_file = buffer;
+            button_choose_output_name.set_text(_output_file);
+        });
     };
 };
 
@@ -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)

firmware/application/apps/ui_recon_settings.hpp

@@ -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"};
 

firmware/application/apps/ui_search.hpp

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

firmware/application/apps/ui_settings.cpp

@@ -343,31 +343,35 @@ void SetUIView::focus() {
     button_save.focus();
 }
 
-/* SetAppSettingsView ************************************/
+/* SetSDCardView *********************************************/
 
-SetAppSettingsView::SetAppSettingsView(NavigationView& nav) {
-    add_children({
-        &labels,
-        &checkbox_load_app_settings,
-        &checkbox_save_app_settings,
-        &button_save,
-        &button_cancel,
-    });
+SetSDCardView::SetSDCardView(NavigationView& nav) {
+    add_children({&labels,
+                  &checkbox_sdcard_speed,
+                  &button_test_sdcard_high_speed,
+                  &text_sdcard_test_status,
+                  &button_save,
+                  &button_cancel});
 
-    checkbox_load_app_settings.set_value(pmem::load_app_settings());
-    checkbox_save_app_settings.set_value(pmem::save_app_settings());
+    checkbox_sdcard_speed.set_value(pmem::config_sdcard_high_speed_io());
+
+    button_test_sdcard_high_speed.on_select = [&nav, this](Button&) {
+        pmem::set_config_sdcard_high_speed_io(true, false);
+        text_sdcard_test_status.set("!! HIGH SPEED MODE ON !!");
+    };
 
     button_save.on_select = [&nav, this](Button&) {
-        pmem::set_load_app_settings(checkbox_load_app_settings.value());
-        pmem::set_save_app_settings(checkbox_save_app_settings.value());
+        pmem::set_config_sdcard_high_speed_io(checkbox_sdcard_speed.value(), true);
+        send_system_refresh();
         nav.pop();
     };
+
     button_cancel.on_select = [&nav, this](Button&) {
         nav.pop();
     };
 }
 
-void SetAppSettingsView::focus() {
+void SetSDCardView::focus() {
     button_save.focus();
 }
 
@@ -455,7 +459,7 @@ SetFrequencyCorrectionView::SetFrequencyCorrectionView(NavigationView& nav) {
         pmem::set_freq_rx_correction_updown(v);
     };
 
-    opt_tx_correction_mode.set_by_value(pmem::config_freq_rx_correction_updown());
+    opt_tx_correction_mode.set_by_value(pmem::config_freq_tx_correction_updown());
     opt_tx_correction_mode.on_change = [this](size_t, OptionsField::value_t v) {
         pmem::set_freq_tx_correction_updown(v);
     };
@@ -654,7 +658,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>(); }},
@@ -665,6 +668,7 @@ SettingsMenuView::SettingsMenuView(NavigationView& nav) {
         {"QR Code", ui::Color::dark_cyan(), &bitmap_icon_qr_code, [&nav]() { nav.push<SetQRCodeView>(); }},
         {"Radio", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [&nav]() { nav.push<SetRadioView>(); }},
         {"User Interface", ui::Color::dark_cyan(), &bitmap_icon_options_ui, [&nav]() { nav.push<SetUIView>(); }},
+        {"SD Card", ui::Color::dark_cyan(), &bitmap_icon_sdcard, [&nav]() { nav.push<SetSDCardView>(); }},
     });
     set_max_rows(2);  // allow wider buttons
 }

firmware/application/apps/ui_settings.hpp

@@ -306,34 +306,35 @@ class SetUIView : public View {
 
     Button button_cancel{
         {16 * 8, 16 * 16, 12 * 8, 32},
-        "Cancel",
-    };
+        "Cancel"};
 };
 
-class SetAppSettingsView : public View {
+class SetSDCardView : public View {
    public:
-    SetAppSettingsView(NavigationView& nav);
+    SetSDCardView(NavigationView& nav);
 
     void focus() override;
-    std::string title() const override { return "App Settings"; };
+
+    std::string title() const override { return "SD Card"; };
 
    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()},
-    };
+        // 01234567890123456789012345678
+        {{1 * 8, 120 - 48}, "    HIGH SPEED SDCARD IO     ", Color::light_grey()},
+        {{1 * 8, 120 - 32}, "   May or may not work !!    ", Color::light_grey()}};
 
-    Checkbox checkbox_load_app_settings{
-        {3 * 8, 6 * 16},
-        25,
-        "Load radio settings"};
+    Checkbox checkbox_sdcard_speed{
+        {2 * 8, 120},
+        20,
+        "enable high speed IO"};
 
-    Checkbox checkbox_save_app_settings{
-        {3 * 8, 8 * 16},
-        25,
-        "Save radio settings"};
+    Button button_test_sdcard_high_speed{
+        {2 * 8, 152, 27 * 8, 32},
+        "TEST BUTTON (NO PMEM SAVE)"};
+
+    Text text_sdcard_test_status{
+        {2 * 8, 198, 28 * 8, 16},
+        ""};
 
     Button button_save{
         {2 * 8, 16 * 16, 12 * 8, 32},
@@ -341,8 +342,7 @@ class SetAppSettingsView : public View {
 
     Button button_cancel{
         {16 * 8, 16 * 16, 12 * 8, 32},
-        "Cancel",
-    };
+        "Cancel"};
 };
 
 class SetConverterSettingsView : public View {

firmware/application/apps/ui_siggen.cpp

@@ -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]);

firmware/application/apps/ui_siggen.hpp

@@ -51,21 +51,23 @@ class SigGenView : public View {
     void on_tx_progress(const uint32_t progress, const bool done);
 
     TxRadioState radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         1536000 /* sampling rate */
     };
     app_settings::SettingsManager settings_{
         "tx_siggen", app_settings::Mode::TX};
 
-    const std::string shape_strings[7] = {
-        "CW-just carrier",
-        "Sine signal    ",
-        "Triangle signal",
-        "Saw up signal  ",
-        "Saw down signal",
-        "Square signal  ",
-        "Noise signal   "  // using 16 bits LFSR register, 16 order polynomial feedback.
-    };
+    const std::string shape_strings[9] = {
+        "CW  (No mod.) ",
+        "Sine mod. FM",
+        "Triangle mod.FM",  // max 15 character text space.
+        "Saw up mod. FM",
+        "Saw down mod.FM",
+        "Square mod. FM",
+        "Pseudo Noise FM",  // using 16 bits LFSR register, 16 order polynomial feedback.
+        "BPSK 0,1,0,1...",
+        "QPSK 00-01-10.."};
 
     bool auto_update{false};
 
@@ -85,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{

firmware/application/apps/ui_sonde.cpp

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

firmware/application/apps/ui_sonde.hpp

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

firmware/application/apps/ui_spectrum_painter.cpp

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

firmware/application/apps/ui_sstvtx.cpp

@@ -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(

firmware/application/apps/ui_subghzd.cpp

@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 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_subghzd.hpp"
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+namespace ui {
+
+void SubGhzDRecentEntryDetailView::update_data() {
+    // set text elements
+    text_type.set(SubGhzDView::getSensorTypeName((FPROTO_SUBGHZD_SENSOR)entry_.sensorType));
+    text_id.set("0x" + to_string_hex(entry_.serial));
+    if (entry_.bits > 0) console.writeln("Bits: " + to_string_dec_uint(entry_.bits));
+    if (entry_.btn != SD_NO_BTN) console.writeln("Btn: " + to_string_dec_uint(entry_.btn));
+    if (entry_.cnt != SD_NO_CNT) console.writeln("Cnt: " + to_string_dec_uint(entry_.cnt));
+
+    if (entry_.data != 0) console.writeln("Data: " + to_string_hex(entry_.data));
+}
+
+SubGhzDRecentEntryDetailView::SubGhzDRecentEntryDetailView(NavigationView& nav, const SubGhzDRecentEntry& entry)
+    : nav_{nav},
+      entry_{entry} {
+    add_children({&button_done,
+                  &text_type,
+                  &text_id,
+                  &console,
+                  &labels});
+
+    button_done.on_select = [&nav](const ui::Button&) {
+        nav.pop();
+    };
+    update_data();
+}
+
+void SubGhzDRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+void SubGhzDView::focus() {
+    field_frequency.focus();
+}
+
+SubGhzDView::SubGhzDView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&rssi,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_frequency,
+                  &button_clear_list,
+                  &recent_entries_view});
+
+    baseband::run_image(portapack::spi_flash::image_tag_subghzd);
+
+    button_clear_list.on_select = [this](Button&) {
+        recent.clear();
+        recent_entries_view.set_dirty();
+    };
+    field_frequency.set_step(100000);
+
+    const Rect content_rect{0, header_height, screen_width, screen_height - header_height};
+    recent_entries_view.set_parent_rect(content_rect);
+    recent_entries_view.on_select = [this](const SubGhzDRecentEntry& entry) {
+        nav_.push<SubGhzDRecentEntryDetailView>(entry);
+    };
+    baseband::set_subghzd_config(0, receiver_model.sampling_rate());  // 0=am
+    receiver_model.enable();
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        on_tick_second();
+    };
+}
+
+void SubGhzDView::on_tick_second() {
+    for (auto& entry : recent) {
+        entry.inc_age(1);
+    }
+    recent_entries_view.set_dirty();
+}
+
+void SubGhzDView::on_data(const SubGhzDDataMessage* data) {
+    SubGhzDRecentEntry key{data->sensorType, data->serial, data->bits, data->data, data->btn, data->cnt};
+    auto matching_recent = find(recent, key.key());
+    if (matching_recent != std::end(recent)) {
+        // Found within. Move to front of list, increment counter.
+        (*matching_recent).reset_age();
+        recent.push_front(*matching_recent);
+        recent.erase(matching_recent);
+    } else {
+        recent.emplace_front(key);
+        truncate_entries(recent, 64);
+    }
+    recent_entries_view.set_dirty();
+}
+
+SubGhzDView::~SubGhzDView() {
+    rtc_time::signal_tick_second -= signal_token_tick_second;
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+const char* SubGhzDView::getSensorTypeName(FPROTO_SUBGHZD_SENSOR type) {
+    switch (type) {
+        case FPS_PRINCETON:
+            return "Princeton";
+        case FPS_BETT:
+            return "Bett";
+        case FPS_CAME:
+            return "Came";
+        case FPS_PRASTEL:
+            return "Prastel";
+        case FPS_AIRFORCE:
+            return "Airforce";
+        case FPS_CAMEATOMO:
+            return "Came Atomo";
+        case FPS_CAMETWEE:
+            return "Came Twee";
+        case FPS_CHAMBCODE:
+            return "Chamb Code";
+        case FPS_CLEMSA:
+            return "Clemsa";
+        case FPS_DOITRAND:
+            return "Doitrand";
+        case FPS_DOOYA:
+            return "Dooya";
+        case FPS_FAAC:
+            return "Faac";
+        case FPS_GATETX:
+            return "Gate TX";
+        case FPS_HOLTEK:
+            return "Holtek";
+        case FPS_HOLTEKHT12X:
+            return "Holtek HT12X";
+        case FPS_HONEYWELL:
+            return "Honeywell";
+        case FPS_HONEYWELLWDB:
+            return "Honeywell Wdb";
+        case FPS_HORMANN:
+            return "Hormann";
+        case FPS_IDO:
+            return "Ido 11x";
+        case FPS_INTERTECHNOV3:
+            return "InterTehcno v3";
+        case FPS_KEELOQ:
+            return "KeeLoq";
+        case FPS_KINGGATESSTYLO4K:
+            return "Kinggate Stylo4K";
+        case FPS_LINEAR:
+            return "Linear";
+        case FPS_LINEARDELTA3:
+            return "Linear Delta3";
+        case FPS_MAGELLAN:
+            return "Magellan";
+        case FPS_MARANTEC:
+            return "Marantec";
+        case FPS_MASTERCODE:
+            return "Mastercode";
+        case FPS_MEGACODE:
+            return "Megacode";
+        case FPS_NERORADIO:
+            return "Nero Radio";
+        case FPS_NERO_SKETCH:
+            return "Nero Sketch";
+        case FPS_NICEFLO:
+            return "Nice Flo";
+        case FPS_NICEFLORS:
+            return "Nice Flor S";
+        case FPS_PHOENIXV2:
+            return "Phoenix V2";
+        case FPS_POWERSMART:
+            return "PowerSmart";
+        case FPS_SECPLUSV1:
+            return "SecPlus V1";
+        case FPS_SECPLUSV2:
+            return "SecPlus V2";
+        case FPS_SMC5326:
+            return "SMC5326";
+        case FPS_STARLINE:
+            return "Star Line";
+        case FPS_X10:
+            return "X10";
+        case FPS_Invalid:
+        default:
+            return "Unknown";
+    }
+}
+
+std::string SubGhzDView::pad_string_with_spaces(int snakes) {
+    std::string paddedStr(snakes, ' ');
+    return paddedStr;
+}
+
+template <>
+void RecentEntriesTable<ui::SubGhzDRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line{};
+    line.reserve(30);
+
+    line = SubGhzDView::getSensorTypeName((FPROTO_SUBGHZD_SENSOR)entry.sensorType);
+    line = line + " " + to_string_hex(entry.serial);
+    if (line.length() < 19) {
+        line += SubGhzDView::pad_string_with_spaces(19 - line.length());
+    } else {
+        line = truncate(line, 19);
+    }
+    std::string ageStr = to_string_dec_uint(entry.age);
+    std::string bitsStr = to_string_dec_uint(entry.bits);
+    line += SubGhzDView::pad_string_with_spaces(5 - bitsStr.length()) + bitsStr;
+    line += SubGhzDView::pad_string_with_spaces(4 - ageStr.length()) + ageStr;
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+}  // namespace ui

firmware/application/apps/ui_subghzd.hpp

@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_SUBGHZD_H__
+#define __UI_SUBGHZD_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "utility.hpp"
+#include "recent_entries.hpp"
+
+#include "../baseband/fprotos/subghztypes.hpp"
+
+using namespace ui;
+
+namespace ui {
+
+struct SubGhzDRecentEntry {
+    using Key = uint64_t;
+    static constexpr Key invalid_key = 0x0fffffff;
+    uint8_t sensorType = FPS_Invalid;
+    uint8_t btn = SD_NO_BTN;
+    uint32_t serial = SD_NO_SERIAL;
+    uint16_t bits = 0;
+    uint16_t age = 0;  // updated on each seconds, show how long the signal was last seen
+    uint32_t cnt = SD_NO_CNT;
+    uint64_t data = 0;
+    SubGhzDRecentEntry() {}
+    SubGhzDRecentEntry(
+        uint8_t sensorType,
+        uint32_t serial,
+        uint16_t bits = 0,
+        uint64_t data = 0,
+        uint8_t btn = SD_NO_BTN,
+        uint32_t cnt = SD_NO_CNT)
+        : sensorType{sensorType},
+          btn{btn},
+          serial{serial},
+          bits{bits},
+          cnt{cnt},
+          data{data} {
+    }
+    Key key() const {
+        return (data ^ ((static_cast<uint64_t>(serial) << 32) | (static_cast<uint64_t>(sensorType) & 0xFF) << 0));
+    }
+    void inc_age(int delta) {
+        if (UINT16_MAX - delta > age) age += delta;
+    }
+    void reset_age() {
+        age = 0;
+    }
+};
+using SubGhzDRecentEntries = RecentEntries<SubGhzDRecentEntry>;
+using SubGhzDRecentEntriesView = RecentEntriesView<SubGhzDRecentEntries>;
+
+class SubGhzDView : public View {
+   public:
+    SubGhzDView(NavigationView& nav);
+    ~SubGhzDView();
+
+    void focus() override;
+
+    std::string title() const override { return "SubGhzD"; };
+    static const char* getSensorTypeName(FPROTO_SUBGHZD_SENSOR type);
+    static std::string pad_string_with_spaces(int snakes);
+
+   private:
+    void on_tick_second();
+    void on_data(const SubGhzDDataMessage* data);
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{
+        433'920'000 /* frequency */,
+        1'750'000 /* bandwidth */,
+        4'000'000 /* sampling rate */,
+        ReceiverModel::Mode::AMAudio};
+    app_settings::SettingsManager settings_{
+        "rx_subghzd",
+        app_settings::Mode::RX,
+        {}};
+
+    SubGhzDRecentEntries recent{};
+
+    RFAmpField field_rf_amp{
+        {13 * 8, 0 * 16}};
+    LNAGainField field_lna{
+        {15 * 8, 0 * 16}};
+    VGAGainField field_vga{
+        {18 * 8, 0 * 16}};
+    RSSI rssi{
+        {21 * 8, 0, 6 * 8, 4}};
+    RxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+
+    SignalToken signal_token_tick_second{};
+
+    Button button_clear_list{
+        {0, 16, 7 * 8, 32},
+        "Clear"};
+
+    static constexpr auto header_height = 3 * 16;
+
+    const RecentEntriesColumns columns{{
+        {"Type", 19},
+        {"Bits", 4},
+        {"Age", 3},
+    }};
+    SubGhzDRecentEntriesView recent_entries_view{columns, recent};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::SubGhzDData,
+        [this](Message* const p) {
+            const auto message = static_cast<const SubGhzDDataMessage*>(p);
+            this->on_data(message);
+        }};
+};
+
+class SubGhzDRecentEntryDetailView : public View {
+   public:
+    SubGhzDRecentEntryDetailView(NavigationView& nav, const SubGhzDRecentEntry& entry);
+
+    void update_data();
+    void focus() override;
+
+   private:
+    NavigationView& nav_;
+    SubGhzDRecentEntry entry_{};
+    Text text_type{{0 * 8, 1 * 16, 15 * 8, 16}, "?"};
+    Text text_id{{6 * 8, 2 * 16, 10 * 8, 16}, "?"};
+
+    Console console{
+        {0, 4 * 16, 240, screen_height - (4 * 16) - 36}};
+
+    Labels labels{
+        {{0 * 8, 0 * 16}, "Type:", Color::light_grey()},
+        {{0 * 8, 2 * 16}, "Serial: ", Color::light_grey()},
+        {{0 * 8, 3 * 16}, "Data:", Color::light_grey()},
+    };
+
+    Button button_done{
+        {screen_width - 96 - 4, screen_height - 32 - 12, 96, 32},
+        "Done"};
+};
+
+}  // namespace ui
+
+#endif /*__UI_SUBGHZD_H__*/

firmware/application/apps/ui_test.hpp

@@ -62,6 +62,7 @@ class TestView : public View {
    private:
     NavigationView& nav_;
     RxRadioState radio_state_{
+        0 /* frequency */,
         1750000 /* bandwidth */,
         2457600 * 2 /* sampling rate */
     };

firmware/application/apps/ui_text_editor.cpp

@@ -72,6 +72,11 @@ void TextViewer::paint(Painter& painter) {
         paint_state_.redraw_text = false;
     }
 
+    if (paint_state_.redraw_marked) {
+        paint_marked(painter);
+        paint_state_.redraw_marked = false;
+    }
+
     paint_cursor(painter);
 }
 
@@ -118,8 +123,9 @@ bool TextViewer::on_encoder(EncoderEvent delta) {
     return updated;
 }
 
-void TextViewer::redraw(bool redraw_text) {
+void TextViewer::redraw(bool redraw_text, bool redraw_marked) {
     paint_state_.redraw_text = redraw_text;
+    paint_state_.redraw_marked = redraw_marked;
     set_dirty();
 }
 
@@ -140,6 +146,32 @@ void TextViewer::cursor_end() {
     redraw();
 }
 
+void TextViewer::cursor_set(uint16_t line, uint16_t col) {
+    cursor_.line = line;
+    cursor_.col = col;
+}
+
+void TextViewer::cursor_mark_selected() {
+    LineColPair newMarker = std::make_pair(cursor_.line, cursor_.col);
+    auto it = std::find(lineColPair.begin(), lineColPair.end(), newMarker);
+
+    if (it != lineColPair.end()) {
+        lineColPair.erase(it);
+    } else {
+        lineColPair.push_back(newMarker);
+    }
+
+    // Mark pending change.
+    cursor_.mark_change = false;
+
+    redraw();
+}
+
+void TextViewer::cursor_clear_marked() {
+    lineColPair.clear();
+    redraw(true, true);
+}
+
 uint16_t TextViewer::line_length() {
     return file_->line_length(cursor_.line);
 }
@@ -247,12 +279,52 @@ void TextViewer::paint_cursor(Painter& painter) {
     };
 
     if (paint_state_.line != UINT32_MAX)  // only XOR old cursor if it still appears on the screen
-        xor_cursor(paint_state_.line, paint_state_.col);
+    {
+        // Only reset previous cursor if we aren't marking.
+        if (paint_state_.mark_change) {
+            xor_cursor(paint_state_.line, paint_state_.col);
+        }
+    }
 
     xor_cursor(cursor_.line, cursor_.col);
 
     paint_state_.line = cursor_.line;
     paint_state_.col = cursor_.col;
+    paint_state_.mark_change = cursor_.mark_change;
+
+    // Reset marking and wait for new change.
+    cursor_.mark_change = true;
+}
+
+void TextViewer::paint_marked(Painter& painter) {
+    auto xor_cursor = [this, &painter](int32_t line, uint16_t col) {
+        int cursor_width = char_width + 1;
+        int x = (col - paint_state_.first_col) * char_width - 1;
+        if (x < 0) {  // cursor is one pixel narrower when in left column
+            cursor_width--;
+            x = 0;
+        }
+        int y = screen_rect().top() + (line - paint_state_.first_line) * char_height;
+
+        // Converting one row at a time to reduce buffer size
+        auto pbuf8 = cursor_.pixel_buffer8;
+        auto pbuf = cursor_.pixel_buffer;
+        for (auto col = 0; col < char_height; col++) {
+            // Annoyingly, read_pixels uses a 24-bit pixel format vs draw_pixels which uses 16-bit
+            portapack::display.read_pixels({x, y + col, cursor_width, 1}, pbuf8, cursor_width);
+            for (auto i = 0; i < cursor_width; i++)
+                pbuf[i] = Color(pbuf8[i].r, pbuf8[i].g, pbuf8[i].b).v ^ 0xFFFF;
+            portapack::display.draw_pixels({x, y + col, cursor_width, 1}, pbuf, cursor_width);
+        }
+    };
+
+    auto it = lineColPair.begin();
+
+    while (it != lineColPair.end()) {
+        LineColPair entry = (LineColPair)*it;
+        xor_cursor(entry.first, entry.second);
+        it++;
+    }
 }
 
 void TextViewer::reset_file(FileWrapper* file) {

firmware/application/apps/ui_text_editor.hpp

@@ -59,7 +59,7 @@ class TextViewer : public Widget {
     bool on_key(KeyEvent key) override;
     bool on_encoder(EncoderEvent delta) override;
 
-    void redraw(bool redraw_text = false);
+    void redraw(bool redraw_text = false, bool redraw_marked = false);
 
     void set_file(FileWrapper& file) { reset_file(&file); }
     void clear_file() { reset_file(); }
@@ -71,6 +71,12 @@ class TextViewer : public Widget {
 
     void cursor_home();
     void cursor_end();
+    void cursor_set(uint16_t line, uint16_t col);
+    void cursor_mark_selected();
+    void cursor_clear_marked();
+
+    typedef std::pair<uint16_t, uint16_t> LineColPair;
+    std::vector<LineColPair> lineColPair{};
 
     // Gets the length of the current line.
     uint16_t line_length();
@@ -97,6 +103,7 @@ class TextViewer : public Widget {
 
     void paint_text(Painter& painter, uint32_t line, uint16_t col);
     void paint_cursor(Painter& painter);
+    void paint_marked(Painter& painter);
 
     void reset_file(FileWrapper* file = nullptr);
 
@@ -111,6 +118,8 @@ class TextViewer : public Widget {
         uint32_t first_line{};
         uint16_t first_col{};
         bool redraw_text{true};
+        bool redraw_marked{false};
+        bool mark_change{true};
     } paint_state_{};
 
     struct {
@@ -121,6 +130,8 @@ class TextViewer : public Widget {
         // Pixel buffer used for cursor XOR'ing - Max cursor width = Max char width + 1
         ColorRGB888 pixel_buffer8[ui::char_width + 1]{};
         Color pixel_buffer[ui::char_width + 1]{};
+
+        bool mark_change{true};
     } cursor_{};
 };
 

firmware/application/apps/ui_touchtunes.cpp

@@ -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(

firmware/application/apps/ui_touchtunes.hpp

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

firmware/application/apps/ui_weatherstation.cpp

@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 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_weatherstation.hpp"
+#include "modems.hpp"
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+namespace ui {
+
+void WeatherRecentEntryDetailView::update_data() {
+    // set text elements
+    text_type.set(WeatherView::getWeatherSensorTypeName((FPROTO_WEATHER_SENSOR)entry_.sensorType));
+    if (entry_.id != WS_NO_ID)
+        text_id.set("0x" + to_string_hex(entry_.id));
+    else
+        text_id.set("-");
+    if (entry_.temp != WS_NO_TEMPERATURE)
+        text_temp.set(weather_units_fahr ? to_string_decimal((entry_.temp * 9 / 5) + 32, 1) + STR_DEGREES_F : to_string_decimal(entry_.temp, 2) + STR_DEGREES_C);
+    else
+        text_temp.set("-");
+    if (entry_.humidity != WS_NO_HUMIDITY)
+        text_hum.set(to_string_dec_uint(entry_.humidity) + "%");
+    else
+        text_hum.set("-");
+    if (entry_.channel != WS_NO_CHANNEL)
+        text_ch.set(to_string_dec_uint(entry_.channel));
+    else
+        text_ch.set("-");
+    if (entry_.battery_low != WS_NO_BATT)
+        text_batt.set(to_string_dec_uint(entry_.battery_low) + " " + ((entry_.battery_low == 0) ? "OK" : "LOW"));
+    else
+        text_batt.set("-");
+    text_age.set(to_string_dec_uint(entry_.age) + " sec");
+}
+
+WeatherRecentEntryDetailView::WeatherRecentEntryDetailView(NavigationView& nav, const WeatherRecentEntry& entry)
+    : nav_{nav},
+      entry_{entry} {
+    add_children({&button_done,
+                  &text_type,
+                  &text_id,
+                  &text_temp,
+                  &text_hum,
+                  &text_ch,
+                  &text_batt,
+                  &text_age,
+                  &labels});
+
+    button_done.on_select = [&nav](const ui::Button&) {
+        nav.pop();
+    };
+    update_data();
+}
+
+void WeatherRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+void WeatherView::focus() {
+    field_frequency.focus();
+}
+
+WeatherView::WeatherView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&rssi,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_frequency,
+                  &options_temperature,
+                  &button_clear_list,
+                  &recent_entries_view});
+
+    baseband::run_image(portapack::spi_flash::image_tag_weather);
+
+    button_clear_list.on_select = [this](Button&) {
+        recent.clear();
+        recent_entries_view.set_dirty();
+    };
+    field_frequency.set_step(100000);
+
+    options_temperature.on_change = [this](size_t, int32_t i) {
+        weather_units_fahr = (bool)i;
+        recent_entries_view.set_dirty();
+    };
+    options_temperature.set_selected_index(weather_units_fahr, false);
+
+    const Rect content_rect{0, header_height, screen_width, screen_height - header_height};
+    recent_entries_view.set_parent_rect(content_rect);
+    recent_entries_view.on_select = [this](const WeatherRecentEntry& entry) {
+        nav_.push<WeatherRecentEntryDetailView>(entry);
+    };
+    baseband::set_subghzd_config(0, receiver_model.sampling_rate());  // 0=am
+    receiver_model.enable();
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        on_tick_second();
+    };
+}
+
+void WeatherView::on_tick_second() {
+    for (auto& entry : recent) {
+        entry.inc_age(1);
+    }
+    recent_entries_view.set_dirty();
+}
+
+void WeatherView::on_data(const WeatherDataMessage* data) {
+    WeatherRecentEntry key{data->sensorType, data->id, data->temp, data->humidity, data->channel, data->battery_low};
+    auto matching_recent = find(recent, key.key());
+    if (matching_recent != std::end(recent)) {
+        // Found within. Move to front of list, increment counter.
+        (*matching_recent).reset_age();
+        recent.push_front(*matching_recent);
+        recent.erase(matching_recent);
+    } else {
+        recent.emplace_front(key);
+        truncate_entries(recent, 64);
+    }
+    recent_entries_view.set_dirty();
+}
+
+WeatherView::~WeatherView() {
+    rtc_time::signal_tick_second -= signal_token_tick_second;
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+const char* WeatherView::getWeatherSensorTypeName(FPROTO_WEATHER_SENSOR type) {
+    switch (type) {
+        case FPW_NexusTH:
+            return "NexusTH";
+        case FPW_Acurite592TXR:
+            return "Acurite592TXR";
+        case FPW_Acurite606TX:
+            return "Acurite606TX";
+        case FPW_Acurite609TX:
+            return "Acurite609TX";
+        case FPW_Ambient:
+            return "Ambient";
+        case FPW_AuriolAhfl:
+            return "AuriolAhfl";
+        case FPW_AuriolTH:
+            return "AuriolTH";
+        case FPW_GTWT02:
+            return "GT-WT02";
+        case FPW_GTWT03:
+            return "GT-WT03";
+        case FPW_INFACTORY:
+            return "InFactory";
+        case FPW_LACROSSETX:
+            return "LaCrosse TX";
+        case FPW_LACROSSETX141thbv2:
+            return "LaCrosse TX141THBv2";
+        case FPW_OREGON2:
+            return "Oregon2";
+        case FPW_OREGON3:
+            return "Oregon3";
+        case FPW_OREGONv1:
+            return "OregonV1";
+        case FPW_THERMOPROTX4:
+            return "ThermoPro TX4";
+        case FPW_TX_8300:
+            return "TX 8300";
+        case FPW_WENDOX_W6726:
+            return "Wendox W6726";
+        case FPW_Acurite986:
+            return "Acurite986";
+
+        case FPW_Invalid:
+        default:
+            return "Unknown";
+    }
+}
+
+std::string WeatherView::pad_string_with_spaces(int snakes) {
+    std::string paddedStr(snakes, ' ');
+    return paddedStr;
+}
+
+template <>
+void RecentEntriesTable<ui::WeatherRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line{};
+    line.reserve(30);
+
+    line = WeatherView::getWeatherSensorTypeName((FPROTO_WEATHER_SENSOR)entry.sensorType);
+    if (line.length() < 10) {
+        line += WeatherView::pad_string_with_spaces(10 - line.length());
+    } else {
+        line = truncate(line, 10);
+    }
+
+    std::string temp = (weather_units_fahr ? to_string_decimal((entry.temp * 9 / 5) + 32, 1) : to_string_decimal(entry.temp, 1));
+    std::string humStr = (entry.humidity != WS_NO_HUMIDITY) ? to_string_dec_uint(entry.humidity) + "%" : "-";
+    std::string chStr = (entry.channel != WS_NO_CHANNEL) ? to_string_dec_uint(entry.channel) : "-";
+    std::string ageStr = to_string_dec_uint(entry.age);
+
+    line += WeatherView::pad_string_with_spaces(6 - temp.length()) + temp;
+    line += WeatherView::pad_string_with_spaces(5 - humStr.length()) + humStr;
+    line += WeatherView::pad_string_with_spaces(4 - chStr.length()) + chStr;
+    line += WeatherView::pad_string_with_spaces(5 - ageStr.length()) + ageStr;
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+}  // namespace ui

firmware/application/apps/ui_weatherstation.hpp

@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_WEATHER_H__
+#define __UI_WEATHER_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "utility.hpp"
+#include "recent_entries.hpp"
+
+#include "../baseband/fprotos/weathertypes.hpp"
+using namespace ui;
+
+namespace ui {
+
+static bool weather_units_fahr{false};
+
+struct WeatherRecentEntry {
+    using Key = uint64_t;
+    static constexpr Key invalid_key = 0x0fffffff;  // todo calc the invalid all
+    uint8_t sensorType = FPW_Invalid;
+    uint32_t id = WS_NO_ID;
+    float temp = WS_NO_TEMPERATURE;
+    uint8_t humidity = WS_NO_HUMIDITY;
+    uint8_t battery_low = WS_NO_BATT;
+    uint8_t channel = WS_NO_CHANNEL;
+    uint16_t age = 0;  // updated on each seconds, show how long the signal was last seen
+
+    WeatherRecentEntry() {}
+    WeatherRecentEntry(
+        uint8_t sensorType,
+        uint32_t id,
+        float temp,
+        uint8_t humidity,
+        uint8_t channel,
+        uint8_t battery_low = WS_NO_BATT)
+        : sensorType{sensorType},
+          id{id},
+          temp{temp},
+          humidity{humidity},
+          battery_low{battery_low},
+          channel{channel} {
+    }
+    Key key() const {
+        return (((static_cast<uint64_t>(temp * 10) & 0xFFFF) << 48) ^ static_cast<uint64_t>(id) << 24) |
+               (static_cast<uint64_t>(sensorType) & 0xFF) << 16 |
+               (static_cast<uint64_t>(humidity) & 0xFF) << 8 |
+               (static_cast<uint64_t>(battery_low) & 0xF) << 4 |
+               (static_cast<uint64_t>(channel) & 0xF);
+    }
+    void inc_age(int delta) {
+        if (UINT16_MAX - delta > age) age += delta;
+    }
+    void reset_age() {
+        age = 0;
+    }
+};
+using WeatherRecentEntries = RecentEntries<WeatherRecentEntry>;
+using WeatherRecentEntriesView = RecentEntriesView<WeatherRecentEntries>;
+
+class WeatherView : public View {
+   public:
+    WeatherView(NavigationView& nav);
+    ~WeatherView();
+
+    void focus() override;
+
+    std::string title() const override { return "Weather"; };
+    static const char* getWeatherSensorTypeName(FPROTO_WEATHER_SENSOR type);
+    static std::string pad_string_with_spaces(int snakes);
+
+   private:
+    void on_tick_second();
+    void on_data(const WeatherDataMessage* data);
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{
+        433'920'000 /* frequency */,
+        1'750'000 /* bandwidth */,
+        2'000'000 /* sampling rate */,
+        ReceiverModel::Mode::AMAudio};
+    app_settings::SettingsManager settings_{
+        "rx_weather",
+        app_settings::Mode::RX,
+        {
+            {"units_fahr"sv, &weather_units_fahr},
+        }};
+
+    WeatherRecentEntries recent{};
+
+    OptionsField options_temperature{
+        {10 * 8, 0 * 16},
+        2,
+        {{STR_DEGREES_C, 0},
+         {STR_DEGREES_F, 1}}};
+
+    RFAmpField field_rf_amp{
+        {13 * 8, 0 * 16}};
+    LNAGainField field_lna{
+        {15 * 8, 0 * 16}};
+    VGAGainField field_vga{
+        {18 * 8, 0 * 16}};
+    RSSI rssi{
+        {21 * 8, 0, 6 * 8, 4}};
+    RxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+
+    SignalToken signal_token_tick_second{};
+
+    Button button_clear_list{
+        {0, 16, 7 * 8, 32},
+        "Clear"};
+
+    static constexpr auto header_height = 3 * 16;
+
+    const RecentEntriesColumns columns{{
+        {"Type", 10},
+        {"Temp", 5},
+        {"Hum", 4},
+        {"Ch", 3},
+        {"Age", 4},
+    }};
+    WeatherRecentEntriesView recent_entries_view{columns, recent};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::WeatherData,
+        [this](Message* const p) {
+            const auto message = static_cast<const WeatherDataMessage*>(p);
+            this->on_data(message);
+        }};
+};
+
+class WeatherRecentEntryDetailView : public View {
+   public:
+    WeatherRecentEntryDetailView(NavigationView& nav, const WeatherRecentEntry& entry);
+
+    void update_data();
+    void focus() override;
+
+   private:
+    NavigationView& nav_;
+    WeatherRecentEntry entry_{};
+    Text text_type{{10 * 8, 1 * 16, 15 * 8, 16}, "?"};
+    Text text_id{{10 * 8, 2 * 16, 10 * 8, 16}, "?"};
+    Text text_temp{{10 * 8, 3 * 16, 8 * 8, 16}, "?"};
+    Text text_hum{{10 * 8, 4 * 16, 6 * 8, 16}, "?"};
+    Text text_ch{{10 * 8, 5 * 16, 6 * 8, 16}, "?"};
+    Text text_batt{{10 * 8, 6 * 16, 6 * 8, 16}, "?"};
+    Text text_age{{10 * 8, 7 * 16, 10 * 8, 16}, "?"};
+
+    Labels labels{
+        {{0 * 8, 0 * 16}, "Weather Station", Color::light_grey()},
+        {{0 * 8, 1 * 16}, "Type:", Color::light_grey()},
+        {{0 * 8, 2 * 16}, "Id: ", Color::light_grey()},
+        {{0 * 8, 3 * 16}, "Temp:", Color::light_grey()},
+        {{0 * 8, 4 * 16}, "Humidity:", Color::light_grey()},
+        {{0 * 8, 5 * 16}, "Channel:", Color::light_grey()},
+        {{0 * 8, 6 * 16}, "Battery:", Color::light_grey()},
+        {{0 * 8, 7 * 16}, "Age:", Color::light_grey()},
+    };
+
+    Button button_done{
+        {screen_width - 96 - 4, screen_height - 32 - 12, 96, 32},
+        "Done"};
+};
+
+}  // namespace ui
+
+#endif /*__UI_WEATHER_H__*/

firmware/application/audio.cpp

@@ -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 {
@@ -232,6 +240,10 @@ uint32_t reg_read(const size_t register_number) {
     return audio_codec->reg_read(register_number);
 }
 
+void reg_write(const size_t register_number, uint32_t value) {
+    audio_codec->reg_write(register_number, value);
+}
+
 std::string codec_name() {
     return audio_codec->name();
 }

firmware/application/audio.hpp

@@ -50,12 +50,16 @@ 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;
+    virtual void reg_write(const size_t register_number, const uint32_t value) = 0;
 };
 
 namespace output {
@@ -76,9 +80,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 {
@@ -101,6 +108,7 @@ namespace debug {
 
 size_t reg_count();
 uint32_t reg_read(const size_t register_number);
+void reg_write(const size_t register_number, uint32_t value);
 std::string codec_name();
 size_t reg_bits();
 

firmware/application/baseband_api.cpp

@@ -149,12 +149,18 @@ void set_aprs(const uint32_t baudrate) {
     send_message(&message);
 }
 
-void set_btle(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word) {
+void set_btlerx(uint8_t channel_number) {
     const BTLERxConfigureMessage message{
-        baudrate,
-        word_length,
-        trigger_value,
-        trigger_word};
+        channel_number};
+    send_message(&message);
+}
+
+void set_btletx(uint8_t channel_number, char* macAddress, char* advertisementData, uint8_t pduType) {
+    const BTLETxConfigureMessage message{
+        channel_number,
+        macAddress,
+        advertisementData,
+        pduType};
     send_message(&message);
 }
 
@@ -167,6 +173,17 @@ void set_nrf(const uint32_t baudrate, const uint32_t word_length, const uint32_t
     send_message(&message);
 }
 
+void set_fsk(const size_t deviation) {
+    const FSKRxConfigureMessage message{
+        taps_200k_decim_0,
+        taps_16k0_decim_1,
+        taps_11k0_channel,
+        2,
+        deviation};
+
+    send_message(&message);
+}
+
 void set_afsk_data(const uint32_t afsk_samples_per_bit, const uint32_t afsk_phase_inc_mark, const uint32_t afsk_phase_inc_space, const uint8_t afsk_repeat, const uint32_t afsk_bw, const uint8_t symbol_count) {
     const AFSKTxConfigureMessage message{
         afsk_samples_per_bit,
@@ -261,8 +278,7 @@ void set_pocsag() {
 }
 
 void set_adsb() {
-    const ADSBConfigureMessage message{
-        1};
+    const ADSBConfigureMessage message{};
     send_message(&message);
 }
 
@@ -303,6 +319,11 @@ void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bo
     send_message(&message);
 }
 
+void set_subghzd_config(uint8_t modulation = 0, uint32_t sampling_rate = 0) {
+    const SubGhzFPRxConfigureMessage message{modulation, sampling_rate};
+    send_message(&message);
+}
+
 static bool baseband_image_running = false;
 
 void run_image(const spi_flash::image_tag_t image_tag) {

firmware/application/baseband_api.hpp

@@ -69,9 +69,11 @@ void set_pitch_rssi(int32_t avg, bool enabled);
 void set_afsk_data(const uint32_t afsk_samples_per_bit, const uint32_t afsk_phase_inc_mark, const uint32_t afsk_phase_inc_space, const uint8_t afsk_repeat, const uint32_t afsk_bw, const uint8_t symbol_count);
 void kill_afsk();
 void set_afsk(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word);
+void set_fsk(const size_t deviation);
 void set_aprs(const uint32_t baudrate);
 
-void set_btle(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word);
+void set_btlerx(uint8_t channel_number);
+void set_btletx(uint8_t channel_number, char* macAddress, char* advertisementData, uint8_t pduType);
 
 void set_nrf(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word);
 
@@ -86,6 +88,7 @@ void set_spectrum(const size_t sampling_rate, const size_t trigger);
 void set_siggen_tone(const uint32_t tone);
 void set_siggen_config(const uint32_t bw, const uint32_t shape, const uint32_t duration);
 void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bool update, int32_t bw);
+void set_subghzd_config(uint8_t modulation, uint32_t sampling_rate);
 void request_beep();
 
 void run_image(const portapack::spi_flash::image_tag_t image_tag);

firmware/application/bitmap.hpp

@@ -1169,20 +1169,20 @@ static constexpr uint8_t bitmap_icon_tpms_data[] = {
     0xEC,
     0x37,
     0x36,
-    0x6C,
-    0x1A,
-    0x58,
-    0x0B,
-    0xD0,
-    0x0B,
-    0xD0,
-    0x0B,
-    0xD0,
-    0x0B,
-    0xD0,
-    0x1A,
-    0x58,
-    0x36,
+    0x6D,
+    0x3A,
+    0x59,
+    0x4B,
+    0xD5,
+    0x8B,
+    0xD3,
+    0xCB,
+    0xD1,
+    0xAB,
+    0xD2,
+    0x9A,
+    0x5C,
+    0xB6,
     0x6C,
     0xEC,
     0x37,
@@ -5645,6 +5645,120 @@ static constexpr Bitmap bitmap_icon_shift{
     {16, 16},
     bitmap_icon_shift_data};
 
+static constexpr uint8_t bitmap_icon_trim_data[] = {
+    0x10,
+    0x10,
+    0x30,
+    0x12,
+    0x50,
+    0x15,
+    0x50,
+    0x15,
+    0x50,
+    0x15,
+    0x52,
+    0x95,
+    0x56,
+    0xD5,
+    0x5F,
+    0xF5,
+    0x56,
+    0xD5,
+    0x52,
+    0x95,
+    0x50,
+    0x15,
+    0x50,
+    0x15,
+    0x50,
+    0x15,
+    0x90,
+    0x18,
+    0x10,
+    0x10,
+    0x00,
+    0x00,
+};
+static constexpr Bitmap bitmap_icon_trim{
+    {16, 16},
+    bitmap_icon_trim_data};
+
+static constexpr uint8_t bitmap_icon_hide_data[] = {
+    0x00,
+    0x00,
+    0x00,
+    0x40,
+    0x00,
+    0x20,
+    0xE0,
+    0x17,
+    0x18,
+    0x18,
+    0xC4,
+    0x27,
+    0x62,
+    0x42,
+    0x21,
+    0x85,
+    0xA1,
+    0x84,
+    0x62,
+    0x46,
+    0xA4,
+    0x23,
+    0x18,
+    0x18,
+    0xE8,
+    0x07,
+    0x04,
+    0x00,
+    0x02,
+    0x00,
+    0x00,
+    0x00,
+};
+static constexpr Bitmap bitmap_icon_hide{
+    {16, 16},
+    bitmap_icon_hide_data};
+
+static constexpr uint8_t bitmap_icon_thermometer_data[] = {
+    0xC0,
+    0x00,
+    0x20,
+    0x01,
+    0x10,
+    0x02,
+    0x10,
+    0x3A,
+    0x10,
+    0x02,
+    0x10,
+    0x1A,
+    0x10,
+    0x02,
+    0xD0,
+    0x3A,
+    0xD0,
+    0x02,
+    0xD0,
+    0x1A,
+    0xD0,
+    0x02,
+    0xE8,
+    0x05,
+    0xE8,
+    0x05,
+    0xC8,
+    0x04,
+    0x10,
+    0x02,
+    0xE0,
+    0x01,
+};
+static constexpr Bitmap bitmap_icon_thermometer{
+    {16, 16},
+    bitmap_icon_thermometer_data};
+
 } /* namespace ui */
 
 #endif /*__BITMAP_HPP__*/

firmware/application/de_bruijn.hpp

@@ -21,6 +21,7 @@
  */
 
 #include <string>
+#include <cstdint>
 
 #ifndef __DE_BRUIJN_H__
 #define __DE_BRUIJN_H__

firmware/application/debug.cpp

@@ -57,6 +57,9 @@ uint32_t fault_address{0};
 void draw_guru_meditation_header(uint8_t source, const char* hint) {
     Painter painter;
 
+    // disable scroll in case a waterfall/spectrum display was active (scroll would mess up the fault display)
+    portapack::display.scroll_disable();
+
     painter.fill_rectangle(
         {0, 0, portapack::display.width(), portapack::display.height()},
         Color::red());
@@ -134,6 +137,10 @@ void runtime_error(uint8_t source) {
 
     led.off();
 
+    // wait for DFU button release if pressed, so we don't immediately jump into stack dump
+    while (swizzled_switches() & (1 << (int)Switch::Dfu))
+        ;
+
     while (true) {
         volatile size_t n = 1000000U;
         while (n--)
@@ -243,10 +250,6 @@ void draw_stack_dump() {
                     p = &__process_stack_base__;
                 break;
             }
-
-            // If SEL button pressed, try writing to file (likely to hang in fault condition but heh)
-            if (switches & (1 << (int)Switch::Sel))
-                stack_dump();
         }
 
         // clear screen to allow new range to be displayed, if we're not at the end
@@ -255,38 +258,43 @@ void draw_stack_dump() {
     }
 }
 
-// Disk I/O in this function doesn't work after a fault
-// Using the stack while dumping the stack isn't ideal, but hopefully anything imporant is still on the call stack.
 bool stack_dump() {
+    uint32_t num_words = &__process_stack_end__ - &__process_stack_base__;
+    return memory_dump(&__process_stack_base__, num_words, true);
+}
+
+bool memory_dump(uint32_t* addr_start, uint32_t num_words, bool stack_flag) {
     Painter painter;
     std::string debug_dir = "DEBUG";
     std::filesystem::path filename{};
-    File stack_dump_file{};
+    File dump_file{};
     bool error;
     std::string str;
+    uint32_t* addr_end;
     uint32_t* p;
     int n{0};
     bool data_found{false};
 
     make_new_directory(debug_dir);
-    filename = next_filename_matching_pattern(debug_dir + "/STACK_DUMP_????.TXT");
+    filename = next_filename_matching_pattern(debug_dir + "/" + (stack_flag ? "STACK" : "MEMORY") + "_DUMP_????.TXT");
     error = filename.empty();
     if (!error)
-        error = stack_dump_file.create(filename) != 0;
+        error = dump_file.create(filename) != 0;
     if (error) {
         painter.draw_string({16, 320 - 32}, ui::Styles::red, "ERROR DUMPING " + filename.filename().string() + "!");
         return false;
     }
 
-    for (p = &__process_stack_base__; p < &__process_stack_end__; p++) {
+    addr_end = addr_start + num_words;
+    for (p = addr_start; p < addr_end; p++) {
         // skip past unused stack words
-        if (!data_found) {
+        if (stack_flag && !data_found) {
             if (*p == CRT0_STACKS_FILL_PATTERN)
                 continue;
             else {
                 data_found = true;
-                auto stack_space_left = p - &__process_stack_base__;
-                stack_dump_file.write_line(to_string_hex((uint32_t)&__process_stack_base__, 8) + ": Unused words " + to_string_dec_uint(stack_space_left));
+                auto stack_space_left = p - addr_start;
+                dump_file.write_line(to_string_hex((uint32_t)addr_start, 8) + ": Unused words " + to_string_dec_uint(stack_space_left));
 
                 // align subsequent lines to start on 16-byte boundaries
                 p -= (stack_space_left & 3);
@@ -296,20 +304,20 @@ bool stack_dump() {
         // write address
         if (n++ == 0) {
             str = to_string_hex((uint32_t)p, 8) + ":";
-            stack_dump_file.write(str.data(), 9);
+            dump_file.write(str.data(), 9);
         }
 
         // write stack dword
         str = " " + to_string_hex(*p, 8);
-        stack_dump_file.write(str.data(), 9);
+        dump_file.write(str.data(), 9);
 
         if (n == 4) {
-            stack_dump_file.write("\r\n", 2);
+            dump_file.write("\r\n", 2);
             n = 0;
         }
     }
 
-    painter.draw_string({16, 320 - 32}, ui::Styles::green, filename.filename().string() + " dumped!");
+    painter.draw_string({0, 320 - 16}, ui::Styles::green, filename.filename().string() + " dumped!");
     return true;
 }
 

firmware/application/debug.hpp

@@ -48,5 +48,6 @@ inline uint32_t get_free_stack_space() {
 }
 
 bool stack_dump();
+bool memory_dump(uint32_t* addr_start, uint32_t num_words, bool stack_flag);
 
 #endif /*__DEBUG_H__*/

firmware/application/event_m0.cpp

@@ -113,6 +113,7 @@ void EventDispatcher::run() {
     while (is_running) {
         const auto events = wait();
         dispatch(events);
+        portapack::usb_serial.dispatch();
     }
 }
 

firmware/application/external/afsk_rx/ui_afsk_rx.hpp

@@ -24,6 +24,7 @@
 #define __UI_AFSK_RX_H__
 
 #include "ui.hpp"
+#include "ui_language.hpp"
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
 #include "ui_freq_field.hpp"
@@ -92,16 +93,16 @@ class AFSKRxView : public View {
     Checkbox check_log{
         {0 * 8, 1 * 16},
         3,
-        "LOG",
+        LanguageHelper::currentMessages[LANG_LOG],
         false};
 
     Text text_debug{
         {0 * 8, 12 + 2 * 16, screen_width, 16},
-        "DEBUG"};
+        LanguageHelper::currentMessages[LANG_DEBUG]};
 
     Button button_modem_setup{
         {screen_width - 12 * 8, 1 * 16, 96, 24},
-        "Modem setup"};
+        LanguageHelper::currentMessages[LANG_MODEM_SETUP]};
 
     Console console{
         {0, 4 * 16, 240, screen_width}};

firmware/application/external/analogtv/analog_tv_app.cpp

@@ -37,7 +37,7 @@ using namespace tonekey;
 
 #include "string_format.hpp"
 
-namespace ui {
+namespace ui::external_app::analogtv {
 
 /* AnalogTvView *******************************************************/
 
@@ -192,10 +192,11 @@ void AnalogTvView::update_modulation(const ReceiverModel::Mode modulation) {
 
     baseband::shutdown();
 
-    portapack::spi_flash::image_tag_t image_tag;
-    image_tag = portapack::spi_flash::image_tag_am_tv;
+    // portapack::spi_flash::image_tag_t image_tag; //moved to ext app, disabled
+    // image_tag = portapack::spi_flash::image_tag_am_tv;
 
-    baseband::run_image(image_tag);
+    // baseband::run_image(image_tag);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());  // moved the baseband too
 
     receiver_model.set_modulation(modulation);
     receiver_model.set_sampling_rate(2000000);
@@ -203,4 +204,4 @@ void AnalogTvView::update_modulation(const ReceiverModel::Mode modulation) {
     receiver_model.enable();
 }
 
-} /* namespace ui */
+}  // namespace ui::external_app::analogtv

firmware/application/external/analogtv/analog_tv_app.hpp

@@ -36,7 +36,7 @@
 
 #include "tone_key.hpp"
 
-namespace ui {
+namespace ui::external_app::analogtv {
 
 class AnalogTvView : public View {
    public:
@@ -111,6 +111,6 @@ class AnalogTvView : public View {
     void update_modulation(const ReceiverModel::Mode modulation);
 };
 
-} /* namespace ui */
+}  // namespace ui::external_app::analogtv
 
 #endif /*__ANALOG_TV_APP_H__*/

firmware/application/external/analogtv/main.cpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "analog_tv_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::analogtv {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<AnalogTvView>();
+}
+}  // namespace ui::external_app::analogtv
+
+extern "C" {
+
+__attribute__((section(".external_app.app_analogtv.application_information"), used)) application_information_t _application_information_analogtv = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::analogtv::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Analog TV",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xFE,
+        0x7F,
+        0x03,
+        0xC0,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0x03,
+        0xC0,
+        0xFF,
+        0xFF,
+        0xFB,
+        0xD7,
+        0xFE,
+        0x7F,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::RX,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_am_tv */ {'P', 'A', 'M', 'T'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/blespam/main.cpp

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

firmware/application/external/blespam/ui_blespam.hpp

@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 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.
+ */
+
+// Code from https://github.com/Flipper-XFW/Xtreme-Apps/tree/04c3a60093e2c2378e79498b4505aa8072980a42/ble_spam/protocols
+// Thanks for the work of the original creators!
+// Saying thanks in the main view!
+
+#ifndef __UI_BLESPAM_H__
+#define __UI_BLESPAM_H__
+
+#include "ui.hpp"
+#include "ui_language.hpp"
+#include "ui_navigation.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+using namespace ui;
+
+namespace ui::external_app::blespam {
+
+enum ATK_TYPE {
+    ATK_ANDROID,
+    ATK_IOS,
+    ATK_IOS_CRASH,
+    ATK_WINDOWS,
+    ATK_SAMSUNG
+};
+enum PKT_TYPE {
+    PKT_TYPE_INVALID_TYPE,
+    PKT_TYPE_RAW,
+    PKT_TYPE_DISCOVERY,
+    PKT_TYPE_IBEACON,
+    PKT_TYPE_ADV_IND,
+    PKT_TYPE_ADV_DIRECT_IND,
+    PKT_TYPE_ADV_NONCONN_IND,
+    PKT_TYPE_ADV_SCAN_IND,
+    PKT_TYPE_SCAN_REQ,
+    PKT_TYPE_SCAN_RSP,
+    PKT_TYPE_CONNECT_REQ,
+    PKT_TYPE_LL_DATA,
+    PKT_TYPE_LL_CONNECTION_UPDATE_REQ,
+    PKT_TYPE_LL_CHANNEL_MAP_REQ,
+    PKT_TYPE_LL_TERMINATE_IND,
+    PKT_TYPE_LL_ENC_REQ,
+    PKT_TYPE_LL_ENC_RSP,
+    PKT_TYPE_LL_START_ENC_REQ,
+    PKT_TYPE_LL_START_ENC_RSP,
+    PKT_TYPE_LL_UNKNOWN_RSP,
+    PKT_TYPE_LL_FEATURE_REQ,
+    PKT_TYPE_LL_FEATURE_RSP,
+    PKT_TYPE_LL_PAUSE_ENC_REQ,
+    PKT_TYPE_LL_PAUSE_ENC_RSP,
+    PKT_TYPE_LL_VERSION_IND,
+    PKT_TYPE_LL_REJECT_IND,
+    PKT_TYPE_NUM_PKT_TYPE
+};
+
+class BLESpamView : public View {
+   public:
+    BLESpamView(NavigationView& nav);
+    ~BLESpamView();
+
+    void focus() override;
+
+    std::string title() const override {
+        return "BLESpam";
+    };
+
+   private:
+    NavigationView& nav_;
+    TxRadioState radio_state_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */
+    };
+    TxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+    TransmitterView2 tx_view{
+        {11 * 8, 0 * 16},
+        /*short_ui*/ true};
+    app_settings::SettingsManager settings_{
+        "tx_blespam", app_settings::Mode::TX};
+
+    Button button_startstop{
+        {0, 3 * 16, 96, 24},
+        LanguageHelper::currentMessages[LANG_START]};
+    Checkbox chk_randdev{{100, 16}, 10, "Rnd device", true};
+
+    Console console{
+        {0, 70, 240, 220}};
+
+    OptionsField options_atkmode{
+        {0 * 8, 2 * 8},
+        10,
+        {{"Android", 0},
+         {"iOs", 1},
+         {"iOs crash", 2},
+         {"Windows", 3},
+         {"Samsung", 4}}};
+
+    bool is_running{false};
+
+    uint8_t counter = 0;         // for packet change
+    uint8_t displayCounter = 0;  // for packet display
+
+    ATK_TYPE attackType = ATK_ANDROID;
+
+    bool randomMac{true};
+    bool randomDev{true};
+
+    uint8_t channel_number = 37;
+    char mac[13] = "010203040507";
+    char advertisementData[63] = {"03032CFE06162CFED5A59E020AB4\0"};
+    PKT_TYPE pduType = {PKT_TYPE_DISCOVERY};
+
+    void start();
+    void stop();
+    void reset();
+    void createFastPairPacket();
+    void createIosPacket(bool crash);
+    void createSamsungPacket();
+    void createWindowsPacket();
+    void changePacket(bool forced);
+    void on_tx_progress(const bool done);
+
+    uint64_t get_freq_by_channel_number(uint8_t channel_number);
+    void randomizeMac();
+    void randomChn();
+
+    void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len);
+
+    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);
+        }};
+
+    // continuity
+
+    typedef enum {
+        PayloadModeRandom,
+        PayloadModeValue,
+        PayloadModeBruteforce,
+    } PayloadMode;
+
+    typedef enum {
+        ContinuityTypeAirDrop = 0x05,
+        ContinuityTypeProximityPair = 0x07,
+        ContinuityTypeAirplayTarget = 0x09,
+        ContinuityTypeHandoff = 0x0C,
+        ContinuityTypeTetheringSource = 0x0E,
+        ContinuityTypeNearbyAction = 0x0F,
+        ContinuityTypeNearbyInfo = 0x10,
+
+        ContinuityTypeCustomCrash,
+        ContinuityTypeCOUNT
+    } ContinuityType;
+
+    typedef enum {
+        ContinuityPpBruteforceModel,
+        ContinuityPpBruteforceColor,
+    } ContinuityPpBruteforce;
+
+    typedef struct {
+        uint8_t value;
+        // const char* name;
+    } ContinuityColor;
+
+    static const uint8_t pp_prefixes_count;
+
+    static const uint8_t na_actions_count;
+    static const uint8_t pp_models_count;
+    static const ContinuityColor colors_beats_studio_buds_[];
+    static const ContinuityColor colors_beats_fit_pro[];
+    static const ContinuityColor colors_beats_studio_pro[];
+    static const ContinuityColor colors_beats_studio_3[];
+    static const ContinuityColor colors_beats_x[];
+    static const ContinuityColor colors_beats_studio_buds[];
+    static const ContinuityColor colors_beats_solo_pro[];
+    static const ContinuityColor colors_powerbeats_pro[];
+    static const ContinuityColor colors_powerbeats_3[];
+    static const ContinuityColor colors_beats_solo_3[];
+    static const ContinuityColor colors_beats_flex[];
+    static const ContinuityColor colors_airpods_max[];
+    static const ContinuityColor colors_white[];
+    typedef struct {
+        uint16_t value;
+        // const char* name;
+        const ContinuityColor* colors;
+        const uint8_t colors_count;
+    } contiModels;
+    static const contiModels pp_models[];
+    typedef struct {
+        uint8_t value;
+    } contiU8;
+    static const contiU8 pp_prefixes[];
+    static const contiU8 na_actions[];
+
+    // fastpair:
+
+    static const uint16_t fastpairModels_count;
+    typedef struct {
+        uint32_t value;
+        const char* name;  // could be moved too
+    } fpUi32;
+    static const fpUi32 fastpairModels[];
+
+    // easysetup:
+    static const uint8_t watch_models_count;
+    typedef struct {
+        uint8_t value;
+    } easyU8;
+    typedef struct {
+        uint32_t value;
+    } easyU32;
+    typedef enum {
+        EasysetupTypeBuds = 0x01,  // Skip 0 as it means unset
+        EasysetupTypeWatch,
+        EasysetupTypeCOUNT,
+    } EasysetupType;
+    static const easyU8 watch_models[];
+    static const uint8_t buds_models_count;
+    static const easyU32 buds_models[];
+};
+};  // namespace ui::external_app::blespam
+
+#endif /*__UI_BLESPAM_H__*/