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

fix button label (#1597 )
Co-authored-by: GullCode <gullradriel@hotmail.com>
2026-09-14 18:43:01 +00:00 · 2023-11-21 18:44:10 +01:00 · 2023-11-20 12:09:47 -05:00 · 2023-11-20 08:37:56 +01:00 · 2023-11-19 20:53:53 -05:00 · 2023-11-19 08:08:29 -06:00
67 changed files with 3772 additions and 1791 deletions
@@ -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).

@@ -244,6 +244,7 @@ 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
@@ -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 */
@@ -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__*/
@@ -22,7 +22,6 @@
 */

 #include "ble_rx_app.hpp"
-#include "ble_tx_app.hpp"

 #include "ui_modemsetup.hpp"

@@ -57,24 +56,102 @@ uint64_t copy_mac_address_to_uint64(const uint8_t* macAddress) {
    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 = to_string_mac_address(entry.packetData.macAddress, 6);
+    std::string line{};
+    line.reserve(30);

-    // Handle spacing for negative sign.
-    uint8_t db_spacing = entry.dbValue > 0 ? 7 : 6;
+    if (!entry.nameString.empty() && entry.include_name) {
+        line = entry.nameString;

-    // Pushing single digit values down right justified.
-    if (entry.dbValue > 9 || entry.dbValue < -9) {
-        db_spacing--;
+        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);
    }

-    line += pad_string_with_spaces(db_spacing) + to_string_dec_int(entry.dbValue);
+    // 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);
@@ -84,11 +161,69 @@ BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const Bl
    : 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});

-    button_done.on_select = [this](const ui::Button&) {
-        nav_.pop();
+    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() {
@@ -118,7 +253,7 @@ void BleRecentEntryDetailView::paint(Painter& painter) {
    const auto s = style();
    const auto rect = screen_rect();

-    auto field_rect = Rect{rect.left(), rect.top() + 16, rect.width(), 16};
+    auto field_rect = Rect{rect.left(), rect.top() + 64, rect.width(), 16};

    uint8_t type[total_data_lines];
    uint8_t length[total_data_lines];
@@ -130,41 +265,92 @@ void BleRecentEntryDetailView::paint(Painter& painter) {
    int j = 0;
    int k = 0;

-    for (currentByte = 0; (currentByte < entry_.packetData.dataLen) && (currentPacket < total_data_lines);) {
-        length[currentPacket] = entry_.packetData.data[currentByte++];
-        type[currentPacket] = entry_.packetData.data[currentByte++];
+    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;

-        // Subtract 1 because type is part of the length.
-        for (i = 0; i < length[currentPacket] - 1; i++) {
-            data[currentPacket][i] = entry_.packetData.data[currentByte++];
-        }
+            for (currentByte = 0; (currentByte < entry_.packetData.dataLen) && (currentPacket < total_data_lines);) {
+                length[currentPacket] = advertiseData->Data[currentByte++];
+                type[currentPacket] = advertiseData->Data[currentByte++];

-        currentPacket++;
-    }
+                // Subtract 1 because type is part of the length.
+                for (i = 0; i < length[currentPacket] - 1; i++) {
+                    data[currentPacket][i] = advertiseData->Data[currentByte++];
+                }

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

-            data_strings[current_line] += to_string_hex(data[i][j], 2);
-        }
+            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{};

-        // 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]);
+                for (j = 0; (j < (number_data_lines * 10)) && (j < length[i] - 1); j++) {
+                    if ((j / 10) != current_line) {
+                        current_line++;
+                    }

-        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]);
+                    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;
    }
 }

@@ -173,6 +359,20 @@ void BleRecentEntryDetailView::set_entry(const BleRecentEntry& 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;

@@ -215,38 +415,46 @@ BLERxView::BLERxView(NavigationView& nav)
                  &options_channel,
                  &field_frequency,
                  &check_log,
+                  &check_name,
                  &label_sort,
                  &options_sort,
-                  &button_message,
+                  &button_filter,
+                  &button_save_list,
+                  &button_clear_list,
                  &button_switch,
-                  &recent_entries_view,
-                  &recent_entries_filter_view,
-                  &recent_entry_detail_view});
-
-    recent_entry_detail_view.hidden(true);
-    recent_entries_filter_view.hidden(true);
+                  &recent_entries_view});

    recent_entries_view.on_select = [this](const BleRecentEntry& entry) {
        nav_.push<BleRecentEntryDetailView>(entry);
    };

-    recent_entries_filter_view.on_select = [this](const BleRecentEntry& entry) {
-        nav_.push<BleRecentEntryDetailView>(entry);
-    };
-
-    button_message.on_select = [this, &nav](Button&) {
+    button_filter.on_select = [this](Button&) {
        text_prompt(
-            nav,
+            nav_,
            filterBuffer,
            64,
            [this](std::string& buffer) {
-                on_switch_table(buffer);
+                on_filter_change(buffer);
            });
    };

-    button_switch.on_select = [this, &nav](Button&) {
-        nav.pop();
-        nav.push<BLETxView>();
+    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);
@@ -256,41 +464,35 @@ BLERxView::BLERxView(NavigationView& nav)
    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 i) {
-        switch (i) {
-            case 0:
-                sortEntriesBy(
-                    recent, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
-                sortEntriesBy(
-                    filterEntries, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
-                break;
-            case 1:
-                sortEntriesBy(
-                    recent, [](const BleRecentEntry& entry) { return entry.dbValue; }, true);
-                sortEntriesBy(
-                    filterEntries, [](const BleRecentEntry& entry) { return entry.dbValue; }, true);
-                break;
-            case 2:
-                sortEntriesBy(
-                    recent, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
-                sortEntriesBy(
-                    filterEntries, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
-                break;
-            default:
-                break;
-        }
-
-        recent_entries_view.set_dirty();
-        recent_entries_filter_view.set_dirty();
+    options_sort.on_change = [this](size_t, int32_t index) {
+        handle_entries_sort(index);
    };

    options_channel.set_selected_index(0, true);
@@ -298,59 +500,180 @@ BLERxView::BLERxView(NavigationView& nav)

    logger = std::make_unique<BLELogger>();

-    if (logger)
-        logger->append(LOG_ROOT_DIR "/BLELOG_" + to_string_timestamp(rtc_time::now()) + ".TXT");
-
    // 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 = "";
    }

-    switch ((ADV_PDU_TYPE)packet->type) {
-        case ADV_IND:
-            str_console += "ADV_IND";
-            break;
-        case ADV_DIRECT_IND:
-            str_console += "ADV_DIRECT_IND";
-            break;
-        case ADV_NONCONN_IND:
-            str_console += "ADV_NONCONN_IND";
-            break;
-        case SCAN_REQ:
-            str_console += "SCAN_REQ";
-            break;
-        case SCAN_RSP:
-            str_console += "SCAN_RSP";
-            break;
-        case CONNECT_REQ:
-            str_console += "CONNECT_REQ";
-            break;
-        case ADV_SCAN_IND:
-            str_console += "ADV_SCAN_IND";
-            break;
-        case RESERVED0:
-        case RESERVED1:
-        case RESERVED2:
-        case RESERVED3:
-        case RESERVED4:
-        case RESERVED5:
-        case RESERVED6:
-        case RESERVED7:
-        case RESERVED8:
-            str_console += "RESERVED";
-            break;
-        default:
-            str_console += "UNKNOWN";
-            break;
-    }
+    str_console += pdu_type_to_string((ADV_PDU_TYPE)packet->type);

    str_console += " Len:";
    str_console += to_string_dec_uint(packet->size);
@@ -358,7 +681,7 @@ void BLERxView::on_data(BlePacketData* packet) {
    str_console += "\n";

    str_console += "Mac:";
-    str_console += to_string_mac_address(packet->macAddress, 6);
+    str_console += to_string_mac_address(packet->macAddress, 6, false);

    str_console += "\n";
    str_console += "Data:";
@@ -376,7 +699,15 @@ void BLERxView::on_data(BlePacketData* packet) {
    // Start of Packet stuffing.
    // Masking off the top 2 bytes to avoid invalid keys.
    auto& entry = ::on_packet(recent, macAddressEncoded & 0xFFFFFFFFFFFF);
-    updateEntry(packet, entry);
+    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) {
@@ -384,33 +715,50 @@ void BLERxView::on_data(BlePacketData* packet) {
    }
 }

-void BLERxView::on_switch_table(const std::string value) {
-    filter = value;
-
-    if (!value.empty()) {
-        removeEntriesWithoutKey(recent, filterEntries, [&value](const BleRecentEntry& entry) {
-            return entry.dataString.find(value) == std::string::npos;
+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);
        });
+    }

-        recent_entries_view.set_dirty();
+    filter = value;
+}

-        recent_entries_filter_view.hidden(false);
-        recent_entries_view.hidden(true);
-    } else {
-        recent_entries_view.hidden(false);
-        recent_entries_filter_view.hidden(true);
+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();
-    recent_entries_filter_view.set_dirty();
 }

 void BLERxView::set_parent_rect(const Rect new_parent_rect) {
    View::set_parent_rect(new_parent_rect);
    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
    recent_entries_view.set_parent_rect(content_rect);
-    recent_entry_detail_view.set_parent_rect(content_rect);
-    recent_entries_filter_view.set_parent_rect(content_rect);
 }

 BLERxView::~BLERxView() {
@@ -418,7 +766,7 @@ BLERxView::~BLERxView() {
    baseband::shutdown();
 }

-void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry) {
+void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type) {
    std::string data_string;

    int i;
@@ -435,6 +783,7 @@ void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry)
    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];
@@ -442,40 +791,45 @@ void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry)
    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.update(packet);
+    entry.include_name = check_name.value();

-    switch (options_sort.selected_index()) {
-        case 0:
-            sortEntriesBy(
-                recent, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
-            sortEntriesBy(
-                filterEntries, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
-            break;
-        case 1:
-            sortEntriesBy(
-                recent, [](const BleRecentEntry& entry) { return entry.dbValue; }, true);
-            sortEntriesBy(
-                filterEntries, [](const BleRecentEntry& entry) { return entry.dbValue; }, true);
-            break;
-        case 2:
-            sortEntriesBy(
-                recent, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
-            sortEntriesBy(
-                filterEntries, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
-            break;
-        default:
-            break;
-    }
+    // 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;

-    on_switch_table(filter);
+        uint8_t currentByte = 0;
+        uint8_t length = 0;
+        uint8_t type = 0;

-    // TODO: Crude hack, should be a more formal listener arrangement...
-    if (entry.key() == recent_entry_detail_view.entry().key()) {
-        recent_entry_detail_view.set_entry(entry);
+        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);
    }
 }

@@ -24,6 +24,8 @@
 #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"
@@ -78,6 +80,12 @@ struct BleRecentEntry {
    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} {
@@ -89,7 +97,13 @@ struct BleRecentEntry {
          dbValue{},
          packetData{},
          timestamp{},
-          dataString{} {
+          dataString{},
+          nameString{},
+          include_name{},
+          numHits{},
+          pduType{},
+          channelNumber{},
+          entryFound{} {
    }

    Key key() const {
@@ -114,19 +128,45 @@ class BleRecentEntryDetailView : public View {
   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, 0 * 16}, "Len", Color::light_grey()},
-        {{5 * 8, 0 * 16}, "Type", Color::light_grey()},
-        {{10 * 8, 0 * 16}, "Value", Color::light_grey()},
+        {{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(
@@ -150,9 +190,13 @@ class BLERxView : public View {
    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_switch_table(const std::string value);
-    void updateEntry(const BlePacketData* packet, BleRecentEntry& entry);
+    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_{
@@ -166,9 +210,13 @@ class BLERxView : public View {
    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;
@@ -178,7 +226,8 @@ class BLERxView : public View {
        5,
        {{"Ch.37 ", 37},
         {"Ch.38", 38},
-         {"Ch.39", 39}}};
+         {"Ch.39", 39},
+         {"Auto", 40}}};

    RxFrequencyField field_frequency{
        {6 * 8, 0 * 16},
@@ -199,55 +248,64 @@ class BLERxView : public View {
    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{
-        {0 * 8, 3 * 8},
+        {17 * 8, 3 * 8},
        3,
        "Log",
        true};

-    Labels label_sort{
-        {{6 * 8, 3 * 8}, "Sort:", Color::light_grey()}};
-
-    OptionsField options_sort{
-        {12 * 8, 3 * 8},
-        6,
-        {{"MAC", 0},
-         {"dB", 1},
-         {"Recent", 2}}};
-
-    Button button_message{
-        {22 * 8, 3 * 8, 4 * 8, 16},
-        "Filter"};
+    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{
-        {8 * 8, 16 * 16, 14 * 8, 2 * 16},
-        "Switch to Tx"};
+        {240 - 6 * 8, 320 - (16 + 32), 4 * 8, 32},
+        "Tx"};

    std::string str_log{""};
    bool logging{false};

    std::unique_ptr<BLELogger> logger{};

-    // const RecentEntriesColumns columns{{{"Source", 9},
-    //                             {"Loc", 6},
-    //                             {"Hits", 4},
-    //                             {"Time", 8}}};
-
    BleRecentEntries recent{};
-    BleRecentEntries filterEntries{};
+    BleRecentEntries tempList{};

    const RecentEntriesColumns columns{{
-        {"Mac Address", 20},
-        {"dB", 20},
+        {"Mac Address", 17},
+        {"Hits", 7},
+        {"dB", 4},
    }};

-    BleRecentEntry entry_{};
    BleRecentEntriesView recent_entries_view{columns, recent};
-    BleRecentEntriesView recent_entries_filter_view{columns, filterEntries};
-    BleRecentEntryDetailView recent_entry_detail_view{nav_, entry_};

    MessageHandlerRegistration message_handler_packet{
        Message::ID::BlePacket,
@@ -94,44 +94,6 @@ uint32_t stringToUint32(const std::string& str) {
    return result;
 }

-void readUntil(File& file, char* result, std::size_t maxBufferSize, char delimiter) {
-    std::size_t bytesRead = 0;
-
-    while (true) {
-        char ch;
-        File::Result<File::Size> readResult = file.read(&ch, 1);
-
-        if (readResult.is_ok() && readResult.value() > 0) {
-            if (ch == delimiter) {
-                // Found a space character, stop reading
-                break;
-            } else if (bytesRead < maxBufferSize) {
-                // Append the character to the result if there's space
-                result[bytesRead++] = ch;
-            } else {
-                // Buffer is full, break to prevent overflow
-                break;
-            }
-        } else {
-            break;  // End of file or error
-        }
-    }
-
-    // Null-terminate the result string
-    result[bytesRead] = '\0';
-}
-
-void generateRandomMacAddress(char* macAddress) {
-    const char hexDigits[] = "0123456789ABCDEF";
-
-    // Generate 12 random hexadecimal characters
-    for (int i = 0; i < 12; i++) {
-        int randomIndex = rand() % 16;
-        macAddress[i] = hexDigits[randomIndex];
-    }
-    macAddress[12] = '\0';  // Null-terminate the string
-}
-
 static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
    uint64_t freq_hz;

@@ -172,6 +134,30 @@ 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();
@@ -181,40 +167,47 @@ void BLETxView::toggle() {
 }

 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()) {
-        // Check if file is present before continuing.
        File data_file;

        auto error = data_file.open(file_path);
-        if (error) {
+        if (error && !file_override) {
            file_error();
            check_loop.set_value(false);
            return;
-        } else {
-            // Send first or single packet.
-            packet_counter = packets[current_packet].packet_count;
-            progressbar.set_max(packets[current_packet].packet_count);
-            button_play.set_bitmap(&bitmap_stop);
-
-            baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
-            transmitter_model.enable();
-
-            is_running = true;
        }
-    } else {
-        // Send next packet.
-        baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
+
+        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);
 }

@@ -224,41 +217,44 @@ void BLETxView::stop() {
    button_play.set_bitmap(&bitmap_play);
    check_loop.set_value(false);

-    current_packet = 0;
-    text_packets_sent.set(to_string_dec_uint(packets[0].packet_count));
-    packet_counter = packets[0].packet_count;
-    update_packet_display(packets[0]);
+    update_current_packet(packets[0], 0);

    is_running = false;
 }

-void BLETxView::on_tx_progress(const bool done) {
-    if (done) {
-        if (is_active()) {
+// 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()) {
-                        current_packet = 0;
-                        packet_counter = packets[current_packet].packet_count;
-                        update_packet_display(packets[current_packet]);
+                        update_current_packet(packets[current_packet], 0);
+                        start();
                    } else {
                        stop();
                    }
                } else {
                    current_packet++;
-                    packet_counter = packets[current_packet].packet_count;
-                    update_packet_display(packets[current_packet]);
-                }
-            } else {
-                if ((timer_count % timer_period) == 0) {
+                    update_current_packet(packets[current_packet], current_packet);
                    start();
                }
+            } else {
+                start();
            }
+        }
+    }
+}

-            timer_count++;
+void BLETxView::on_tx_progress(const bool done) {
+    if (done) {
+        if (is_active()) {
+            is_sending = false;
        }
    }
 }
@@ -286,22 +282,34 @@ BLETxView::BLETxView(NavigationView& nav)
                  &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) {
@@ -309,23 +317,49 @@ BLETxView::BLETxView(NavigationView& nav)
    };

    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, &nav](Button&) {
-        auto open_view = nav.push<FileLoadView>(".TXT");
+    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_switch.on_select = [this, &nav](Button&) {
-        nav.pop();
-        nav.push<BLERxView>();
+    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) {
@@ -351,11 +385,10 @@ void BLETxView::on_file_changed(const fs::path& new_file_path) {
            uint64_t packetCountSize = strlen(packets[num_packets].packetCount);

            packets[num_packets].packet_count = stringToUint32(packets[num_packets].packetCount);
-            packet_counter = packets[num_packets].packet_count;

            // Verify Data.
            if ((macAddressSize == mac_address_size_str) && (advertisementDataSize < max_packet_size_str) && (packetCountSize < max_packet_repeat_str) &&
-                hasValidHexPairs(packets[num_packets].macAddress, macAddressSize / 2) && hasValidHexPairs(packets[num_packets].advertisementData, advertisementDataSize / 2) && (packets[num_packets].packet_count > 0) && (packets[num_packets].packet_count < max_packet_repeat_count)) {
+                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 {
@@ -372,10 +405,18 @@ void BLETxView::on_file_changed(const fs::path& new_file_path) {

        } while (num_packets < max_num_packets);

-        update_packet_display(packets[0]);
+        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 = "";

@@ -386,7 +427,7 @@ void BLETxView::on_data(uint32_t value, bool is_data) {
    console.write(str_console);
 }

-void BLETxView::update_packet_display(BLETxPacket packet) {
+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);
@@ -402,6 +443,9 @@ void BLETxView::update_packet_display(BLETxPacket packet) {
    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) {
@@ -55,9 +55,48 @@ class BLELoggerTx {

 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;
@@ -71,21 +110,17 @@ class BLETxView : public View {
    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"; };

-    struct BLETxPacket {
-        char macAddress[13];
-        char advertisementData[63];
-        char packetCount[11];
-        uint32_t packet_count;
-    };
-
   private:
+    void on_timer();
    void on_data(uint32_t value, bool is_data);
-    void on_tx_progress(const bool done);
    void on_file_changed(const std::filesystem::path& new_file_path);
-    void update_packet_display(BLETxPacket packet);
+    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_{
@@ -100,58 +135,33 @@ class BLETxView : public View {
    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};
-    uint64_t timer_period{256};
+    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;
-
-    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
-    };
+    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{256};
+    static constexpr uint32_t max_num_packets{32};
+    int16_t mscounter = 0;

    BLETxPacket packets[max_num_packets];

-    PKT_TYPE pduType = {DISCOVERY};
+    PKT_TYPE pduType = {PKT_TYPE_DISCOVERY};

    static constexpr auto header_height = 9 * 16;
    static constexpr auto switch_button_height = 3 * 16;
@@ -199,29 +209,31 @@ class BLETxView : public View {
    OptionsField options_speed{
        {7 * 8, 6 * 8},
        3,
-        {{"1 ", 256},
-         {"2 ", 128},
-         {"3 ", 64},
-         {"4 ", 32},
-         {"5 ", 16}}};
+        {{"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}}};
+         {"Ch.39", 39},
+         {"Auto", 40}}};

    OptionsField options_adv_type{
        {17 * 8, 6 * 8},
        14,
-        {{"DISCOVERY ", DISCOVERY},
-         {"ADV_IND", ADV_IND},
-         {"ADV_DIRECT", ADV_DIRECT_IND},
-         {"ADV_NONCONN", ADV_NONCONN_IND},
-         {"SCAN_REQ", SCAN_REQ},
-         {"SCAN_RSP", SCAN_RSP},
-         {"CONNECT_REQ", CONNECT_REQ}}};
+        {{"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()}};
@@ -250,13 +262,18 @@ class BLETxView : public View {
    Console console{
        {0, 8 * 16, 240, 240}};

+    Button button_save_packet{
+        {1 * 8, 16 * 16, 13 * 8, 2 * 16},
+        "Save Packet"};
+
    Button button_switch{
-        {8 * 8, 16 * 16, 14 * 8, 2 * 16},
+        {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{};

@@ -273,6 +290,12 @@ class BLETxView : public View {
            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 */
@@ -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) {
@@ -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},
        }};

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

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

@@ -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};
@@ -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
 }
@@ -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 {
@@ -240,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();
 }
@@ -59,6 +59,7 @@ class Codec {
    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 {
@@ -107,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();

@@ -278,8 +278,7 @@ void set_pocsag() {
 }

 void set_adsb() {
-    const ADSBConfigureMessage message{
-        1};
+    const ADSBConfigureMessage message{};
    send_message(&message);
 }

@@ -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__*/
@@ -21,6 +21,7 @@
 */

 #include <string>
+#include <cstdint>

 #ifndef __DE_BRUIJN_H__
 #define __DE_BRUIJN_H__
@@ -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;
 }

@@ -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__*/
@@ -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
@@ -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);

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

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

@@ -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);
@@ -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);
@@ -20,6 +20,8 @@
 * Boston, MA 02110-1301, USA.
 */

+#include <cstdint>
+
 #include "aprs.hpp"
 #include "ax25.hpp"

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

@@ -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) {
@@ -96,19 +103,28 @@ void sortEntriesBy(ContainerType& entries, KeySelector keySelector, SortOrder as
 }

 template <typename ContainerType, typename KeySelector>
-void removeEntriesWithoutKey(ContainerType& entries, ContainerType& filteredEntries, KeySelector keySelector) {
+void resetFilteredEntries(ContainerType& entries, KeySelector keySelector) {
    // Clear the filteredEntries container
-    filteredEntries.clear();
-
    auto it = entries.begin();
    while (it != entries.end()) {
-        if (!keySelector(*it)) {
-            filteredEntries.emplace_back(*it);  // Add a new entry to filteredEntries
+        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>;
@@ -311,13 +311,13 @@ 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) {
+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 += ":" + to_string_hex(macAddress[i], 2);
+        string += noColon ? to_string_hex(macAddress[i], 2) : ":" + to_string_hex(macAddress[i], 2);
    }

    return string;
@@ -337,6 +337,46 @@ std::string to_string_formatted_mac_address(const char* macAddress) {
    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{""};
@@ -77,8 +77,11 @@ std::string to_string_FAT_timestamp(const FATTimestamp& timestamp);
 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);
+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. */
@@ -29,7 +29,7 @@

 class TemperatureLogger {
   public:
-    using sample_t = uint8_t;
+    using sample_t = int8_t;

    void second_tick();

@@ -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) {
@@ -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{};
@@ -86,6 +86,7 @@
 #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"
@@ -170,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);

@@ -551,6 +555,7 @@ ReceiversMenuView::ReceiversMenuView(NavigationView& nav) {
        {"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>(); }},
+        //{"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>(); }},
@@ -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;
    }
 }
@@ -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};
@@ -339,6 +339,9 @@ void BTLETxProcessor::execute(const buffer_c8_t& 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.
@@ -363,9 +366,6 @@ void BTLETxProcessor::execute(const buffer_c8_t& buffer) {
            buffer.p[i] = {re, im};
        }
    }
-
-    txprogress_message.done = true;
-    shared_memory.application_queue.push(txprogress_message);
 }

 void BTLETxProcessor::on_message(const Message* const message) {
@@ -95,32 +95,7 @@ void BTLERxProcessor::scramble_byte(uint8_t* byte_in, int num_byte, const uint8_
    }
 }

-// void BTLERxProcessor::demod_byte(int num_byte, uint8_t *out_byte)
-//{
-//    int i, j;
-//    int I0, Q0, I1, Q1;
-//    uint8_t bit_decision;
-//    int sample_idx = 0;
-
-// for (i = 0; i < num_byte; i++)
-// {
-//   out_byte[i] = 0;
-
-// for (j = 0; j < 8; j++)
-// {
-//     I0 = dst_buffer.p[sample_idx].real();
-//     Q0 = dst_buffer.p[sample_idx].imag();
-//     I1 = dst_buffer.p[sample_idx + 1].real();
-//     Q1 = dst_buffer.p[sample_idx + 1].imag();
-
-// bit_decision = (I0 * Q1 - I1 * Q0) > 0 ? 1 : 0;
-
-// out_byte[i] = out_byte[i] | (bit_decision << j);
-
-// sample_idx += SAMPLE_PER_SYMBOL;;}
-//}
-
-int BTLERxProcessor::parse_adv_pdu_payload_byte(uint8_t* payload_byte, int num_payload_byte, ADV_PDU_TYPE pdu_type, void* adv_pdu_payload) {
+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) {
@@ -129,178 +104,26 @@ int BTLERxProcessor::parse_adv_pdu_payload_byte(uint8_t* payload_byte, int num_p
    }

    if (pdu_type == ADV_IND || pdu_type == ADV_NONCONN_IND || pdu_type == SCAN_RSP || pdu_type == ADV_SCAN_IND) {
-        payload_type_0_2_4_6 = (ADV_PDU_PAYLOAD_TYPE_0_2_4_6*)adv_pdu_payload;
-
-        macAddress[0] = payload_byte[5];
-        macAddress[1] = payload_byte[4];
-        macAddress[2] = payload_byte[3];
-        macAddress[3] = payload_byte[2];
-        macAddress[4] = payload_byte[1];
-        macAddress[5] = payload_byte[0];
-
-        memcpy(payload_type_0_2_4_6->Data, payload_byte + 6, num_payload_byte - 6);
-    }
-    // Only processing advertisments for right now.
-    else {
+        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;
    }
-    // 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);
-    //     }
-
-    // payload_type_1_3 = (ADV_PDU_PAYLOAD_TYPE_1_3 *)adv_pdu_payload;
-
-    // //AdvA = reorder_bytes_str( payload_bytes(1 : (2*6)) );
-    // macAddress[0] = payload_byte[5];
-    // macAddress[1] = payload_byte[4];
-    // macAddress[2] = payload_byte[3];
-    // macAddress[3] = payload_byte[2];
-    // macAddress[4] = payload_byte[1];
-    // macAddress[5] = payload_byte[0];
-
-    // //InitA = reorder_bytes_str( payload_bytes((2*6+1):end) );
-    // payload_type_1_3->A1[0] = payload_byte[11];
-    // payload_type_1_3->A1[1] = payload_byte[10];
-    // payload_type_1_3->A1[2] = payload_byte[9];
-    // payload_type_1_3->A1[3] = payload_byte[8];
-    // payload_type_1_3->A1[4] = payload_byte[7];
-    // payload_type_1_3->A1[5] = payload_byte[6];
-
-    // //payload_parse_result_str = ['AdvA:' AdvA ' InitA:' InitA];
-    // }
-    // 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);
-    // }
-
-    // payload_type_5 = (ADV_PDU_PAYLOAD_TYPE_5 *)adv_pdu_payload;
-
-    // //InitA = reorder_bytes_str( payload_bytes(1 : (2*6)) );
-    // macAddress[0] = payload_byte[5];
-    // macAddress[1] = payload_byte[4];
-    // macAddress[2] = payload_byte[3];
-    // macAddress[3] = payload_byte[2];
-    // macAddress[4] = payload_byte[1];
-    // macAddress[5] = payload_byte[0];
-
-    // //AdvA = reorder_bytes_str( payload_bytes((2*6+1):(2*6+2*6)) );
-    // payload_type_5->AdvA[0] = payload_byte[11];
-    // payload_type_5->AdvA[1] = payload_byte[10];
-    // payload_type_5->AdvA[2] = payload_byte[9];
-    // payload_type_5->AdvA[3] = payload_byte[8];
-    // payload_type_5->AdvA[4] = payload_byte[7];
-    // payload_type_5->AdvA[5] = payload_byte[6];
-
-    // //AA = reorder_bytes_str( payload_bytes((2*6+2*6+1):(2*6+2*6+2*4)) );
-    // payload_type_5->AA[0] = payload_byte[15];
-    // payload_type_5->AA[1] = payload_byte[14];
-    // payload_type_5->AA[2] = payload_byte[13];
-    // payload_type_5->AA[3] = payload_byte[12];
-
-    // //CRCInit = payload_bytes((2*6+2*6+2*4+1):(2*6+2*6+2*4+2*3));
-    // payload_type_5->CRCInit = ( payload_byte[16] );
-    // payload_type_5->CRCInit = ( (payload_type_5->CRCInit << 8) | payload_byte[17] );
-    // payload_type_5->CRCInit = ( (payload_type_5->CRCInit << 8) | payload_byte[18] );
-
-    // //WinSize = payload_bytes((2*6+2*6+2*4+2*3+1):(2*6+2*6+2*4+2*3+2*1));
-    // payload_type_5->WinSize = payload_byte[19];
-
-    // //WinOffset = reorder_bytes_str( payload_bytes((2*6+2*6+2*4+2*3+2*1+1):(2*6+2*6+2*4+2*3+2*1+2*2)) );
-    // payload_type_5->WinOffset = ( payload_byte[21] );
-    // payload_type_5->WinOffset = ( (payload_type_5->WinOffset << 8) | payload_byte[20] );
-
-    // //Interval = reorder_bytes_str( payload_bytes((2*6+2*6+2*4+2*3+2*1+2*2+1):(2*6+2*6+2*4+2*3+2*1+2*2+2*2)) );
-    // payload_type_5->Interval = ( payload_byte[23] );
-    // payload_type_5->Interval = ( (payload_type_5->Interval << 8) | payload_byte[22] );
-
-    // //Latency = reorder_bytes_str( payload_bytes((2*6+2*6+2*4+2*3+2*1+2*2+2*2+1):(2*6+2*6+2*4+2*3+2*1+2*2+2*2+2*2)) );
-    // payload_type_5->Latency = ( payload_byte[25] );
-    // payload_type_5->Latency = ( (payload_type_5->Latency << 8) | payload_byte[24] );
-
-    // //Timeout = reorder_bytes_str( payload_bytes((2*6+2*6+2*4+2*3+2*1+2*2+2*2+2*2+1):(2*6+2*6+2*4+2*3+2*1+2*2+2*2+2*2+2*2)) );
-    // payload_type_5->Timeout = ( payload_byte[27] );
-    // payload_type_5->Timeout = ( (payload_type_5->Timeout << 8) | payload_byte[26] );
-
-    // //ChM = reorder_bytes_str( payload_bytes((2*6+2*6+2*4+2*3+2*1+2*2+2*2+2*2+2*2+1):(2*6+2*6+2*4+2*3+2*1+2*2+2*2+2*2+2*2+2*5)) );
-    // payload_type_5->ChM[0] = payload_byte[32];
-    // payload_type_5->ChM[1] = payload_byte[31];
-    // payload_type_5->ChM[2] = payload_byte[30];
-    // payload_type_5->ChM[3] = payload_byte[29];
-    // payload_type_5->ChM[4] = payload_byte[28];
-
-    // //tmp_bits = payload_bits((end-7) : end);
-    // //Hop = num2str( bi2de(tmp_bits(1:5), 'right-msb') );
-    // //SCA = num2str( bi2de(tmp_bits(6:end), 'right-msb') );
-    // payload_type_5->Hop = (payload_byte[33]&0x1F);
-    // payload_type_5->SCA = ((payload_byte[33]>>5)&0x07);
-    // }
-    // else
-    // {
-    // //TODO: Handle Unknown PDU.
-    //  payload_type_R = (ADV_PDU_PAYLOAD_TYPE_R *)adv_pdu_payload;
-    //  memcpy(payload_type_R->payload_byte, payload_byte, num_payload_byte);
-    // return(-1);
-    // }

    return 0;
 }

-void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
-    if (!configured) return;
-
-    // Pulled this implementation from channel_stats_collector.c to time slice a specific packet's dB.
-    uint32_t max_squared = 0;
-
-    void* src_p = buffer.p;
-
-    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 float max_squared_f = max_squared;
-    const int32_t max_dB = mag2_to_dbv_norm(max_squared_f * (1.0f / (32768.0f * 32768.0f)));
-
-    decim_0.execute(buffer, dst_buffer);
-    feed_channel_stats(dst_buffer);
-
-    const buffer_c8_t iq_buffer{
-        buffer.p,
-        buffer.count,
-        baseband_fs};
-
-    // process++;
-
-    // if ((process % 50) != 0) return;
-
-    // 4Mhz 2048 samples
-
-    //--------------Variable Defines---------------------------------//
-
-    int i, sp, j = 0;
-    int I0, Q0, I1, Q1 = 0;
-    int k, p, phase_idx = 0;
-    int num_demod_byte = 0;
-
-    bool unequal_flag;
-
-    const int demod_buf_len = LEN_DEMOD_BUF_ACCESS;  // For AA
-    int demod_buf_offset = 0;
+void BTLERxProcessor::handleBeginState() {
    int num_symbol_left = dst_buffer.count / SAMPLE_PER_SYMBOL;  // One buffer sample consist of I and Q.
-    int symbols_eaten = 0;
-    int hit_idx = (-1);
-
-    //--------------Start Parsing For Access Address---------------//

    static uint8_t demod_buf_access[SAMPLE_PER_SYMBOL][LEN_DEMOD_BUF_ACCESS];

@@ -310,33 +133,38 @@ void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
    uint32_t accesssAddress = 0;

    // Filling up addressBits with the access address we are looking to find.
-    for (i = 0; i < 32; i++) {
+    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 (i = 0; i < num_symbol_left * SAMPLE_PER_SYMBOL; i += SAMPLE_PER_SYMBOL) {
-        sp = ((demod_buf_offset - demod_buf_len + 1) & (demod_buf_len - 1));
+    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 (j = 0; j < SAMPLE_PER_SYMBOL; j++) {
+        for (int j = 0; j < SAMPLE_PER_SYMBOL; j++) {
            // Sample and compare with the adjacent next sample.
-            I0 = dst_buffer.p[i + j].real();
-            Q0 = dst_buffer.p[i + j].imag();
-            I1 = dst_buffer.p[i + j + 1].real();
-            Q1 = dst_buffer.p[i + j + 1].imag();
+            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();

-            phase_idx = j;
+            int phase_idx = j;

            demod_buf_access[phase_idx][demod_buf_offset] = (I0 * Q1 - I1 * Q0) > 0 ? 1 : 0;

-            k = sp;
+            int k = sp;
            unequal_flag = false;

            accesssAddress = 0;

-            for (p = 0; p < demod_buf_len; p++) {
+            for (int p = 0; p < demod_buf_len; p++) {
                if (demod_buf_access[phase_idx][k] != accessAddrBits[p]) {
                    unequal_flag = true;
                    hit_idx = (-1);
@@ -368,13 +196,15 @@ void BTLERxProcessor::execute(const buffer_c8_t& buffer) {

    symbols_eaten += hit_idx;

-    symbols_eaten += (8 * NUM_ACCESS_ADDR_BYTE * SAMPLE_PER_SYMBOL);  // move to beginning of PDU header
+    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;

-    //--------------Start PDU Header Parsing-----------------------//
+    parseState = Parse_State_PDU_Header;
+}

-    num_demod_byte = 2;  // PDU header has 2 octets
+void BTLERxProcessor::handlePDUHeaderState() {
+    int num_demod_byte = 2;  // PDU header has 2 octets

    symbols_eaten += 8 * num_demod_byte * SAMPLE_PER_SYMBOL;

@@ -382,22 +212,19 @@ void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
        return;
    }

-    // //Demod the PDU Header
-    uint8_t bit_decision;
+    // Jump back down to the beginning of PDU header.
+    sample_idx = symbols_eaten - (8 * num_demod_byte * SAMPLE_PER_SYMBOL);

-    // Jump back down to beginning of PDU header.
-    int sample_idx = symbols_eaten - (8 * num_demod_byte * SAMPLE_PER_SYMBOL);
+    packet_index = 0;

-    uint16_t packet_index = 0;
-
-    for (i = 0; i < num_demod_byte; i++) {
+    for (int i = 0; i < num_demod_byte; i++) {
        rb_buf[packet_index] = 0;

-        for (j = 0; j < 8; j++) {
-            I0 = dst_buffer.p[sample_idx].real();
-            Q0 = dst_buffer.p[sample_idx].imag();
-            I1 = dst_buffer.p[sample_idx + 1].real();
-            Q1 = dst_buffer.p[sample_idx + 1].imag();
+        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);
@@ -408,39 +235,39 @@ void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
        packet_index++;
    }

-    // demod_byte(num_demod_byte, rb_buf);
-
    scramble_byte(rb_buf, num_demod_byte, scramble_table[channel_number], rb_buf);

-    uint8_t pdu_type = (ADV_PDU_TYPE)(rb_buf[0] & 0x0F);
+    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);
-    uint8_t payload_len = (rb_buf[1] & 0x3F);
+    payload_len = (rb_buf[1] & 0x3F);

-    // Not valid Advertise Payload.
+    // Not a valid Advertise Payload.
    if ((payload_len < 6) || (payload_len > 37)) {
+        parseState = Parse_State_Begin;
        return;
+    } else {
+        parseState = Parse_State_PDU_Payload;
    }
+}

-    //--------------Start Payload Parsing--------------------------//
-
-    num_demod_byte = (payload_len + 3);
+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;
    }

-    // sample_idx = symbols_eaten - (8 * num_demod_byte * SAMPLE_PER_SYMBOL);
-
    for (i = 0; i < num_demod_byte; i++) {
        rb_buf[packet_index] = 0;

-        for (j = 0; j < 8; j++) {
-            I0 = dst_buffer.p[sample_idx].real();
-            Q0 = dst_buffer.p[sample_idx].imag();
-            I1 = dst_buffer.p[sample_idx + 1].real();
-            Q1 = dst_buffer.p[sample_idx + 1].imag();
+        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);
@@ -451,12 +278,8 @@ void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
        packet_index++;
    }

-    // demod_byte(num_demod_byte, rb_buf + 2);
-
    scramble_byte(rb_buf + 2, num_demod_byte, scramble_table[channel_number] + 2, rb_buf + 2);

-    //--------------Start CRC Checking-----------------------------//
-
    // Check CRC
    bool crc_flag = crc_check(rb_buf, payload_len + 2, crc_init_internal);
    // pkt_count++;
@@ -466,7 +289,7 @@ void BTLERxProcessor::execute(const buffer_c8_t& buffer) {

    // Checking CRC and excluding Reserved PDU types.
    if (pdu_type < RESERVED0 && !crc_flag) {
-        if (parse_adv_pdu_payload_byte(rb_buf + 2, payload_len, (ADV_PDU_TYPE)pdu_type, (void*)(&adv_pdu_payload)) == 0) {
+        if (verify_payload_byte(payload_len, (ADV_PDU_TYPE)pdu_type) == 0) {
            sendPacket = true;
        }

@@ -477,12 +300,12 @@ void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
            blePacketData.type = pdu_type;
            blePacketData.size = payload_len;

-            blePacketData.macAddress[0] = macAddress[0];
-            blePacketData.macAddress[1] = macAddress[1];
-            blePacketData.macAddress[2] = macAddress[2];
-            blePacketData.macAddress[3] = macAddress[3];
-            blePacketData.macAddress[4] = macAddress[4];
-            blePacketData.macAddress[5] = macAddress[5];
+            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;
@@ -498,6 +321,48 @@ void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
            shared_memory.application_queue.push(data_message);
        }
    }
+
+    parseState = Parse_State_Begin;
+}
+
+void BTLERxProcessor::execute(const buffer_c8_t& buffer) {
+    if (!configured) return;
+
+    // Pulled this implementation from channel_stats_collector.c to time slice a specific packet's dB.
+    uint32_t max_squared = 0;
+
+    void* src_p = buffer.p;
+
+    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 float max_squared_f = max_squared;
+    max_dB = mag2_to_dbv_norm(max_squared_f * (1.0f / (32768.0f * 32768.0f)));
+
+    // 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);
+
+    symbols_eaten = 0;
+
+    // Handle parsing based on parseState
+    if (parseState == Parse_State_Begin) {
+        handleBeginState();
+    }
+
+    if (parseState == Parse_State_PDU_Header) {
+        handlePDUHeaderState();
+    }
+
+    if (parseState == Parse_State_PDU_Payload) {
+        handlePDUPayloadState();
+    }
 }

 void BTLERxProcessor::on_message(const Message* const message) {
@@ -507,8 +372,7 @@ void BTLERxProcessor::on_message(const Message* const message) {

 void BTLERxProcessor::configure(const BTLERxConfigureMessage& message) {
    channel_number = message.channel_number;
-    decim_0.configure(taps_200k_wfm_decim_0.taps);
-    demod.configure(48000, 5000);
+    decim_0.configure(taps_BTLE_1M_PHY_decim_0.taps);

    configured = true;

@@ -48,6 +48,12 @@ class BTLERxProcessor : public BasebandProcessor {
    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,
@@ -70,28 +76,6 @@ class BTLERxProcessor : public BasebandProcessor {
    uint8_t macAddress[6];
    int checksumReceived = 0;

-    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 ADV_PDU_PAYLOAD_TYPE_R {
        uint8_t payload_byte[40];
    };
@@ -109,15 +93,19 @@ class BTLERxProcessor : public BasebandProcessor {

    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 parse_adv_pdu_payload_byte(uint8_t* payload_byte, int num_payload_byte, ADV_PDU_TYPE pdu_type, void* adv_pdu_payload);
+    int verify_payload_byte(int num_payload_byte, ADV_PDU_TYPE pdu_type);

-    std::array<complex16_t, 1024> dst{};
+    void handleBeginState();
+    void handlePDUHeaderState();
+    void handlePDUPayloadState();
+
+    std::array<complex16_t, 512> dst{};
    const buffer_c16_t dst_buffer{
        dst.data(),
        dst.size()};

-    static constexpr int RB_SIZE = 2048;
-    uint8_t rb_buf[2048];
+    static constexpr int RB_SIZE = 512;
+    uint8_t rb_buf[RB_SIZE];

    dsp::decimate::FIRC8xR16x24FS4Decim4 decim_0{};

@@ -131,18 +119,21 @@ class BTLERxProcessor : public BasebandProcessor {
    bool configured{false};
    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);

-    ADV_PDU_PAYLOAD_TYPE_0_2_4_6* payload_type_0_2_4_6 = nullptr;
-    ADV_PDU_PAYLOAD_TYPE_1_3* payload_type_1_3 = nullptr;
-    ADV_PDU_PAYLOAD_TYPE_5* payload_type_5 = nullptr;
-    ADV_PDU_PAYLOAD_TYPE_R* payload_type_R = nullptr;
-    ADV_PDU_PAYLOAD_TYPE_R adv_pdu_payload = {0};
-
    // clang-format off
    // Scramble table definition
    const uint8_t scramble_table[40][42] = 
@@ -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
@@ -25,6 +25,7 @@

 #include <cstring>
 #include <string>
+#include <cstdint>

 namespace adsb {

@@ -862,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;
@@ -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__*/
@@ -403,6 +403,28 @@ 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;
@@ -1089,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 {
@@ -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;
 }
@@ -990,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]");
@@ -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();
@@ -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:
@@ -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(
@@ -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);
@@ -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);
@@ -405,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;
@@ -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
Author	SHA1	Message	Date
Mark Thompson	1cbe5cb293	Save TPMS units in App Settings and tune frequency (#1598 )	2023-11-21 18:44:10 +01:00
gullradriel	df6003c08f	fix button label (#1597 ) Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-20 12:09:47 -05:00
Netro	50fcbf0f5a	BLE: added deleting and renaming temp file (#1596 )	2023-11-20 08:37:56 +01:00
Netro	5a1676a0b9	BLE List improvements (#1595 ) * WIP on add to save list * Added rewriting existing lines and appending new to same file. * format * not looking on new file. * Added temp list due to some issue of recent being updated during save I was receiving a system halt and this seems to fix it. Needs more testing though. * clang format * Stored entries backward. Fix. * Update file working, need to replace temp file though.	2023-11-19 20:53:53 -05:00
gullradriel	309f2fbd2c	support for a sdcard speed option (#1594 ) * support for a sdcard speed option * trying to link sdio_cclk_set from file * changed io to IO in checkbox text * changed order so high speed option is read after pmem is restored from sd * test button * took out unneeded comment * force behavior of test button --------- Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-19 08:08:29 -06:00
gullradriel	650aacfaa7	BLE RX: added clear list button (#1593 ) * added clear list button * Bigger buttons and text * Change case on labels --------- Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-18 16:32:52 -05:00
Mark Thompson	8655027a5b	Fixed SPI Read timing issue affecting MAX283x chips (#1590 ) * Slowed SPI timing to MAX283x by 20% * Fix temperature scaling	2023-11-18 09:50:57 -06:00
Mark Thompson	de937f02d4	Added Memory Dump app for Debug (#1588 ) * Add files via upload * Add files via upload * Added single word read/write support * Add files via upload	2023-11-18 07:16:56 -06:00
Mark Thompson	2c0446e83d	Improved Focus Manager navigation (#1589 ) * Focus manager navigation fix * Add files via upload	2023-11-18 06:58:38 -06:00
Netro	9e6699d8cc	Fixed name. (#1586 )	2023-11-17 13:28:09 -05:00
Mark Thompson	ef92c5bc0a	Enhanced Debug -> Peripherals app to allow direct register modification (#1584 ) * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Clang * Clang * Tweak position of field on screen * Reverted text on Write button per reviewer feedback	2023-11-17 12:10:11 -06:00
Netro	10f6600f52	No need limit to 50 since we moved to min 16ms send times. (#1583 )	2023-11-16 21:28:22 +01:00
Netro	aeb607e73b	BLE Rx Save List / Save packet from BLE Rx (#1582 ) * Added Tx Save from Rx Details View * Added saving of current list	2023-11-16 20:00:52 +01:00
Netro	8479d2edf0	BLE Comm WIP (#1578 ) * Initial BLE Comm commit. * SCAN_RSP MAC was reversed. * Added Auto Channel Hop. * Improvements to Tx to better handle timers. * Auto channel and more work on timers. * more advertisement numbers.	2023-11-16 14:46:45 +01:00
Bernd Herzog	d2e9a8dc06	Hackrf mode when no pp attached (#1580 ) * added portapack presence detection * adjusted timeout * fixed ak4951 initialisation	2023-11-14 12:22:26 +01:00
Netro	4571cb0b61	BLE Rx Refactoring / Cleanup (#1577 ) , also added showing MAC for Scan_Rsp Adv_Direct	2023-11-12 19:10:53 +01:00
gullradriel	351f7b13b3	BTLE RX: fix for name disappearing (#1575 ) * Fix for name disappearing * cleanings --------- Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-12 09:59:36 -05:00
Netro	5953cb57b0	Rx parsing fix (#1573 ) * restored mistakenly quoted code * removed unneeded line. * added parsing for other PDU Types and added PDU Type label. * added missing SCAN_IND	2023-11-12 08:54:04 +01:00
Brumi-2021	b60b873428	Changing BLTE FIR filter to improve RX sensitivity (#1574 )	2023-11-11 20:43:10 -05:00
Netro	a3249cae26	BLE Rx/Tx App Cleanup (#1570 ) * Showing highest dB first * Including namestring in search * Using replace seems to work better. * bletx cleanup * removing pop * pop is needed on this view. * cleanup switching * reduce to 1 entry list * Setting to use the name of BLE with a toggle checkbox. * Removed &nav reference. * Removing const * Fixed issue with memory being run out when switching from a previous app * Fixed not setting updated progressbar for each new packet.	2023-11-11 20:46:51 +01:00
Kyle Reed	f7f784c0f4	Cleanup dead code in the ADSB RX proc (#1572 ) * Cleanup dead code in the ADSB RX proc * Fix comments * Formatting	2023-11-10 11:38:06 -08:00
Kyle Reed	f4f538f69b	ADSB RX App cleanup (#1569 ) * WIP refactoring/gardening * WIP cleanup, adding status dots * Rename ageStep * WIP Cleanup * Wrapping up ADSB refactor/cleanup. * Don't initialize strings to " " * Better map refresh * Fix colorization of recent entries * Fit and finish	2023-11-10 08:22:29 -08:00
Netro	bbd1a5a2ef	Changing filter on ble rx. Seems to work better? (#1568 )	2023-11-08 19:22:57 +01:00
Nemanja Nedeljković	bc71238046	Patch build for gcc 13.2.0 (#1567 )	2023-11-08 19:22:26 +01:00
Netro	a9df9dde69	BLE Rx parsing improvements (#1566 ) * Running simple state machine to better catch in between buffers. * Fixed buffer size 2048 was too large for a decimated before only containing 512 (2048/4 Decimation) Bytes. * attempt at trying to minimize uncleared str buffers	2023-11-07 18:10:18 +01:00
Mark Thompson	7a87e3f3af	Added File Manager button to show hidden files (#1564 ) * Add files via upload * Add files via upload * Add files via upload * Add files via upload	2023-11-06 16:33:19 -06:00
Mark Thompson	68f960e4e7	Temperature scaling changes for HackRF r9 (MAX2839) (#1561 ) * Add files via upload * Add files via upload * Add files via upload	2023-11-06 13:56:09 -06:00
gullradriel	6784fe72dd	fixed display when delete/remove entry (#1563 )	2023-11-06 20:38:37 +01:00
Netro	312df0fcec	Save tx file (#1560 ) * Added saving current packets to file	2023-11-06 19:09:26 +01:00
Erwin Ried	2913a41aec	Update README.md (#1559 )	2023-11-06 11:16:13 +01:00
Netro	adabbfbef1	Send on select (#1557 ) * fixed bug not fully displaying rx packet * added sending selected packet * setting packet count to 100 as 1 is too aggressive for speed > 2 * setting limit to 50 as 50 does not bog down UI at speed 5. * fix tx channel getting out of sync with freq	2023-11-06 11:16:01 +01:00
gullradriel	2b7962fa7c	Level RSSIGraph tuning (#1556 ) * Added whole graph RSSI min/avg/max/delta to RSSIGraph * fix for min=0 values when modulation is changed * literal number as a #define flag	2023-11-06 11:12:36 +01:00
gullradriel	645f02e2f3	updated submodule (#1551 ) Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-04 22:41:38 -05:00
Netro	b178462e47	BLE Rx improvements. (#1550 ) * Added parsing for ble name added focus for ble tx play button. * Added sort by name * Fixed issue where we were pushing too early before pop was finished. * Fix ordering * Fix field location. * truncating entries to stop memory overflow * Added Number of Hits. * Limiting number of hits to uint16_t, as any higher would overflow screen * Limiting number of hits to uint16_t due to possible screen overflow. * Stop creating a log every time app starts. Cluttering log folder.	2023-11-04 08:29:48 +01:00