Save TPMS units in App Settings and tune frequency (#1598)

Co-authored-by: GullCode <gullradriel@hotmail.com>

.gitignore

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

README.md

@@ -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](https://discord.com/channels/719669764804444213/1165624357129834547) of this [PortaPack H2](https://www.aliexpress.com/item/4000247041639.html?gatewayAdapt=4itemAdapt), you can support them too.
 
 :heavy_check_mark: Another popular option is the clone of the [PortaPack H1](https://s.click.aliexpress.com/e/_Dkbqs2X).
 

firmware/application/CMakeLists.txt

@@ -244,6 +244,9 @@ set(CPPSRC
 	apps/ais_app.cpp
 	apps/analog_audio_app.cpp
 	apps/analog_tv_app.cpp
+	apps/ble_comm_app.cpp
+	apps/ble_rx_app.cpp
+	apps/ble_tx_app.cpp
 	apps/capture_app.cpp
 	apps/ert_app.cpp
 	apps/gps_sim_app.cpp
@@ -268,6 +271,7 @@ set(CPPSRC
 	apps/ui_fileman.cpp
 	apps/ui_flash_utility.cpp
 	apps/ui_freqman.cpp
+	apps/ui_fsk_rx.cpp
 	apps/ui_iq_trim.cpp
 	apps/ui_jammer.cpp
     # apps/ui_keyfob.cpp

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;
@@ -249,7 +250,7 @@ SettingsManager::SettingsManager(
     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);
 
     // Settings should always be loaded because apps now rely

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. */

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,836 @@
+/*
+ * 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 "ui_modemsetup.hpp"
+
+#include "modems.hpp"
+#include "audio.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "ui_textentry.hpp"
+
+using namespace portapack;
+using namespace modems;
+
+void BLELogger::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+std::string pad_string_with_spaces(int snakes) {
+    std::string paddedStr(snakes, ' ');
+    return paddedStr;
+}
+
+uint64_t copy_mac_address_to_uint64(const uint8_t* macAddress) {
+    uint64_t result = 0;
+
+    // Copy each byte of the MAC address to the corresponding byte in the uint64_t.
+    for (int i = 0; i < 6; ++i) {
+        result |= static_cast<uint64_t>(macAddress[i]) << ((5 - i) * 8);
+    }
+
+    return result;
+}
+
+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) {
+    std::filesystem::path packet_save_path{u"BLERX/Packets/????.TXT"};
+
+    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();
+}
+
+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,
+                  &check_name,
+                  &label_sort,
+                  &options_sort,
+                  &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);
+    };
+
+    button_filter.on_select = [this](Button&) {
+        text_prompt(
+            nav_,
+            filterBuffer,
+            64,
+            [this](std::string& buffer) {
+                on_filter_change(buffer);
+            });
+    };
+
+    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_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");
+    };
+
+    check_name.set_value(true);
+
+    check_name.on_select = [this](Checkbox&, bool v) {
+        setAllMembersToValue(recent, &BleRecentEntry::include_name, v);
+        recent_entries_view.set_dirty();
+    };
+
+    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;
+
+        baseband::set_btlerx(channel_number);
+    };
+
+    options_sort.on_change = [this](size_t, int32_t index) {
+        handle_entries_sort(index);
+    };
+
+    options_channel.set_selected_index(0, true);
+    options_sort.set_selected_index(0, true);
+
+    logger = std::make_unique<BLELogger>();
+
+    // Auto-configure modem for LCR RX (will be removed later)
+    baseband::set_btlerx(channel_number);
+
+    receiver_model.enable();
+}
+
+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) {
+    std::filesystem::path packet_save_path{u"BLERX/Lists/????.csv"};
+
+    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);
+}
+
+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 (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);
+    }
+
+    std::string str_console = "";
+
+    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 += "\n";
+
+    str_console += "Mac:";
+    str_console += to_string_mac_address(packet->macAddress, 6, false);
+
+    str_console += "\n";
+    str_console += "Data:";
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        str_console += to_string_hex(packet->data[i], 2);
+    }
+
+    str_console += "\n";
+
+    uint64_t macAddressEncoded = copy_mac_address_to_uint64(packet->macAddress);
+
+    // Start of Packet stuffing.
+    // Masking off the top 2 bytes to avoid invalid keys.
+    auto& entry = ::on_packet(recent, macAddressEncoded & 0xFFFFFFFFFFFF);
+    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);
+    }
+}
+
+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::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,320 @@
+/*
+ * 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 "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{};
+
+    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);
+    void on_data(BlePacketData* packetData);
+    void on_filter_change(std::string value);
+    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};
+    app_settings::SettingsManager settings_{
+        "BLE Rx", app_settings::Mode::RX};
+
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+    uint8_t channel_number = 37;
+    bool auto_channel = false;
+
+    std::string filterBuffer{};
+    std::string filter{};
+    std::string listFileBuffer{};
+    std::string headerStr = "Timestamp, MAC Address, Name, Packet Type, Data, Hits, dB, Channel";
+    uint16_t maxLineLength = 140;
+
+    static constexpr auto header_height = 3 * 16;
+    static constexpr auto switch_button_height = 3 * 16;
+
+    OptionsField options_channel{
+        {0 * 8, 0 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39},
+         {"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};
+
+    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{""};
+    bool logging{false};
+
+    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);
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/

firmware/application/apps/ble_tx_app.cpp

@@ -0,0 +1,462 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ble_tx_app.hpp"
+#include "ble_rx_app.hpp"
+
+#include "ui_fileman.hpp"
+#include "ui_modemsetup.hpp"
+
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "io_file.hpp"
+#include "modems.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "rtc_time.hpp"
+#include "string_format.hpp"
+
+using namespace portapack;
+using namespace modems;
+namespace fs = std::filesystem;
+
+void BLELoggerTx::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+bool hasValidHexPairs(const std::string& str, int totalPairs) {
+    int validPairs = 0;
+
+    for (int i = 0; i < totalPairs * 2; i += 2) {
+        char c1 = str[i];
+        char c2 = str[i + 1];
+
+        if (!(std::isxdigit(c1) && std::isxdigit(c2))) {
+            return false;  // Return false if any pair is invalid.
+        }
+
+        validPairs++;
+    }
+
+    return (validPairs == totalPairs);
+}
+
+std::vector<std::string> splitIntoStrings(const char* input) {
+    std::vector<std::string> result;
+    int length = std::strlen(input);
+    int start = 0;
+
+    while (start < length) {
+        int remaining = length - start;
+        int chunkSize = (remaining > 30) ? 30 : remaining;
+        result.push_back(std::string(input + start, chunkSize));
+        start += chunkSize;
+    }
+
+    return result;
+}
+
+uint32_t stringToUint32(const std::string& str) {
+    size_t pos = 0;
+    uint32_t result = 0;
+
+    while (pos < str.size() && std::isdigit(str[pos])) {
+        int digit = str[pos] - '0';
+
+        // Check for overflow before adding the next digit
+        if (result > (UINT32_MAX - digit) / 10) {
+            return 0;
+        }
+
+        result = result * 10 + digit;
+        pos++;
+    }
+
+    return result;
+}
+
+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() {
+    int randomChannel = channel_number;
+
+    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));
+    }
+
+    // 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;
+        }
+
+        transmitter_model.enable();
+        button_play.set_bitmap(&bitmap_stop);
+        is_running = true;
+    }
+
+    // Send next packet.
+    progressbar.set_max(packets[current_packet].packet_count);
+    baseband::set_btletx(randomChannel, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
+
+    is_sending = true;
+
+    if ((packet_counter % 10) == 0) {
+        text_packets_sent.set(to_string_dec_uint(packet_counter));
+    }
+
+    packet_counter--;
+    progressbar.set_value(packets[current_packet].packet_count - packet_counter);
+}
+
+void BLETxView::stop() {
+    transmitter_model.disable();
+    progressbar.set_value(0);
+    button_play.set_bitmap(&bitmap_play);
+    check_loop.set_value(false);
+
+    update_current_packet(packets[0], 0);
+
+    is_running = false;
+}
+
+// called each 1/60th of second, so 6 = 100ms
+void BLETxView::on_timer() {
+    if (++mscounter == timer_period) {
+        mscounter = 0;
+
+        if (is_active() && !is_sending) {
+            // Reached end of current packet repeats.
+            if (packet_counter == 0) {
+                // Done sending all packets.
+                if (current_packet == (num_packets - 1)) {
+                    // If looping, restart from beginning.
+                    if (check_loop.value()) {
+                        update_current_packet(packets[current_packet], 0);
+                        start();
+                    } else {
+                        stop();
+                    }
+                } else {
+                    current_packet++;
+                    update_current_packet(packets[current_packet], current_packet);
+                    start();
+                }
+            } else {
+                start();
+            }
+        }
+    }
+}
+
+void BLETxView::on_tx_progress(const bool done) {
+    if (done) {
+        if (is_active()) {
+            is_sending = false;
+        }
+    }
+}
+
+BLETxView::BLETxView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+
+    add_children({&button_open,
+                  &text_filename,
+                  &progressbar,
+                  &check_rand_mac,
+                  &field_frequency,
+                  &tx_view,  // now it handles previous rfgain, rfamp.
+                  &check_loop,
+                  &button_play,
+                  &label_speed,
+                  &options_speed,
+                  &options_channel,
+                  &options_adv_type,
+                  &label_packet_index,
+                  &text_packet_index,
+                  &label_packets_sent,
+                  &text_packets_sent,
+                  &label_mac_address,
+                  &text_mac_address,
+                  &label_data_packet,
+                  &button_save_packet,
+                  &button_switch,
+                  &console});
+
+    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;
+        mscounter = 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>();
+    };
+}
+
+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);
+    }
+
+    console.write(str_console);
+}
+
+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);
+
+    console.clear(true);
+
+    for (const std::string& str : strings) {
+        console.writeln(str);
+    }
+
+    packet_counter = packet.packet_count;
+    current_packet = currentIndex;
+}
+
+void BLETxView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
+    console.set_parent_rect(content_rect);
+}
+
+BLETxView::~BLETxView() {
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+} /* namespace ui */

firmware/application/apps/ble_tx_app.hpp

@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLE_TX_APP_H__
+#define __BLE_TX_APP_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "replay_thread.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+#include "recent_entries.hpp"
+
+#include <string>
+#include <memory>
+
+class BLELoggerTx {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+
+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 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 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_{
+        "ble_tx_app", 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;
+    bool is_sending = false;
+    uint64_t timer_count{0};
+    int16_t timer_period{1};
+    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;
+
+    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};
+    int16_t mscounter = 0;
+
+    BLETxPacket packets[max_num_packets];
+
+    PKT_TYPE pduType = {PKT_TYPE_DISCOVERY};
+
+    static constexpr auto header_height = 9 * 16;
+    static constexpr auto switch_button_height = 3 * 16;
+
+    Button button_open{
+        {0 * 8, 0 * 16, 10 * 8, 2 * 16},
+        "Open file"};
+
+    Text text_filename{
+        {11 * 8, 0 * 16, 12 * 8, 16},
+        "-"};
+
+    ProgressBar progressbar{
+        {11 * 8, 1 * 16, 9 * 8, 16}};
+
+    Checkbox check_rand_mac{
+        {21 * 8, 1 * 16},
+        6,
+        "Random",
+        true};
+
+    TxFrequencyField field_frequency{
+        {0 * 8, 2 * 16},
+        nav_};
+
+    TransmitterView2 tx_view{
+        {11 * 8, 2 * 16},
+        /*short_ui*/ true};
+
+    Checkbox check_loop{
+        {21 * 8, 2 * 16},
+        4,
+        "Loop",
+        true};
+
+    ImageButton button_play{
+        {28 * 8, 2 * 16, 2 * 8, 1 * 16},
+        &bitmap_play,
+        Color::green(),
+        Color::black()};
+
+    Labels label_speed{
+        {{0 * 8, 6 * 8}, "Speed:", Color::light_grey()}};
+
+    OptionsField options_speed{
+        {7 * 8, 6 * 8},
+        3,
+        {{"1 ", 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_packet_index{
+        {{0 * 8, 10 * 8}, "Packet Index:", Color::light_grey()}};
+
+    Text text_packet_index{
+        {13 * 8, 5 * 16, 12 * 8, 16},
+        "-"};
+
+    Labels label_packets_sent{
+        {{0 * 8, 12 * 8}, "Packets Left:", Color::light_grey()}};
+
+    Text text_packets_sent{
+        {13 * 8, 6 * 16, 12 * 8, 16},
+        "-"};
+
+    Labels label_mac_address{
+        {{0 * 8, 14 * 8}, "Mac Address:", Color::light_grey()}};
+
+    Text text_mac_address{
+        {12 * 8, 7 * 16, 20 * 8, 16},
+        "-"};
+
+    Labels label_data_packet{
+        {{0 * 8, 16 * 8}, "Packet Data:", Color::light_grey()}};
+
+    Console console{
+        {0, 8 * 16, 240, 240}};
+
+    Button button_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/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) {
@@ -165,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 */
@@ -103,11 +114,17 @@ class TPMSAppView : public View {
 
    private:
     RxRadioState radio_state_{
-        315000000 /* frequency*/,
+        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,
@@ -129,11 +146,12 @@ 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},
+            {"315", 314950000},
             {"434", 433920000},
         }};
 

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");
                 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,21 +21,23 @@
  * 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 {
 
-bool ac_details_view_active{false};
+static std::string get_map_tag(const AircraftRecentEntry& entry) {
+    return trimr(entry.callsign.empty() ? entry.icao_str : entry.callsign);
+}
 
 template <>
 void RecentEntriesTable<AircraftRecentEntries>::draw(
@@ -43,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) + " " +
@@ -72,47 +77,59 @@ void RecentEntriesTable<AircraftRecentEntries>::draw(
         entry_string);
 
     if (entry.pos.valid)
-        painter.draw_bitmap(target_rect.location() + Point(8 * 8, 0), bitmap_target, target_color, style.background);
+        painter.draw_bitmap(target_rect.location() + Point(8 * 8, 0),
+                            bitmap_target, target_color, style.background);
 }
 
-void ADSBLogger::log_str(std::string& logline) {
-    log_file.write_entry(logline);
+/* ADSBLogger ********************************************/
+
+void ADSBLogger::log(const ADSBLogEntry& log_entry) {
+    std::string log_line;
+    log_line.reserve(100);
+
+    log_line = log_entry.raw_data;
+    log_line += "ICAO:" + log_entry.icao;
+
+    if (!log_entry.callsign.empty())
+        log_line += " " + log_entry.callsign;
+
+    if (log_entry.pos.valid)
+        log_line += " Alt:" + to_string_dec_int(log_entry.pos.altitude) +
+                    " Lat:" + to_string_decimal(log_entry.pos.latitude, 7) +
+                    " Lon:" + to_string_decimal(log_entry.pos.longitude, 7);
+
+    if (log_entry.vel.valid)
+        log_line += " Type:" + to_string_dec_uint(log_entry.vel_type) +
+                    " Hdg:" + to_string_dec_uint(log_entry.vel.heading) +
+                    " Spd: " + to_string_dec_int(log_entry.vel.speed);
+
+    log_file.write_entry(log_line);
 }
 
-// Aircraft Details
-void ADSBRxAircraftDetailsView::focus() {
-    button_close.focus();
-}
-
-ADSBRxAircraftDetailsView::~ADSBRxAircraftDetailsView() {
-    on_close_();
-}
+/* ADSBRxAircraftDetailsView *****************************/
 
 ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
     NavigationView& nav,
-    const AircraftRecentEntry& entry,
-    const std::function<void(void)> on_close)
-    : entry_copy(entry),
-      on_close_(on_close) {
-    add_children({&labels,
-                  &text_icao_address,
-                  &text_registration,
-                  &text_manufacturer,
-                  &text_model,
-                  &text_type,
-                  &text_number_of_engines,
-                  &text_engine_type,
-                  &text_owner,
-                  &text_operator,
-                  &button_close});
+    const AircraftRecentEntry& entry) {
+    add_children(
+        {&labels,
+         &text_icao_address,
+         &text_registration,
+         &text_manufacturer,
+         &text_model,
+         &text_type,
+         &text_number_of_engines,
+         &text_engine_type,
+         &text_owner,
+         &text_operator,
+         &button_close});
 
-    std::unique_ptr<ADSBLogger> logger{};
-
-    icao_code = to_string_hex(entry_copy.ICAO_address, 6);
-    text_icao_address.set(to_string_hex(entry_copy.ICAO_address, 6));
+    text_icao_address.set(entry.icao_str);
 
     // Try getting the aircraft information from icao24.db
-    return_code = db.retrieve_aircraft_record(&aircraft_record, icao_code);
+    std::database db{};
+    std::database::AircraftDBRecord aircraft_record;
+    auto return_code = db.retrieve_aircraft_record(&aircraft_record, entry.icao_str);
     switch (return_code) {
         case DATABASE_RECORD_FOUND:
             text_registration.set(aircraft_record.aircraft_registration);
@@ -120,6 +137,7 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
             text_model.set(aircraft_record.aircraft_model);
             text_owner.set(aircraft_record.aircraft_owner);
             text_operator.set(aircraft_record.aircraft_operator);
+
             // Check for ICAO type, e.g. L2J
             if (strlen(aircraft_record.icao_type) == 3) {
                 switch (aircraft_record.icao_type[0]) {
@@ -142,7 +160,8 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
                         text_type.set("Tilt-wing aircraft");
                         break;
                 }
-                text_number_of_engines.set(std::string(1, aircraft_record.icao_type[1]));
+
+                text_number_of_engines.set(std::string{1, aircraft_record.icao_type[1]});
                 switch (aircraft_record.icao_type[2]) {
                     case 'P':
                         text_engine_type.set("Piston engine");
@@ -157,8 +176,8 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
                         text_engine_type.set("Electric engine");
                         break;
                 }
-
             }
+
             // Check for ICAO type designator
             else if (strlen(aircraft_record.icao_type) == 4) {
                 if (strcmp(aircraft_record.icao_type, "SHIP") == 0)
@@ -179,77 +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&) {
-        ac_details_view_active = false;
         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() {
-    ac_details_view_active = false;
-    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);
@@ -260,34 +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&) {
-        ac_details_view_active = true;
-        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() {
@@ -296,232 +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.
 
-    // NB: Temporarily pausing updates in rtc_timer_tick context when viewing AC Details screen (kludge for some Guru faults)
-    // TODO: More targeted blocking of updates in rtc_timer_tick when ADSB processes are running
-    if (ac_details_view_active)
-        return;
+    if (details_view) {
+        // The details view is showing, forward updates to that UI.
+        bool current_updated = false;
+        bool map_needs_update = false;
 
-    // Sort and truncate the entries, grouped, newest group first
-    sort_entries_by_state();
-    truncate_entries(recent);
-    remove_old_entries();
+        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;
+        }
 
-    // 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;
+        // 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.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,46 +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_{
-        1090000000 /* frequency */,
-        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()}};
@@ -386,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_btle_rx.cpp

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

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

@@ -124,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 {
@@ -159,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() {
@@ -180,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)};
 
@@ -197,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(
@@ -212,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&) {
@@ -237,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() {
@@ -376,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
 }
@@ -402,9 +447,10 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
         {"Buttons Test", ui::Color::dark_cyan(), &bitmap_icon_controls, [&nav]() { nav.push<DebugControlsView>(); }},
         {"Debug Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { portapack::persistent_memory::debug_dump(); }},
         {"M0 Stack Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { stack_dump(); }},
-        {"Memory", 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>(); }},
@@ -418,30 +464,53 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
     set_max_rows(2);  // allow wider buttons
 }
 
-/* DebugPmemView *********************************************************/
+/* DebugMemoryDumpView *********************************************************/
 
-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();
+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();
+    };
 }
 
-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());
+void DebugMemoryDumpView::focus() {
+    button_done.focus();
+}
 
+/* DebugPmemView *********************************************************/
+
+DebugPmemView::DebugPmemView(NavigationView& nav)
+    : 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();
@@ -451,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();
 
@@ -463,17 +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);
-}
-
 /* 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,7 +377,6 @@ class DebugPmemView : public View {
     };
 
     void update();
-    uint32_t registers_widget_feed(const size_t register_number);
 };
 
 class DebugScreenTest : public View {

firmware/application/apps/ui_fileman.cpp

@@ -156,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())) {
@@ -568,6 +568,7 @@ FileManagerView::FileManagerView(
         &button_open_notepad,
         &button_rename_timestamp,
         &button_open_iq_trim,
+        &button_show_hidden_files,
     });
 
     menu_view.on_highlight = [this]() {
@@ -658,6 +659,12 @@ FileManagerView::FileManagerView(
         } 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()}};
 
@@ -278,6 +280,12 @@ class FileManagerView : public FileManBaseView {
         {},
         &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,
     });
 
@@ -72,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();
@@ -133,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();
 }
 
@@ -191,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

@@ -107,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{
@@ -135,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{
@@ -145,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_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) {
@@ -101,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) {
@@ -128,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;
                 }
@@ -138,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.
@@ -183,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(
@@ -199,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.
@@ -602,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(
@@ -611,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.
@@ -630,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.
@@ -637,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,67 +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()},
@@ -143,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},
@@ -224,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},
@@ -277,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
@@ -286,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{
@@ -340,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_recon.cpp

@@ -481,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]() {
@@ -567,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>");
@@ -614,7 +613,7 @@ ReconView::ReconView(NavigationView& nav)
             button_scanner_mode.set_text("SCAN");
             button_remove.set_text("DELETE");
         }
-        frequency_file_load(true);
+        frequency_file_load();
         if (autostart) {
             recon_resume();
         } else {
@@ -642,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) {
@@ -709,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 {
@@ -718,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();
 
@@ -784,7 +783,7 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
     // 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();
@@ -1214,11 +1213,12 @@ void ReconView::handle_remove_current_item() {
     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();
 }
 

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

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_settings.cpp

@@ -343,6 +343,38 @@ void SetUIView::focus() {
     button_save.focus();
 }
 
+/* SetSDCardView *********************************************/
+
+SetSDCardView::SetSDCardView(NavigationView& nav) {
+    add_children({&labels,
+                  &checkbox_sdcard_speed,
+                  &button_test_sdcard_high_speed,
+                  &text_sdcard_test_status,
+                  &button_save,
+                  &button_cancel});
+
+    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_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 SetSDCardView::focus() {
+    button_save.focus();
+}
+
 /* SetConverterSettingsView ******************************/
 
 SetConverterSettingsView::SetConverterSettingsView(NavigationView& nav) {
@@ -636,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,8 +306,43 @@ class SetUIView : public View {
 
     Button button_cancel{
         {16 * 8, 16 * 16, 12 * 8, 32},
-        "Cancel",
-    };
+        "Cancel"};
+};
+
+class SetSDCardView : public View {
+   public:
+    SetSDCardView(NavigationView& nav);
+
+    void focus() override;
+
+    std::string title() const override { return "SD Card"; };
+
+   private:
+    Labels labels{
+        // 01234567890123456789012345678
+        {{1 * 8, 120 - 48}, "    HIGH SPEED SDCARD IO     ", Color::light_grey()},
+        {{1 * 8, 120 - 32}, "   May or may not work !!    ", Color::light_grey()}};
+
+    Checkbox checkbox_sdcard_speed{
+        {2 * 8, 120},
+        20,
+        "enable high speed IO"};
+
+    Button button_test_sdcard_high_speed{
+        {2 * 8, 152, 27 * 8, 32},
+        "TEST BUTTON (NO PMEM SAVE)"};
+
+    Text text_sdcard_test_status{
+        {2 * 8, 198, 28 * 8, 16},
+        ""};
+
+    Button button_save{
+        {2 * 8, 16 * 16, 12 * 8, 32},
+        "Save"};
+
+    Button button_cancel{
+        {16 * 8, 16 * 16, 12 * 8, 32},
+        "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

@@ -58,15 +58,16 @@ class SigGenView : public View {
     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};
 
@@ -86,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/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);
 }
 

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

firmware/application/bitmap.hpp

@@ -5683,6 +5683,44 @@ 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};
+
 } /* 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

@@ -258,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);
@@ -299,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/hw/max2837.cpp

@@ -321,7 +321,7 @@ void MAX2837::set_rx_buff_vcm(const size_t v) {
     flush();
 }
 
-reg_t MAX2837::temp_sense() {
+int8_t MAX2837::temp_sense() {
     if (!_map.r.rx_top.ts_en) {
         _map.r.rx_top.ts_en = 1;
         flush_one(Register::RX_TOP);
@@ -334,12 +334,15 @@ reg_t MAX2837::temp_sense() {
 
     halPolledDelay(ticks_for_temperature_sense_adc_conversion);
 
-    const auto value = read(Register::TEMP_SENSE);
+    /*
+     * Conversion to degrees C determined by testing - does not match data sheet.
+     */
+    reg_t value = read(Register::TEMP_SENSE) & 0x1F;
 
     _map.r.rx_top.ts_adc_trigger = 0;
     flush_one(Register::RX_TOP);
 
-    return value;
+    return std::min(127, (int)(value * 4.31 - 40));  // reg value is 0 to 31; possible return range is -40 C to 127 C
 }
 
 }  // namespace max2837

firmware/application/hw/max2837.hpp

@@ -833,9 +833,10 @@ class MAX2837 : public MAX283x {
     void set_vco_bias(const size_t v);
     void set_rx_buff_vcm(const size_t v) override;
 
-    reg_t temp_sense() override;
+    int8_t temp_sense() override;
 
     reg_t read(const address_t reg_num) override;
+    void write(const address_t reg_num, const reg_t value) override;
 
    private:
     spi::arbiter::Target& _target;
@@ -845,8 +846,6 @@ class MAX2837 : public MAX283x {
 
     void flush_one(const Register reg);
 
-    void write(const address_t reg_num, const reg_t value);
-
     void write(const Register reg, const reg_t value);
     reg_t read(const Register reg);
 

firmware/application/hw/max2839.cpp

@@ -351,7 +351,7 @@ void MAX2839::set_rx_buff_vcm(const size_t v) {
     flush();
 }
 
-reg_t MAX2839::temp_sense() {
+int8_t MAX2839::temp_sense() {
     if (!_map.r.rx_top_2.ts_en) {
         _map.r.rx_top_2.ts_en = 1;
         flush_one(Register::RX_TOP_2);
@@ -365,15 +365,14 @@ reg_t MAX2839::temp_sense() {
     halPolledDelay(ticks_for_temperature_sense_adc_conversion);
 
     /*
-     * Things look very similar to MAX2837, so this probably works, but the
-     * MAX2839 data sheet does not describe the TEMP_SENSE register contents.
+     * Conversion to degrees C determined by testing - does not match data sheet.
      */
-    const auto value = read(Register::TEMP_SENSE);
+    reg_t value = read(Register::TEMP_SENSE) & 0x1F;
 
     _map.r.rx_top_2.ts_adc_trigger = 0;
     flush_one(Register::RX_TOP_2);
 
-    return value;
+    return std::min(127, (int)(value * 4.31 - 40));  // reg value is 0 to 31; possible return range is -40 C to 127 C
 }
 
 }  // namespace max2839

firmware/application/hw/max2839.hpp

@@ -692,9 +692,10 @@ class MAX2839 : public MAX283x {
     void set_rx_lo_iq_calibration(const size_t v) override;
     void set_rx_buff_vcm(const size_t v) override;
 
-    reg_t temp_sense() override;
+    int8_t temp_sense() override;
 
     reg_t read(const address_t reg_num) override;
+    void write(const address_t reg_num, const reg_t value) override;
 
    private:
     spi::arbiter::Target& _target;
@@ -704,8 +705,6 @@ class MAX2839 : public MAX283x {
 
     void flush_one(const Register reg);
 
-    void write(const address_t reg_num, const reg_t value);
-
     void write(const Register reg, const reg_t value);
     reg_t read(const Register reg);
 

firmware/application/hw/max283x.hpp

@@ -131,9 +131,10 @@ class MAX283x {
     virtual void set_rx_lo_iq_calibration(const size_t v);
     virtual void set_rx_buff_vcm(const size_t v);
 
-    virtual reg_t temp_sense();
+    virtual int8_t temp_sense();
 
     virtual reg_t read(const address_t reg_num);
+    virtual void write(const address_t reg_num, const reg_t value);
 };
 
 }  // namespace max283x

firmware/application/hw/rffc507x.hpp

@@ -841,6 +841,7 @@ class RFFC507x {
     void set_gpo1(const bool new_value);
 
     reg_t read(const address_t reg_num);
+    void write(const address_t reg_num, const reg_t value);
 
    private:
     spi::SPI _bus{};
@@ -848,8 +849,6 @@ class RFFC507x {
     RegisterMap _map{default_hackrf_one};
     DirtyRegisters<Register, reg_count> _dirty{};
 
-    void write(const address_t reg_num, const reg_t value);
-
     void write(const Register reg, const reg_t value);
     reg_t read(const Register reg);
 

firmware/application/iq_trim.cpp

@@ -36,6 +36,13 @@ uint32_t power(T value) {
     return (real * real) + (imag * imag);
 }
 
+template <typename T>
+uint32_t iq_max(T value) {
+    auto real = abs(value.real());
+    auto imag = abs(value.imag());
+    return (real > imag) ? real : imag;
+}
+
 /* Collects capture file metadata and sample power buckets. */
 template <typename T>
 Optional<CaptureInfo> profile_capture(
@@ -51,7 +58,8 @@ Optional<CaptureInfo> profile_capture(
         .file_size = f.size(),
         .sample_count = f.size() / sizeof(T),
         .sample_size = sizeof(T),
-        .max_power = 0};
+        .max_power = 0,
+        .max_iq = 0};
 
     auto profile_samples = buckets.size * samples_per_bucket;
     auto sample_interval = info.sample_count / profile_samples;
@@ -67,8 +75,11 @@ Optional<CaptureInfo> profile_capture(
         if (*result != info.sample_size)
             break;  // EOF
 
-        auto mag_squared = power(value);
+        auto max_iq = iq_max(value);
+        if (max_iq > info.max_iq)
+            info.max_iq = max_iq;
 
+        auto mag_squared = power(value);
         if (mag_squared > info.max_power)
             info.max_power = mag_squared;
 
@@ -133,13 +144,50 @@ TrimRange compute_trim_range(
         info.sample_size};
 }
 
+void amplify_iq_buffer(uint8_t* buffer, uint32_t length, uint32_t amplification, uint8_t sample_size) {
+    uint32_t mult_count = length / sample_size / 2;
+
+    switch (sample_size) {
+        case sizeof(complex16_t): {
+            int16_t* buf_ptr = (int16_t*)buffer;
+            for (uint32_t i = 0; i < mult_count; i++) {
+                int32_t val = *buf_ptr * amplification;
+                if (val > 0x7FFF)
+                    val = 0x7FFF;
+                else if (val < -0x7FFF)
+                    val = -0x7FFF;
+                *buf_ptr++ = val;
+            }
+            break;
+        }
+
+        case sizeof(complex8_t): {
+            int8_t* buf_ptr = (int8_t*)buffer;
+            for (uint32_t i = 0; i < mult_count; i++) {
+                int32_t val = *buf_ptr * amplification;
+                if (val > 0x7F)
+                    val = 0x7F;
+                else if (val < -0x7F)
+                    val = -0x7F;
+                *buf_ptr++ = val;
+            }
+            break;
+        }
+
+        default:
+            break;
+    }
+}
+
 bool trim_capture_with_range(
     const fs::path& path,
     TrimRange range,
-    const std::function<void(uint8_t)>& on_progress) {
+    const std::function<void(uint8_t)>& on_progress,
+    const uint32_t amplification) {
     constexpr size_t buffer_size = std::filesystem::max_file_block_size;
     uint8_t buffer[buffer_size];
     auto temp_path = path + u"-tmp";
+    auto sample_size = fs::capture_file_sample_size(path);
 
     // end_sample is the first sample to _not_ include.
     auto start_byte = range.start_sample * range.sample_size;
@@ -168,6 +216,9 @@ bool trim_capture_with_range(
         auto remaining = length - processed;
         auto to_write = std::min(remaining, *result);
 
+        if (amplification > 1)
+            amplify_iq_buffer(buffer, to_write, amplification, sample_size);
+
         result = dst->write(buffer, to_write);
         if (result.is_error()) return false;
 

firmware/application/iq_trim.hpp

@@ -37,6 +37,7 @@ struct CaptureInfo {
     uint64_t sample_count;
     uint8_t sample_size;
     uint32_t max_power;
+    uint32_t max_iq;
 };
 
 /* Holds sample average power by bucket. */
@@ -82,11 +83,19 @@ TrimRange compute_trim_range(
     const PowerBuckets& buckets,
     uint8_t cutoff_percent);
 
+/* Multiplies samples in an IQ buffer by amplification value */
+void amplify_iq_buffer(
+    uint8_t* buffer,
+    uint32_t length,
+    uint32_t amplification,
+    uint8_t sample_size);
+
 /* Trims the capture file with the specified range. */
 bool trim_capture_with_range(
     const std::filesystem::path& path,
     TrimRange range,
-    const std::function<void(uint8_t)>& on_progress);
+    const std::function<void(uint8_t)>& on_progress,
+    const uint32_t amplification);
 
 }  // namespace iq
 

firmware/application/main.cpp

@@ -186,6 +186,8 @@ int main(void) {
         sdcStop(&SDCD1);
 
         portapack::shutdown();
+    } else {
+        config_mode_clear();
     }
 
     m4_init(portapack::spi_flash::image_tag_hackrf, portapack::memory::map::m4_code_hackrf, true);

firmware/application/portapack.cpp

@@ -467,6 +467,20 @@ bool init() {
     i2c0.start(i2c_config_fast_clock);
     chThdSleepMilliseconds(10);
 
+    /* Check if portapack is attached by checking if any of the two audio chips is present. */
+    systime_t timeout = 50;
+    uint8_t wm8731_reset_command[] = {0x0f, 0x00};
+    if (i2c0.transmit(0x1a /* wm8731 */, wm8731_reset_command, 2, timeout) == false) {
+        audio_codec_ak4951.reset();
+        uint8_t ak4951_init_command[] = {0x00, 0x00};
+        i2c0.transmit(0x12 /* ak4951 */, ak4951_init_command, 2, timeout);
+        chThdSleepMilliseconds(10);
+        if (i2c0.transmit(0x12 /* ak4951 */, ak4951_init_command, 2, timeout) == false) {
+            shutdown_base();
+            return false;
+        }
+    }
+
     touch::adc::init();
     controls_init();
     chThdSleepMilliseconds(10);

firmware/application/protocols/aprs.cpp

@@ -20,6 +20,8 @@
  * Boston, MA 02110-1301, USA.
  */
 
+#include <cstdint>
+
 #include "aprs.hpp"
 #include "ax25.hpp"
 

firmware/application/radio.cpp

@@ -61,7 +61,7 @@ static constexpr SPIConfig ssp_config_max283x = {
     .ssport = gpio_max283x_select.port(),
     .sspad = gpio_max283x_select.pad(),
     .cr0 =
-        CR0_CLOCKRATE(ssp_scr(ssp1_pclk_f, ssp1_cpsr, max283x_spi_f)) | CR0_FRFSPI | CR0_DSS16BIT,
+        CR0_CLOCKRATE(ssp_scr(ssp1_pclk_f, ssp1_cpsr, max283x_spi_f) + 1) | CR0_FRFSPI | CR0_DSS16BIT,
     .cpsr = ssp1_cpsr,
 };
 
@@ -287,6 +287,10 @@ uint32_t register_read(const size_t register_number) {
     return radio::first_if.read(register_number);
 }
 
+void register_write(const size_t register_number, uint32_t value) {
+    radio::first_if.write(register_number, value);
+}
+
 } /* namespace first_if */
 
 namespace second_if {
@@ -295,8 +299,12 @@ uint32_t register_read(const size_t register_number) {
     return radio::second_if->read(register_number);
 }
 
-uint8_t temp_sense() {
-    return radio::second_if->temp_sense() & 0x1f;
+void register_write(const size_t register_number, uint32_t value) {
+    radio::second_if->write(register_number, value);
+}
+
+int8_t temp_sense() {
+    return radio::second_if->temp_sense();
 }
 
 } /* namespace second_if */

firmware/application/radio.hpp

@@ -65,15 +65,17 @@ namespace debug {
 namespace first_if {
 
 uint32_t register_read(const size_t register_number);
+void register_write(const size_t register_number, uint32_t value);
 
 } /* namespace first_if */
 
 namespace second_if {
 
 uint32_t register_read(const size_t register_number);
+void register_write(const size_t register_number, uint32_t value);
 
 // TODO: This belongs somewhere else.
-uint8_t temp_sense();
+int8_t temp_sense();
 
 } /* namespace second_if */
 

firmware/application/recent_entries.hpp

@@ -24,13 +24,13 @@
 
 #include "ui_widget.hpp"
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <list>
-#include <utility>
 #include <functional>
 #include <iterator>
-#include <algorithm>
+#include <list>
+#include <utility>
 
 template <class Entry>
 using RecentEntries = std::list<Entry>;
@@ -42,6 +42,13 @@ typename ContainerType::const_iterator find(const ContainerType& entries, const
         [key](typename ContainerType::const_reference e) { return e.key() == key; });
 }
 
+template <typename ContainerType, typename Key>
+typename ContainerType::iterator find(ContainerType& entries, const Key key) {
+    return std::find_if(
+        std::begin(entries), std::end(entries),
+        [key](typename ContainerType::const_reference e) { return e.key() == key; });
+}
+
 template <typename ContainerType>
 static void truncate_entries(ContainerType& entries, const size_t entries_max = 64) {
     while (entries.size() > entries_max) {
@@ -88,6 +95,36 @@ static std::pair<typename ContainerType::const_iterator, typename ContainerType:
     return {start, end};
 }
 
+template <typename ContainerType, typename KeySelector, typename SortOrder>
+void sortEntriesBy(ContainerType& entries, KeySelector keySelector, SortOrder ascending) {
+    entries.sort([keySelector, ascending](const auto& a, const auto& b) {
+        return ascending ? keySelector(a) < keySelector(b) : keySelector(a) > keySelector(b);
+    });
+}
+
+template <typename ContainerType, typename KeySelector>
+void resetFilteredEntries(ContainerType& entries, KeySelector keySelector) {
+    // Clear the filteredEntries container
+    auto it = entries.begin();
+    while (it != entries.end()) {
+        if (keySelector(*it)) {
+            entries.erase(it);  // Add a new entry to filteredEntries
+        }
+        ++it;  // Move to the next element, outside of the if block
+    }
+}
+
+template <typename ContainerType, typename MemberPtr, typename KeyValue>
+void setAllMembersToValue(ContainerType& entries, MemberPtr memberPtr, const KeyValue& keyValue) {
+    for (auto& entry : entries) {
+        // Check if the member specified by memberPtr is equal to keyValue
+        if (entry.*memberPtr != keyValue) {
+            // Update the member with keyValue
+            entry.*memberPtr = keyValue;
+        }
+    }
+}
+
 namespace ui {
 
 using RecentEntriesColumn = std::pair<std::string, size_t>;
@@ -272,6 +309,10 @@ class RecentEntriesView : public View {
         _table.focus();
     }
 
+    void set_table(Entries& new_table) {
+        _table = new_table;
+    }
+
    private:
     RecentEntriesHeader _header;
     RecentEntriesTable<Entries> _table;

firmware/application/string_format.cpp

@@ -311,6 +311,72 @@ std::string to_string_file_size(uint32_t file_size) {
     return to_string_dec_uint(file_size) + suffix[suffix_index];
 }
 
+std::string to_string_mac_address(const uint8_t* macAddress, uint8_t length, bool noColon) {
+    std::string string;
+
+    string += to_string_hex(macAddress[0], 2);
+
+    for (int i = 1; i < length; i++) {
+        string += noColon ? to_string_hex(macAddress[i], 2) : ":" + to_string_hex(macAddress[i], 2);
+    }
+
+    return string;
+}
+
+std::string to_string_formatted_mac_address(const char* macAddress) {
+    std::string formattedAddress;
+
+    for (int i = 0; i < 12; i += 2) {
+        if (i > 0) {
+            formattedAddress += ':';
+        }
+        formattedAddress += macAddress[i];
+        formattedAddress += macAddress[i + 1];
+    }
+
+    return formattedAddress;
+}
+
+void generateRandomMacAddress(char* macAddress) {
+    const char hexDigits[] = "0123456789ABCDEF";
+
+    // Generate 12 random hexadecimal characters
+    for (int i = 0; i < 12; i++) {
+        int randomIndex = rand() % 16;
+        macAddress[i] = hexDigits[randomIndex];
+    }
+    macAddress[12] = '\0';  // Null-terminate the string
+}
+
+uint64_t readUntil(File& file, char* result, std::size_t maxBufferSize, char delimiter) {
+    std::size_t bytesRead = 0;
+
+    while (true) {
+        char ch;
+        File::Result<File::Size> readResult = file.read(&ch, 1);
+
+        if (readResult.is_ok() && readResult.value() > 0) {
+            if (ch == delimiter) {
+                // Found a space character, stop reading
+                break;
+            } else if (bytesRead < maxBufferSize) {
+                // Append the character to the result if there's space
+                result[bytesRead++] = ch;
+            } else {
+                // Buffer is full, break to prevent overflow
+                break;
+            }
+        } else {
+            break;  // End of file or error
+        }
+    }
+
+    // Null-terminate the result string
+    result[bytesRead] = '\0';
+
+    return bytesRead;
+}
+
 std::string unit_auto_scale(double n, const uint32_t base_unit, uint32_t precision) {
     const uint32_t powers_of_ten[5] = {1, 10, 100, 1000, 10000};
     std::string string{""};

firmware/application/string_format.hpp

@@ -76,6 +76,13 @@ std::string to_string_FAT_timestamp(const FATTimestamp& timestamp);
 // Gets a human readable file size string.
 std::string to_string_file_size(uint32_t file_size);
 
+// Converts Mac Address to string.
+std::string to_string_mac_address(const uint8_t* macAddress, uint8_t length, bool noColon);
+std::string to_string_formatted_mac_address(const char* macAddress);
+void generateRandomMacAddress(char* macAddress);
+
+uint64_t readUntil(File& file, char* result, std::size_t maxBufferSize, char delimiter);
+
 /* Scales 'n' to be a value less than 1000. 'base_unit' is the index of the unit from
  * 'unit_prefix' that 'n' is in initially. 3 is the index of the '1s' unit. */
 std::string unit_auto_scale(double n, const uint32_t base_unit, uint32_t precision);

firmware/application/temperature_logger.hpp

@@ -29,7 +29,7 @@
 
 class TemperatureLogger {
    public:
-    using sample_t = uint8_t;
+    using sample_t = int8_t;
 
     void second_tick();
 

firmware/application/ui/ui_alphanum.cpp

@@ -118,7 +118,12 @@ void AlphanumView::refresh_keys() {
 
     size_t n = 0;
     for (auto& button : buttons) {
-        button.set_text(std::string{key_list[n]});
+        if (n > strlen(key_list)) {
+            button.set_text(std::string{'\0'});
+        } else {
+            button.set_text(std::string{key_list[n]});
+        }
+
         n++;
     }
 
@@ -137,7 +142,9 @@ void AlphanumView::refresh_keys() {
 
 void AlphanumView::on_button(Button& button) {
     const auto c = button.text()[0];
-    char_add(c);
+    if (c != '\0') {
+        char_add(c);
+    }
 
     // TODO: Consolidate shift handling.
     if (shift_mode == ShiftMode::Shift) {

firmware/application/ui/ui_alphanum.hpp

@@ -57,6 +57,7 @@ class AlphanumView : public TextEntryView {
     const char* const keys_upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ, .";
     const char* const keys_digit = "1234567890()'`\"+-*/=<>_\\!?, .";
     const char* const keys_symbl = "!@#$%^&*()[]'`\"{}|:;<>-_~?, .";
+    const char* const keys_hex = "1234567890ABCDEF ";
 
     struct key_set_t {
         const char* name;
@@ -64,9 +65,10 @@ class AlphanumView : public TextEntryView {
         const char* shifted;
     };
 
-    const key_set_t key_sets[2] = {
+    const key_set_t key_sets[3] = {
         {"abc", keys_lower, keys_upper},
-        {"123", keys_digit, keys_symbl}};
+        {"123", keys_digit, keys_symbl},
+        {"hex", keys_hex, keys_hex}};
 
     int16_t focused_button = 0;
     uint32_t mode = 0;  // Letters.

firmware/application/ui/ui_btngrid.cpp

@@ -246,13 +246,24 @@ void load_blacklist() {
     if (error)
         return;
 
-    blacklist_ptr = std::unique_ptr<char>(new char[f.size()]);
-    if (f.read(blacklist_ptr.get(), f.size()))
-        blacklist_len = f.size();
+    // allocating two extra bytes for leading & trailing commas
+    blacklist_ptr = std::unique_ptr<char>(new char[f.size() + 2]);
+    if (f.read(blacklist_ptr.get() + 1, f.size())) {
+        blacklist_len = f.size() + 2;
+
+        // replace any CR/LF characters with comma delineator, and add comma prefix/suffix, to simplify searching
+        char* ptr = blacklist_ptr.get();
+        *ptr = ',';
+        *(ptr + blacklist_len - 1) = ',';
+        for (size_t i = 0; i < blacklist_len; i++, ptr++) {
+            if (*ptr == 0x0D || *ptr == 0x0A)
+                *ptr = ',';
+        }
+    }
 }
 
 bool BtnGridView::blacklisted_app(GridItem new_item) {
-    std::string app_name = new_item.text;
+    std::string app_name = "," + new_item.text + ",";
 
     if (blacklist_len < app_name.size())
         return false;

firmware/application/ui/ui_receiver.cpp

@@ -42,6 +42,16 @@ FrequencyField::FrequencyField(
     set_focusable(true);
 }
 
+FrequencyField::FrequencyField(
+    const Point parent_pos,
+    const rf::FrequencyRange range)
+    : Widget{{parent_pos, {8 * 10, 16}}},
+      length_{11},
+      range_{range} {
+    initial_switch_config_ = get_switches_long_press_config();
+    set_focusable(true);
+}
+
 FrequencyField::~FrequencyField() {
     reset_switch_config();
 }

firmware/application/ui/ui_receiver.hpp

@@ -48,6 +48,7 @@ class FrequencyField : public Widget {
     using range_t = rf::FrequencyRange;
 
     FrequencyField(Point parent_pos);
+    FrequencyField(Point parent_pos, rf::FrequencyRange range);
     ~FrequencyField();
 
     rf::Frequency value() const;
@@ -66,8 +67,7 @@ class FrequencyField : public Widget {
 
    private:
     const size_t length_;
-    const range_t range_;
-
+    range_t range_;
     rf::Frequency value_{0};
     rf::Frequency step_{25000};
     uint64_t last_ms_{0};

firmware/application/ui/ui_rssi.cpp

@@ -30,6 +30,10 @@
 #define max(a, b) ((a) > (b) ? (a) : (b))
 #define abs(x) ((x) > 0 ? (x) : -(x))
 
+// flag value for graph min
+// If it does not change, then all graph min values are is zero
+#define GRAPH_MIN_ALL_ZERO_FLAG 666
+
 namespace ui {
 
 RSSI::RSSI(
@@ -209,17 +213,48 @@ void RSSI::on_statistics_update(const RSSIStatistics& statistics) {
     set_dirty();
 }
 
+int16_t RSSIGraph::get_graph_min() {
+    return graph_min_;
+}
+
+int16_t RSSIGraph::get_graph_avg() {
+    return graph_avg_;
+}
+
+int16_t RSSIGraph::get_graph_max() {
+    return graph_max_;
+}
+
+int16_t RSSIGraph::get_graph_delta() {
+    return graph_max_ - graph_min_;
+}
+
 void RSSIGraph::paint(Painter& painter) {
     const auto r = screen_rect();
 
-    RSSIGraph_entry& prev_entry = graph_list[0];
-    int xpos = 0, prev_xpos = r.width();
+    if (graph_list.size() == 0)
+        return;
 
+    int xpos = 0, prev_xpos = r.width();
+    RSSIGraph_entry& prev_entry = graph_list[0];
+
+    graph_min_ = GRAPH_MIN_ALL_ZERO_FLAG;  // if it stays at that value the whole graphlist min are zero
+    graph_max_ = 0;
+    int avg_sum = 0;
     for (int n = 1; (unsigned)n <= graph_list.size(); n++) {
         xpos = (r.width() * (graph_list.size() - n)) / graph_list.size();
         int size = abs(xpos - prev_xpos);
         RSSIGraph_entry& entry = graph_list[n - 1];
 
+        // stats
+        if (entry.rssi_min != 0 && entry.rssi_min < graph_min_) {
+            graph_min_ = entry.rssi_min;
+        }
+        if (entry.rssi_max > graph_max_) {
+            graph_max_ = entry.rssi_max;
+        }
+        avg_sum += entry.rssi_avg;
+
         // black
         const Rect r0{r.right() - prev_xpos, r.top(), size, r.height()};
         painter.fill_rectangle(
@@ -293,6 +328,10 @@ void RSSIGraph::paint(Painter& painter) {
         prev_entry = entry;
         prev_xpos = xpos;
     }
+    graph_avg_ = (avg_sum / graph_list.size());
+    // hack to only set to 0 if all graphlist min values are 0
+    if (graph_min_ == GRAPH_MIN_ALL_ZERO_FLAG)
+        graph_min_ = 0;
 }
 
 /*void RSSIGraph::paintOld(Painter& painter) {

firmware/application/ui/ui_rssi.hpp

@@ -49,6 +49,7 @@ class RSSI : public Widget {
         : RSSI{{}, {}} {
     }
 
+    // get last used/received min/avg/max/delta
     int16_t get_min();
     int16_t get_avg();
     int16_t get_max();
@@ -113,8 +114,16 @@ class RSSIGraph : public Widget {
 
     void on_hide() override;
     void on_show() override;
+    // get whole graph_list min/avg/max/delta
+    int16_t get_graph_min();
+    int16_t get_graph_avg();
+    int16_t get_graph_max();
+    int16_t get_graph_delta();
 
    private:
+    int16_t graph_min_ = 0;
+    int16_t graph_avg_ = 0;
+    int16_t graph_max_ = 0;
     uint16_t nb_columns_before_hide = 16;
     uint16_t nb_columns = 16;
     RSSIGraphList graph_list{};

firmware/application/ui_navigation.cpp

@@ -45,6 +45,7 @@
 #include "ui_flash_utility.hpp"
 #include "ui_font_fixed_8x16.hpp"
 #include "ui_freqman.hpp"
+#include "ui_fsk_rx.hpp"
 #include "ui_iq_trim.hpp"
 #include "ui_jammer.hpp"
 // #include "ui_keyfob.hpp"
@@ -85,6 +86,9 @@
 #include "ais_app.hpp"
 #include "analog_audio_app.hpp"
 #include "analog_tv_app.hpp"
+#include "ble_comm_app.hpp"
+#include "ble_rx_app.hpp"
+#include "ble_tx_app.hpp"
 #include "capture_app.hpp"
 #include "ert_app.hpp"
 #include "gps_sim_app.hpp"
@@ -167,6 +171,9 @@ SystemStatusView::SystemStatusView(
         pmem::load_persistent_settings_from_file();
     }
 
+    // force apply of selected sdcard speed override at UI startup
+    pmem::set_config_sdcard_high_speed_io(pmem::config_sdcard_high_speed_io(), false);
+
     button_back.id = -1;  // Special ID used by FocusManager
     title.set_style(&Styles::bg_dark_grey);
 
@@ -395,6 +402,7 @@ void SystemStatusView::rtc_battery_workaround() {
                 }
             }
         } else {
+            make_new_directory(SETTINGS_DIR);
             make_new_file(DATE_FILEFLAG);
 
             year = 1980;
@@ -546,7 +554,9 @@ ReceiversMenuView::ReceiversMenuView(NavigationView& nav) {
         {"Analog TV", Color::yellow(), &bitmap_icon_sstv, [&nav]() { nav.push<AnalogTvView>(); }},
         {"APRS", Color::green(), &bitmap_icon_aprs, [&nav]() { nav.push<APRSRXView>(); }},
         {"Audio", Color::green(), &bitmap_icon_speaker, [&nav]() { nav.push<AnalogAudioView>(); }},
-        {"BTLE", Color::yellow(), &bitmap_icon_btle, [&nav]() { nav.push<BTLERxView>(); }},
+        //{"BTLE", Color::yellow(), &bitmap_icon_btle, [&nav]() { nav.push<BTLERxView>(); }},
+        //{"BLE Comm", ui::Color::orange(), &bitmap_icon_btle, [&nav]() { nav.push<BLECommView>(); }},
+        {"BLE Rx", Color::green(), &bitmap_icon_btle, [&nav]() { nav.push<BLERxView>(); }},
         {"ERT Meter", Color::green(), &bitmap_icon_ert, [&nav]() { nav.push<ERTAppView>(); }},
         {"Level", Color::green(), &bitmap_icon_options_radio, [&nav]() { nav.push<LevelView>(); }},
         {"NRF", Color::yellow(), &bitmap_icon_nrf, [&nav]() { nav.push<NRFRxView>(); }},
@@ -555,6 +565,7 @@ ReceiversMenuView::ReceiversMenuView(NavigationView& nav) {
         {"Recon", Color::green(), &bitmap_icon_scanner, [&nav]() { nav.push<ReconView>(); }},
         {"Search", Color::yellow(), &bitmap_icon_search, [&nav]() { nav.push<SearchView>(); }},
         {"TPMS Cars", Color::green(), &bitmap_icon_tpms, [&nav]() { nav.push<TPMSAppView>(); }},
+        // {"FSK RX", Color::yellow(), &bitmap_icon_remote, [&nav]() { nav.push<FskxRxMainView>(); }},
         // {"DMR", Color::dark_grey(), &bitmap_icon_dmr, [&nav](){ nav.push<NotImplementedView>(); }},
         // {"SIGFOX", Color::dark_grey(), &bitmap_icon_fox, [&nav](){ nav.push<NotImplementedView>(); }},
         // {"LoRa", Color::dark_grey(), &bitmap_icon_lora, [&nav](){ nav.push<NotImplementedView>(); }},
@@ -577,6 +588,7 @@ TransmittersMenuView::TransmittersMenuView(NavigationView& nav) {
         {"ADS-B TX", ui::Color::green(), &bitmap_icon_adsb, [&nav]() { nav.push<ADSBTxView>(); }},
         {"APRS TX", ui::Color::green(), &bitmap_icon_aprs, [&nav]() { nav.push<APRSTXView>(); }},
         {"BHT Xy/EP", ui::Color::green(), &bitmap_icon_bht, [&nav]() { nav.push<BHTView>(); }},
+        {"BLE Tx", ui::Color::green(), &bitmap_icon_btle, [&nav]() { nav.push<BLETxView>(); }},
         {"BurgerPgr", ui::Color::yellow(), &bitmap_icon_burger, [&nav]() { nav.push<CoasterPagerView>(); }},
         {"GPS Sim", ui::Color::green(), &bitmap_icon_gps_sim, [&nav]() { nav.push<GpsSimAppView>(); }},
         {"Jammer", ui::Color::green(), &bitmap_icon_jammer, [&nav]() { nav.push<JammerView>(); }},

firmware/application/ui_record_view.cpp

@@ -322,7 +322,7 @@ void RecordView::trim_capture() {
             auto trim_range = iq::compute_trim_range(*info, power_buckets, 7);
 
             trim_ui.show_trimming();
-            iq::trim_capture_with_range(trim_path, trim_range, trim_ui.get_callback());
+            iq::trim_capture_with_range(trim_path, trim_range, trim_ui.get_callback(), 1);
         }
 
         trim_ui.clear();

firmware/baseband/CMakeLists.txt

@@ -360,6 +360,14 @@ set(MODE_CPPSRC
 	proc_btlerx.cpp
 )
 DeclareTargets(PBTR btlerx)
+
+### BTLE TX
+
+set(MODE_CPPSRC
+	proc_ble_tx.cpp
+)
+DeclareTargets(PBTT btletx)
+
 ### AIS
 
 set(MODE_CPPSRC
@@ -416,6 +424,13 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PFSK fsktx)
 
+### FSK RX
+
+set(MODE_CPPSRC
+	proc_fsk_rx.cpp
+)
+DeclareTargets(PFSR fskrx)
+
 ### Jammer
 
 set(MODE_CPPSRC

firmware/baseband/proc_adsbrx.cpp

@@ -20,6 +20,8 @@
  * Boston, MA 02110-1301, USA.
  */
 
+// https://www.icao.int/SAM/Documents/2015-SEMAUTOM/Ses4%20Presentation%20CUBA_ADSB.pdf
+
 #include "proc_adsbrx.hpp"
 #include "portapack_shared_memory.hpp"
 #include "sine_table_int8.hpp"
@@ -31,29 +33,27 @@
 using namespace adsb;
 
 void ADSBRXProcessor::execute(const buffer_c8_t& buffer) {
-    int8_t re, im;
-    uint32_t mag;
-    uint32_t c;
-    uint8_t bit, byte{};
-
     // This is called at 2M/2048 = 977Hz
-    // One pulse = 500ns = 2 samples
-    // One bit = 2 pulses = 1us = 4 samples
+    // Each sample is 500ns.
+    // One bit is 2 samples == 1us.
+    // Bit value is the transition between samples.
+    // i.e. lo->hi == 0, hi->lo == 1
 
     if (!configured) return;
 
+    uint8_t bit = 0;
+    uint8_t byte = 0;
+
     for (size_t i = 0; i < buffer.count; i++) {
-        // Compute sample's magnitude
-        re = (int32_t)buffer.p[i].real();
-        im = (int32_t)buffer.p[i].imag();
-        mag = ((uint32_t)(re * re) + (uint32_t)(im * im));
+        // Compute sample's magnitude.
+        int8_t re = buffer.p[i].real();
+        int8_t im = buffer.p[i].imag();
+        uint16_t mag = (re * re) + (im * im);
 
         if (decoding) {
-            // Decode
-
-            // 1 bit lasts 2 samples
-            if (sample_count & 1) {
-                if (bit_count >= msgLen) {
+            // 1 bit == 2 samples, transition defines bit value.
+            if ((sample_count & 1) == 1) {
+                if (bit_count >= msg_len) {
                     const ADSBFrameMessage message(frame, amp);
                     shared_memory.application_queue.push(message);
                     decoding = false;
@@ -65,40 +65,42 @@ void ADSBRXProcessor::execute(const buffer_c8_t& buffer) {
                 byte = bit | (byte << 1);
                 bit_count++;
 
-                // Perform checks at the end of the first byte
-                if (!(bit_count & 7)) {
-                    // Store the byte
+                // Every 8th bit...
+                if ((bit_count & 0x7) == 0) {
+                    // Store the byte.
                     frame.push_byte(byte);
 
-                    // Check at the end of the first byte of the message
-                    uint8_t df = (byte >> 3);
-                    if ((bit_count == 8) && !(df & 0x10)) {
-                        msgLen = 56;  // DFs 16 or greater are long 112. DFs 15 or less are short 56.
+                    // Perform additional check on the first byte.
+                    if (bit_count == 8) {
+                        // Abandon all frames that aren't DF17 or DF18 extended squitters.
+                        uint8_t df = (byte >> 3);
+                        if (df != 17 && df != 18) {
+                            decoding = false;
+                            bit = (prev_mag > mag) ? 1 : 0;
+                            frame.clear();
+                        }
                     }
+                }
+            }
 
-                    // Abondon all frames that arent DF17 or DF18 extended squitters
-                    if ((bit_count == 8) && !((df == 17) || (df == 18))) {
-                        decoding = false;
-                        bit = (prev_mag > mag) ? 1 : 0;
-                        frame.clear();
-                    }
-                }  // last bit of a byte
-            }      // Second sample of each bit
             sample_count++;
         }
 
-        // Continue looking for preamble even if in a packet
-        // switch if new preamble is higher magnitude
+        // Continue looking for preamble, even if in a packet.
+        // Switch if new preamble is higher magnitude.
 
-        // Shift the preamble
-        for (c = 0; c < (ADSB_PREAMBLE_LENGTH); c++) {
+        // Shift the preamble.
+        for (uint8_t c = 0; c < ADSB_PREAMBLE_LENGTH; c++) {
             shifter[c] = shifter[c + 1];
         }
         shifter[ADSB_PREAMBLE_LENGTH] = mag;
 
-        // First check of relations between the first 10 samples
-        // representing a valid preamble. We don't even investigate further
-        // if this simple test is not passed
+        // First check of relations between the first 12 samples
+        // representing a valid preamble. We don't even investigate
+        // further if this simple test is not passed.
+        // Preamble is 8us - or 16 samples.
+        //    0123456789ABCDEF
+        //    _-_-____-_-_____
         if (shifter[0] < shifter[1] &&
             shifter[1] > shifter[2] &&
             shifter[2] < shifter[3] &&
@@ -113,32 +115,30 @@ void ADSBRXProcessor::execute(const buffer_c8_t& buffer) {
             // The samples between the two spikes must be < than the average
             // of the high spikes level. We don't test bits too near to
             // the high levels as signals can be out of phase so part of the
-            // energy can be in the near samples
-            int32_t thisAmp = (shifter[1] + shifter[3] + shifter[8] + shifter[10]);
-            uint32_t high = thisAmp / 9;
-            if (
-                shifter[5] < high &&
+            // energy can be in the near samples.
+            int32_t this_amp = (shifter[1] + shifter[3] + shifter[8] + shifter[10]);
+            uint32_t high = this_amp / 9;  // TBD: Why 9?
+            if (shifter[5] < high &&
                 shifter[6] < high &&
                 // Similarly samples in the range 11-13 must be low, as it is the
                 // space between the preamble and real data. Again we don't test
-                // bits too near to high levels, see above
+                // bits too near to high levels, see above.
                 shifter[12] < high &&
                 shifter[13] < high &&
                 shifter[14] < high) {
-                if ((decoding == false) ||                    // New preamble
-                    ((decoding == true) && (thisAmp > amp)))  // Higher power than existing packet
+                if ((decoding == false) ||                     // New preamble
+                    ((decoding == true) && (this_amp > amp)))  // Higher power than existing packet
                 {
                     decoding = true;
-                    msgLen = 112;
-                    amp = thisAmp;
+                    amp = this_amp;
                     sample_count = 0;
                     bit_count = 0;
                     frame.clear();
                 }
-            }  // 4 & 5 low and 11-14 low
-        }      // Check for preamble pattern
+            }
+        }
 
-        // Store mag for next time
+        // Store mag for next time.
         prev_mag = mag;
     }
 }

firmware/baseband/proc_adsbrx.hpp

@@ -39,21 +39,19 @@ class ADSBRXProcessor : public BasebandProcessor {
     void on_message(const Message* const message) override;
 
    private:
-    static constexpr size_t baseband_fs = 2000000;
+    static constexpr size_t baseband_fs = 2'000'000;
+    static constexpr size_t msg_len = 112;
 
     ADSBFrame frame{};
     bool configured{false};
+    bool decoding{false};
+
     uint32_t prev_mag{0};
-    size_t bit_count{0}, sample_count{0};
-    size_t msgLen{112};
-    uint32_t shifter[ADSB_PREAMBLE_LENGTH + 1];
-    bool decoding{};
-    bool preamble{}, active{};
-    uint16_t bit_pos{0};
-    uint8_t cur_bit{0};
-    uint32_t sample{0};
-    int32_t re{}, im{};
     int32_t amp{0};
+    size_t bit_count{0};
+    size_t sample_count{0};
+
+    uint32_t shifter[ADSB_PREAMBLE_LENGTH + 1];
 
     /* NB: Threads should be the last members in the class definition. */
     BasebandThread baseband_thread{baseband_fs, this, baseband::Direction::Receive};

firmware/baseband/proc_ble_tx.cpp

@@ -0,0 +1,411 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 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 "proc_ble_tx.hpp"
+#include "portapack_shared_memory.hpp"
+#include "sine_table_int8.hpp"
+#include "event_m4.hpp"
+
+#include <cstdint>
+
+#define new_way
+
+int BTLETxProcessor::gen_sample_from_phy_bit(char* bit, char* sample, int num_bit) {
+    int num_sample = (num_bit * SAMPLE_PER_SYMBOL) + (LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL);
+
+    int8_t* tmp_phy_bit_over_sampling_int8 = (int8_t*)tmp_phy_bit_over_sampling;
+
+    int i, j;
+
+    for (i = 0; i < (LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL - 1); i++) {
+        tmp_phy_bit_over_sampling_int8[i] = 0;
+    }
+    for (i = (LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL - 1 + num_bit * SAMPLE_PER_SYMBOL); i < (2 * LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL - 2 + num_bit * SAMPLE_PER_SYMBOL); i++) {
+        tmp_phy_bit_over_sampling_int8[i] = 0;
+    }
+    for (i = 0; i < (num_bit * SAMPLE_PER_SYMBOL); i++) {
+        if (i % SAMPLE_PER_SYMBOL == 0) {
+            tmp_phy_bit_over_sampling_int8[i + (LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL - 1)] = (bit[i / SAMPLE_PER_SYMBOL]) * 2 - 1;
+        } else {
+            tmp_phy_bit_over_sampling_int8[i + (LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL - 1)] = 0;
+        }
+    }
+
+    int16_t tmp = 0;
+    sample[0] = cos_table_int8[tmp];
+    sample[1] = sin_table_int8[tmp];
+
+    int len_conv_result = num_sample - 1;
+    for (i = 0; i < len_conv_result; i++) {
+        int16_t acc = 0;
+        for (j = 3; j < (LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL - 4); j++) {
+            acc = acc + gauss_coef_int8[(LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL) - j - 1] * tmp_phy_bit_over_sampling_int8[i + j];
+        }
+
+        tmp = (tmp + acc) & 1023;
+        sample[(i + 1) * 2 + 0] = cos_table_int8[tmp];
+        sample[(i + 1) * 2 + 1] = sin_table_int8[tmp];
+    }
+
+    return (num_sample);
+}
+
+void BTLETxProcessor::octet_hex_to_bit(char* hex, char* bit) {
+    char tmp_hex[3];
+
+    tmp_hex[0] = hex[0];
+    tmp_hex[1] = hex[1];
+    tmp_hex[2] = 0;
+
+    int n = strtol(tmp_hex, NULL, 16);
+
+    bit[0] = 0x01 & (n >> 0);
+    bit[1] = 0x01 & (n >> 1);
+    bit[2] = 0x01 & (n >> 2);
+    bit[3] = 0x01 & (n >> 3);
+    bit[4] = 0x01 & (n >> 4);
+    bit[5] = 0x01 & (n >> 5);
+    bit[6] = 0x01 & (n >> 6);
+    bit[7] = 0x01 & (n >> 7);
+}
+
+int BTLETxProcessor::convert_hex_to_bit(char* hex, char* bit, int stream_flip, int octet_limit) {
+    int num_hex_orig = strlen(hex);
+
+    int i, num_hex;
+    num_hex = num_hex_orig;
+    for (i = 0; i < num_hex_orig; i++) {
+        if (!((hex[i] >= 48 && hex[i] <= 57) || (hex[i] >= 65 && hex[i] <= 70) || (hex[i] >= 97 && hex[i] <= 102)))  // not a hex
+            num_hex--;
+    }
+
+    if (num_hex % 2 != 0) {
+        return (-1);
+    }
+
+    if (num_hex > (octet_limit * 2)) {
+        return (-1);
+    }
+    if (num_hex <= 1) {  // NULL data
+        return (-1);
+    }
+
+    char tmp_str[max_char];
+
+    if (stream_flip == 1) {
+        strcpy(tmp_str, hex);
+        for (i = 0; i < num_hex; i = i + 2) {
+            hex[num_hex - i - 2] = tmp_str[i];
+            hex[num_hex - i - 1] = tmp_str[i + 1];
+        }
+    }
+
+    int num_bit = num_hex * 4;
+
+    int j;
+    for (i = 0; i < num_hex; i = i + 2) {
+        j = i * 4;
+        octet_hex_to_bit(hex + i, bit + j);
+    }
+
+    return (num_bit);
+}
+
+void BTLETxProcessor::crc24(char* bit_in, int num_bit, char* init_hex, char* crc_result) {
+    char bit_store[24], bit_store_update[24];
+    int i;
+    convert_hex_to_bit(init_hex, bit_store, 0, 3);
+
+    for (i = 0; i < num_bit; i++) {
+        char new_bit = (bit_store[23] + bit_in[i]) % 2;
+        bit_store_update[0] = new_bit;
+        bit_store_update[1] = (bit_store[0] + new_bit) % 2;
+        bit_store_update[2] = bit_store[1];
+        bit_store_update[3] = (bit_store[2] + new_bit) % 2;
+        bit_store_update[4] = (bit_store[3] + new_bit) % 2;
+        bit_store_update[5] = bit_store[4];
+        bit_store_update[6] = (bit_store[5] + new_bit) % 2;
+
+        bit_store_update[7] = bit_store[6];
+        bit_store_update[8] = bit_store[7];
+
+        bit_store_update[9] = (bit_store[8] + new_bit) % 2;
+        bit_store_update[10] = (bit_store[9] + new_bit) % 2;
+
+        memcpy(bit_store_update + 11, bit_store + 10, 13);
+
+        memcpy(bit_store, bit_store_update, 24);
+    }
+
+    for (i = 0; i < 24; i++) {
+        crc_result[i] = bit_store[23 - i];
+    }
+}
+
+void BTLETxProcessor::scramble(char* bit_in, int num_bit, int channel_number, char* bit_out) {
+    char bit_store[7], bit_store_update[7];
+    int i;
+
+    bit_store[0] = 1;
+    bit_store[1] = 0x01 & (channel_number >> 5);
+    bit_store[2] = 0x01 & (channel_number >> 4);
+    bit_store[3] = 0x01 & (channel_number >> 3);
+    bit_store[4] = 0x01 & (channel_number >> 2);
+    bit_store[5] = 0x01 & (channel_number >> 1);
+    bit_store[6] = 0x01 & (channel_number >> 0);
+
+    for (i = 0; i < num_bit; i++) {
+        bit_out[i] = (bit_store[6] + bit_in[i]) % 2;
+
+        bit_store_update[0] = bit_store[6];
+
+        bit_store_update[1] = bit_store[0];
+        bit_store_update[2] = bit_store[1];
+        bit_store_update[3] = bit_store[2];
+
+        bit_store_update[4] = (bit_store[3] + bit_store[6]) % 2;
+
+        bit_store_update[5] = bit_store[4];
+        bit_store_update[6] = bit_store[5];
+
+        memcpy(bit_store, bit_store_update, 7);
+    }
+}
+
+void BTLETxProcessor::disp_bit_in_hex(char* bit, int num_bit) {
+    int i, a;
+
+    for (i = 0; i < num_bit; i = i + 8) {
+        a = bit[i] + bit[i + 1] * 2 + bit[i + 2] * 4 + bit[i + 3] * 8 + bit[i + 4] * 16 + bit[i + 5] * 32 + bit[i + 6] * 64 + bit[i + 7] * 128;
+
+        data_message.is_data = true;
+        data_message.value = (uint8_t)a;
+        shared_memory.application_queue.push(data_message);
+    }
+}
+
+void BTLETxProcessor::crc24_and_scramble_to_gen_phy_bit(char* crc_init_hex, PKT_INFO* pkt) {
+    crc24(pkt->info_bit + 5 * 8, pkt->num_info_bit - 5 * 8, crc_init_hex, pkt->info_bit + pkt->num_info_bit);
+
+    // disp_bit_in_hex(pkt->info_bit, pkt->num_info_bit + 3*8);
+
+    scramble(pkt->info_bit + 5 * 8, pkt->num_info_bit - 5 * 8 + 24, pkt->channel_number, pkt->phy_bit + 5 * 8);
+    memcpy(pkt->phy_bit, pkt->info_bit, 5 * 8);
+    pkt->num_phy_bit = pkt->num_info_bit + 24;
+
+    // disp_bit_in_hex(pkt->phy_bit, pkt->num_phy_bit);
+}
+
+void BTLETxProcessor::fill_adv_pdu_header(PKT_INFO* pkt, int txadd, int rxadd, int payload_len, char* bit_out) {
+    if (pkt->pkt_type == ADV_IND || pkt->pkt_type == IBEACON) {
+        bit_out[3] = 0;
+        bit_out[2] = 0;
+        bit_out[1] = 0;
+        bit_out[0] = 0;
+    } else if (pkt->pkt_type == ADV_DIRECT_IND) {
+        bit_out[3] = 0;
+        bit_out[2] = 0;
+        bit_out[1] = 0;
+        bit_out[0] = 1;
+    } else if (pkt->pkt_type == ADV_NONCONN_IND || pkt->pkt_type == DISCOVERY) {
+        bit_out[3] = 0;
+        bit_out[2] = 0;
+        bit_out[1] = 1;
+        bit_out[0] = 0;
+    } else if (pkt->pkt_type == SCAN_REQ) {
+        bit_out[3] = 0;
+        bit_out[2] = 0;
+        bit_out[1] = 1;
+        bit_out[0] = 1;
+    } else if (pkt->pkt_type == SCAN_RSP) {
+        bit_out[3] = 0;
+        bit_out[2] = 1;
+        bit_out[1] = 0;
+        bit_out[0] = 0;
+    } else if (pkt->pkt_type == CONNECT_REQ) {
+        bit_out[3] = 0;
+        bit_out[2] = 1;
+        bit_out[1] = 0;
+        bit_out[0] = 1;
+    } else if (pkt->pkt_type == ADV_SCAN_IND) {
+        bit_out[3] = 0;
+        bit_out[2] = 1;
+        bit_out[1] = 1;
+        bit_out[0] = 0;
+    } else {
+        bit_out[3] = 1;
+        bit_out[2] = 1;
+        bit_out[1] = 1;
+        bit_out[0] = 1;
+    }
+
+    bit_out[4] = 0;
+    bit_out[5] = 0;
+
+    bit_out[6] = txadd;
+    bit_out[7] = rxadd;
+
+    bit_out[8] = 0x01 & (payload_len >> 0);
+    bit_out[9] = 0x01 & (payload_len >> 1);
+    bit_out[10] = 0x01 & (payload_len >> 2);
+    bit_out[11] = 0x01 & (payload_len >> 3);
+    bit_out[12] = 0x01 & (payload_len >> 4);
+    bit_out[13] = 0x01 & (payload_len >> 5);
+
+    bit_out[14] = 0;
+    bit_out[15] = 0;
+}
+
+int BTLETxProcessor::calculate_sample_for_ADV(PKT_INFO* pkt) {
+    pkt->num_info_bit = 0;
+
+    // gen preamble and access address
+    const char* AA = "AA";
+    const char* AAValue = "D6BE898E";
+    pkt->num_info_bit = pkt->num_info_bit + convert_hex_to_bit((char*)AA, pkt->info_bit, 0, 1);
+    pkt->num_info_bit = pkt->num_info_bit + convert_hex_to_bit((char*)AAValue, pkt->info_bit + pkt->num_info_bit, 0, 4);
+
+    // get txadd and rxadd
+    int txadd = 0, rxadd = 0;
+
+    pkt->num_info_bit = pkt->num_info_bit + 16;  // 16 is header length
+
+    // get AdvA and AdvData
+    pkt->num_info_bit = pkt->num_info_bit + convert_hex_to_bit(macAddress, pkt->info_bit + pkt->num_info_bit, 1, 6);
+
+    pkt->num_info_bit = pkt->num_info_bit + convert_hex_to_bit(advertisementData, pkt->info_bit + pkt->num_info_bit, 0, 31);
+
+    int payload_len = (pkt->num_info_bit / 8) - 7;
+
+    fill_adv_pdu_header(pkt, txadd, rxadd, payload_len, pkt->info_bit + 5 * 8);
+    const char* checksumInit = "555555";
+    crc24_and_scramble_to_gen_phy_bit((char*)checksumInit, pkt);
+
+#ifdef new_way
+    pkt->num_phy_sample = gen_sample_from_phy_bit(pkt->phy_bit, pkt->phy_sample, pkt->num_phy_bit);
+#endif
+
+    // disp_bit_in_hex(pkt->phy_sample, pkt->num_phy_sample);
+
+    return (0);
+}
+
+int BTLETxProcessor::calculate_sample_from_pkt_type(PKT_INFO* pkt) {
+    // Todo: Handle other Enum values.
+    // if (packetType == ADV_IND);
+
+    if (calculate_sample_for_ADV(pkt) == -1) {
+        return (-1);
+    }
+
+    return (0);
+}
+
+int BTLETxProcessor::calculate_pkt_info(PKT_INFO* pkt) {
+    if (calculate_sample_from_pkt_type(pkt) == -1) {
+        return (-1);
+    }
+
+    return (0);
+}
+
+void BTLETxProcessor::execute(const buffer_c8_t& buffer) {
+    int8_t re, im;
+
+    // This is called at 4M/2048 = 1953Hz
+    for (size_t i = 0; i < buffer.count; i++) {
+        if (configured) {
+            // This is going to loop through each sample bit and push it to the output buffer.
+            if (sample_count > length) {
+                configured = false;
+                sample_count = 0;
+
+                txprogress_message.done = true;
+                shared_memory.application_queue.push(txprogress_message);
+            } else {
+                // Real and imaginary was already calculated in gen_sample_from_phy_bit.
+                // It was processed from each data bit, run through a Gaussian Filter, and then ran through sin and cos table to get each IQ bit.
+                re = (int8_t)packets.phy_sample[sample_count++];
+                im = (int8_t)packets.phy_sample[sample_count++];
+
+                buffer.p[i] = {re, im};
+
+                if (progress_count >= progress_notice) {
+                    progress_count = 0;
+                    txprogress_message.progress++;
+                    txprogress_message.done = false;
+                    shared_memory.application_queue.push(txprogress_message);
+                } else {
+                    progress_count++;
+                }
+            }
+        } else {
+            re = 0;
+            im = 0;
+
+            buffer.p[i] = {re, im};
+        }
+    }
+}
+
+void BTLETxProcessor::on_message(const Message* const message) {
+    if (message->id == Message::ID::BTLETxConfigure) {
+        configure(*reinterpret_cast<const BTLETxConfigureMessage*>(message));
+    }
+}
+
+void BTLETxProcessor::configure(const BTLETxConfigureMessage& message) {
+    channel_number = message.channel_number;
+    packetType = (PKT_TYPE)message.pduType;
+
+    memcpy(macAddress, message.macAddress, sizeof(macAddress));
+    memcpy(advertisementData, message.advertisementData, sizeof(advertisementData));
+
+    packets.channel_number = channel_number;
+    packets.pkt_type = packetType;
+
+    // Calculates the samples based on the BLE packet data and generates IQ values into an array to be sent out.
+    calculate_pkt_info(&packets);
+
+#ifdef new_way
+    // This is because each sample contains I and Q, but packet.num_phy_samples just returns the total samples.
+    length = (uint32_t)(packets.num_phy_sample * 2);
+#else
+    length = (uint32_t)packets.num_phy_bit;
+#endif
+
+    // Starting at sample_count 0 since packets.num_phy_sample contains every sample needed to be sent out.
+    sample_count = 0;
+    progress_count = 0;
+    progress_notice = 64;
+
+    txprogress_message.progress = 0;
+    txprogress_message.done = false;
+    configured = true;
+}
+
+int main() {
+    EventDispatcher event_dispatcher{std::make_unique<BTLETxProcessor>()};
+    event_dispatcher.run();
+    return 0;
+}

firmware/baseband/proc_ble_tx.hpp

@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 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 __PROC_BLE_TX_H__
+#define __PROC_BLE_TX_H__
+
+#include "baseband_processor.hpp"
+#include "baseband_thread.hpp"
+
+class BTLETxProcessor : public BasebandProcessor {
+   public:
+    void execute(const buffer_c8_t& buffer) override;
+    void on_message(const Message* const message) override;
+    void configure(const BTLETxConfigureMessage& message);
+
+   private:
+    static constexpr int max_char{256};
+    static constexpr int SAMPLE_PER_SYMBOL{4};
+    static constexpr float AMPLITUDE{127.0};
+    static constexpr float MOD_IDX{0.5};
+    static constexpr int LEN_GAUSS_FILTER{4};
+    static constexpr int MAX_NUM_INFO_BYTE{43};
+    static constexpr int MAX_NUM_PHY_BYTE{47};
+    static constexpr int MAX_NUM_PHY_SAMPLE{(MAX_NUM_PHY_BYTE * 8 * SAMPLE_PER_SYMBOL) + (LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL)};
+
+    enum PKT_TYPE {
+        INVALID_TYPE,
+        RAW,
+        DISCOVERY,
+        IBEACON,
+        ADV_IND,
+        ADV_DIRECT_IND,
+        ADV_NONCONN_IND,
+        ADV_SCAN_IND,
+        SCAN_REQ,
+        SCAN_RSP,
+        CONNECT_REQ,
+        LL_DATA,
+        LL_CONNECTION_UPDATE_REQ,
+        LL_CHANNEL_MAP_REQ,
+        LL_TERMINATE_IND,
+        LL_ENC_REQ,
+        LL_ENC_RSP,
+        LL_START_ENC_REQ,
+        LL_START_ENC_RSP,
+        LL_UNKNOWN_RSP,
+        LL_FEATURE_REQ,
+        LL_FEATURE_RSP,
+        LL_PAUSE_ENC_REQ,
+        LL_PAUSE_ENC_RSP,
+        LL_VERSION_IND,
+        LL_REJECT_IND,
+        NUM_PKT_TYPE
+    };
+
+    struct PKT_INFO {
+        int channel_number;
+        PKT_TYPE pkt_type;
+
+        int num_info_bit;
+        char info_bit[MAX_NUM_PHY_BYTE * 8];  // without CRC and whitening
+
+        int num_info_byte;
+        uint8_t info_byte[MAX_NUM_PHY_BYTE];
+
+        int num_phy_bit;
+        char phy_bit[MAX_NUM_PHY_BYTE * 8];  // all bits which will be fed to GFSK modulator
+
+        int num_phy_byte;
+        uint8_t phy_byte[MAX_NUM_PHY_BYTE];
+
+        int num_phy_sample;
+        char phy_sample[2 * MAX_NUM_PHY_SAMPLE];     // GFSK output to D/A (hackrf board)
+        int8_t phy_sample1[2 * MAX_NUM_PHY_SAMPLE];  // GFSK output to D/A (hackrf board)
+
+        int space;  // how many millisecond null signal shouwl be padded after this packet
+    };
+
+    PKT_INFO packets{};
+
+    int calculate_pkt_info(PKT_INFO* pkt);
+    int calculate_sample_from_pkt_type(PKT_INFO* pkt);
+    int calculate_sample_for_ADV(PKT_INFO* pkt);
+    void fill_adv_pdu_header(PKT_INFO* pkt, int txadd, int rxadd, int payload_len, char* bit_out);
+    void crc24_and_scramble_to_gen_phy_bit(char* crc_init_hex, PKT_INFO* pkt);
+    void disp_bit_in_hex(char* bit, int num_bit);
+    void scramble(char* bit_in, int num_bit, int channel_number, char* bit_out);
+    void crc24(char* bit_in, int num_bit, char* init_hex, char* crc_result);
+    int convert_hex_to_bit(char* hex, char* bit, int stream_flip, int octet_limit);
+    void octet_hex_to_bit(char* hex, char* bit);
+    int gen_sample_from_phy_bit(char* bit, char* sample, int num_bit);
+    bool configured = false;
+
+    float tmp_phy_bit_over_sampling[MAX_NUM_PHY_SAMPLE + 2 * LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL];
+    float gauss_coef[LEN_GAUSS_FILTER * SAMPLE_PER_SYMBOL] = {7.561773e-09, 1.197935e-06, 8.050684e-05, 2.326833e-03, 2.959908e-02, 1.727474e-01, 4.999195e-01, 8.249246e-01, 9.408018e-01, 8.249246e-01, 4.999195e-01, 1.727474e-01, 2.959908e-02, 2.326833e-03, 8.050684e-05, 1.197935e-06};
+
+    uint32_t samples_per_bit{4};
+    uint32_t channel_number{37};
+    char macAddress[13] = "FFFFFFFFFF";
+    char advertisementData[63] = {0};
+
+    uint32_t length{0};
+    uint32_t shift_zero{}, shift_one{};
+    uint32_t progress_notice{}, progress_count{0};
+    uint32_t sample_count{0};
+    uint32_t phase{0}, sphase{0};
+
+    uint8_t cur_bit{0};
+    uint16_t bit_pos{0};
+
+    uint16_t process{0};
+
+    // clang-format off
+    const int8_t gauss_coef_int8[16] = {
+    0, 0, 0, 0, 2, 11, 32, 53, 60, 53, 32, 11, 2, 0, 0, 0, };
+
+    const int8_t cos_table_int8[1024] = {
+    127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 126, 126, 126, 126, 126, 126, 126, 126, 126, 
+    126, 126, 125, 125, 125, 125, 125, 125, 125, 124, 124, 124, 124, 124, 124, 123, 123, 123, 123, 123, 122, 122, 122, 122, 
+    122, 121, 121, 121, 121, 120, 120, 120, 120, 119, 119, 119, 118, 118, 118, 118, 117, 117, 117, 116, 116, 116, 115, 115, 
+    115, 114, 114, 114, 113, 113, 113, 112, 112, 112, 111, 111, 111, 110, 110, 109, 109, 109, 108, 108, 107, 107, 106, 106, 
+    106, 105, 105, 104, 104, 103, 103, 102, 102, 102, 101, 101, 100, 100, 99, 99, 98, 98, 97, 97, 96, 96, 95, 95, 
+    94, 94, 93, 93, 92, 91, 91, 90, 90, 89, 89, 88, 88, 87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 
+    81, 80, 79, 79, 78, 78, 77, 76, 76, 75, 74, 74, 73, 72, 72, 71, 71, 70, 69, 69, 68, 67, 67, 66, 
+    65, 65, 64, 63, 63, 62, 61, 61, 60, 59, 58, 58, 57, 56, 56, 55, 54, 54, 53, 52, 51, 51, 50, 49, 
+    49, 48, 47, 46, 46, 45, 44, 44, 43, 42, 41, 41, 40, 39, 38, 38, 37, 36, 35, 35, 34, 33, 32, 32, 
+    31, 30, 29, 29, 28, 27, 26, 26, 25, 24, 23, 22, 22, 21, 20, 19, 19, 18, 17, 16, 16, 15, 14, 13, 
+    12, 12, 11, 10, 9, 9, 8, 7, 6, 5, 5, 4, 3, 2, 2, 1, 0, -1, -2, -2, -3, -4, -5, -5, 
+    -6, -7, -8, -9, -9, -10, -11, -12, -12, -13, -14, -15, -16, -16, -17, -18, -19, -19, -20, -21, -22, -22, -23, -24, 
+    -25, -26, -26, -27, -28, -29, -29, -30, -31, -32, -32, -33, -34, -35, -35, -36, -37, -38, -38, -39, -40, -41, -41, -42, 
+    -43, -44, -44, -45, -46, -46, -47, -48, -49, -49, -50, -51, -51, -52, -53, -54, -54, -55, -56, -56, -57, -58, -58, -59, 
+    -60, -61, -61, -62, -63, -63, -64, -65, -65, -66, -67, -67, -68, -69, -69, -70, -71, -71, -72, -72, -73, -74, -74, -75, 
+    -76, -76, -77, -78, -78, -79, -79, -80, -81, -81, -82, -82, -83, -84, -84, -85, -85, -86, -86, -87, -88, -88, -89, -89, 
+    -90, -90, -91, -91, -92, -93, -93, -94, -94, -95, -95, -96, -96, -97, -97, -98, -98, -99, -99, -100, -100, -101, -101, -102, 
+    -102, -102, -103, -103, -104, -104, -105, -105, -106, -106, -106, -107, -107, -108, -108, -109, -109, -109, -110, -110, -111, -111, -111, -112, 
+    -112, -112, -113, -113, -113, -114, -114, -114, -115, -115, -115, -116, -116, -116, -117, -117, -117, -118, -118, -118, -118, -119, -119, -119, 
+    -120, -120, -120, -120, -121, -121, -121, -121, -122, -122, -122, -122, -122, -123, -123, -123, -123, -123, -124, -124, -124, -124, -124, -124, 
+    -125, -125, -125, -125, -125, -125, -125, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -127, -127, -127, -127, -127, -127, 
+    -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -126, 
+    -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -125, -125, -125, -125, -125, -125, -125, -124, -124, -124, -124, -124, -124, -123, 
+    -123, -123, -123, -123, -122, -122, -122, -122, -122, -121, -121, -121, -121, -120, -120, -120, -120, -119, -119, -119, -118, -118, -118, -118, 
+    -117, -117, -117, -116, -116, -116, -115, -115, -115, -114, -114, -114, -113, -113, -113, -112, -112, -112, -111, -111, -111, -110, -110, -109, 
+    -109, -109, -108, -108, -107, -107, -106, -106, -106, -105, -105, -104, -104, -103, -103, -102, -102, -102, -101, -101, -100, -100, -99, -99, 
+    -98, -98, -97, -97, -96, -96, -95, -95, -94, -94, -93, -93, -92, -91, -91, -90, -90, -89, -89, -88, -88, -87, -86, -86, 
+    -85, -85, -84, -84, -83, -82, -82, -81, -81, -80, -79, -79, -78, -78, -77, -76, -76, -75, -74, -74, -73, -72, -72, -71, 
+    -71, -70, -69, -69, -68, -67, -67, -66, -65, -65, -64, -63, -63, -62, -61, -61, -60, -59, -58, -58, -57, -56, -56, -55, 
+    -54, -54, -53, -52, -51, -51, -50, -49, -49, -48, -47, -46, -46, -45, -44, -44, -43, -42, -41, -41, -40, -39, -38, -38, 
+    -37, -36, -35, -35, -34, -33, -32, -32, -31, -30, -29, -29, -28, -27, -26, -26, -25, -24, -23, -22, -22, -21, -20, -19, 
+    -19, -18, -17, -16, -16, -15, -14, -13, -12, -12, -11, -10, -9, -9, -8, -7, -6, -5, -5, -4, -3, -2, -2, -1, 
+    0, 1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9, 10, 11, 12, 12, 13, 14, 15, 16, 16, 17, 18, 
+    19, 19, 20, 21, 22, 22, 23, 24, 25, 26, 26, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36, 
+    37, 38, 38, 39, 40, 41, 41, 42, 43, 44, 44, 45, 46, 46, 47, 48, 49, 49, 50, 51, 51, 52, 53, 54, 
+    54, 55, 56, 56, 57, 58, 58, 59, 60, 61, 61, 62, 63, 63, 64, 65, 65, 66, 67, 67, 68, 69, 69, 70, 
+    71, 71, 72, 72, 73, 74, 74, 75, 76, 76, 77, 78, 78, 79, 79, 80, 81, 81, 82, 82, 83, 84, 84, 85, 
+    85, 86, 86, 87, 88, 88, 89, 89, 90, 90, 91, 91, 92, 93, 93, 94, 94, 95, 95, 96, 96, 97, 97, 98, 
+    98, 99, 99, 100, 100, 101, 101, 102, 102, 102, 103, 103, 104, 104, 105, 105, 106, 106, 106, 107, 107, 108, 108, 109, 
+    109, 109, 110, 110, 111, 111, 111, 112, 112, 112, 113, 113, 113, 114, 114, 114, 115, 115, 115, 116, 116, 116, 117, 117, 
+    117, 118, 118, 118, 118, 119, 119, 119, 120, 120, 120, 120, 121, 121, 121, 121, 122, 122, 122, 122, 122, 123, 123, 123, 
+    123, 123, 124, 124, 124, 124, 124, 124, 125, 125, 125, 125, 125, 125, 125, 126, 126, 126, 126, 126, 126, 126, 126, 126, 
+    126, 126, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, };
+
+    const int8_t sin_table_int8[1024] = {
+    0, 1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9, 10, 11, 12, 12, 13, 14, 15, 16, 16, 17, 18, 
+    19, 19, 20, 21, 22, 22, 23, 24, 25, 26, 26, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36, 
+    37, 38, 38, 39, 40, 41, 41, 42, 43, 44, 44, 45, 46, 46, 47, 48, 49, 49, 50, 51, 51, 52, 53, 54, 
+    54, 55, 56, 56, 57, 58, 58, 59, 60, 61, 61, 62, 63, 63, 64, 65, 65, 66, 67, 67, 68, 69, 69, 70, 
+    71, 71, 72, 72, 73, 74, 74, 75, 76, 76, 77, 78, 78, 79, 79, 80, 81, 81, 82, 82, 83, 84, 84, 85, 
+    85, 86, 86, 87, 88, 88, 89, 89, 90, 90, 91, 91, 92, 93, 93, 94, 94, 95, 95, 96, 96, 97, 97, 98, 
+    98, 99, 99, 100, 100, 101, 101, 102, 102, 102, 103, 103, 104, 104, 105, 105, 106, 106, 106, 107, 107, 108, 108, 109, 
+    109, 109, 110, 110, 111, 111, 111, 112, 112, 112, 113, 113, 113, 114, 114, 114, 115, 115, 115, 116, 116, 116, 117, 117, 
+    117, 118, 118, 118, 118, 119, 119, 119, 120, 120, 120, 120, 121, 121, 121, 121, 122, 122, 122, 122, 122, 123, 123, 123, 
+    123, 123, 124, 124, 124, 124, 124, 124, 125, 125, 125, 125, 125, 125, 125, 126, 126, 126, 126, 126, 126, 126, 126, 126, 
+    126, 126, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 
+    127, 127, 127, 127, 127, 127, 127, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 125, 125, 125, 125, 125, 125, 
+    125, 124, 124, 124, 124, 124, 124, 123, 123, 123, 123, 123, 122, 122, 122, 122, 122, 121, 121, 121, 121, 120, 120, 120, 
+    120, 119, 119, 119, 118, 118, 118, 118, 117, 117, 117, 116, 116, 116, 115, 115, 115, 114, 114, 114, 113, 113, 113, 112, 
+    112, 112, 111, 111, 111, 110, 110, 109, 109, 109, 108, 108, 107, 107, 106, 106, 106, 105, 105, 104, 104, 103, 103, 102, 
+    102, 102, 101, 101, 100, 100, 99, 99, 98, 98, 97, 97, 96, 96, 95, 95, 94, 94, 93, 93, 92, 91, 91, 90, 
+    90, 89, 89, 88, 88, 87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 81, 80, 79, 79, 78, 78, 77, 76, 
+    76, 75, 74, 74, 73, 72, 72, 71, 71, 70, 69, 69, 68, 67, 67, 66, 65, 65, 64, 63, 63, 62, 61, 61, 
+    60, 59, 58, 58, 57, 56, 56, 55, 54, 54, 53, 52, 51, 51, 50, 49, 49, 48, 47, 46, 46, 45, 44, 44, 
+    43, 42, 41, 41, 40, 39, 38, 38, 37, 36, 35, 35, 34, 33, 32, 32, 31, 30, 29, 29, 28, 27, 26, 26, 
+    25, 24, 23, 22, 22, 21, 20, 19, 19, 18, 17, 16, 16, 15, 14, 13, 12, 12, 11, 10, 9, 9, 8, 7, 
+    6, 5, 5, 4, 3, 2, 2, 1, 0, -1, -2, -2, -3, -4, -5, -5, -6, -7, -8, -9, -9, -10, -11, -12, 
+    -12, -13, -14, -15, -16, -16, -17, -18, -19, -19, -20, -21, -22, -22, -23, -24, -25, -26, -26, -27, -28, -29, -29, -30, 
+    -31, -32, -32, -33, -34, -35, -35, -36, -37, -38, -38, -39, -40, -41, -41, -42, -43, -44, -44, -45, -46, -46, -47, -48, 
+    -49, -49, -50, -51, -51, -52, -53, -54, -54, -55, -56, -56, -57, -58, -58, -59, -60, -61, -61, -62, -63, -63, -64, -65, 
+    -65, -66, -67, -67, -68, -69, -69, -70, -71, -71, -72, -72, -73, -74, -74, -75, -76, -76, -77, -78, -78, -79, -79, -80, 
+    -81, -81, -82, -82, -83, -84, -84, -85, -85, -86, -86, -87, -88, -88, -89, -89, -90, -90, -91, -91, -92, -93, -93, -94, 
+    -94, -95, -95, -96, -96, -97, -97, -98, -98, -99, -99, -100, -100, -101, -101, -102, -102, -102, -103, -103, -104, -104, -105, -105, 
+    -106, -106, -106, -107, -107, -108, -108, -109, -109, -109, -110, -110, -111, -111, -111, -112, -112, -112, -113, -113, -113, -114, -114, -114, 
+    -115, -115, -115, -116, -116, -116, -117, -117, -117, -118, -118, -118, -118, -119, -119, -119, -120, -120, -120, -120, -121, -121, -121, -121, 
+    -122, -122, -122, -122, -122, -123, -123, -123, -123, -123, -124, -124, -124, -124, -124, -124, -125, -125, -125, -125, -125, -125, -125, -126, 
+    -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, 
+    -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -126, -126, -126, -126, -126, -126, -126, -126, -126, 
+    -126, -126, -125, -125, -125, -125, -125, -125, -125, -124, -124, -124, -124, -124, -124, -123, -123, -123, -123, -123, -122, -122, -122, -122, 
+    -122, -121, -121, -121, -121, -120, -120, -120, -120, -119, -119, -119, -118, -118, -118, -118, -117, -117, -117, -116, -116, -116, -115, -115, 
+    -115, -114, -114, -114, -113, -113, -113, -112, -112, -112, -111, -111, -111, -110, -110, -109, -109, -109, -108, -108, -107, -107, -106, -106, 
+    -106, -105, -105, -104, -104, -103, -103, -102, -102, -102, -101, -101, -100, -100, -99, -99, -98, -98, -97, -97, -96, -96, -95, -95, 
+    -94, -94, -93, -93, -92, -91, -91, -90, -90, -89, -89, -88, -88, -87, -86, -86, -85, -85, -84, -84, -83, -82, -82, -81, 
+    -81, -80, -79, -79, -78, -78, -77, -76, -76, -75, -74, -74, -73, -72, -72, -71, -71, -70, -69, -69, -68, -67, -67, -66, 
+    -65, -65, -64, -63, -63, -62, -61, -61, -60, -59, -58, -58, -57, -56, -56, -55, -54, -54, -53, -52, -51, -51, -50, -49, 
+    -49, -48, -47, -46, -46, -45, -44, -44, -43, -42, -41, -41, -40, -39, -38, -38, -37, -36, -35, -35, -34, -33, -32, -32, 
+    -31, -30, -29, -29, -28, -27, -26, -26, -25, -24, -23, -22, -22, -21, -20, -19, -19, -18, -17, -16, -16, -15, -14, -13, 
+    -12, -12, -11, -10, -9, -9, -8, -7, -6, -5, -5, -4, -3, -2, -2, -1, };
+    // clang-format on
+
+    PKT_TYPE packetType = ADV_IND;
+
+    TXProgressMessage txprogress_message{};
+
+    /* NB: Threads should be the last members in the class definition. */
+
+    // BasebandThread baseband_thread{4000000, this, baseband::Direction::Transmit};
+    // Rx for now because trying to test formulation of packet.
+    AFSKDataMessage data_message{false, 0};
+    BasebandThread baseband_thread{4000000, this, baseband::Direction::Transmit};
+};
+
+#endif

firmware/baseband/proc_btlerx.cpp

@@ -2,6 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2020 Shao
+ * Copyright (C) 2023 TJ Baginski
  *
  * This file is part of PortaPack.
  *
@@ -26,246 +27,341 @@
 
 #include "event_m4.hpp"
 
+uint32_t BTLERxProcessor::crc_init_reorder(uint32_t crc_init) {
+    int i;
+    uint32_t crc_init_tmp, crc_init_input, crc_init_input_tmp;
+
+    crc_init_input_tmp = crc_init;
+    crc_init_input = 0;
+
+    crc_init_input = crc_init_input_tmp & 0xFF;
+
+    crc_init_input_tmp = (crc_init_input_tmp >> 8);
+    crc_init_input = ((crc_init_input << 8) | (crc_init_input_tmp & 0xFF));
+
+    crc_init_input_tmp = (crc_init_input_tmp >> 8);
+    crc_init_input = ((crc_init_input << 8) | (crc_init_input_tmp & 0xFF));
+
+    crc_init_input = (crc_init_input << 1);
+    crc_init_tmp = 0;
+
+    for (i = 0; i < 24; i++) {
+        crc_init_input = (crc_init_input >> 1);
+        crc_init_tmp = ((crc_init_tmp << 1) | (crc_init_input & 0x01));
+    }
+
+    return (crc_init_tmp);
+}
+
+uint_fast32_t BTLERxProcessor::crc_update(uint_fast32_t crc, const void* data, size_t data_len) {
+    const unsigned char* d = (const unsigned char*)data;
+    unsigned int tbl_idx;
+
+    while (data_len--) {
+        tbl_idx = (crc ^ *d) & 0xff;
+        crc = (crc_table[tbl_idx] ^ (crc >> 8)) & 0xffffff;
+
+        d++;
+    }
+
+    return crc & 0xffffff;
+}
+
+uint_fast32_t BTLERxProcessor::crc24_byte(uint8_t* byte_in, int num_byte, uint32_t init_hex) {
+    uint_fast32_t crc = init_hex;
+
+    crc = crc_update(crc, byte_in, num_byte);
+
+    return (crc);
+}
+
+bool BTLERxProcessor::crc_check(uint8_t* tmp_byte, int body_len, uint32_t crc_init) {
+    int crc24_checksum;
+
+    crc24_checksum = crc24_byte(tmp_byte, body_len, crc_init);  // 0x555555 --> 0xaaaaaa. maybe because byte order
+    checksumReceived = 0;
+    checksumReceived = ((checksumReceived << 8) | tmp_byte[body_len + 2]);
+    checksumReceived = ((checksumReceived << 8) | tmp_byte[body_len + 1]);
+    checksumReceived = ((checksumReceived << 8) | tmp_byte[body_len + 0]);
+
+    return (crc24_checksum != checksumReceived);
+}
+
+void BTLERxProcessor::scramble_byte(uint8_t* byte_in, int num_byte, const uint8_t* scramble_table_byte, uint8_t* byte_out) {
+    int i;
+
+    for (i = 0; i < num_byte; i++) {
+        byte_out[i] = byte_in[i] ^ scramble_table_byte[i];
+    }
+}
+
+int BTLERxProcessor::verify_payload_byte(int num_payload_byte, ADV_PDU_TYPE pdu_type) {
+    // Should at least have 6 bytes for the MAC Address.
+    // Also ensuring that there is at least 1 byte of data.
+    if (num_payload_byte <= 6) {
+        // printf("Error: Payload Too Short (only %d bytes)!\n", num_payload_byte);
+        return -1;
+    }
+
+    if (pdu_type == ADV_IND || pdu_type == ADV_NONCONN_IND || pdu_type == SCAN_RSP || pdu_type == ADV_SCAN_IND) {
+        return 0;
+    } else if (pdu_type == ADV_DIRECT_IND || pdu_type == SCAN_REQ) {
+        if (num_payload_byte != 12) {
+            // printf("Error: Payload length %d bytes. Need to be 12 for PDU Type %s!\n", num_payload_byte, ADV_PDU_TYPE_STR[pdu_type]);
+            return -1;
+        }
+    } else if (pdu_type == CONNECT_REQ) {
+        if (num_payload_byte != 34) {
+            // printf("Error: Payload length %d bytes. Need to be 34 for PDU Type %s!\n", num_payload_byte, ADV_PDU_TYPE_STR[pdu_type]);
+            return -1;
+        }
+    } else {
+        return -1;
+    }
+
+    return 0;
+}
+
+void BTLERxProcessor::handleBeginState() {
+    int num_symbol_left = dst_buffer.count / SAMPLE_PER_SYMBOL;  // One buffer sample consist of I and Q.
+
+    static uint8_t demod_buf_access[SAMPLE_PER_SYMBOL][LEN_DEMOD_BUF_ACCESS];
+
+    uint32_t uint32_tmp = DEFAULT_ACCESS_ADDR;
+    uint8_t accessAddrBits[LEN_DEMOD_BUF_ACCESS];
+
+    uint32_t accesssAddress = 0;
+
+    // Filling up addressBits with the access address we are looking to find.
+    for (int i = 0; i < 32; i++) {
+        accessAddrBits[i] = 0x01 & uint32_tmp;
+        uint32_tmp = (uint32_tmp >> 1);
+    }
+
+    const int demod_buf_len = LEN_DEMOD_BUF_ACCESS;  // For AA
+    int demod_buf_offset = 0;
+    int hit_idx = (-1);
+    bool unequal_flag = false;
+
+    memset(demod_buf_access, 0, SAMPLE_PER_SYMBOL * demod_buf_len);
+
+    for (int i = 0; i < num_symbol_left * SAMPLE_PER_SYMBOL; i += SAMPLE_PER_SYMBOL) {
+        int sp = ((demod_buf_offset - demod_buf_len + 1) & (demod_buf_len - 1));
+
+        for (int j = 0; j < SAMPLE_PER_SYMBOL; j++) {
+            // Sample and compare with the adjacent next sample.
+            int I0 = dst_buffer.p[i + j].real();
+            int Q0 = dst_buffer.p[i + j].imag();
+            int I1 = dst_buffer.p[i + j + 1].real();
+            int Q1 = dst_buffer.p[i + j + 1].imag();
+
+            int phase_idx = j;
+
+            demod_buf_access[phase_idx][demod_buf_offset] = (I0 * Q1 - I1 * Q0) > 0 ? 1 : 0;
+
+            int k = sp;
+            unequal_flag = false;
+
+            accesssAddress = 0;
+
+            for (int p = 0; p < demod_buf_len; p++) {
+                if (demod_buf_access[phase_idx][k] != accessAddrBits[p]) {
+                    unequal_flag = true;
+                    hit_idx = (-1);
+                    break;
+                }
+
+                accesssAddress = (accesssAddress & (~(1 << p))) | (demod_buf_access[phase_idx][k] << p);
+
+                k = ((k + 1) & (demod_buf_len - 1));
+            }
+
+            if (unequal_flag == false) {
+                hit_idx = (i + j - (demod_buf_len - 1) * SAMPLE_PER_SYMBOL);
+                break;
+            }
+        }
+
+        if (unequal_flag == false) {
+            break;
+        }
+
+        demod_buf_offset = ((demod_buf_offset + 1) & (demod_buf_len - 1));
+    }
+
+    if (hit_idx == -1) {
+        // Process more samples.
+        return;
+    }
+
+    symbols_eaten += hit_idx;
+
+    symbols_eaten += (8 * NUM_ACCESS_ADDR_BYTE * SAMPLE_PER_SYMBOL);  // move to the beginning of PDU header
+
+    num_symbol_left = num_symbol_left - symbols_eaten;
+
+    parseState = Parse_State_PDU_Header;
+}
+
+void BTLERxProcessor::handlePDUHeaderState() {
+    int num_demod_byte = 2;  // PDU header has 2 octets
+
+    symbols_eaten += 8 * num_demod_byte * SAMPLE_PER_SYMBOL;
+
+    if (symbols_eaten > (int)dst_buffer.count) {
+        return;
+    }
+
+    // Jump back down to the beginning of PDU header.
+    sample_idx = symbols_eaten - (8 * num_demod_byte * SAMPLE_PER_SYMBOL);
+
+    packet_index = 0;
+
+    for (int i = 0; i < num_demod_byte; i++) {
+        rb_buf[packet_index] = 0;
+
+        for (int j = 0; j < 8; j++) {
+            int I0 = dst_buffer.p[sample_idx].real();
+            int Q0 = dst_buffer.p[sample_idx].imag();
+            int I1 = dst_buffer.p[sample_idx + 1].real();
+            int Q1 = dst_buffer.p[sample_idx + 1].imag();
+
+            bit_decision = (I0 * Q1 - I1 * Q0) > 0 ? 1 : 0;
+            rb_buf[packet_index] = rb_buf[packet_index] | (bit_decision << j);
+
+            sample_idx += SAMPLE_PER_SYMBOL;
+        }
+
+        packet_index++;
+    }
+
+    scramble_byte(rb_buf, num_demod_byte, scramble_table[channel_number], rb_buf);
+
+    pdu_type = (ADV_PDU_TYPE)(rb_buf[0] & 0x0F);
+    // uint8_t tx_add = ((rb_buf[0] & 0x40) != 0);
+    // uint8_t rx_add = ((rb_buf[0] & 0x80) != 0);
+    payload_len = (rb_buf[1] & 0x3F);
+
+    // Not a valid Advertise Payload.
+    if ((payload_len < 6) || (payload_len > 37)) {
+        parseState = Parse_State_Begin;
+        return;
+    } else {
+        parseState = Parse_State_PDU_Payload;
+    }
+}
+
+void BTLERxProcessor::handlePDUPayloadState() {
+    int i;
+    int num_demod_byte = (payload_len + 3);
+    symbols_eaten += 8 * num_demod_byte * SAMPLE_PER_SYMBOL;
+
+    if (symbols_eaten > (int)dst_buffer.count) {
+        return;
+    }
+
+    for (i = 0; i < num_demod_byte; i++) {
+        rb_buf[packet_index] = 0;
+
+        for (int j = 0; j < 8; j++) {
+            int I0 = dst_buffer.p[sample_idx].real();
+            int Q0 = dst_buffer.p[sample_idx].imag();
+            int I1 = dst_buffer.p[sample_idx + 1].real();
+            int Q1 = dst_buffer.p[sample_idx + 1].imag();
+
+            bit_decision = (I0 * Q1 - I1 * Q0) > 0 ? 1 : 0;
+            rb_buf[packet_index] = rb_buf[packet_index] | (bit_decision << j);
+
+            sample_idx += SAMPLE_PER_SYMBOL;
+        }
+
+        packet_index++;
+    }
+
+    scramble_byte(rb_buf + 2, num_demod_byte, scramble_table[channel_number] + 2, rb_buf + 2);
+
+    // Check CRC
+    bool crc_flag = crc_check(rb_buf, payload_len + 2, crc_init_internal);
+    // pkt_count++;
+
+    // This should be the flag that determines if the data should be sent to the application layer.
+    bool sendPacket = false;
+
+    // Checking CRC and excluding Reserved PDU types.
+    if (pdu_type < RESERVED0 && !crc_flag) {
+        if (verify_payload_byte(payload_len, (ADV_PDU_TYPE)pdu_type) == 0) {
+            sendPacket = true;
+        }
+
+        // TODO: Make this a packet builder function?
+        if (sendPacket) {
+            blePacketData.max_dB = max_dB;
+
+            blePacketData.type = pdu_type;
+            blePacketData.size = payload_len;
+
+            blePacketData.macAddress[0] = rb_buf[7];
+            blePacketData.macAddress[1] = rb_buf[6];
+            blePacketData.macAddress[2] = rb_buf[5];
+            blePacketData.macAddress[3] = rb_buf[4];
+            blePacketData.macAddress[4] = rb_buf[3];
+            blePacketData.macAddress[5] = rb_buf[2];
+
+            // Skip Header Byte and MAC Address
+            uint8_t startIndex = 8;
+
+            for (i = 0; i < payload_len - 6; i++) {
+                blePacketData.data[i] = rb_buf[startIndex++];
+            }
+
+            blePacketData.dataLen = i;
+
+            BLEPacketMessage data_message{&blePacketData};
+
+            shared_memory.application_queue.push(data_message);
+        }
+    }
+
+    parseState = Parse_State_Begin;
+}
+
 void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
     if (!configured) return;
 
-    // FM demodulation
+    // Pulled this implementation from channel_stats_collector.c to time slice a specific packet's dB.
+    uint32_t max_squared = 0;
 
-    /*const auto decim_0_out = decim_0.execute(buffer, dst_buffer);
-        const auto channel = decim_1.execute(decim_0_out, dst_buffer);
+    void* src_p = buffer.p;
 
-        feed_channel_stats(channel);
-
-        auto audio_oversampled = demod.execute(channel, work_audio_buffer);*/
-
-    const auto decim_0_out = decim_0.execute(buffer, dst_buffer);
-    feed_channel_stats(decim_0_out);
-
-    auto audio_oversampled = demod.execute(decim_0_out, work_audio_buffer);
-
-    /*std::fill(spectrum.begin(), spectrum.end(), 0);
-        for(size_t i=0; i<spectrum.size(); i++) {
-                spectrum[i] += buffer.p[i];
+    while (src_p < &buffer.p[buffer.count]) {
+        const uint32_t sample = *__SIMD32(src_p)++;
+        const uint32_t mag_sq = __SMUAD(sample, sample);
+        if (mag_sq > max_squared) {
+            max_squared = mag_sq;
         }
-        const buffer_c16_t buffer_c16 {spectrum.data(),spectrum.size(),buffer.sampling_rate};
-        feed_channel_stats(buffer_c16);
+    }
 
-        auto audio_oversampled = demod.execute(buffer_c16, work_audio_buffer);*/
-    // Audio signal processing
-    for (size_t c = 0; c < audio_oversampled.count; c++) {
-        /*const int32_t sample_int = audio_oversampled.p[c] * 32768.0f;
-                int32_t current_sample = __SSAT(sample_int, 16);
-                current_sample /= 128;*/
+    const float max_squared_f = max_squared;
+    max_dB = mag2_to_dbv_norm(max_squared_f * (1.0f / (32768.0f * 32768.0f)));
 
-        int32_t current_sample = audio_oversampled.p[c];  // if I directly use this, some results can pass crc but not correct.
-        rb_head++;
-        rb_head = (rb_head) % RB_SIZE;
+    // 4Mhz 2048 samples
+    // Decimated by 4 to achieve 2048/4 = 512 samples at 1 sample per symbol.
+    decim_0.execute(buffer, dst_buffer);
+    feed_channel_stats(dst_buffer);
 
-        rb_buf[rb_head] = current_sample;
+    symbols_eaten = 0;
 
-        skipSamples = skipSamples - 1;
+    // Handle parsing based on parseState
+    if (parseState == Parse_State_Begin) {
+        handleBeginState();
+    }
 
-        if (skipSamples < 1) {
-            int32_t threshold_tmp = 0;
-            for (int c = 0; c < 8; c++) {
-                threshold_tmp = threshold_tmp + (int32_t)rb_buf[(rb_head + c) % RB_SIZE];
-            }
-            g_threshold = (int32_t)threshold_tmp / 8;
+    if (parseState == Parse_State_PDU_Header) {
+        handlePDUHeaderState();
+    }
 
-            int transitions = 0;
-            if (rb_buf[(rb_head + 9) % RB_SIZE] > g_threshold) {
-                for (int c = 0; c < 8; c++) {
-                    if (rb_buf[(rb_head + c) % RB_SIZE] > rb_buf[(rb_head + c + 1) % RB_SIZE])
-                        transitions = transitions + 1;
-                }
-            } else {
-                for (int c = 0; c < 8; c++) {
-                    if (rb_buf[(rb_head + c) % RB_SIZE] < rb_buf[(rb_head + c + 1) % RB_SIZE])
-                        transitions = transitions + 1;
-                }
-            }
-
-            bool packet_detected = false;
-            // if ( transitions==4 && abs(g_threshold)<15500)
-            if (transitions == 4) {
-                uint8_t packet_data[500];
-                int packet_length;
-                uint32_t packet_crc;
-                // uint32_t calced_crc; // NOTE: restore when CRC is passing
-                uint64_t packet_addr_l;
-                // uint32_t result; // NOTE: restore when CRC is passing
-                uint8_t crc[3];
-                uint8_t packet_header_arr[2];
-
-                packet_addr_l = 0;
-                for (int i = 0; i < 4; i++) {
-                    bool current_bit;
-                    uint8_t byte = 0;
-                    for (int c = 0; c < 8; c++) {
-                        if (rb_buf[(rb_head + (i + 1) * 8 + c) % RB_SIZE] > g_threshold)
-                            current_bit = true;
-                        else
-                            current_bit = false;
-                        byte |= current_bit << (7 - c);
-                    }
-                    uint8_t byte_temp = (uint8_t)(((byte * 0x0802LU & 0x22110LU) | (byte * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16);
-                    packet_addr_l |= ((uint64_t)byte_temp) << (8 * i);
-                }
-
-                channel_number = 38;
-
-                for (int t = 0; t < 2; t++) {
-                    bool current_bit;
-                    uint8_t byte = 0;
-                    for (int c = 0; c < 8; c++) {
-                        if (rb_buf[(rb_head + 5 * 8 + t * 8 + c) % RB_SIZE] > g_threshold)
-                            current_bit = true;
-                        else
-                            current_bit = false;
-                        byte |= current_bit << (7 - c);
-                    }
-
-                    packet_header_arr[t] = byte;
-                }
-
-                uint8_t byte_temp2 = (uint8_t)(((channel_number * 0x0802LU & 0x22110LU) | (channel_number * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16);
-                uint8_t lfsr_1 = byte_temp2 | 2;
-                int header_length = 2;
-                int header_counter = 0;
-                while (header_length--) {
-                    for (uint8_t i = 0x80; i; i >>= 1) {
-                        if (lfsr_1 & 0x80) {
-                            lfsr_1 ^= 0x11;
-                            (packet_header_arr[header_counter]) ^= i;
-                        }
-                        lfsr_1 <<= 1;
-                    }
-                    header_counter = header_counter + 1;
-                }
-
-                if (packet_addr_l == 0x8E89BED6) {
-                    uint8_t byte_temp3 = (uint8_t)(((packet_header_arr[1] * 0x0802LU & 0x22110LU) | (packet_header_arr[1] * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16);
-                    packet_length = byte_temp3 & 0x3F;
-
-                } else {
-                    packet_length = 0;
-                }
-
-                for (int t = 0; t < packet_length + 2 + 3; t++) {
-                    bool current_bit;
-                    uint8_t byte = 0;
-                    for (int c = 0; c < 8; c++) {
-                        if (rb_buf[(rb_head + 5 * 8 + t * 8 + c) % RB_SIZE] > g_threshold)
-                            current_bit = true;
-                        else
-                            current_bit = false;
-                        byte |= current_bit << (7 - c);
-                    }
-
-                    packet_data[t] = byte;
-                }
-
-                uint8_t byte_temp4 = (uint8_t)(((channel_number * 0x0802LU & 0x22110LU) | (channel_number * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16);
-                uint8_t lfsr_2 = byte_temp4 | 2;
-                int pdu_crc_length = packet_length + 2 + 3;
-                int pdu_crc_counter = 0;
-                while (pdu_crc_length--) {
-                    for (uint8_t i = 0x80; i; i >>= 1) {
-                        if (lfsr_2 & 0x80) {
-                            lfsr_2 ^= 0x11;
-                            (packet_data[pdu_crc_counter]) ^= i;
-                        }
-                        lfsr_2 <<= 1;
-                    }
-                    pdu_crc_counter = pdu_crc_counter + 1;
-                }
-
-                if (packet_addr_l == 0x8E89BED6) {
-                    crc[0] = crc[1] = crc[2] = 0x55;
-                } else {
-                    crc[0] = crc[1] = crc[2] = 0;
-                }
-
-                uint8_t v, t, d, crc_length;
-                uint32_t crc_result = 0;
-                crc_length = packet_length + 2;
-                int counter = 0;
-                while (crc_length--) {
-                    uint8_t byte_temp5 = (uint8_t)(((packet_data[counter] * 0x0802LU & 0x22110LU) | (packet_data[counter] * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16);
-                    d = byte_temp5;
-                    for (v = 0; v < 8; v++, d >>= 1) {
-                        t = crc[0] >> 7;
-                        crc[0] <<= 1;
-                        if (crc[1] & 0x80) crc[0] |= 1;
-                        crc[1] <<= 1;
-                        if (crc[2] & 0x80) crc[1] |= 1;
-                        crc[2] <<= 1;
-                        if (t != (d & 1)) {
-                            crc[2] ^= 0x5B;
-                            crc[1] ^= 0x06;
-                        }
-                    }
-                    counter = counter + 1;
-                }
-                for (v = 0; v < 3; v++) crc_result = (crc_result << 8) | crc[v];
-                // calced_crc = crc_result; // NOTE: restore when CRC is passing
-
-                packet_crc = 0;
-                for (int c = 0; c < 3; c++) packet_crc = (packet_crc << 8) | packet_data[packet_length + 2 + c];
-
-                if (packet_addr_l == 0x8E89BED6)
-                // if (packet_crc==calced_crc) // NOTE: restore when CRC is passing
-                {
-                    uint8_t mac_data[6];
-                    int counter = 0;
-                    for (int i = 7; i >= 2; i--) {
-                        uint8_t byte_temp6 = (uint8_t)(((packet_data[i] * 0x0802LU & 0x22110LU) | (packet_data[i] * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16);
-                        // result = byte_temp6; // NOTE: restore when CRC is passing
-                        mac_data[counter] = byte_temp6;
-                        counter = counter + 1;
-                    }
-
-                    data_message.is_data = false;
-                    data_message.value = 'A';
-                    shared_memory.application_queue.push(data_message);
-
-                    data_message.is_data = true;
-                    data_message.value = mac_data[0];
-                    shared_memory.application_queue.push(data_message);
-
-                    data_message.is_data = true;
-                    data_message.value = mac_data[1];
-                    shared_memory.application_queue.push(data_message);
-
-                    data_message.is_data = true;
-                    data_message.value = mac_data[2];
-                    shared_memory.application_queue.push(data_message);
-
-                    data_message.is_data = true;
-                    data_message.value = mac_data[3];
-                    shared_memory.application_queue.push(data_message);
-
-                    data_message.is_data = true;
-                    data_message.value = mac_data[4];
-                    shared_memory.application_queue.push(data_message);
-
-                    data_message.is_data = true;
-                    data_message.value = mac_data[5];
-                    shared_memory.application_queue.push(data_message);
-
-                    data_message.is_data = false;
-                    data_message.value = 'B';
-                    shared_memory.application_queue.push(data_message);
-
-                    packet_detected = true;
-                } else
-                    packet_detected = false;
-            }
-
-            if (packet_detected) {
-                skipSamples = 20;
-            }
-        }
+    if (parseState == Parse_State_PDU_Payload) {
+        handlePDUPayloadState();
     }
 }
 
@@ -275,12 +371,12 @@ void BTLERxProcessor::on_message(const Message* const message) {
 }
 
 void BTLERxProcessor::configure(const BTLERxConfigureMessage& message) {
-    (void)message;  // avoid warning
-    decim_0.configure(taps_200k_wfm_decim_0.taps);
-    decim_1.configure(taps_200k_wfm_decim_1.taps);
-    demod.configure(audio_fs, 5000);
+    channel_number = message.channel_number;
+    decim_0.configure(taps_BTLE_1M_PHY_decim_0.taps);
 
     configured = true;
+
+    crc_init_internal = crc_init_reorder(crc_initalVale);
 }
 
 int main() {

firmware/baseband/proc_btlerx.hpp

@@ -2,6 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2020 Shao
+ * Copyright (C) 2023 Netro
  *
  * This file is part of PortaPack.
  *
@@ -42,48 +43,182 @@ class BTLERxProcessor : public BasebandProcessor {
     void on_message(const Message* const message) override;
 
    private:
+    static constexpr int SAMPLE_PER_SYMBOL{1};
+    static constexpr int LEN_DEMOD_BUF_ACCESS{32};
+    static constexpr uint32_t DEFAULT_ACCESS_ADDR{0x8E89BED6};
+    static constexpr int NUM_ACCESS_ADDR_BYTE{4};
+
+    enum Parse_State {
+        Parse_State_Begin = 0,
+        Parse_State_PDU_Header,
+        Parse_State_PDU_Payload
+    };
+
+    enum ADV_PDU_TYPE {
+        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
+    };
+
+    uint8_t macAddress[6];
+    int checksumReceived = 0;
+
+    struct ADV_PDU_PAYLOAD_TYPE_R {
+        uint8_t payload_byte[40];
+    };
+
     static constexpr size_t baseband_fs = 4000000;
     static constexpr size_t audio_fs = baseband_fs / 8 / 8 / 2;
 
+    uint_fast32_t crc_update(uint_fast32_t crc, const void* data, size_t data_len);
+    uint_fast32_t crc24_byte(uint8_t* byte_in, int num_byte, uint32_t init_hex);
+    bool crc_check(uint8_t* tmp_byte, int body_len, uint32_t crc_init);
+    uint32_t crc_init_reorder(uint32_t crc_init);
+
+    uint32_t crc_initalVale = 0x555555;
+    uint32_t crc_init_internal = 0x00;
+
+    void scramble_byte(uint8_t* byte_in, int num_byte, const uint8_t* scramble_table_byte, uint8_t* byte_out);
+    // void demod_byte(int num_byte, uint8_t *out_byte);
+    int verify_payload_byte(int num_payload_byte, ADV_PDU_TYPE pdu_type);
+
+    void handleBeginState();
+    void handlePDUHeaderState();
+    void handlePDUPayloadState();
+
     std::array<complex16_t, 512> dst{};
     const buffer_c16_t dst_buffer{
         dst.data(),
         dst.size()};
 
-    std::array<complex16_t, 512> spectrum{};
-    const buffer_c16_t spectrum_buffer{
-        spectrum.data(),
-        spectrum.size()};
+    static constexpr int RB_SIZE = 512;
+    uint8_t rb_buf[RB_SIZE];
 
-    const buffer_s16_t work_audio_buffer{
-        (int16_t*)dst.data(),
-        sizeof(dst) / sizeof(int16_t)};
-
-    // Array size ok down to 375 bauds (24000 / 375)
-    std::array<int32_t, 64> delay_line{0};
-    std::array<int16_t, 1000> rb_buf{0};
-
-    /*dsp::decimate::FIRC8xR16x24FS4Decim8 decim_0 { };
-        dsp::decimate::FIRC16xR16x32Decim8 decim_1 { };
-        dsp::decimate::FIRAndDecimateComplex channel_filter { };*/
     dsp::decimate::FIRC8xR16x24FS4Decim4 decim_0{};
-    dsp::decimate::FIRC16xR16x16Decim2 decim_1{};
 
     dsp::demodulate::FM demod{};
     int rb_head{-1};
     int32_t g_threshold{0};
-    uint8_t channel_number{38};
-    int skipSamples{1000};
-    int RB_SIZE{1000};
+    uint8_t channel_number{37};
+
+    uint16_t process = 0;
 
     bool configured{false};
-    AFSKDataMessage data_message{false, 0};
+    BlePacketData blePacketData{};
+
+    Parse_State parseState{Parse_State_Begin};
+    uint16_t packet_index{0};
+    int sample_idx{0};
+    int symbols_eaten{0};
+    uint8_t bit_decision{0};
+    uint8_t payload_len{0};
+    uint8_t pdu_type{0};
+    int32_t max_dB{0};
 
     /* NB: Threads should be the last members in the class definition. */
     BasebandThread baseband_thread{baseband_fs, this, baseband::Direction::Receive};
     RSSIThread rssi_thread{};
 
     void configure(const BTLERxConfigureMessage& message);
+
+    // clang-format off
+    // Scramble table definition
+    const uint8_t scramble_table[40][42] = 
+    {
+        {64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, },
+        {137, 64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, },
+        {210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, },
+        {27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, },
+        {100, 121, 135, 63, 110, 148, 190, 10, 237, 57, 53, 131, 173, 139, 137, 64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, },
+        {173, 139, 137, 64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, },
+        {246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, },
+        {63, 110, 148, 190, 10, 237, 57, 53, 131, 173, 139, 137, 64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, },
+        {8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, },
+        {193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, },
+        {154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, },
+        {83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, },
+        {44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, },
+        {229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, 91, 23, 19, 129, 100, 121, 135, 63, 110, 148, 190, 10, 237, 57, 53, },
+        {190, 10, 237, 57, 53, 131, 173, 139, 137, 64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, },
+        {119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, },
+        {208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, },
+        {25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, 91, 23, 19, 129, 100, 121, 135, 63, 110, },
+        {66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, },
+        {139, 137, 64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, },
+        {244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, 91, 23, 19, 129, },
+        {61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, },
+        {102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, },
+        {175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, },
+        {152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, },
+        {81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, 91, 23, 19, 129, 100, 121, 135, 63, 110, 148, 190, 10, 237, 57, 53, 131, 173, 139, 137, },
+        {10, 237, 57, 53, 131, 173, 139, 137, 64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, },
+        {195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, },
+        {188, 195, 31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, },
+        {117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, },
+        {46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, 91, 23, 19, 129, 100, 121, 135, 63, 110, 148, 190, 10, 237, 57, 53, 131, 173, 139, 137, 64, 178, 188, 195, 31, 55, 74, 95, },
+        {231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, 91, 23, 19, 129, 100, 121, 135, 63, 110, 148, 190, 10, 237, 57, 53, 131, 173, 139, 137, 64, 178, 188, 195, },
+        {96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, },
+        {169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, 91, 23, 19, 129, 100, 121, 135, 63, },
+        {242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, 91, 23, 19, 129, 100, 121, 135, 63, 110, 148, 190, 10, 237, 57, 53, 131, 173, 139, 137, 64, 178, 188, 195, 31, 55, 74, 95, 133, 246, 156, 154, },
+        {59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, 4, 146, 229, 29, 254, 184, 81, 250, 42, 180, 231, 212, 12, 182, 46, 38, 2, 201, 242, 14, 127, 220, 40, 125, 21, 218, 115, 106, 6, },
+        {68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, },
+        {141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, 171, 208, 158, 83, 51, 216, 186, 152, 8, 36, 203, 59, 252, 113, 163, 244, 85, 104, 207, 169, 25, 108, 93, 76, },
+        {214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, 49, 17, 72, 150, 119, 248, 227, 70, 233, },
+        {31, 55, 74, 95, 133, 246, 156, 154, 193, 214, 197, 68, 32, 89, 222, 225, 143, 27, 165, 175, 66, 123, 78, 205, 96, 235, 98, 34, 144, 44, 239, 240, 199, 141, 210, 87, 161, 61, 167, 102, 176, 117, },
+    };
+
+    /**
+     * Static table used for the table_driven implementation.
+     *****************************************************************************/
+    const uint_fast32_t crc_table[256] =
+    {
+        0x000000, 0x01b4c0, 0x036980, 0x02dd40, 0x06d300, 0x0767c0, 0x05ba80, 0x040e40,
+        0x0da600, 0x0c12c0, 0x0ecf80, 0x0f7b40, 0x0b7500, 0x0ac1c0, 0x081c80, 0x09a840,
+        0x1b4c00, 0x1af8c0, 0x182580, 0x199140, 0x1d9f00, 0x1c2bc0, 0x1ef680, 0x1f4240,
+        0x16ea00, 0x175ec0, 0x158380, 0x143740, 0x103900, 0x118dc0, 0x135080, 0x12e440,
+        0x369800, 0x372cc0, 0x35f180, 0x344540, 0x304b00, 0x31ffc0, 0x332280, 0x329640,
+        0x3b3e00, 0x3a8ac0, 0x385780, 0x39e340, 0x3ded00, 0x3c59c0, 0x3e8480, 0x3f3040,
+        0x2dd400, 0x2c60c0, 0x2ebd80, 0x2f0940, 0x2b0700, 0x2ab3c0, 0x286e80, 0x29da40,
+        0x207200, 0x21c6c0, 0x231b80, 0x22af40, 0x26a100, 0x2715c0, 0x25c880, 0x247c40,
+        0x6d3000, 0x6c84c0, 0x6e5980, 0x6fed40, 0x6be300, 0x6a57c0, 0x688a80, 0x693e40,
+        0x609600, 0x6122c0, 0x63ff80, 0x624b40, 0x664500, 0x67f1c0, 0x652c80, 0x649840,
+        0x767c00, 0x77c8c0, 0x751580, 0x74a140, 0x70af00, 0x711bc0, 0x73c680, 0x727240,
+        0x7bda00, 0x7a6ec0, 0x78b380, 0x790740, 0x7d0900, 0x7cbdc0, 0x7e6080, 0x7fd440,
+        0x5ba800, 0x5a1cc0, 0x58c180, 0x597540, 0x5d7b00, 0x5ccfc0, 0x5e1280, 0x5fa640,
+        0x560e00, 0x57bac0, 0x556780, 0x54d340, 0x50dd00, 0x5169c0, 0x53b480, 0x520040,
+        0x40e400, 0x4150c0, 0x438d80, 0x423940, 0x463700, 0x4783c0, 0x455e80, 0x44ea40,
+        0x4d4200, 0x4cf6c0, 0x4e2b80, 0x4f9f40, 0x4b9100, 0x4a25c0, 0x48f880, 0x494c40,
+        0xda6000, 0xdbd4c0, 0xd90980, 0xd8bd40, 0xdcb300, 0xdd07c0, 0xdfda80, 0xde6e40,
+        0xd7c600, 0xd672c0, 0xd4af80, 0xd51b40, 0xd11500, 0xd0a1c0, 0xd27c80, 0xd3c840,
+        0xc12c00, 0xc098c0, 0xc24580, 0xc3f140, 0xc7ff00, 0xc64bc0, 0xc49680, 0xc52240,
+        0xcc8a00, 0xcd3ec0, 0xcfe380, 0xce5740, 0xca5900, 0xcbedc0, 0xc93080, 0xc88440,
+        0xecf800, 0xed4cc0, 0xef9180, 0xee2540, 0xea2b00, 0xeb9fc0, 0xe94280, 0xe8f640,
+        0xe15e00, 0xe0eac0, 0xe23780, 0xe38340, 0xe78d00, 0xe639c0, 0xe4e480, 0xe55040,
+        0xf7b400, 0xf600c0, 0xf4dd80, 0xf56940, 0xf16700, 0xf0d3c0, 0xf20e80, 0xf3ba40,
+        0xfa1200, 0xfba6c0, 0xf97b80, 0xf8cf40, 0xfcc100, 0xfd75c0, 0xffa880, 0xfe1c40,
+        0xb75000, 0xb6e4c0, 0xb43980, 0xb58d40, 0xb18300, 0xb037c0, 0xb2ea80, 0xb35e40,
+        0xbaf600, 0xbb42c0, 0xb99f80, 0xb82b40, 0xbc2500, 0xbd91c0, 0xbf4c80, 0xbef840,
+        0xac1c00, 0xada8c0, 0xaf7580, 0xaec140, 0xaacf00, 0xab7bc0, 0xa9a680, 0xa81240,
+        0xa1ba00, 0xa00ec0, 0xa2d380, 0xa36740, 0xa76900, 0xa6ddc0, 0xa40080, 0xa5b440,
+        0x81c800, 0x807cc0, 0x82a180, 0x831540, 0x871b00, 0x86afc0, 0x847280, 0x85c640,
+        0x8c6e00, 0x8ddac0, 0x8f0780, 0x8eb340, 0x8abd00, 0x8b09c0, 0x89d480, 0x886040,
+        0x9a8400, 0x9b30c0, 0x99ed80, 0x985940, 0x9c5700, 0x9de3c0, 0x9f3e80, 0x9e8a40,
+        0x972200, 0x9696c0, 0x944b80, 0x95ff40, 0x91f100, 0x9045c0, 0x929880, 0x932c40
+    };
+    // clang-format on
 };
 
 #endif /*__PROC_BTLERX_H__*/

firmware/baseband/proc_fsk_rx.cpp

@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 1996 Thomas Sailer (sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu)
+ * Copyright (C) 2012-2014 Elias Oenal (multimon-ng@eliasoenal.com)
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ * Copyright (C) 2023 Kyle Reed
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "proc_fsk_rx.hpp"
+
+#include "event_m4.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstddef>
+
+using namespace std;
+using namespace dsp::decimate;
+
+namespace {
+/* Count of bits that differ between the two values. */
+uint8_t diff_bit_count(uint32_t left, uint32_t right) {
+    uint32_t diff = left ^ right;
+    uint8_t count = 0;
+    for (size_t i = 0; i < sizeof(diff) * 8; ++i) {
+        if (((diff >> i) & 0x1) == 1)
+            ++count;
+    }
+
+    return count;
+}
+}  // namespace
+
+/* AudioNormalizer ***************************************/
+
+void AudioNormalizer::execute_in_place(const buffer_f32_t& audio) {
+    // Decay min/max every second (@24kHz).
+    if (counter_ >= 24'000) {
+        // 90% decay factor seems to work well.
+        // This keeps large transients from wrecking the filter.
+        max_ *= 0.9f;
+        min_ *= 0.9f;
+        counter_ = 0;
+        calculate_thresholds();
+    }
+
+    counter_ += audio.count;
+
+    for (size_t i = 0; i < audio.count; ++i) {
+        auto& val = audio.p[i];
+
+        if (val > max_) {
+            max_ = val;
+            calculate_thresholds();
+        }
+        if (val < min_) {
+            min_ = val;
+            calculate_thresholds();
+        }
+
+        if (val >= t_hi_)
+            val = 1.0f;
+        else if (val <= t_lo_)
+            val = -1.0f;
+        else
+            val = 0.0;
+    }
+}
+
+void AudioNormalizer::calculate_thresholds() {
+    auto center = (max_ + min_) / 2.0f;
+    auto range = (max_ - min_) / 2.0f;
+
+    // 10% off center force either +/-1.0f.
+    // Higher == larger dead zone.
+    // Lower == more false positives.
+    auto threshold = range * 0.1;
+    t_hi_ = center + threshold;
+    t_lo_ = center - threshold;
+}
+
+/* FSKRxProcessor ******************************************/
+
+void FSKRxProcessor::clear_data_bits() {
+    data = 0;
+    bit_count = 0;
+}
+
+void FSKRxProcessor::handle_sync(bool inverted) {
+    clear_data_bits();
+    has_sync_ = true;
+    inverted = inverted;
+    word_count = 0;
+}
+
+void FSKRxProcessor::process_bits(const buffer_c8_t& buffer) {
+    // Process all of the bits in the bits queue.
+    while (buffer.count > 0) {
+        // Wait until data_ is full.
+        if (bit_count < data_bit_count)
+            continue;
+
+        // Wait for the sync frame.
+        if (!has_sync_) {
+            if (diff_bit_count(data, sync_codeword) <= 2)
+                handle_sync(/*inverted=*/false);
+            else if (diff_bit_count(data, ~sync_codeword) <= 2)
+                handle_sync(/*inverted=*/true);
+            continue;
+        }
+    }
+}
+
+/* FSKRxProcessor ***************************************/
+
+FSKRxProcessor::FSKRxProcessor() {
+}
+
+void FSKRxProcessor::execute(const buffer_c8_t& buffer) {
+    if (!configured) {
+        return;
+    }
+
+    // Decimate by current decim 0 and decim 1.
+    const auto decim_0_out = decim_0.execute(buffer, dst_buffer);
+    const auto decim_1_out = decim_1.execute(decim_0_out, dst_buffer);
+
+    feed_channel_stats(decim_1_out);
+
+    spectrum_samples += decim_1_out.count;
+
+    if (spectrum_samples >= spectrum_interval_samples) {
+        spectrum_samples -= spectrum_interval_samples;
+        channel_spectrum.feed(decim_1_out, channel_filter_low_f,
+                              channel_filter_high_f, channel_filter_transition);
+    }
+
+    // process_bits();
+
+    // Update the status.
+    samples_processed += buffer.count;
+
+    if (samples_processed >= stat_update_threshold) {
+        // send_packet(data);
+        samples_processed -= stat_update_threshold;
+    }
+}
+
+void FSKRxProcessor::on_message(const Message* const message) {
+    switch (message->id) {
+        case Message::ID::FSKRxConfigure:
+            configure(*reinterpret_cast<const FSKRxConfigureMessage*>(message));
+            break;
+        case Message::ID::UpdateSpectrum:
+        case Message::ID::SpectrumStreamingConfig:
+            channel_spectrum.on_message(message);
+            break;
+
+        case Message::ID::SampleRateConfig:
+            sample_rate_config(*reinterpret_cast<const SampleRateConfigMessage*>(message));
+            break;
+
+        case Message::ID::CaptureConfig:
+            capture_config(*reinterpret_cast<const CaptureConfigMessage*>(message));
+            break;
+
+        default:
+            break;
+    }
+}
+
+void FSKRxProcessor::configure(const FSKRxConfigureMessage& message) {
+    // Extract message variables.
+    deviation = message.deviation;
+    channel_decimation = message.channel_decimation;
+    // channel_filter_taps = message.channel_filter;
+
+    channel_spectrum.set_decimation_factor(1);
+}
+
+void FSKRxProcessor::capture_config(const CaptureConfigMessage& message) {
+    if (message.config) {
+        audio_output.set_stream(std::make_unique<StreamInput>(message.config));
+    } else {
+        audio_output.set_stream(nullptr);
+    }
+}
+
+void FSKRxProcessor::sample_rate_config(const SampleRateConfigMessage& message) {
+    const auto sample_rate = message.sample_rate;
+
+    // The actual sample rate is the requested rate * the oversample rate.
+    // See oversample.hpp for more details on oversampling.
+    baseband_fs = sample_rate * toUType(message.oversample_rate);
+    baseband_thread.set_sampling_rate(baseband_fs);
+
+    // TODO: Do we need to use the taps that the decimators get configured with?
+    channel_filter_low_f = taps_200k_decim_1.low_frequency_normalized * sample_rate;
+    channel_filter_high_f = taps_200k_decim_1.high_frequency_normalized * sample_rate;
+    channel_filter_transition = taps_200k_decim_1.transition_normalized * sample_rate;
+
+    // Compute the scalar that corrects the oversample_rate to be x8 when computing
+    // the spectrum update interval. The original implementation only supported x8.
+    // TODO: Why is this needed here but not in proc_replay? There must be some other
+    // assumption about x8 oversampling in some component that makes this necessary.
+    const auto oversample_correction = toUType(message.oversample_rate) / 8.0;
+
+    // The spectrum update interval controls how often the waterfall is fed new samples.
+    spectrum_interval_samples = sample_rate / (spectrum_rate_hz * oversample_correction);
+    spectrum_samples = 0;
+
+    // For high sample rates, the M4 is busy collecting samples so the
+    // waterfall runs slower. Reduce the update interval so it runs faster.
+    // NB: Trade off: looks nicer, but more frequent updates == more CPU.
+    if (sample_rate >= 1'500'000)
+        spectrum_interval_samples /= (sample_rate / 750'000);
+
+    switch (message.oversample_rate) {
+        case OversampleRate::x4:
+            // M4 can't handle 2 decimation passes for sample rates needing x4.
+            decim_0.set<FIRC8xR16x24FS4Decim4>().configure(taps_200k_decim_0.taps);
+            decim_1.set<NoopDecim>();
+            break;
+
+        case OversampleRate::x8:
+            // M4 can't handle 2 decimation passes for sample rates <= 600k.
+            if (message.sample_rate < 600'000) {
+                decim_0.set<FIRC8xR16x24FS4Decim4>().configure(taps_200k_decim_0.taps);
+                decim_1.set<FIRC16xR16x16Decim2>().configure(taps_200k_decim_1.taps);
+            } else {
+                // Using 180k taps to provide better filtering with a single pass.
+                decim_0.set<FIRC8xR16x24FS4Decim8>().configure(taps_180k_wfm_decim_0.taps);
+                decim_1.set<NoopDecim>();
+            }
+            break;
+
+        case OversampleRate::x16:
+            decim_0.set<FIRC8xR16x24FS4Decim8>().configure(taps_200k_decim_0.taps);
+            decim_1.set<FIRC16xR16x16Decim2>().configure(taps_200k_decim_1.taps);
+            break;
+
+        case OversampleRate::x32:
+            decim_0.set<FIRC8xR16x24FS4Decim4>().configure(taps_200k_decim_0.taps);
+            decim_1.set<FIRC16xR16x32Decim8>().configure(taps_16k0_decim_1.taps);
+            break;
+
+        case OversampleRate::x64:
+            decim_0.set<FIRC8xR16x24FS4Decim8>().configure(taps_200k_decim_0.taps);
+            decim_1.set<FIRC16xR16x32Decim8>().configure(taps_16k0_decim_1.taps);
+            break;
+
+        default:
+            chDbgPanic("Unhandled OversampleRate");
+            break;
+    }
+
+    // Update demodulator based on new decimation. Todo: Confirm this works.
+    size_t decim_0_input_fs = baseband_fs;
+    size_t decim_0_output_fs = decim_0_input_fs / decim_0.decimation_factor();
+
+    size_t decim_1_input_fs = decim_0_output_fs;
+    size_t decim_1_output_fs = decim_1_input_fs / decim_1.decimation_factor();
+
+    // size_t channel_filter_input_fs = decim_1_output_fs;
+    // size_t channel_filter_output_fs = channel_filter_input_fs / channel_decimation;
+
+    size_t demod_input_fs = decim_1_output_fs;
+
+    send_packet((uint32_t)demod_input_fs);
+
+    // Set ready to process data.
+    configured = true;
+}
+
+void FSKRxProcessor::flush() {
+    // word_extractor.flush();
+}
+
+void FSKRxProcessor::reset() {
+    clear_data_bits();
+    has_sync_ = false;
+    inverted = false;
+    word_count = 0;
+
+    samples_processed = 0;
+}
+
+void FSKRxProcessor::send_packet(uint32_t data) {
+    data_message.is_data = true;
+    data_message.value = data;
+    shared_memory.application_queue.push(data_message);
+}
+
+/* main **************************************************/
+
+int main() {
+    EventDispatcher event_dispatcher{std::make_unique<FSKRxProcessor>()};
+    event_dispatcher.run();
+    return 0;
+}

firmware/baseband/proc_fsk_rx.hpp

@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2016 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __PROC_FSK_RX_H__
+#define __PROC_FSK_RX_H__
+
+#include "audio_output.hpp"
+#include "baseband_processor.hpp"
+#include "baseband_thread.hpp"
+#include "rssi_thread.hpp"
+
+#include "dsp_decimate.hpp"
+#include "dsp_demodulate.hpp"
+#include "dsp_iir_config.hpp"
+#include "dsp_fir_taps.hpp"
+
+#include "spectrum_collector.hpp"
+#include "stream_input.hpp"
+
+#include "message.hpp"
+#include "portapack_shared_memory.hpp"
+
+#include <array>
+#include <memory>
+#include <tuple>
+#include <variant>
+#include <cstdint>
+#include <functional>
+
+/* Normalizes audio stream to +/-1.0f */
+class AudioNormalizer {
+   public:
+    void execute_in_place(const buffer_f32_t& audio);
+
+   private:
+    void calculate_thresholds();
+
+    uint32_t counter_ = 0;
+    float min_ = 99.0f;
+    float max_ = -99.0f;
+    float t_hi_ = 1.0;
+    float t_lo_ = 1.0;
+};
+
+/* A decimator that just returns the source buffer. */
+class NoopDecim {
+   public:
+    static constexpr int decimation_factor = 1;
+
+    template <typename Buffer>
+    Buffer execute(const Buffer& src, const Buffer&) {
+        // TODO: should this copy to 'dst'?
+        return {src.p, src.count, src.sampling_rate};
+    }
+};
+
+/* Decimator wrapper that can hold one of a set of decimators and dispatch at runtime. */
+template <typename... Args>
+class MultiDecimator {
+   public:
+    /* Dispatches to the underlying type's execute. */
+    template <typename Source, typename Destination>
+    Destination execute(
+        const Source& src,
+        const Destination& dst) {
+        return std::visit(
+            [&src, &dst](auto&& arg) -> Destination {
+                return arg.execute(src, dst);
+            },
+            decimator_);
+    }
+
+    size_t decimation_factor() const {
+        return std::visit(
+            [](auto&& arg) -> size_t {
+                return arg.decimation_factor;
+            },
+            decimator_);
+    }
+
+    /* Sets this decimator to a new instance of the specified decimator type.
+     * NB: The instance is returned by-ref so 'configure' can easily be called. */
+    template <typename Decimator>
+    Decimator& set() {
+        decimator_ = Decimator{};
+        return std::get<Decimator>(decimator_);
+    }
+
+   private:
+    std::variant<Args...> decimator_{};
+};
+
+class FSKRxProcessor : public BasebandProcessor {
+   public:
+    FSKRxProcessor();
+    void execute(const buffer_c8_t& buffer) override;
+    void on_message(const Message* const message) override;
+
+   private:
+    size_t baseband_fs = 1024000;  // aka: sample_rate
+    uint8_t stat_update_interval = 10;
+    uint32_t stat_update_threshold = baseband_fs / stat_update_interval;
+    static constexpr auto spectrum_rate_hz = 50.0f;
+
+    void configure(const FSKRxConfigureMessage& message);
+    void capture_config(const CaptureConfigMessage& message);
+    void sample_rate_config(const SampleRateConfigMessage& message);
+    void flush();
+    void reset();
+    void send_packet(uint32_t data);
+    void process_bits(const buffer_c8_t& buffer);
+
+    void clear_data_bits();
+    void handle_sync(bool inverted);
+
+    /* Returns true if the batch has as sync frame. */
+    bool has_sync() const { return has_sync_; }
+
+    /* Set once app is ready to receive messages. */
+    bool configured = false;
+
+    /* Buffer for decimated IQ data. */
+    std::array<complex16_t, 512> dst{};
+    const buffer_c16_t dst_buffer{
+        dst.data(),
+        dst.size()};
+
+    /* Buffer for demodulated audio. */
+    std::array<float, 16> audio{};
+    const buffer_f32_t audio_buffer{audio.data(), audio.size()};
+
+    /* The actual type will be configured depending on the sample rate. */
+    MultiDecimator<
+        dsp::decimate::FIRC8xR16x24FS4Decim4,
+        dsp::decimate::FIRC8xR16x24FS4Decim8>
+        decim_0{};
+    MultiDecimator<
+        dsp::decimate::FIRC16xR16x16Decim2,
+        dsp::decimate::FIRC16xR16x32Decim8,
+        NoopDecim>
+        decim_1{};
+
+    /* Filter to 24kHz and demodulate. */
+    dsp::decimate::FIRAndDecimateComplex channel_filter{};
+    size_t deviation = 3750;
+    // fir_taps_real<32> channel_filter_taps = 0;
+    size_t channel_decimation = 2;
+    int32_t channel_filter_low_f = 0;
+    int32_t channel_filter_high_f = 0;
+    int32_t channel_filter_transition = 0;
+
+    /* Squelch to ignore noise. */
+    FMSquelch squelch{};
+    uint64_t squelch_history = 0;
+
+    // /* LPF to reduce noise. POCSAG supports 2400 baud, but that falls
+    //  * nicely into the transition band of this 1800Hz filter.
+    //  * scipy.signal.butter(2, 1800, "lowpass", fs=24000, analog=False) */
+    // IIRBiquadFilter lpf{{{0.04125354f, 0.082507070f, 0.04125354f},
+    //                      {1.00000000f, -1.34896775f, 0.51398189f}}};
+
+    /* Attempts to de-noise and normalize signal. */
+    AudioNormalizer normalizer{};
+
+    /* Handles writing audio stream to hardware. */
+    AudioOutput audio_output{};
+
+    /* Holds the data sent to the app. */
+    AFSKDataMessage data_message{false, 0};
+
+    /* Used to keep track of how many samples were processed
+     * between status update messages. */
+    uint32_t samples_processed = 0;
+
+    /* Number of bits in 'data_' member. */
+    static constexpr uint8_t data_bit_count = sizeof(uint32_t) * 8;
+
+    /* Sync frame codeword. */
+    static constexpr uint32_t sync_codeword = 0x12345678;
+
+    /* When true, sync frame has been received. */
+    bool has_sync_ = false;
+
+    /* When true, bit vales are flipped in the codewords. */
+    bool inverted = false;
+
+    uint32_t data = 0;
+    uint8_t bit_count = 0;
+    uint8_t word_count = 0;
+
+    /* LPF to reduce noise. POCSAG supports 2400 baud, but that falls
+     * nicely into the transition band of this 1800Hz filter.
+     * scipy.signal.butter(2, 1800, "lowpass", fs=24000, analog=False) */
+    IIRBiquadFilter lpf{{{0.04125354f, 0.082507070f, 0.04125354f},
+                         {1.00000000f, -1.34896775f, 0.51398189f}}};
+
+    SpectrumCollector channel_spectrum{};
+    size_t spectrum_interval_samples = 0;
+    size_t spectrum_samples = 0;
+
+    /* NB: Threads should be the last members in the class definition. */
+    BasebandThread baseband_thread{baseband_fs, this, baseband::Direction::Receive};
+    RSSIThread rssi_thread{};
+};
+
+#endif

firmware/baseband/proc_siggen.cpp

@@ -40,7 +40,7 @@ void SigGenProcessor::execute(const buffer_c8_t& buffer) {
 
         if (tone_shape == 0) {
             // CW
-            re = 127;
+            re = 127;  // max. signed 8 bits value .   (-128 ...+127), max. amplitude ,  static phasor at 0º
             im = 0;
         } else {
             if (tone_shape == 1) {
@@ -79,20 +79,58 @@ void SigGenProcessor::execute(const buffer_c8_t& buffer) {
                 if (counter == 15) {
                     counter = 0;
                 }
+            } else if (tone_shape == 7) {
+                // Digital BPSK consecutive 0,1,0,...continuous cycle, 1 bit/symbol, at rate of 2 symbols / Freq Tone Periode... without any Pulse shape at the moment .
+                re = (((tone_phase & 0xFF000000) >> 24) & 0x80) ? 127 : -128;  // Sending 2 bits by Periode T of the GUI tone, alternative static phasor to 0, -180º , 0º
+                im = 0;
+            } else if (tone_shape == 8) {
+                // Digital QPSK  consecutive 00, 01, 10, 11,00, ...continuous cycle ,2 bits/symbol, at rate of 4 symbols / Freq Tone Periode. not random., without any Pulse shape at the moment .
+
+                switch (((tone_phase & 0xFF000000) >> 24)) {
+                    case 0 ... 63:  // equivalent to 1/4 of total 360º degrees.
+                        /* "00" */
+                        re = (sine_table_i8[32]);       // we are sending symbol-phasor 45º during  1/4 of the total periode
+                        im = (sine_table_i8[32 + 64]);  // 32 index  = rounded (45º/360º * 255 total sin table steps) = 31,875
+                        break;
+
+                    case 64 ... 127:
+                        /* "01" */
+                        re = (sine_table_i8[96]);       // symbol-phasor 135º
+                        im = (sine_table_i8[96 + 64]);  // 96 index   = 32 + 256/4
+                        break;
+                        break;
+
+                    case 128 ... 191:
+                        /* "10" */
+                        re = (sine_table_i8[159]);       // symbol-phasor 225º
+                        im = (sine_table_i8[159 + 64]);  // 159 rounded index = 96 + 256/4 = 159.3
+                        break;
+
+                    case 192 ... 255:
+                        /* "11" */
+                        re = (sine_table_i8[223]);                  // symbol-phasor 315º ; 223 rounded index = (315/360) * 255 =223.125
+                        im = (sine_table_i8[((223 + 64) & 0xFF)]);  // Max index 255, circular periodic conversion.
+                        break;
+
+                    default:
+                        break;
+                }
             }
 
-            if (tone_shape < 6) {  // we are in periodic signals, we need tone phases update.
-                tone_phase += tone_delta;
+            if (tone_shape != 6) {         //(all except Pseudo Random White Noise). We are in (1):periodic signals or (2):BPSK/QPSK , in both cases ,we  need Tone updated acum sum phases to modulate in FM / or control phasor phase (BPSK & QPSK.)
+                tone_phase += tone_delta;  // In periodic signals(Sine/triangle/square) we are using to FM mod. in BPSK-QSPK we are using to calculate each 1/4 of the periode.
             }
 
-            // Do FM modulation
-            delta = sample * fm_delta;
+            if (tone_shape < 7) {  // All Option shape signals  except BPSK(7) & QPSK(8) we are modulating in FM. (Those two has phase shift modulation XPSK , not FM  )
+                // Do FM modulation
+                delta = sample * fm_delta;
 
-            phase += delta;
-            sphase = phase + (64 << 24);
+                phase += delta;
+                sphase = phase + (64 << 24);
 
-            re = (sine_table_i8[(sphase & 0xFF000000) >> 24]);
-            im = (sine_table_i8[(phase & 0xFF000000) >> 24]);
+                re = (sine_table_i8[(sphase & 0xFF000000) >> 24]);  // sin LUT is not dealing with decimals , output range [-128 ,...127]
+                im = (sine_table_i8[(phase & 0xFF000000) >> 24]);
+            }
         }
 
         buffer.p[i] = {re, im};

firmware/chibios/os/hal/include/hal.h

@@ -205,11 +205,12 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-  void halInit(void);
+void halInit(void);
 #if HAL_IMPLEMENTS_COUNTERS
-  bool_t halIsCounterWithin(halrtcnt_t start, halrtcnt_t end);
-  void halPolledDelay(halrtcnt_t ticks);
+bool_t halIsCounterWithin(halrtcnt_t start, halrtcnt_t end);
+void halPolledDelay(halrtcnt_t ticks);
 #endif /* HAL_IMPLEMENTS_COUNTERS */
+void sdio_cclk_set(const size_t divider_value);
 #ifdef __cplusplus
 }
 #endif

firmware/common/adsb_frame.hpp

@@ -25,6 +25,7 @@
 
 #include <cstring>
 #include <string>
+#include <cstdint>
 
 namespace adsb {
 

firmware/common/ak4951.cpp

@@ -224,7 +224,7 @@ void AK4951::speaker_disable() {
     set_speaker_power(false);
 }
 
-void AK4951::microphone_enable(int8_t alc_mode) {
+void AK4951::microphone_enable(int8_t alc_mode, bool mic_to_HP_enabled) {
     // alc_mode =0 = (OFF =same as original code = NOT using AK4951 Programmable digital filter block),
     // alc_mode >1 (with  DIGITAL FILTER BLOCK , example :  1:(+12dB) , 2:(+9dB)", 3:(+6dB), ...)
 
@@ -279,7 +279,7 @@ void AK4951::microphone_enable(int8_t alc_mode) {
         update(Register::DigitalFilterMode);     // Writing the Audio Path :  NO DIGITAL BLOCK or DIG BLOCK FOR  MIC ,   Audio mode path : Playback mode /-Recording mode.
 
         map.r.power_management_1.PMADL = 1;   // ADC Lch = Lch input signal. Mic Amp Lch and ADC Lch Power Management
-        map.r.power_management_1.PMADR = 1;   // ADC Rch = Rch input signal. Mic Amp Rch and ADC Rch Power Management
+        map.r.power_management_1.PMADR = 0;   // ADC Rch = Rch input signal. Mic Amp Rch and ADC Rch Power Management. (PMADL=1, PMADR=0) means MONO MIC input connected to Left pin.
         map.r.power_management_1.PMPFIL = 0;  // Pre-loading , Programmable Dig. filter OFF ,filter unused, routed around.(original value = 0 )
         update(Register::PowerManagement1);   // Activating the Power management of the used blocks . (Mic ADC always + Dig Block filter , when used )
 
@@ -461,7 +461,7 @@ void AK4951::microphone_enable(int8_t alc_mode) {
         // When changing those modes, PMPFIL bit must be “0”, it is OK (*1)
         map.r.digital_filter_mode.ADCPF = 1;     // ADCPF bit swith ("0" Mic  after ADC Output connected (recording mode) to the DIGITAL FILTER  BLOCK. ("1" Playback mode)
         map.r.digital_filter_mode.PFSDO = 1;     // ADC (+ 1st order HPF) Output
-        map.r.digital_filter_mode.PFDAC = 0b00;  // (Input selector for DAC (not used in MIC), SDTI= Audio Serial Data Input Pin)
+        map.r.digital_filter_mode.PFDAC = 0b00;  // (Input selector for DAC (initially not used in MIC), SDTI= Audio Serial Data Input Pin)
         update(Register::DigitalFilterMode);     // Writing the Audio Path :  NO DIGITAL BLOCK or DIG BLOCK FOR  MIC ,   Audio mode path : Playback mode /-Recording mode.
 
         // The EQn (n=1, 2, 3, 4 or 5) coefficient must be set when EQn bit = “0” or PMPFIL bit = “0”., but we are already (*1)
@@ -501,10 +501,15 @@ void AK4951::microphone_enable(int8_t alc_mode) {
 
         // Acitivating digital block , power supply
         map.r.power_management_1.PMADL = 1;   // ADC Lch = Lch input signal. Mic Amp Lch and ADC Lch Power Management
-        map.r.power_management_1.PMADR = 1;   // ADC Rch = Rch input signal. Mic Amp Rch and ADC Rch Power Management
+        map.r.power_management_1.PMADR = 0;   // ADC Rch = Rch input signal. Mic Amp Rch and ADC Rch Power Management. (PMADL=1, PMADR=0) means MONO MIC input connected to Left pin.
         map.r.power_management_1.PMPFIL = 1;  // Pre-loaded in top part.  Orig value=0, Programmable Digital filter unused (not power up), routed around.
         update(Register::PowerManagement1);   // Activating the Power management of the used blocks . (Mic ADC always + Dig Block filter , when used )
 
+        if (mic_to_HP_enabled)
+            microphone_to_HP_enable();
+        else
+            microphone_to_HP_disable();
+
         // 1059/fs, 22ms @ 48kHz
         chThdSleepMilliseconds(22);
     }
@@ -522,8 +527,13 @@ void AK4951::microphone_disable() {
     map.r.power_management_1.PMADL = 0;   // original code  , disable Power managem.Mic  ADC L
     map.r.power_management_1.PMADR = 0;   // original code  , disable Power managem.Mic  ADC R
     map.r.power_management_1.PMPFIL = 0;  // original code  , disable Power managem. all Programmable Dig. block
+    map.r.power_management_1.PMDAC = 0;   // Pre-loaded power management DAC block OFF
     update(Register::PowerManagement1);
 
+    map.r.power_management_2.PMHPL = 0;  // Pre-loaded power management HP LEFT block OFF
+    map.r.power_management_2.PMHPR = 0;  // Pre-loaded power management HP RIGHT block OFF
+    update(Register::PowerManagement2);  // Deactivating the Power management of the HP L&R blocks.
+
     map.r.alc_mode_control_1.ALC = 0;  // original code  , Restore , disable ALC block.
     update(Register::ALCModeControl1);
 
@@ -560,6 +570,30 @@ void AK4951::microphone_disable() {
     update(Register::DigitalFilterSelect3);
 }
 
+void AK4951::microphone_to_HP_enable() {
+    map.r.digital_filter_mode.PFDAC = 0b01;  // (Input selector for DAC, audio Loopback Mode .
+    update(Register::DigitalFilterMode);     // Writing the Audio Path ,   Audio mode path : Loopback Mode .
+
+    map.r.power_management_1.PMDAC = 1;  // Pre-loaded power management DAC block ON
+    update(Register::PowerManagement1);  // Activating the Power management of the DAC block for the loopback mode
+
+    map.r.power_management_2.PMHPL = 1;  // Pre-loaded power management HP LEFT block ON
+    map.r.power_management_2.PMHPR = 1;  // Pre-loaded power management HP RIGHT block ON
+    update(Register::PowerManagement2);  // Activating the Power management of the HP L&R blocks.
+}
+
+void AK4951::microphone_to_HP_disable() {
+    map.r.digital_filter_mode.PFDAC = 0b00;  // (Input selector for DAC (not used in MIC), SDTI= Audio Serial Data Input Pin)
+    update(Register::DigitalFilterMode);     // Writing the Audio Path ,   Audio mode path : Loopback Mode .
+
+    map.r.power_management_1.PMDAC = 0;  // Pre-loaded power management DAC block OFF
+    update(Register::PowerManagement1);  // Deactivating the Power management of the DAC block for the loopback mode
+
+    map.r.power_management_2.PMHPL = 0;  // Pre-loaded power management HP LEFT block OFF
+    map.r.power_management_2.PMHPR = 0;  // Pre-loaded power management HP RIGHT block OFF
+    update(Register::PowerManagement2);  // Deactivating the Power management of the HP L&R blocks.
+}
+
 reg_t AK4951::read(const address_t reg_address) {
     const std::array<uint8_t, 1> tx{reg_address};
     std::array<uint8_t, 1> rx{0x00};

firmware/common/ak4951.hpp

@@ -844,9 +844,12 @@ class AK4951 : public audio::Codec {
     void set_headphone_volume(const volume_t volume) override;
     void headphone_mute();
 
-    void microphone_enable(int8_t alc_mode);  // added user GUI parameter , to set up AK4951 ALC mode.
+    void microphone_enable(int8_t alc_mode, bool mic_to_HP_enabled);  // added user GUI parameter , to set up AK4951 ALC mode, and mic_to_HP_enabled to control "Hear to Mic"
     void microphone_disable();
 
+    void microphone_to_HP_enable();
+    void microphone_to_HP_disable();
+
     size_t reg_count() const override {
         return asahi_kasei::ak4951::reg_count;
     }
@@ -859,6 +862,10 @@ class AK4951 : public audio::Codec {
         return read(reg_address);
     }
 
+    void reg_write(const size_t reg_address, const uint32_t value) override {
+        write(reg_address, value);
+    }
+
    private:
     I2C& bus;
     const I2C::address_t bus_address;

firmware/common/dsp_fir_taps.hpp

@@ -1264,4 +1264,82 @@ static constexpr fir_taps_real<16> taps_200k_decim_1 = {
     }},
 };
 
+// BTLE RX decimation filters ////////////////////////////////////////////////
+// Default BTLE filter, it is supporting 1M PHY.
+// IFIR image-reject filter: fs=4000000, pass=430000, stop=825000, decim=4, fout=1000000
+// 1M PHY,  This one it is for the classic bluetooth , (BW = 1Mhz : +-500k, channel space is 2Mhz)
+// The traditional transmission of 1 Mbit in the Bluetooth Basic Rate was renamed 1M PHY
+static constexpr fir_taps_real<24> taps_BTLE_1M_PHY_decim_0 = {
+    .low_frequency_normalized = -430000.0f / 4000000.0f,
+    .high_frequency_normalized = 430000.0f / 4000000.0f,
+    .transition_normalized = 395000.0f / 4000000.0f,
+    .taps = {{
+
+        12,
+        57,
+        112,
+        83,
+        -139,
+        -531,
+        -813,
+        -507,
+        766,
+        2916,
+        5255,
+        6788,
+        6788,
+        5255,
+        2916,
+        766,
+        -507,
+        -813,
+        -531,
+        -139,
+        83,
+        112,
+        57,
+        12,
+
+    }},
+};
+
+// IFIR image-reject filter: fs=4000000, pass=920000, stop=1350000, decim=4, fout=1000000
+// Alternative filter, Note : in local test, it improves slightly the sensitivity compared to above filter, but it should have aliasing if co-adjacent channels.
+// Then , we leave that filter in the code ,as experimental , but it should not be set up as default one.
+// It may work well, in areas where we just receive few signals,  without adjacent channels and weak far away signals.
+// 2M PHY , Bluetooth 5 has introduced a new transmission mode with a doubled symbol rate.
+// Bluetooth LE has been traditionally transmitting 1 bit per symbol so that theoretically the data rate doubles as well. (BW 2Mhz : +-1Mhz, channel space 2Mhz)
+static constexpr fir_taps_real<24> taps_BTLE_2M_PHY_decim_0 = {
+    .low_frequency_normalized = -920000.0f / 4000000.0f,
+    .high_frequency_normalized = 920000.0f / 4000000.0f,
+    .transition_normalized = 430000.0f / 4000000.0f,
+    .taps = {{
+
+        -8,
+        -20,
+        42,
+        81,
+        -142,
+        -234,
+        371,
+        573,
+        -884,
+        -1414,
+        2573,
+        8062,
+        8062,
+        2573,
+        -1414,
+        -884,
+        573,
+        371,
+        -234,
+        -142,
+        81,
+        42,
+        -20,
+        -8,
+
+    }},
+};
 #endif /*__DSP_FIR_TAPS_H__*/

firmware/common/message.hpp

@@ -112,6 +112,9 @@ class Message {
         SpectrumPainterBufferRequestConfigure = 55,
         SpectrumPainterBufferResponseConfigure = 56,
         POCSAGStats = 57,
+        FSKRxConfigure = 58,
+        BlePacket = 58,
+        BTLETxConfigure = 59,
         MAX
     };
 
@@ -400,6 +403,48 @@ class AFSKDataMessage : public Message {
     uint32_t value;
 };
 
+struct ADV_PDU_PAYLOAD_TYPE_0_2_4_6 {
+    uint8_t Data[31];
+};
+
+struct ADV_PDU_PAYLOAD_TYPE_1_3 {
+    uint8_t A1[6];
+};
+
+struct ADV_PDU_PAYLOAD_TYPE_5 {
+    uint8_t AdvA[6];
+    uint8_t AA[4];
+    uint32_t CRCInit;
+    uint8_t WinSize;
+    uint16_t WinOffset;
+    uint16_t Interval;
+    uint16_t Latency;
+    uint16_t Timeout;
+    uint8_t ChM[5];
+    uint8_t Hop;
+    uint8_t SCA;
+};
+
+struct BlePacketData {
+    int max_dB;
+    uint8_t type;
+    uint8_t size;
+    uint8_t macAddress[6];
+    uint8_t data[40];
+    uint8_t dataLen;
+};
+
+class BLEPacketMessage : public Message {
+   public:
+    constexpr BLEPacketMessage(
+        BlePacketData* packet)
+        : Message{ID::BlePacket},
+          packet{packet} {
+    }
+
+    BlePacketData* packet{nullptr};
+};
+
 class CodedSquelchMessage : public Message {
    public:
     constexpr CodedSquelchMessage(
@@ -726,20 +771,30 @@ class APRSRxConfigureMessage : public Message {
 class BTLERxConfigureMessage : public Message {
    public:
     constexpr BTLERxConfigureMessage(
-        const uint32_t baudrate,
-        const uint32_t word_length,
-        const uint32_t trigger_value,
-        const bool trigger_word)
+        const uint8_t channel_number)
         : Message{ID::BTLERxConfigure},
-          baudrate(baudrate),
-          word_length(word_length),
-          trigger_value(trigger_value),
-          trigger_word(trigger_word) {
+          channel_number(channel_number) {
     }
-    const uint32_t baudrate;
-    const uint32_t word_length;
-    const uint32_t trigger_value;
-    const bool trigger_word;
+    const uint8_t channel_number;
+};
+
+class BTLETxConfigureMessage : public Message {
+   public:
+    constexpr BTLETxConfigureMessage(
+        const uint8_t channel_number,
+        char* macAddress,
+        char* advertisementData,
+        const uint8_t pduType)
+        : Message{ID::BTLETxConfigure},
+          channel_number(channel_number),
+          macAddress(macAddress),
+          advertisementData(advertisementData),
+          pduType(pduType) {
+    }
+    const uint8_t channel_number;
+    char* macAddress;
+    char* advertisementData;
+    const uint8_t pduType;
 };
 
 class NRFRxConfigureMessage : public Message {
@@ -1013,6 +1068,29 @@ class FSKConfigureMessage : public Message {
     const uint32_t progress_notice;
 };
 
+class FSKRxConfigureMessage : public Message {
+   public:
+    constexpr FSKRxConfigureMessage(
+        const fir_taps_real<24> decim_0_filter,
+        const fir_taps_real<32> decim_1_filter,
+        const fir_taps_real<32> channel_filter,
+        const size_t channel_decimation,
+        const size_t deviation)
+        : Message{ID::FSKRxConfigure},
+          decim_0_filter(decim_0_filter),
+          decim_1_filter(decim_1_filter),
+          channel_filter(channel_filter),
+          channel_decimation{channel_decimation},
+          deviation{deviation} {
+    }
+
+    const fir_taps_real<24> decim_0_filter;
+    const fir_taps_real<32> decim_1_filter;
+    const fir_taps_real<32> channel_filter;
+    const size_t channel_decimation;
+    const size_t deviation;
+};
+
 class POCSAGConfigureMessage : public Message {
    public:
     constexpr POCSAGConfigureMessage()
@@ -1033,13 +1111,9 @@ class APRSPacketMessage : public Message {
 
 class ADSBConfigureMessage : public Message {
    public:
-    constexpr ADSBConfigureMessage(
-        const uint32_t test)
-        : Message{ID::ADSBConfigure},
-          test(test) {
+    constexpr ADSBConfigureMessage()
+        : Message{ID::ADSBConfigure} {
     }
-
-    const uint32_t test;
 };
 
 class JammerConfigureMessage : public Message {

firmware/common/portapack_persistent_memory.cpp

@@ -40,6 +40,7 @@
 #include <utility>
 
 #include <ch.h>
+#include <hal.h>
 
 using namespace std;
 
@@ -143,7 +144,7 @@ struct misc_config_t {
     bool mute_audio : 1;
     bool disable_speaker : 1;
     bool config_disable_external_tcxo : 1;
-    bool UNUSED_3 : 1;
+    bool config_sdcard_high_speed_io : 1;
     bool UNUSED_4 : 1;
     bool UNUSED_5 : 1;
     bool UNUSED_6 : 1;
@@ -345,6 +346,19 @@ struct backup_ram_t {
         check_value = compute_check_value();
         copy(*this, dst);
     }
+
+    /* Access functions for DebugPmemView */
+    uint32_t pmem_data_word(uint32_t index) {
+        return (index > sizeof(regfile) / sizeof(uint32_t)) ? 0xFFFFFFFF : regfile[index];
+    }
+
+    uint32_t pmem_stored_checksum(void) {
+        return check_value;
+    }
+
+    uint32_t pmem_calculated_checksum(void) {
+        return compute_check_value();
+    }
 };
 
 static_assert(sizeof(backup_ram_t) == memory::map::backup_ram.size());
@@ -381,6 +395,8 @@ void defaults() {
     set_recon_update_ranges_when_recon(true);
     set_recon_load_hamradios(true);
     set_recon_match_mode(0);
+
+    set_config_sdcard_high_speed_io(false, true);
 }
 
 void init() {
@@ -413,6 +429,18 @@ void persist() {
 
 } /* namespace cache */
 
+uint32_t pmem_data_word(uint32_t index) {
+    return backup_ram->pmem_data_word(index);
+}
+
+uint32_t pmem_stored_checksum(void) {
+    return backup_ram->pmem_stored_checksum();
+}
+
+uint32_t pmem_calculated_checksum(void) {
+    return backup_ram->pmem_calculated_checksum();
+}
+
 rf::Frequency target_frequency() {
     rf::tuning_range.reset_if_outside(data->target_frequency, target_frequency_reset_value);
     return data->target_frequency;
@@ -556,6 +584,10 @@ bool config_disable_external_tcxo() {
     return data->misc_config.config_disable_external_tcxo;
 }
 
+bool config_sdcard_high_speed_io() {
+    return data->misc_config.config_sdcard_high_speed_io;
+}
+
 bool stealth_mode() {
     return data->ui_config.stealth_mode;
 }
@@ -621,6 +653,19 @@ void set_config_disable_external_tcxo(bool v) {
     data->misc_config.config_disable_external_tcxo = v;
 }
 
+void set_config_sdcard_high_speed_io(bool v, bool save) {
+    if (v) {
+        /* 200MHz / (2 * 2) = 50MHz */
+        /* TODO: Adjust SCU pin configurations: pull-up/down, slew, glitch filter? */
+        sdio_cclk_set(2);
+    } else {
+        /* 200MHz / (2 * 4) = 25MHz */
+        sdio_cclk_set(4);
+    }
+    if (save)
+        data->misc_config.config_sdcard_high_speed_io = v;
+}
+
 void set_stealth_mode(bool v) {
     data->ui_config.stealth_mode = v;
 }
@@ -868,6 +913,8 @@ bool should_use_sdcard_for_pmem() {
 
 int save_persistent_settings_to_file() {
     File outfile;
+
+    make_new_directory(SETTINGS_DIR);
     auto error = outfile.create(PMEM_SETTING_FILE);
     if (error)
         return false;
@@ -912,7 +959,9 @@ bool debug_dump() {
         painter.draw_string({0, 320 - 16}, ui::Styles::red, "ERROR DUMPING " + filename.filename().string() + " !");
         return false;
     }
-    pmem_dump_file.write_line("FW version " VERSION_STRING);
+    pmem_dump_file.write_line("FW version: " VERSION_STRING);
+    pmem_dump_file.write_line("Ext APPS version req'd: 0x" + to_string_hex(VERSION_MD5));
+    pmem_dump_file.write_line("GCC version: " + to_string_dec_int(__GNUC__) + "." + to_string_dec_int(__GNUC_MINOR__) + "." + to_string_dec_int(__GNUC_PATCHLEVEL__));
 
     // write persistent memory
     pmem_dump_file.write_line("\n[Persistent Memory]");
@@ -986,6 +1035,7 @@ bool debug_dump() {
     pmem_dump_file.write_line("misc_config config_audio_mute: " + to_string_dec_int(config_audio_mute()));
     pmem_dump_file.write_line("misc_config config_speaker_disable: " + to_string_dec_int(config_speaker_disable()));
     pmem_dump_file.write_line("ui_config config_disable_external_tcxo: " + to_string_dec_uint(config_disable_external_tcxo()));
+    pmem_dump_file.write_line("ui_config config_sdcard_high_speed_io: " + to_string_dec_uint(config_sdcard_high_speed_io()));
 
     // receiver_model
     pmem_dump_file.write_line("\n[Receiver Model]");

firmware/common/portapack_persistent_memory.hpp

@@ -174,6 +174,7 @@ uint8_t config_cpld();
 void set_config_cpld(uint8_t i);
 
 bool config_disable_external_tcxo();
+bool config_sdcard_high_speed_io();
 bool config_splash();
 bool config_converter();
 bool config_updown_converter();
@@ -193,6 +194,7 @@ void set_load_app_settings(bool v);
 void set_save_app_settings(bool v);
 void set_show_bigger_qr_code(bool v);
 void set_config_disable_external_tcxo(bool v);
+void set_config_sdcard_high_speed_io(bool v, bool save);
 void set_config_splash(bool v);
 bool config_converter();
 bool config_updown_converter();
@@ -281,6 +283,10 @@ bool should_use_sdcard_for_pmem();
 int save_persistent_settings_to_file();
 int load_persistent_settings_from_file();
 
+uint32_t pmem_data_word(uint32_t index);
+uint32_t pmem_stored_checksum(void);
+uint32_t pmem_calculated_checksum(void);
+
 size_t data_size();
 
 bool debug_dump();

firmware/common/spi_image.hpp

@@ -78,6 +78,7 @@ constexpr image_tag_t image_tag_adsb_rx{'P', 'A', 'D', 'R'};
 constexpr image_tag_t image_tag_afsk_rx{'P', 'A', 'F', 'R'};
 constexpr image_tag_t image_tag_aprs_rx{'P', 'A', 'P', 'R'};
 constexpr image_tag_t image_tag_btle_rx{'P', 'B', 'T', 'R'};
+constexpr image_tag_t image_tag_btle_tx{'P', 'B', 'T', 'T'};
 constexpr image_tag_t image_tag_nrf_rx{'P', 'N', 'R', 'R'};
 constexpr image_tag_t image_tag_ais{'P', 'A', 'I', 'S'};
 constexpr image_tag_t image_tag_am_audio{'P', 'A', 'M', 'A'};
@@ -97,6 +98,7 @@ constexpr image_tag_t image_tag_adsb_tx{'P', 'A', 'D', 'T'};
 constexpr image_tag_t image_tag_afsk{'P', 'A', 'F', 'T'};
 constexpr image_tag_t image_tag_audio_tx{'P', 'A', 'T', 'X'};
 constexpr image_tag_t image_tag_fsktx{'P', 'F', 'S', 'K'};
+constexpr image_tag_t image_tag_fskrx{'P', 'F', 'S', 'R'};
 constexpr image_tag_t image_tag_jammer{'P', 'J', 'A', 'M'};
 constexpr image_tag_t image_tag_mic_tx{'P', 'M', 'T', 'X'};
 constexpr image_tag_t image_tag_ook{'P', 'O', 'O', 'K'};

firmware/common/ui_focus.cpp

@@ -30,6 +30,8 @@
 #include <utility>
 #include <vector>
 
+#define pow2(x) ((x) * (x))
+
 namespace ui {
 
 Widget* FocusManager::focus_widget() const {
@@ -138,12 +140,12 @@ static int32_t rect_distances(
     switch (direction) {
         case KeyEvent::Right:
         case KeyEvent::Left:
-            return ((std::abs(perpendicular_axis_end - perpendicular_axis_start) + 1) ^ 3) * sqrt((on_axis_distance + 1));
+            return pow2(std::abs(perpendicular_axis_end - perpendicular_axis_start) + 1) * (on_axis_distance + 1);
             break;
 
         case KeyEvent::Up:
         case KeyEvent::Down:
-            return (sqrt(std::abs(perpendicular_axis_end - perpendicular_axis_start) + 1)) * ((on_axis_distance + 1) ^ 3);
+            return (std::abs(perpendicular_axis_end - perpendicular_axis_start) + 1) * pow2(on_axis_distance + 1);
             break;
 
         default:

firmware/common/ui_widget.cpp

@@ -587,6 +587,28 @@ void ProgressBar::paint(Painter& painter) {
     painter.draw_rectangle(sr, s.foreground);
 }
 
+/* ActivityDot ***********************************************************/
+
+ActivityDot::ActivityDot(
+    Rect parent_rect,
+    Color color)
+    : Widget{parent_rect},
+      _color{color} {}
+
+void ActivityDot::paint(Painter& painter) {
+    painter.fill_rectangle(screen_rect(), _on ? _color : Color::grey());
+}
+
+void ActivityDot::toggle() {
+    _on = !_on;
+    set_dirty();
+}
+
+void ActivityDot::reset() {
+    _on = false;
+    set_dirty();
+}
+
 /* Console ***************************************************************/
 
 Console::Console(

firmware/common/ui_widget.hpp

@@ -317,6 +317,20 @@ class ProgressBar : public Widget {
     uint32_t _max = 100;
 };
 
+/* A simple status indicator that can be used to indicate activity. */
+class ActivityDot : public Widget {
+   public:
+    ActivityDot(Rect parent_rect, Color color);
+
+    void paint(Painter& painter) override;
+    void toggle();
+    void reset();
+
+   private:
+    bool _on{false};
+    Color _color;
+};
+
 class Console : public Widget {
    public:
     Console(Rect parent_rect);

firmware/common/wm8731.cpp

@@ -116,6 +116,8 @@ bool WM8731::write(const Register reg) {
 }
 
 bool WM8731::write(const address_t reg_address, const reg_t value) {
+    map.w[reg_address] = value;  // Save data written in case this fn is called from Debug->Peripherals app
+
     const uint16_t word = (reg_address << 9) | value;
     const std::array<uint8_t, 2> values{
         static_cast<uint8_t>(word >> 8),
@@ -124,10 +126,15 @@ bool WM8731::write(const address_t reg_address, const reg_t value) {
     return bus.transmit(bus_address, values.data(), values.size());
 }
 
+/* WM8731 is a write-only device; the read function only returns the value we last wrote */
 uint32_t WM8731::reg_read(const size_t reg_address) {
     return map.w[reg_address];
 }
 
+void WM8731::reg_write(const size_t reg_address, uint32_t value) {
+    write(reg_address, value);
+}
+
 void WM8731::write(const LeftLineIn value) {
     map.r.left_line_in = value;
     write(Register::LeftLineIn);

firmware/common/wm8731.hpp

@@ -349,17 +349,36 @@ class WM8731 : public audio::Codec {
         return false;
     }
 
-    void microphone_enable(int8_t wm8731_boost_GUI) override {
+    void microphone_enable(int8_t wm8731_boost_GUI, bool mic_to_HP_enabled) override {
         microphone_mute(true);  // c/m to reduce "plop noise" when changing wm8731_boost_GUI.
         // chThdSleepMilliseconds(20);  					// does not help to reduce the "plop noise"
         microphone_boost((wm8731_boost_GUI < 2) ? 1 : 0);  // 1 = Enable Boost (+20 dBs) .  0 = Disable Boost (0dBs).
         chThdSleepMilliseconds(120);                       // >50 msegs, very effective , >100 msegs minor improvement ,120 msegs trade off speed .
         microphone_mute(false);
         //	(void)alc_mode; 		In prev. fw version ,  when we did not use at all param., to avoid "unused warning" when compiling.)
+
+        if (mic_to_HP_enabled)
+            microphone_to_HP_enable();
+        else
+            microphone_to_HP_disable();
     }
 
     void microphone_disable() override {
-        // TODO: Implement
+        microphone_mute(true);
+        microphone_to_HP_disable();
+    }
+
+    void microphone_to_HP_enable() override {
+        map.r.analog_audio_path_control.sidetone = 1;    // Side Tone Switch (Analogue) 1 = Enable Side Tone
+        map.r.analog_audio_path_control.sideatt = 0b00;  // Side Tone Attenuation 00 = -6dB
+        write(Register::AnalogAudioPathControl);
+        headphone_enable();
+    }
+
+    void microphone_to_HP_disable() override {
+        map.r.analog_audio_path_control.sidetone = 0;    // Side Tone Switch (Analogue) 0 = Disable Side Tone
+        map.r.analog_audio_path_control.sideatt = 0b11;  // Side Tone Attenuation 11 = -15dB
+        write(Register::AnalogAudioPathControl);
     }
 
     void microphone_boost(const bool boost) {
@@ -386,6 +405,7 @@ class WM8731 : public audio::Codec {
     }
 
     uint32_t reg_read(const size_t reg_address) override;
+    void reg_write(const size_t reg_address, uint32_t value) override;
 
    private:
     I2C& bus;

sdcard/BLETX/Android Spam v4.txt

@@ -0,0 +1,464 @@
+010203040506 03032CFE06162CFE000006020AA8 1 
+010203040506 03032CFE06162CFE000007020AA9 1 
+010203040506 03032CFE06162CFE000008020AAA 1 
+010203040506 03032CFE06162CFE000009020AAB 1 
+010203040506 03032CFE06162CFE00000A020AAC 1 
+010203040506 03032CFE06162CFE00000B020AAD 1 
+010203040506 03032CFE06162CFE00000C020AAE 1 
+010203040506 03032CFE06162CFE00000D020AAF 1 
+010203040506 03032CFE06162CFE000035020AB0 1 
+010203040506 03032CFE06162CFE000047020AB1 1 
+010203040506 03032CFE06162CFE000048020AB2 1 
+010203040506 03032CFE06162CFE000049020AB3 1 
+010203040506 03032CFE06162CFE0000F0020AB4 1 
+010203040506 03032CFE06162CFE0002F0020AB5 1 
+010203040506 03032CFE06162CFE0003F0020AB6 1 
+010203040506 03032CFE06162CFE001000020AB7 1 
+010203040506 03032CFE06162CFE002000020AB8 1 
+010203040506 03032CFE06162CFE003000020AB9 1 
+010203040506 03032CFE06162CFE003001020ABA 1 
+010203040506 03032CFE06162CFE003B41020ABB 1 
+010203040506 03032CFE06162CFE003D8A020ABC 1 
+010203040506 03032CFE06162CFE0052DA020ABD 1 
+010203040506 03032CFE06162CFE005BC3020ABE 1 
+010203040506 03032CFE06162CFE008F7D020ABF 1 
+010203040506 03032CFE06162CFE00A168020AC0 1 
+010203040506 03032CFE06162CFE00AA48020AC1 1 
+010203040506 03032CFE06162CFE00AA91020AC2 1 
+010203040506 03032CFE06162CFE00B727020AC3 1 
+010203040506 03032CFE06162CFE00C95C020AC4 1 
+010203040506 03032CFE06162CFE00F7D4020AC5 1 
+010203040506 03032CFE06162CFE00FA72020AC6 1 
+010203040506 03032CFE06162CFE0100F0020AC7 1 
+010203040506 03032CFE06162CFE0102F0020AC8 1 
+010203040506 03032CFE06162CFE0103F0020AC9 1 
+010203040506 03032CFE06162CFE011242020ACA 1 
+010203040506 03032CFE06162CFE013D8A020ACB 1 
+010203040506 03032CFE06162CFE01AA91020ACC 1 
+010203040506 03032CFE06162CFE01C95C020ACD 1 
+010203040506 03032CFE06162CFE01E5CE020ACE 1 
+010203040506 03032CFE06162CFE01EEB4020ACF 1 
+010203040506 03032CFE06162CFE0200F0020AD0 1 
+010203040506 03032CFE06162CFE0202F0020AD1 1 
+010203040506 03032CFE06162CFE0203F0020AD2 1 
+010203040506 03032CFE06162CFE02AA91020AD3 1 
+010203040506 03032CFE06162CFE02C95C020AD4 1 
+010203040506 03032CFE06162CFE02D815020AD5 1 
+010203040506 03032CFE06162CFE02D886020AD6 1 
+010203040506 03032CFE06162CFE02DD4F020AD7 1 
+010203040506 03032CFE06162CFE02E2A9020AD8 1 
+010203040506 03032CFE06162CFE02F637020AD9 1 
+010203040506 03032CFE06162CFE0302F0020ADA 1 
+010203040506 03032CFE06162CFE0303F0020ADB 1 
+010203040506 03032CFE06162CFE035754020ADC 1 
+010203040506 03032CFE06162CFE035764020ADD 1 
+010203040506 03032CFE06162CFE038B91020ADE 1 
+010203040506 03032CFE06162CFE038CC7020ADF 1 
+010203040506 03032CFE06162CFE038F16020AE0 1 
+010203040506 03032CFE06162CFE039F8F020AE1 1 
+010203040506 03032CFE06162CFE03AA91020AE2 1 
+010203040506 03032CFE06162CFE03B716020AE3 1 
+010203040506 03032CFE06162CFE03C95C020AE4 1 
+010203040506 03032CFE06162CFE03C99C020AE5 1 
+010203040506 03032CFE06162CFE03F5D4020AE6 1 
+010203040506 03032CFE06162CFE0402F0020AE7 1 
+010203040506 03032CFE06162CFE0403F0020AE8 1 
+010203040506 03032CFE06162CFE045754020AE9 1 
+010203040506 03032CFE06162CFE045764020AEA 1 
+010203040506 03032CFE06162CFE04AA91020AEB 1 
+010203040506 03032CFE06162CFE04ACFC020AEC 1 
+010203040506 03032CFE06162CFE04AFB8020AED 1 
+010203040506 03032CFE06162CFE04C95C020AEE 1 
+010203040506 03032CFE06162CFE0502F0020AEF 1 
+010203040506 03032CFE06162CFE0503F0020AF0 1 
+010203040506 03032CFE06162CFE050F0C020AF1 1 
+010203040506 03032CFE06162CFE052CC7020AF2 1 
+010203040506 03032CFE06162CFE054B2D020AF3 1 
+010203040506 03032CFE06162CFE0577B1020AF4 1 
+010203040506 03032CFE06162CFE057802020AF5 1 
+010203040506 03032CFE06162CFE0582FD020AF6 1 
+010203040506 03032CFE06162CFE058D08020AF7 1 
+010203040506 03032CFE06162CFE05A963020AF8 1 
+010203040506 03032CFE06162CFE05A9BC020AF9 1 
+010203040506 03032CFE06162CFE05AA91020AFA 1 
+010203040506 03032CFE06162CFE05C452020AFB 1 
+010203040506 03032CFE06162CFE05C95C020AFC 1 
+010203040506 03032CFE06162CFE060000020AFD 1 
+010203040506 03032CFE06162CFE0602F0020AFE 1 
+010203040506 03032CFE06162CFE0603F0020AFF 1 
+010203040506 03032CFE06162CFE0660D7020B00 1 
+010203040506 03032CFE06162CFE06AE20020B01 1 
+010203040506 03032CFE06162CFE06C197020B02 1 
+010203040506 03032CFE06162CFE06C95C020B03 1 
+010203040506 03032CFE06162CFE06D8FC020B04 1 
+010203040506 03032CFE06162CFE070000020B05 1 
+010203040506 03032CFE06162CFE0702F0020B06 1 
+010203040506 03032CFE06162CFE0703F0020B07 1 
+010203040506 03032CFE06162CFE0X071C020B08 1 
+010203040506 03032CFE06162CFE0744B6020B09 1 
+010203040506 03032CFE06162CFE07A41C020B0A 1 
+010203040506 03032CFE06162CFE07C95C020B0B 1 
+010203040506 03032CFE06162CFE07F426020B0C 1 
+010203040506 03032CFE06162CFE080000020B0D 1 
+010203040506 03032CFE06162CFE0802F0020B0E 1 
+010203040506 03032CFE06162CFE0803F0020B0F 1 
+010203040506 03032CFE06162CFE090000020B10 1 
+010203040506 03032CFE06162CFE0903F0020B11 1 
+010203040506 03032CFE06162CFE0A0000020B12 1 
+010203040506 03032CFE06162CFE0B0000020B13 1 
+010203040506 03032CFE06162CFE0C0000020B14 1 
+010203040506 03032CFE06162CFE0DC6BF020B15 1 
+010203040506 03032CFE06162CFE0DC95C020B16 1 
+010203040506 03032CFE06162CFE0DEC2B020B17 1 
+010203040506 03032CFE06162CFE0E138D020B18 1 
+010203040506 03032CFE06162CFE0E30C3020B19 1 
+010203040506 03032CFE06162CFE0EC95C020B1A 1 
+010203040506 03032CFE06162CFE0ECE95020B1B 1 
+010203040506 03032CFE06162CFE0F0993020B1C 1 
+010203040506 03032CFE06162CFE0F1B8D020B1D 1 
+010203040506 03032CFE06162CFE0F232A020B1E 1 
+010203040506 03032CFE06162CFE0F2D16020B1F 1 
+010203040506 03032CFE06162CFE1E89A7020B20 1 
+010203040506 03032CFE06162CFE1E8B18020B21 1 
+010203040506 03032CFE06162CFE1E955B020B22 1 
+010203040506 03032CFE06162CFE1EC95C020B23 1 
+010203040506 03032CFE06162CFE1ED9F9020B24 1 
+010203040506 03032CFE06162CFE1EE890020B25 1 
+010203040506 03032CFE06162CFE1EEDF5020B26 1 
+010203040506 03032CFE06162CFE1F1101020B27 1 
+010203040506 03032CFE06162CFE1F181A020B28 1 
+010203040506 03032CFE06162CFE1F2E13020B29 1 
+010203040506 03032CFE06162CFE1F4589020B2A 1 
+010203040506 03032CFE06162CFE1F4627020B2B 1 
+010203040506 03032CFE06162CFE1F5865020B2C 1 
+010203040506 03032CFE06162CFE1FBB50020B2D 1 
+010203040506 03032CFE06162CFE1FC95C020B2E 1 
+010203040506 03032CFE06162CFE1FE765020B2F 1 
+010203040506 03032CFE06162CFE1FF8FA020B30 1 
+010203040506 03032CFE06162CFE201C7C020B31 1 
+010203040506 03032CFE06162CFE202B3D020B32 1 
+010203040506 03032CFE06162CFE20330C020B33 1 
+010203040506 03032CFE06162CFE20A19B020B34 1 
+010203040506 03032CFE06162CFE20C95C020B35 1 
+010203040506 03032CFE06162CFE20CC2C020B36 1 
+010203040506 03032CFE06162CFE213C8C020B37 1 
+010203040506 03032CFE06162CFE21521D020B38 1 
+010203040506 03032CFE06162CFE21A04E020B39 1 
+010203040506 03032CFE06162CFE2D7A23020B3A 1 
+010203040506 03032CFE06162CFE350000020B3B 1 
+010203040506 03032CFE06162CFE470000020B3C 1 
+010203040506 03032CFE06162CFE480000020B3D 1 
+010203040506 03032CFE06162CFE490000020B3E 1 
+010203040506 03032CFE06162CFE5BA9B5020B3F 1 
+010203040506 03032CFE06162CFE5BACD6020B40 1 
+010203040506 03032CFE06162CFE5BD6C9020B41 1 
+010203040506 03032CFE06162CFE5BE3D4020B42 1 
+010203040506 03032CFE06162CFE5C0206020B43 1 
+010203040506 03032CFE06162CFE5C0C84020B44 1 
+010203040506 03032CFE06162CFE5C4833020B45 1 
+010203040506 03032CFE06162CFE5C4A7E020B46 1 
+010203040506 03032CFE06162CFE5C55E7020B47 1 
+010203040506 03032CFE06162CFE5C7CDC020B48 1 
+010203040506 03032CFE06162CFE5C8AA5020B49 1 
+010203040506 03032CFE06162CFE5CC900020B4A 1 
+010203040506 03032CFE06162CFE5CC901020B4B 1 
+010203040506 03032CFE06162CFE5CC902020B4C 1 
+010203040506 03032CFE06162CFE5CC903020B4D 1 
+010203040506 03032CFE06162CFE5CC904020B4E 1 
+010203040506 03032CFE06162CFE5CC905020B4F 1 
+010203040506 03032CFE06162CFE5CC906020B50 1 
+010203040506 03032CFE06162CFE5CC907020B51 1 
+010203040506 03032CFE06162CFE5CC908020B52 1 
+010203040506 03032CFE06162CFE5CC909020B53 1 
+010203040506 03032CFE06162CFE5CC90A020B54 1 
+010203040506 03032CFE06162CFE5CC90B020B55 1 
+010203040506 03032CFE06162CFE5CC90C020B56 1 
+010203040506 03032CFE06162CFE5CC90D020B57 1 
+010203040506 03032CFE06162CFE5CC90E020B58 1 
+010203040506 03032CFE06162CFE5CC90F020B59 1 
+010203040506 03032CFE06162CFE5CC910020B5A 1 
+010203040506 03032CFE06162CFE5CC911020B5B 1 
+010203040506 03032CFE06162CFE5CC912020B5C 1 
+010203040506 03032CFE06162CFE5CC913020B5D 1 
+010203040506 03032CFE06162CFE5CC914020B5E 1 
+010203040506 03032CFE06162CFE5CC915020B5F 1 
+010203040506 03032CFE06162CFE5CC916020B60 1 
+010203040506 03032CFE06162CFE5CC917020B61 1 
+010203040506 03032CFE06162CFE5CC918020B62 1 
+010203040506 03032CFE06162CFE5CC919020B63 1 
+010203040506 03032CFE06162CFE5CC91A020B64 1 
+010203040506 03032CFE06162CFE5CC91B020B65 1 
+010203040506 03032CFE06162CFE5CC91C020B66 1 
+010203040506 03032CFE06162CFE5CC91D020B67 1 
+010203040506 03032CFE06162CFE5CC91E020B68 1 
+010203040506 03032CFE06162CFE5CC91F020B69 1 
+010203040506 03032CFE06162CFE5CC920020B6A 1 
+010203040506 03032CFE06162CFE5CC921020B6B 1 
+010203040506 03032CFE06162CFE5CC922020B6C 1 
+010203040506 03032CFE06162CFE5CC923020B6D 1 
+010203040506 03032CFE06162CFE5CC924020B6E 1 
+010203040506 03032CFE06162CFE5CC925020B6F 1 
+010203040506 03032CFE06162CFE5CC926020B70 1 
+010203040506 03032CFE06162CFE5CC927020B71 1 
+010203040506 03032CFE06162CFE5CC928020B72 1 
+010203040506 03032CFE06162CFE5CC929020B73 1 
+010203040506 03032CFE06162CFE5CC92A020B74 1 
+010203040506 03032CFE06162CFE5CC92B020B75 1 
+010203040506 03032CFE06162CFE5CC92C020B76 1 
+010203040506 03032CFE06162CFE5CC92D020B77 1 
+010203040506 03032CFE06162CFE5CC92E020B78 1 
+010203040506 03032CFE06162CFE5CC92F020B79 1 
+010203040506 03032CFE06162CFE5CC930020B7A 1 
+010203040506 03032CFE06162CFE5CC931020B7B 1 
+010203040506 03032CFE06162CFE5CC932020B7C 1 
+010203040506 03032CFE06162CFE5CC933020B7D 1 
+010203040506 03032CFE06162CFE5CC934020B7E 1 
+010203040506 03032CFE06162CFE5CC935020B7F 1 
+010203040506 03032CFE06162CFE5CC936020B80 1 
+010203040506 03032CFE06162CFE5CC937020B81 1 
+010203040506 03032CFE06162CFE5CC938020B82 1 
+010203040506 03032CFE06162CFE5CC939020B83 1 
+010203040506 03032CFE06162CFE5CC93A020B84 1 
+010203040506 03032CFE06162CFE5CC93B020B85 1 
+010203040506 03032CFE06162CFE5CC93C020B86 1 
+010203040506 03032CFE06162CFE5CC93D020B87 1 
+010203040506 03032CFE06162CFE5CC93E020B88 1 
+010203040506 03032CFE06162CFE5CC93F020B89 1 
+010203040506 03032CFE06162CFE5CC940020B8A 1 
+010203040506 03032CFE06162CFE5CC941020B8B 1 
+010203040506 03032CFE06162CFE5CC942020B8C 1 
+010203040506 03032CFE06162CFE5CC943020B8D 1 
+010203040506 03032CFE06162CFE5CC944020B8E 1 
+010203040506 03032CFE06162CFE5CC945020B8F 1 
+010203040506 03032CFE06162CFE5CEE3C020B90 1 
+010203040506 03032CFE06162CFE6AD226020B91 1 
+010203040506 03032CFE06162CFE6B1C64020B92 1 
+010203040506 03032CFE06162CFE6B8C65020B93 1 
+010203040506 03032CFE06162CFE6B9304020B94 1 
+010203040506 03032CFE06162CFE6BA5C3020B95 1 
+010203040506 03032CFE06162CFE6C42C0020B96 1 
+010203040506 03032CFE06162CFE6C4DE5020B97 1 
+010203040506 03032CFE06162CFE718FA4020B98 1 
+010203040506 03032CFE06162CFE72EF8D020B99 1 
+010203040506 03032CFE06162CFE72FB00020B9A 1 
+010203040506 03032CFE06162CFE821F66020B9B 1 
+010203040506 03032CFE06162CFE89BAD5020B9C 1 
+010203040506 03032CFE06162CFE8A31B7020B9D 1 
+010203040506 03032CFE06162CFE8A3D00020B9E 1 
+010203040506 03032CFE06162CFE8A3D01020B9F 1 
+010203040506 03032CFE06162CFE8A8F23020BA0 1 
+010203040506 03032CFE06162CFE8AADAE020BA1 1 
+010203040506 03032CFE06162CFE8B0A91020BA2 1 
+010203040506 03032CFE06162CFE8B5A7B020BA3 1 
+010203040506 03032CFE06162CFE8B66AB020BA4 1 
+010203040506 03032CFE06162CFE8BB0A0020BA5 1 
+010203040506 03032CFE06162CFE8BF79A020BA6 1 
+010203040506 03032CFE06162CFE8C07D2020BA7 1 
+010203040506 03032CFE06162CFE8C1706020BA8 1 
+010203040506 03032CFE06162CFE8C4236020BA9 1 
+010203040506 03032CFE06162CFE8C6B6A020BAA 1 
+010203040506 03032CFE06162CFE8CAD81020BAB 1 
+010203040506 03032CFE06162CFE8CB05C020BAC 1 
+010203040506 03032CFE06162CFE8CD10F020BAD 1 
+010203040506 03032CFE06162CFE8D13B9020BAE 1 
+010203040506 03032CFE06162CFE8D16EA020BAF 1 
+010203040506 03032CFE06162CFE8D5B67020BB0 1 
+010203040506 03032CFE06162CFE8E14D7020BB1 1 
+010203040506 03032CFE06162CFE8E1996020BB2 1 
+010203040506 03032CFE06162CFE8E4666020BB3 1 
+010203040506 03032CFE06162CFE8E5550020BB4 1 
+010203040506 03032CFE06162CFE9101F0020BB5 1 
+010203040506 03032CFE06162CFE9128CB020BB6 1 
+010203040506 03032CFE06162CFE913B0C020BB7 1 
+010203040506 03032CFE06162CFE915CFA020BB8 1 
+010203040506 03032CFE06162CFE9171BE020BB9 1 
+010203040506 03032CFE06162CFE917E46020BBA 1 
+010203040506 03032CFE06162CFE91AA00020BBB 1 
+010203040506 03032CFE06162CFE91AA01020BBC 1 
+010203040506 03032CFE06162CFE91AA02020BBD 1 
+010203040506 03032CFE06162CFE91AA03020BBE 1 
+010203040506 03032CFE06162CFE91AA04020BBF 1 
+010203040506 03032CFE06162CFE91AA05020BC0 1 
+010203040506 03032CFE06162CFE91BD38020BC1 1 
+010203040506 03032CFE06162CFE91C813020BC2 1 
+010203040506 03032CFE06162CFE91DABC020BC3 1 
+010203040506 03032CFE06162CFE92255E020BC4 1 
+010203040506 03032CFE06162CFE92BBBD020BC5 1 
+010203040506 03032CFE06162CFE989D0A020BC6 1 
+010203040506 03032CFE06162CFE9939BC020BC7 1 
+010203040506 03032CFE06162CFE994374020BC8 1 
+010203040506 03032CFE06162CFE997B4A020BC9 1 
+010203040506 03032CFE06162CFE99C87B020BCA 1 
+010203040506 03032CFE06162CFE99D7EA020BCB 1 
+010203040506 03032CFE06162CFE99F098020BCC 1 
+010203040506 03032CFE06162CFE9A408A020BCD 1 
+010203040506 03032CFE06162CFE9A9BDD020BCE 1 
+010203040506 03032CFE06162CFE9ADB11020BCF 1 
+010203040506 03032CFE06162CFE9AEEA4020BD0 1 
+010203040506 03032CFE06162CFE9B7339020BD1 1 
+010203040506 03032CFE06162CFE9B735A020BD2 1 
+010203040506 03032CFE06162CFE9B9872020BD3 1 
+010203040506 03032CFE06162CFE9BC64D020BD4 1 
+010203040506 03032CFE06162CFE9BE931020BD5 1 
+010203040506 03032CFE06162CFE9C0AF7020BD6 1 
+010203040506 03032CFE06162CFE9C3997020BD7 1 
+010203040506 03032CFE06162CFE9C4058020BD8 1 
+010203040506 03032CFE06162CFE9C6BC0020BD9 1 
+010203040506 03032CFE06162CFE9C888B020BDA 1 
+010203040506 03032CFE06162CFE9C98DB020BDB 1 
+010203040506 03032CFE06162CFE9CA277020BDC 1 
+010203040506 03032CFE06162CFE9CB5F3020BDD 1 
+010203040506 03032CFE06162CFE9CB881020BDE 1 
+010203040506 03032CFE06162CFE9CD0F3020BDF 1 
+010203040506 03032CFE06162CFE9CE3C7020BE0 1 
+010203040506 03032CFE06162CFE9CEFD1020BE1 1 
+010203040506 03032CFE06162CFE9CF08F020BE2 1 
+010203040506 03032CFE06162CFE9D00A6020BE3 1 
+010203040506 03032CFE06162CFE9D7D42020BE4 1 
+010203040506 03032CFE06162CFE9DB896020BE5 1 
+010203040506 03032CFE06162CFEA7E52B020BE6 1 
+010203040506 03032CFE06162CFEA7EF76020BE7 1 
+010203040506 03032CFE06162CFEA8001A020BE8 1 
+010203040506 03032CFE06162CFEA83C10020BE9 1 
+010203040506 03032CFE06162CFEA8658F020BEA 1 
+010203040506 03032CFE06162CFEA8845A020BEB 1 
+010203040506 03032CFE06162CFEA88B69020BEC 1 
+010203040506 03032CFE06162CFEA8A00E020BED 1 
+010203040506 03032CFE06162CFEA8A72A020BEE 1 
+010203040506 03032CFE06162CFEA8C636020BEF 1 
+010203040506 03032CFE06162CFEA8CAAD020BF0 1 
+010203040506 03032CFE06162CFEA8E353020BF1 1 
+010203040506 03032CFE06162CFEA8F96D020BF2 1 
+010203040506 03032CFE06162CFEA90358020BF3 1 
+010203040506 03032CFE06162CFEA92498020BF4 1 
+010203040506 03032CFE06162CFEA9394A020BF5 1 
+010203040506 03032CFE06162CFEC6936A020BF6 1 
+010203040506 03032CFE06162CFEC69AFD020BF7 1 
+010203040506 03032CFE06162CFEC6ABEA020BF8 1 
+010203040506 03032CFE06162CFEC6EC5F020BF9 1 
+010203040506 03032CFE06162CFEC7736C020BFA 1 
+010203040506 03032CFE06162CFEC79B91020BFB 1 
+010203040506 03032CFE06162CFEC7A267020BFC 1 
+010203040506 03032CFE06162CFEC7D620020BFD 1 
+010203040506 03032CFE06162CFEC7FBCC020BFE 1 
+010203040506 03032CFE06162CFEC8162A020BFF 1 
+010203040506 03032CFE06162CFEC85D7A020C00 1 
+010203040506 03032CFE06162CFEC8777E020C01 1 
+010203040506 03032CFE06162CFEC878AA020C02 1 
+010203040506 03032CFE06162CFEC8C641020C03 1 
+010203040506 03032CFE06162CFEC8D335020C04 1 
+010203040506 03032CFE06162CFEC8E228020C05 1 
+010203040506 03032CFE06162CFEC9186B020C06 1 
+010203040506 03032CFE06162CFEC9836A020C07 1 
+010203040506 03032CFE06162CFECA7030020C08 1 
+010203040506 03032CFE06162CFECAB6B8020C09 1 
+010203040506 03032CFE06162CFECAF511020C0A 1 
+010203040506 03032CFE06162CFECB093B020C0B 1 
+010203040506 03032CFE06162CFECB529D020C0C 1 
+010203040506 03032CFE06162CFECC438E020C0D 1 
+010203040506 03032CFE06162CFECC5F29020C0E 1 
+010203040506 03032CFE06162CFECC754F020C0F 1 
+010203040506 03032CFE06162CFECC93A5020C10 1 
+010203040506 03032CFE06162CFECCBB7E020C11 1 
+010203040506 03032CFE06162CFECD8256020C12 1 
+010203040506 03032CFE06162CFED446A7020C13 1 
+010203040506 03032CFE06162CFED5A59E020C14 1 
+010203040506 03032CFE06162CFED5B5F7020C15 1 
+010203040506 03032CFE06162CFED5C6CE020C16 1 
+010203040506 03032CFE06162CFED654CD020C17 1 
+010203040506 03032CFE06162CFED65F4E020C18 1 
+010203040506 03032CFE06162CFED69B2B020C19 1 
+010203040506 03032CFE06162CFED6C195020C1A 1 
+010203040506 03032CFE06162CFED6E870020C1B 1 
+010203040506 03032CFE06162CFED6EE84020C1C 1 
+010203040506 03032CFE06162CFED7102F020C1D 1 
+010203040506 03032CFE06162CFED7E3EB020C1E 1 
+010203040506 03032CFE06162CFED8058C020C1F 1 
+010203040506 03032CFE06162CFED820EA020C20 1 
+010203040506 03032CFE06162CFED87A3E020C21 1 
+010203040506 03032CFE06162CFED8F3BA020C22 1 
+010203040506 03032CFE06162CFED8F4E8020C23 1 
+010203040506 03032CFE06162CFED90617020C24 1 
+010203040506 03032CFE06162CFED933A7020C25 1 
+010203040506 03032CFE06162CFED9414F020C26 1 
+010203040506 03032CFE06162CFED97EBA020C27 1 
+010203040506 03032CFE06162CFED9964B020C28 1 
+010203040506 03032CFE06162CFEDA0F83020C29 1 
+010203040506 03032CFE06162CFEDA4577020C2A 1 
+010203040506 03032CFE06162CFEDA5200020C2B 1 
+010203040506 03032CFE06162CFEDAD3A6020C2C 1 
+010203040506 03032CFE06162CFEDADE43020C2D 1 
+010203040506 03032CFE06162CFEDAE096020C2E 1 
+010203040506 03032CFE06162CFEDB8AC7020C2F 1 
+010203040506 03032CFE06162CFEDBE5B1020C30 1 
+010203040506 03032CFE06162CFEDC5249020C31 1 
+010203040506 03032CFE06162CFEDCF33C020C32 1 
+010203040506 03032CFE06162CFEDD4EC0020C33 1 
+010203040506 03032CFE06162CFEDE215D020C34 1 
+010203040506 03032CFE06162CFEDE577F020C35 1 
+010203040506 03032CFE06162CFEDEC04C020C36 1 
+010203040506 03032CFE06162CFEDEDD6F020C37 1 
+010203040506 03032CFE06162CFEDEE8C0020C38 1 
+010203040506 03032CFE06162CFEDEEA86020C39 1 
+010203040506 03032CFE06162CFEDEF234020C3A 1 
+010203040506 03032CFE06162CFEDF01E3020C3B 1 
+010203040506 03032CFE06162CFEDF271C020C3C 1 
+010203040506 03032CFE06162CFEDF42DE020C3D 1 
+010203040506 03032CFE06162CFEDF4B02020C3E 1 
+010203040506 03032CFE06162CFEDF9BA4020C3F 1 
+010203040506 03032CFE06162CFEDFD433020C40 1 
+010203040506 03032CFE06162CFEE020C1020C41 1 
+010203040506 03032CFE06162CFEE06116020C42 1 
+010203040506 03032CFE06162CFEE07634020C43 1 
+010203040506 03032CFE06162CFEE09172020C44 1 
+010203040506 03032CFE06162CFEE4E457020C45 1 
+010203040506 03032CFE06162CFEE5440B020C46 1 
+010203040506 03032CFE06162CFEE57363020C47 1 
+010203040506 03032CFE06162CFEE57B57020C48 1 
+010203040506 03032CFE06162CFEE5B4B0020C49 1 
+010203040506 03032CFE06162CFEE5B91B020C4A 1 
+010203040506 03032CFE06162CFEE5E2E9020C4B 1 
+010203040506 03032CFE06162CFEE64613020C4C 1 
+010203040506 03032CFE06162CFEE64CC6020C4D 1 
+010203040506 03032CFE06162CFEE69877020C4E 1 
+010203040506 03032CFE06162CFEE6E37E020C4F 1 
+010203040506 03032CFE06162CFEE6E771020C50 1 
+010203040506 03032CFE06162CFEE6E8B8020C51 1 
+010203040506 03032CFE06162CFEE750CE020C52 1 
+010203040506 03032CFE06162CFEF00000020C53 1 
+010203040506 03032CFE06162CFEF00001020C54 1 
+010203040506 03032CFE06162CFEF00002020C55 1 
+010203040506 03032CFE06162CFEF00200020C56 1 
+010203040506 03032CFE06162CFEF00201020C57 1 
+010203040506 03032CFE06162CFEF00202020C58 1 
+010203040506 03032CFE06162CFEF00203020C59 1 
+010203040506 03032CFE06162CFEF00204020C5A 1 
+010203040506 03032CFE06162CFEF00205020C5B 1 
+010203040506 03032CFE06162CFEF00206020C5C 1 
+010203040506 03032CFE06162CFEF00207020C5D 1 
+010203040506 03032CFE06162CFEF00208020C5E 1 
+010203040506 03032CFE06162CFEF00209020C5F 1 
+010203040506 03032CFE06162CFEF0020A020C60 1 
+010203040506 03032CFE06162CFEF0020B020C61 1 
+010203040506 03032CFE06162CFEF0020C020C62 1 
+010203040506 03032CFE06162CFEF0020D020C63 1 
+010203040506 03032CFE06162CFEF0020E020C64 1 
+010203040506 03032CFE06162CFEF0020F020C65 1 
+010203040506 03032CFE06162CFEF00210020C66 1 
+010203040506 03032CFE06162CFEF00211020C67 1 
+010203040506 03032CFE06162CFEF00212020C68 1 
+010203040506 03032CFE06162CFEF00213020C69 1 
+010203040506 03032CFE06162CFEF00214020C6A 1 
+010203040506 03032CFE06162CFEF00215020C6B 1 
+010203040506 03032CFE06162CFEF00300020C6C 1 
+010203040506 03032CFE06162CFEF00301020C6D 1 
+010203040506 03032CFE06162CFEF00302020C6E 1 
+010203040506 03032CFE06162CFEF00303020C6F 1 
+010203040506 03032CFE06162CFEF00304020C70 1 
+010203040506 03032CFE06162CFEF00305020C71 1 
+010203040506 03032CFE06162CFEF00306020C72 1 
+010203040506 03032CFE06162CFEF00307020C73 1 
+010203040506 03032CFE06162CFEF00308020C74 1 
+010203040506 03032CFE06162CFEF00309020C75 1 
+010203040506 03032CFE06162CFEF00400020C76 1 
+010203040506 03032CFE06162CFEF00E97020C77 1 

sdcard/BLETX/BLE Tx Sample.txt

@@ -0,0 +1 @@
+010203040506 00112233445566778899AABBCCDDEEFF 1000