BLE Rx Refactoring / Cleanup (#1577) , also added showing MAC for Scan_Rsp Adv_Direct

* Fix for name disappearing

* cleanings

---------

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

README.md

@@ -20,7 +20,9 @@ This repository expands upon the previous work by many people and aims to consta
 
 ## What to buy?
 
-:heavy_check_mark: A recommended one is this [PortaPack H2](https://s.click.aliexpress.com/e/_DmU7GQX) pack, that includes everything you need. Sadly, the people making the H2 never made the updated schematics available (against the terms of the license). 
+:heavy_check_mark: A recommended one is this [PortaPack H2](https://s.click.aliexpress.com/e/_DmU7GQX), that includes everything you need with the plastic case "inspired" on [this](https://github.com/eried/portapack-mayhem/wiki/H2-Enclosure).
+
+:heavy_check_mark: Our friends at OpenSourceSDRLab give away five units every three months in [our discord](https://discord.com/channels/719669764804444213/1165624357129834547) of this [PortaPack H2](https://www.aliexpress.com/item/4000247041639.html?gatewayAdapt=4itemAdapt), you can support them too.
 
 :heavy_check_mark: Another popular option is the clone of the [PortaPack H1](https://s.click.aliexpress.com/e/_Dkbqs2X).
 

firmware/application/CMakeLists.txt

@@ -244,7 +244,7 @@ set(CPPSRC
 	apps/ais_app.cpp
 	apps/analog_audio_app.cpp
 	apps/analog_tv_app.cpp
-	apps/ble_app.cpp
+	apps/ble_rx_app.cpp
 	apps/ble_tx_app.cpp
 	apps/capture_app.cpp
 	apps/ert_app.cpp

firmware/application/apps/ble_app.cpp

@@ -1,474 +0,0 @@
-/*
- * 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_app.hpp"
-#include "ui_modemsetup.hpp"
-
-#include "modems.hpp"
-#include "audio.hpp"
-#include "rtc_time.hpp"
-#include "baseband_api.hpp"
-#include "string_format.hpp"
-#include "portapack_persistent_memory.hpp"
-#include "ui_textentry.hpp"
-
-using namespace portapack;
-using namespace modems;
-
-void BLELogger::log_raw_data(const std::string& data) {
-    log_file.write_entry(data);
-}
-
-std::string pad_string_with_spaces(int snakes) {
-    std::string paddedStr(snakes, ' ');
-    return paddedStr;
-}
-
-uint64_t copy_mac_address_to_uint64(const uint8_t* macAddress) {
-    uint64_t result = 0;
-
-    // Copy each byte of the MAC address to the corresponding byte in the uint64_t.
-    for (int i = 0; i < 6; ++i) {
-        result |= static_cast<uint64_t>(macAddress[i]) << ((5 - i) * 8);
-    }
-
-    return result;
-}
-
-namespace ui {
-template <>
-void RecentEntriesTable<BleRecentEntries>::draw(
-    const Entry& entry,
-    const Rect& target_rect,
-    Painter& painter,
-    const Style& style) {
-    std::string line = to_string_mac_address(entry.packetData.macAddress, 6);
-
-    // Handle spacing for negative sign.
-    uint8_t db_spacing = entry.dbValue > 0 ? 7 : 6;
-
-    // Pushing single digit values down right justified.
-    if (entry.dbValue > 9 || entry.dbValue < -9) {
-        db_spacing--;
-    }
-
-    line += pad_string_with_spaces(db_spacing) + to_string_dec_int(entry.dbValue);
-
-    line.resize(target_rect.width() / 8, ' ');
-    painter.draw_string(target_rect.location(), style, line);
-}
-
-BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const BleRecentEntry& entry)
-    : nav_{nav},
-      entry_{entry} {
-    add_children({&button_done,
-                  &labels});
-
-    button_done.on_select = [this](const ui::Button&) {
-        nav_.pop();
-    };
-}
-
-void BleRecentEntryDetailView::update_data() {
-}
-
-void BleRecentEntryDetailView::focus() {
-    button_done.focus();
-}
-
-Rect BleRecentEntryDetailView::draw_field(
-    Painter& painter,
-    const Rect& draw_rect,
-    const Style& style,
-    const std::string& label,
-    const std::string& value) {
-    const int label_length_max = 4;
-
-    painter.draw_string(Point{draw_rect.left(), draw_rect.top()}, style, label);
-    painter.draw_string(Point{draw_rect.left() + (label_length_max + 1) * 8, draw_rect.top()}, style, value);
-
-    return {draw_rect.left(), draw_rect.top() + draw_rect.height(), draw_rect.width(), draw_rect.height()};
-}
-
-void BleRecentEntryDetailView::paint(Painter& painter) {
-    View::paint(painter);
-
-    const auto s = style();
-    const auto rect = screen_rect();
-
-    auto field_rect = Rect{rect.left(), rect.top() + 16, rect.width(), 16};
-
-    uint8_t type[total_data_lines];
-    uint8_t length[total_data_lines];
-    uint8_t data[total_data_lines][40];
-
-    int currentByte = 0;
-    int currentPacket = 0;
-    int i = 0;
-    int j = 0;
-    int k = 0;
-
-    for (currentByte = 0; (currentByte < entry_.packetData.dataLen) && (currentPacket < total_data_lines);) {
-        length[currentPacket] = entry_.packetData.data[currentByte++];
-        type[currentPacket] = entry_.packetData.data[currentByte++];
-
-        // Subtract 1 because type is part of the length.
-        for (i = 0; i < length[currentPacket] - 1; i++) {
-            data[currentPacket][i] = entry_.packetData.data[currentByte++];
-        }
-
-        currentPacket++;
-    }
-
-    for (i = 0; i < currentPacket; i++) {
-        uint8_t number_data_lines = ceil((float)(length[i] - 1) / 10.0);
-        uint8_t current_line = 0;
-        std::array<std::string, total_data_lines> data_strings{};
-
-        for (j = 0; (j < (number_data_lines * 10)) && (j < length[i] - 1); j++) {
-            if ((j / 10) != current_line) {
-                current_line++;
-            }
-
-            data_strings[current_line] += to_string_hex(data[i][j], 2);
-        }
-
-        // Read the type back to the total length.
-        field_rect = draw_field(painter, field_rect, s, to_string_hex(length[i]), to_string_hex(type[i]) + pad_string_with_spaces(3) + data_strings[0]);
-
-        if (number_data_lines > 1) {
-            for (k = 1; k < number_data_lines; k++) {
-                if (data_strings[k].empty()) {
-                    field_rect = draw_field(painter, field_rect, s, "", pad_string_with_spaces(5) + data_strings[k]);
-                }
-            }
-        }
-    }
-}
-
-void BleRecentEntryDetailView::set_entry(const BleRecentEntry& entry) {
-    entry_ = entry;
-    set_dirty();
-}
-
-static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
-    uint64_t freq_hz;
-
-    switch (channel_number) {
-        case 37:
-            freq_hz = 2'402'000'000ull;
-            break;
-        case 38:
-            freq_hz = 2'426'000'000ull;
-            break;
-        case 39:
-            freq_hz = 2'480'000'000ull;
-            break;
-        case 0 ... 10:
-            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
-            break;
-        case 11 ... 36:
-            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
-            break;
-        default:
-            freq_hz = UINT64_MAX;
-    }
-
-    return freq_hz;
-}
-
-void BLERxView::focus() {
-    field_frequency.focus();
-}
-
-BLERxView::BLERxView(NavigationView& nav)
-    : nav_{nav} {
-    baseband::run_image(portapack::spi_flash::image_tag_btle_rx);
-
-    add_children({&rssi,
-                  &channel,
-                  &field_rf_amp,
-                  &field_lna,
-                  &field_vga,
-                  &options_channel,
-                  &field_frequency,
-                  &check_log,
-                  &label_sort,
-                  &options_sort,
-                  &button_message,
-                  &recent_entries_view,
-                  &recent_entries_filter_view,
-                  &recent_entry_detail_view});
-
-    recent_entry_detail_view.hidden(true);
-    recent_entries_filter_view.hidden(true);
-
-    recent_entries_view.on_select = [this](const BleRecentEntry& entry) {
-        nav_.push<BleRecentEntryDetailView>(entry);
-    };
-
-    recent_entries_filter_view.on_select = [this](const BleRecentEntry& entry) {
-        nav_.push<BleRecentEntryDetailView>(entry);
-    };
-
-    button_message.on_select = [this, &nav](Button&) {
-        text_prompt(
-            nav,
-            filterBuffer,
-            64,
-            [this](std::string& buffer) {
-                on_switch_table(buffer);
-            });
-    };
-
-    field_frequency.set_step(0);
-
-    check_log.set_value(logging);
-
-    check_log.on_select = [this](Checkbox&, bool v) {
-        str_log = "";
-        logging = v;
-    };
-
-    options_channel.on_change = [this](size_t, int32_t i) {
-        field_frequency.set_value(get_freq_by_channel_number(i));
-        channel_number = i;
-
-        baseband::set_btle(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_channel.set_selected_index(0, true);
-    options_sort.set_selected_index(0, true);
-
-    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_btle(channel_number);
-
-    receiver_model.enable();
-}
-
-void BLERxView::on_data(BlePacketData* packet) {
-    std::string str_console = "";
-
-    if (!logging) {
-        str_log = "";
-    }
-
-    switch ((ADV_PDU_TYPE)packet->type) {
-        case ADV_IND:
-            str_console += "ADV_IND";
-            break;
-        case ADV_DIRECT_IND:
-            str_console += "ADV_DIRECT_IND";
-            break;
-        case ADV_NONCONN_IND:
-            str_console += "ADV_NONCONN_IND";
-            break;
-        case SCAN_REQ:
-            str_console += "SCAN_REQ";
-            break;
-        case SCAN_RSP:
-            str_console += "SCAN_RSP";
-            break;
-        case CONNECT_REQ:
-            str_console += "CONNECT_REQ";
-            break;
-        case ADV_SCAN_IND:
-            str_console += "ADV_SCAN_IND";
-            break;
-        case RESERVED0:
-        case RESERVED1:
-        case RESERVED2:
-        case RESERVED3:
-        case RESERVED4:
-        case RESERVED5:
-        case RESERVED6:
-        case RESERVED7:
-        case RESERVED8:
-            str_console += "RESERVED";
-            break;
-        default:
-            str_console += "UNKNOWN";
-            break;
-    }
-
-    str_console += " Len:";
-    str_console += to_string_dec_uint(packet->size);
-
-    str_console += "\n";
-
-    str_console += "Mac:";
-    str_console += to_string_mac_address(packet->macAddress, 6);
-
-    str_console += "\n";
-    str_console += "Data:";
-
-    int i;
-
-    for (i = 0; i < packet->dataLen; i++) {
-        str_console += to_string_hex(packet->data[i], 2);
-    }
-
-    str_console += "\n";
-
-    uint64_t macAddressEncoded = copy_mac_address_to_uint64(packet->macAddress);
-
-    // Start of Packet stuffing.
-    // Masking off the top 2 bytes to avoid invalid keys.
-    auto& entry = ::on_packet(recent, macAddressEncoded & 0xFFFFFFFFFFFF);
-    updateEntry(packet, entry);
-
-    // Log at End of Packet.
-    if (logger && logging) {
-        logger->log_raw_data(str_console);
-    }
-}
-
-void BLERxView::on_switch_table(const std::string value) {
-    filter = value;
-
-    if (!value.empty()) {
-        removeEntriesWithoutKey(recent, filterEntries, [&value](const BleRecentEntry& entry) {
-            return entry.dataString.find(value) == std::string::npos;
-        });
-
-        recent_entries_view.set_dirty();
-
-        recent_entries_filter_view.hidden(false);
-        recent_entries_view.hidden(true);
-    } else {
-        recent_entries_view.hidden(false);
-        recent_entries_filter_view.hidden(true);
-    }
-
-    recent_entries_view.set_dirty();
-    recent_entries_filter_view.set_dirty();
-}
-
-void BLERxView::set_parent_rect(const Rect new_parent_rect) {
-    View::set_parent_rect(new_parent_rect);
-    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height};
-    recent_entries_view.set_parent_rect(content_rect);
-    recent_entry_detail_view.set_parent_rect(content_rect);
-    recent_entries_filter_view.set_parent_rect(content_rect);
-}
-
-BLERxView::~BLERxView() {
-    receiver_model.disable();
-    baseband::shutdown();
-}
-
-void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry) {
-    std::string data_string;
-
-    int i;
-
-    for (i = 0; i < packet->dataLen; i++) {
-        data_string += to_string_hex(packet->data[i], 2);
-    }
-
-    entry.dbValue = packet->max_dB;
-    entry.timestamp = to_string_timestamp(rtc_time::now());
-    entry.dataString = data_string;
-
-    entry.packetData.type = packet->type;
-    entry.packetData.size = packet->size;
-    entry.packetData.dataLen = packet->dataLen;
-
-    entry.packetData.macAddress[0] = packet->macAddress[0];
-    entry.packetData.macAddress[1] = packet->macAddress[1];
-    entry.packetData.macAddress[2] = packet->macAddress[2];
-    entry.packetData.macAddress[3] = packet->macAddress[3];
-    entry.packetData.macAddress[4] = packet->macAddress[4];
-    entry.packetData.macAddress[5] = packet->macAddress[5];
-
-    for (int i = 0; i < packet->dataLen; i++) {
-        entry.packetData.data[i] = packet->data[i];
-    }
-
-    // entry.update(packet);
-
-    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;
-    }
-
-    on_switch_table(filter);
-
-    // TODO: Crude hack, should be a more formal listener arrangement...
-    if (entry.key() == recent_entry_detail_view.entry().key()) {
-        recent_entry_detail_view.set_entry(entry);
-    }
-}
-
-} /* namespace ui */

firmware/application/apps/ble_rx_app.cpp

@@ -0,0 +1,589 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ble_rx_app.hpp"
+
+#include "ui_modemsetup.hpp"
+
+#include "modems.hpp"
+#include "audio.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "ui_textentry.hpp"
+
+using namespace portapack;
+using namespace modems;
+
+void BLELogger::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+std::string pad_string_with_spaces(int snakes) {
+    std::string paddedStr(snakes, ' ');
+    return paddedStr;
+}
+
+uint64_t copy_mac_address_to_uint64(const uint8_t* macAddress) {
+    uint64_t result = 0;
+
+    // Copy each byte of the MAC address to the corresponding byte in the uint64_t.
+    for (int i = 0; i < 6; ++i) {
+        result |= static_cast<uint64_t>(macAddress[i]) << ((5 - i) * 8);
+    }
+
+    return result;
+}
+
+namespace ui {
+
+std::string pdu_type_to_string(ADV_PDU_TYPE type) {
+    std::string pduTypeStr = "";
+
+    switch (type) {
+        case ADV_IND:
+            pduTypeStr += "ADV_IND";
+            break;
+        case ADV_DIRECT_IND:
+            pduTypeStr += "ADV_DIRECT_IND";
+            break;
+        case ADV_NONCONN_IND:
+            pduTypeStr += "ADV_NONCONN_IND";
+            break;
+        case SCAN_REQ:
+            pduTypeStr += "SCAN_REQ";
+            break;
+        case SCAN_RSP:
+            pduTypeStr += "SCAN_RSP";
+            break;
+        case CONNECT_REQ:
+            pduTypeStr += "CONNECT_REQ";
+            break;
+        case ADV_SCAN_IND:
+            pduTypeStr += "ADV_SCAN_IND";
+            break;
+        case RESERVED0:
+        case RESERVED1:
+        case RESERVED2:
+        case RESERVED3:
+        case RESERVED4:
+        case RESERVED5:
+        case RESERVED6:
+        case RESERVED7:
+        case RESERVED8:
+            pduTypeStr += "RESERVED";
+            break;
+        default:
+            pduTypeStr += "UNKNOWN";
+            break;
+    }
+
+    return pduTypeStr;
+}
+
+template <>
+void RecentEntriesTable<BleRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line{};
+    line.reserve(30);
+
+    if (!entry.nameString.empty() && entry.include_name) {
+        line = entry.nameString;
+
+        if (line.length() < 17) {
+            line += pad_string_with_spaces(17 - line.length());
+        } else {
+            line = truncate(line, 17);
+        }
+    } else {
+        line = to_string_mac_address(entry.packetData.macAddress, 6, false);
+    }
+
+    // Pushing single digit values down right justified.
+    std::string hitsStr = to_string_dec_int(entry.numHits);
+    int hitsDigits = hitsStr.length();
+    uint8_t hits_spacing = 8 - hitsDigits;
+
+    // Pushing single digit values down right justified.
+    std::string dbStr = to_string_dec_int(entry.dbValue);
+    int dbDigits = dbStr.length();
+    uint8_t db_spacing = 5 - dbDigits;
+
+    line += pad_string_with_spaces(hits_spacing) + hitsStr;
+
+    line += pad_string_with_spaces(db_spacing) + dbStr;
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const BleRecentEntry& entry)
+    : nav_{nav},
+      entry_{entry} {
+    add_children({&button_done,
+                  &button_send,
+                  &label_mac_address,
+                  &text_mac_address,
+                  &label_pdu_type,
+                  &text_pdu_type,
+                  &labels});
+
+    text_mac_address.set(to_string_mac_address(entry.packetData.macAddress, 6, false));
+    text_pdu_type.set(pdu_type_to_string(entry.pduType));
+
+    button_done.on_select = [&nav](const ui::Button&) {
+        nav.pop();
+    };
+
+    button_send.on_select = [this, &nav](const ui::Button&) {
+        auto packetToSend = build_packet();
+        nav.set_on_pop([packetToSend, &nav]() {
+            nav.replace<BLETxView>(packetToSend);
+        });
+        nav.pop();
+    };
+}
+
+void BleRecentEntryDetailView::update_data() {
+}
+
+void BleRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+Rect BleRecentEntryDetailView::draw_field(
+    Painter& painter,
+    const Rect& draw_rect,
+    const Style& style,
+    const std::string& label,
+    const std::string& value) {
+    const int label_length_max = 4;
+
+    painter.draw_string(Point{draw_rect.left(), draw_rect.top()}, style, label);
+    painter.draw_string(Point{draw_rect.left() + (label_length_max + 1) * 8, draw_rect.top()}, style, value);
+
+    return {draw_rect.left(), draw_rect.top() + draw_rect.height(), draw_rect.width(), draw_rect.height()};
+}
+
+void BleRecentEntryDetailView::paint(Painter& painter) {
+    View::paint(painter);
+
+    const auto s = style();
+    const auto rect = screen_rect();
+
+    auto field_rect = Rect{rect.left(), rect.top() + 64, rect.width(), 16};
+
+    uint8_t type[total_data_lines];
+    uint8_t length[total_data_lines];
+    uint8_t data[total_data_lines][40];
+
+    int currentByte = 0;
+    int currentPacket = 0;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+
+    switch (entry_.pduType) {
+        case ADV_IND:
+        case ADV_NONCONN_IND:
+        case SCAN_RSP:
+        case ADV_SCAN_IND: {
+            ADV_PDU_PAYLOAD_TYPE_0_2_4_6* advertiseData = (ADV_PDU_PAYLOAD_TYPE_0_2_4_6*)entry_.packetData.data;
+
+            for (currentByte = 0; (currentByte < entry_.packetData.dataLen) && (currentPacket < total_data_lines);) {
+                length[currentPacket] = advertiseData->Data[currentByte++];
+                type[currentPacket] = advertiseData->Data[currentByte++];
+
+                // Subtract 1 because type is part of the length.
+                for (i = 0; i < length[currentPacket] - 1; i++) {
+                    data[currentPacket][i] = advertiseData->Data[currentByte++];
+                }
+
+                currentPacket++;
+            }
+
+            for (i = 0; i < currentPacket; i++) {
+                uint8_t number_data_lines = ceil((float)(length[i] - 1) / 10.0);
+                uint8_t current_line = 0;
+                std::array<std::string, total_data_lines> data_strings{};
+
+                for (j = 0; (j < (number_data_lines * 10)) && (j < length[i] - 1); j++) {
+                    if ((j / 10) != current_line) {
+                        current_line++;
+                    }
+
+                    data_strings[current_line] += to_string_hex(data[i][j], 2);
+                }
+
+                // Read the type back to the total length.
+                field_rect = draw_field(painter, field_rect, s, to_string_hex(length[i]), to_string_hex(type[i]) + pad_string_with_spaces(3) + data_strings[0]);
+
+                if (number_data_lines > 1) {
+                    for (k = 1; k < number_data_lines; k++) {
+                        if (!data_strings[k].empty()) {
+                            field_rect = draw_field(painter, field_rect, s, "", pad_string_with_spaces(5) + data_strings[k]);
+                        }
+                    }
+                }
+            }
+        } break;
+
+        case ADV_DIRECT_IND:
+        case SCAN_REQ: {
+            ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)entry_.packetData.data;
+            uint8_t type = 0xFF;
+            field_rect = draw_field(painter, field_rect, s, to_string_hex(entry_.packetData.dataLen), to_string_hex(type) + pad_string_with_spaces(3) + to_string_mac_address(directed_mac_data->A1, 6, false));
+        } break;
+
+        case CONNECT_REQ:
+        default: {
+            uint8_t type = 0xFF;
+
+            // TODO: Display Connect Request Information. For right now just printing full hex data.
+            // This struct will eventually be used to break apart containing data of Connect Request.
+            // ADV_PDU_PAYLOAD_TYPE_5 * connect_req = (ADV_PDU_PAYLOAD_TYPE_5 *)entry_.packetData.data;
+
+            for (currentByte = 0; (currentByte < entry_.packetData.dataLen); currentByte++) {
+                data[0][currentByte] = entry_.packetData.data[currentByte];
+            }
+
+            uint8_t number_data_lines = ceil((float)entry_.packetData.dataLen / 10.0);
+            uint8_t current_line = 0;
+            std::array<std::string, total_data_lines> data_strings{};
+
+            for (j = 0; (j < (number_data_lines * 10)) && (j < entry_.packetData.dataLen); j++) {
+                if ((j / 10) != current_line) {
+                    current_line++;
+                }
+
+                data_strings[current_line] += to_string_hex(data[0][j], 2);
+            }
+
+            field_rect = draw_field(painter, field_rect, s, to_string_hex(entry_.packetData.dataLen), to_string_hex(type) + pad_string_with_spaces(3) + data_strings[0]);
+
+            if (number_data_lines > 1) {
+                for (k = 1; k < number_data_lines; k++) {
+                    if (!data_strings[k].empty()) {
+                        field_rect = draw_field(painter, field_rect, s, "", pad_string_with_spaces(5) + data_strings[k]);
+                    }
+                }
+            }
+        } break;
+    }
+}
+
+void BleRecentEntryDetailView::set_entry(const BleRecentEntry& entry) {
+    entry_ = entry;
+    set_dirty();
+}
+
+BLETxPacket BleRecentEntryDetailView::build_packet() {
+    BLETxPacket bleTxPacket;
+    memset(&bleTxPacket, 0, sizeof(BLETxPacket));
+
+    std::string macAddressStr = to_string_mac_address(entry_.packetData.macAddress, 6, true);
+
+    strncpy(bleTxPacket.macAddress, macAddressStr.c_str(), 12);
+    strncpy(bleTxPacket.advertisementData, entry_.dataString.c_str(), entry_.packetData.dataLen * 2);
+    strncpy(bleTxPacket.packetCount, "50", 3);
+    bleTxPacket.packet_count = 50;
+
+    return bleTxPacket;
+}
+
+static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
+    uint64_t freq_hz;
+
+    switch (channel_number) {
+        case 37:
+            freq_hz = 2'402'000'000ull;
+            break;
+        case 38:
+            freq_hz = 2'426'000'000ull;
+            break;
+        case 39:
+            freq_hz = 2'480'000'000ull;
+            break;
+        case 0 ... 10:
+            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
+            break;
+        case 11 ... 36:
+            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
+            break;
+        default:
+            freq_hz = UINT64_MAX;
+    }
+
+    return freq_hz;
+}
+
+void BLERxView::focus() {
+    options_channel.focus();
+}
+
+BLERxView::BLERxView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_btle_rx);
+
+    add_children({&rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &options_channel,
+                  &field_frequency,
+                  &check_log,
+                  &check_name,
+                  &label_sort,
+                  &options_sort,
+                  &button_filter,
+                  &button_switch,
+                  &recent_entries_view});
+
+    recent_entries_view.on_select = [this](const BleRecentEntry& entry) {
+        nav_.push<BleRecentEntryDetailView>(entry);
+    };
+
+    button_filter.on_select = [this](Button&) {
+        text_prompt(
+            nav_,
+            filterBuffer,
+            64,
+            [this](std::string& buffer) {
+                on_filter_change(buffer);
+            });
+    };
+
+    button_switch.on_select = [&nav](Button&) {
+        nav.replace<BLETxView>();
+    };
+
+    field_frequency.set_step(0);
+
+    check_log.set_value(logging);
+
+    check_log.on_select = [this](Checkbox&, bool v) {
+        str_log = "";
+        logging = v;
+
+        if (logger && logging)
+            logger->append(LOG_ROOT_DIR "/BLELOG_" + to_string_timestamp(rtc_time::now()) + ".TXT");
+    };
+
+    check_name.set_value(true);
+
+    check_name.on_select = [this](Checkbox&, bool v) {
+        setAllMembersToValue(recent, &BleRecentEntry::include_name, v);
+        recent_entries_view.set_dirty();
+    };
+
+    options_channel.on_change = [this](size_t, int32_t i) {
+        field_frequency.set_value(get_freq_by_channel_number(i));
+        channel_number = i;
+
+        baseband::set_btlerx(channel_number);
+    };
+
+    options_sort.on_change = [this](size_t, int32_t index) {
+        handle_entries_sort(index);
+    };
+
+    options_channel.set_selected_index(0, true);
+    options_sort.set_selected_index(0, true);
+
+    logger = std::make_unique<BLELogger>();
+
+    // Auto-configure modem for LCR RX (will be removed later)
+    baseband::set_btlerx(channel_number);
+
+    receiver_model.enable();
+}
+
+void BLERxView::on_data(BlePacketData* packet) {
+    std::string str_console = "";
+
+    if (!logging) {
+        str_log = "";
+    }
+
+    str_console += pdu_type_to_string((ADV_PDU_TYPE)packet->type);
+
+    str_console += " Len:";
+    str_console += to_string_dec_uint(packet->size);
+
+    str_console += "\n";
+
+    str_console += "Mac:";
+    str_console += to_string_mac_address(packet->macAddress, 6, false);
+
+    str_console += "\n";
+    str_console += "Data:";
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        str_console += to_string_hex(packet->data[i], 2);
+    }
+
+    str_console += "\n";
+
+    uint64_t macAddressEncoded = copy_mac_address_to_uint64(packet->macAddress);
+
+    // Start of Packet stuffing.
+    // Masking off the top 2 bytes to avoid invalid keys.
+    auto& entry = ::on_packet(recent, macAddressEncoded & 0xFFFFFFFFFFFF);
+    updateEntry(packet, entry, (ADV_PDU_TYPE)packet->type);
+
+    // Add entries if they meet the criteria.
+    auto value = filter;
+    resetFilteredEntries(recent, [&value](const BleRecentEntry& entry) {
+        return (entry.dataString.find(value) == std::string::npos) && (entry.nameString.find(value) == std::string::npos);
+    });
+
+    handle_entries_sort(options_sort.selected_index());
+
+    // Log at End of Packet.
+    if (logger && logging) {
+        logger->log_raw_data(str_console);
+    }
+}
+
+void BLERxView::on_filter_change(std::string value) {
+    // New filter? Reset list from recent entries.
+    if (filter != value) {
+        resetFilteredEntries(recent, [&value](const BleRecentEntry& entry) {
+            return (entry.dataString.find(value) == std::string::npos) && (entry.nameString.find(value) == std::string::npos);
+        });
+    }
+
+    filter = value;
+}
+
+void BLERxView::handle_entries_sort(uint8_t index) {
+    switch (index) {
+        case 0:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
+            break;
+        case 1:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.numHits; }, false);
+            break;
+        case 2:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.dbValue; }, false);
+            break;
+        case 3:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.timestamp; }, false);
+            break;
+        case 4:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.nameString; }, true);
+            break;
+        default:
+            break;
+    }
+
+    recent_entries_view.set_dirty();
+}
+
+void BLERxView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
+    recent_entries_view.set_parent_rect(content_rect);
+}
+
+BLERxView::~BLERxView() {
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type) {
+    std::string data_string;
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        data_string += to_string_hex(packet->data[i], 2);
+    }
+
+    entry.dbValue = packet->max_dB;
+    entry.timestamp = to_string_timestamp(rtc_time::now());
+    entry.dataString = data_string;
+
+    entry.packetData.type = packet->type;
+    entry.packetData.size = packet->size;
+    entry.packetData.dataLen = packet->dataLen;
+
+    // Mac Address of sender.
+    entry.packetData.macAddress[0] = packet->macAddress[0];
+    entry.packetData.macAddress[1] = packet->macAddress[1];
+    entry.packetData.macAddress[2] = packet->macAddress[2];
+    entry.packetData.macAddress[3] = packet->macAddress[3];
+    entry.packetData.macAddress[4] = packet->macAddress[4];
+    entry.packetData.macAddress[5] = packet->macAddress[5];
+
+    entry.numHits++;
+    entry.pduType = pdu_type;
+
+    // Parse Data Section into buffer to be interpretted later.
+    for (int i = 0; i < packet->dataLen; i++) {
+        entry.packetData.data[i] = packet->data[i];
+    }
+
+    entry.include_name = check_name.value();
+
+    // Only parse name for advertisment packets and empty name entries
+    if ((pdu_type == ADV_IND || pdu_type == ADV_NONCONN_IND || pdu_type == SCAN_RSP || pdu_type == ADV_SCAN_IND) && entry.nameString.empty()) {
+        ADV_PDU_PAYLOAD_TYPE_0_2_4_6* advertiseData = (ADV_PDU_PAYLOAD_TYPE_0_2_4_6*)entry.packetData.data;
+
+        uint8_t currentByte = 0;
+        uint8_t length = 0;
+        uint8_t type = 0;
+
+        std::string decoded_data;
+        for (currentByte = 0; (currentByte < entry.packetData.dataLen);) {
+            length = advertiseData->Data[currentByte++];
+            type = advertiseData->Data[currentByte++];
+
+            // Subtract 1 because type is part of the length.
+            for (int i = 0; i < length - 1; i++) {
+                if (type == 0x08 || type == 0x09) {
+                    decoded_data += (char)advertiseData->Data[currentByte];
+                }
+                currentByte++;
+            }
+            if (!decoded_data.empty()) {
+                entry.nameString = std::move(decoded_data);
+                break;
+            }
+        }
+    }
+}
+
+} /* namespace ui */

firmware/application/apps/ble_rx_app.hpp

@@ -21,8 +21,10 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef __BLE_APP_H__
-#define __BLE_APP_H__
+#ifndef __BLE_RX_APP_H__
+#define __BLE_RX_APP_H__
+
+#include "ble_tx_app.hpp"
 
 #include "ui.hpp"
 #include "ui_navigation.hpp"
@@ -78,6 +80,10 @@ struct BleRecentEntry {
     BlePacketData packetData;
     std::string timestamp;
     std::string dataString;
+    std::string nameString;
+    bool include_name;
+    uint16_t numHits;
+    ADV_PDU_TYPE pduType;
 
     BleRecentEntry()
         : BleRecentEntry{0} {
@@ -89,7 +95,11 @@ struct BleRecentEntry {
           dbValue{},
           packetData{},
           timestamp{},
-          dataString{} {
+          dataString{},
+          nameString{},
+          include_name{},
+          numHits{},
+          pduType{} {
     }
 
     Key key() const {
@@ -114,15 +124,34 @@ class BleRecentEntryDetailView : public View {
    private:
     NavigationView& nav_;
     BleRecentEntry entry_{};
+    BLETxPacket build_packet();
 
     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"};
@@ -151,8 +180,9 @@ class BLERxView : public View {
 
    private:
     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_{
@@ -170,7 +200,8 @@ class BLERxView : public View {
     std::string filterBuffer{};
     std::string filter{};
 
-    static constexpr auto header_height = 12 + 2 * 16;
+    static constexpr auto header_height = 3 * 16;
+    static constexpr auto switch_button_height = 3 * 16;
 
     OptionsField options_channel{
         {0 * 8, 0 * 8},
@@ -198,51 +229,56 @@ 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_switch{
+        {8 * 8, 16 * 16, 14 * 8, 2 * 16},
+        "Switch to 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{};
 
     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,

firmware/application/apps/ble_tx_app.cpp

@@ -22,6 +22,7 @@
  */
 
 #include "ble_tx_app.hpp"
+#include "ble_rx_app.hpp"
 
 #include "ui_fileman.hpp"
 #include "ui_modemsetup.hpp"
@@ -90,15 +91,10 @@ uint32_t stringToUint32(const std::string& str) {
         pos++;
     }
 
-    // Check if there are any non-digit characters left
-    if (pos < str.size()) {
-        return 0;
-    }
-
     return result;
 }
 
-void readUntilSpace(File& file, char* result, std::size_t maxBufferSize) {
+void readUntil(File& file, char* result, std::size_t maxBufferSize, char delimiter) {
     std::size_t bytesRead = 0;
 
     while (true) {
@@ -106,7 +102,7 @@ void readUntilSpace(File& file, char* result, std::size_t maxBufferSize) {
         File::Result<File::Size> readResult = file.read(&ch, 1);
 
         if (readResult.is_ok() && readResult.value() > 0) {
-            if (ch == ' ') {
+            if (ch == delimiter) {
                 // Found a space character, stop reading
                 break;
             } else if (bytesRead < maxBufferSize) {
@@ -125,6 +121,17 @@ void readUntilSpace(File& file, char* result, std::size_t maxBufferSize) {
     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;
 
@@ -154,7 +161,7 @@ static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
 namespace ui {
 
 void BLETxView::focus() {
-    field_frequency.focus();
+    button_open.focus();
 }
 
 bool BLETxView::is_active() const {
@@ -165,6 +172,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();
@@ -174,27 +205,32 @@ void BLETxView::toggle() {
 }
 
 void BLETxView::start() {
+    // Generate new random Mac Address.
+    generateRandomMacAddress(randomMac);
+
     if (!is_active()) {
         // Check if file is present before continuing.
         File data_file;
 
         auto error = data_file.open(file_path);
-        if (error) {
+        if (error && !file_override) {
             file_error();
             check_loop.set_value(false);
             return;
         } else {
             // Send first or single packet.
-            progressbar.set_max(packet_count);
+            progressbar.set_max(packets[0].packet_count);
             button_play.set_bitmap(&bitmap_stop);
-            baseband::set_btletx(channel_number, macAddress, advertisementData, pduType);
+
+            baseband::set_btletx(channel_number, random_mac ? randomMac : packets[0].macAddress, packets[0].advertisementData, pduType);
             transmitter_model.enable();
 
             is_running = true;
         }
     } else {
         // Send next packet.
-        baseband::set_btletx(channel_number, macAddress, advertisementData, pduType);
+        progressbar.set_max(packets[current_packet].packet_count);
+        baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
     }
 
     if ((packet_counter % 10) == 0) {
@@ -202,8 +238,7 @@ void BLETxView::start() {
     }
 
     packet_counter--;
-
-    progressbar.set_value(packet_count - packet_counter);
+    progressbar.set_value(packets[current_packet].packet_count - packet_counter);
 }
 
 void BLETxView::stop() {
@@ -211,24 +246,37 @@ void BLETxView::stop() {
     progressbar.set_value(0);
     button_play.set_bitmap(&bitmap_play);
     check_loop.set_value(false);
-    text_packets_sent.set(to_string_dec_uint(packet_count));
-    packet_counter = packet_count;
+
+    update_current_packet(packets[0], 0);
+
     is_running = false;
 }
 
 void BLETxView::on_tx_progress(const bool done) {
     if (done) {
-        if (check_loop.value() && (packet_counter != 0) && is_active()) {
-            if ((timer_count % timer_period) == 0) {
-                start();
+        if (is_active()) {
+            // Reached end of current packet repeats.
+            if (packet_counter == 0) {
+                // Done sending all packets.
+                if (current_packet == (num_packets - 1)) {
+                    // If looping, restart from beginning.
+                    if (check_loop.value()) {
+                        update_current_packet(packets[current_packet], 0);
+                    } else {
+                        stop();
+                    }
+                } else {
+                    current_packet++;
+                    update_current_packet(packets[current_packet], current_packet);
+                }
+            } else {
+                if ((timer_count % timer_period) == 0) {
+                    start();
+                }
             }
-        } else {
-            if (is_active()) {
-                stop();
-            }
-        }
 
-        timer_count++;
+            timer_count++;
+        }
     }
 }
 
@@ -239,6 +287,7 @@ BLETxView::BLETxView(NavigationView& nav)
     add_children({&button_open,
                   &text_filename,
                   &progressbar,
+                  &check_rand_mac,
                   &field_frequency,
                   &tx_view,  // now it handles previous rfgain, rfamp.
                   &check_loop,
@@ -247,15 +296,21 @@ BLETxView::BLETxView(NavigationView& nav)
                   &options_speed,
                   &options_channel,
                   &options_adv_type,
+                  &label_packet_index,
+                  &text_packet_index,
                   &label_packets_sent,
                   &text_packets_sent,
                   &label_mac_address,
                   &text_mac_address,
                   &label_data_packet,
+                  &button_save_packet,
+                  &button_switch,
                   &console});
 
     field_frequency.set_step(0);
 
+    ensure_directory(packet_save_path);
+
     button_play.on_select = [this](ImageButton&) {
         this->toggle();
     };
@@ -274,17 +329,54 @@ BLETxView::BLETxView(NavigationView& nav)
     };
 
     options_speed.set_selected_index(0);
+    options_channel.set_selected_index(0);
+    options_adv_type.set_selected_index(0);
 
-    button_open.on_select = [this, &nav](Button&) {
-        auto open_view = nav.push<FileLoadView>(".TXT");
+    check_rand_mac.set_value(false);
+    check_rand_mac.on_select = [this](Checkbox&, bool v) {
+        random_mac = v;
+    };
+
+    button_open.on_select = [this](Button&) {
+        auto open_view = nav_.push<FileLoadView>(".TXT");
         open_view->on_changed = [this](std::filesystem::path new_file_path) {
             on_file_changed(new_file_path);
+
+            nav_.set_on_pop([this]() { button_play.focus(); });
         };
     };
+
+    button_save_packet.on_select = [this, &nav](Button&) {
+        packetFileBuffer = "";
+        text_prompt(
+            nav,
+            packetFileBuffer,
+            64,
+            [this](std::string& buffer) {
+                on_save_file(buffer);
+            });
+    };
+
+    button_switch.on_select = [&nav](Button&) {
+        nav.replace<BLERxView>();
+    };
+}
+
+BLETxView::BLETxView(
+    NavigationView& nav,
+    BLETxPacket packet)
+    : BLETxView(nav) {
+    packets[0] = packet;
+
+    update_current_packet(packets[0], 0);
+
+    num_packets = 1;
+    file_override = true;
 }
 
 void BLETxView::on_file_changed(const fs::path& new_file_path) {
     file_path = fs::path(u"/") + new_file_path;
+    num_packets = 0;
 
     {  // Get the size of the data file.
         File data_file;
@@ -295,43 +387,48 @@ void BLETxView::on_file_changed(const fs::path& new_file_path) {
             return;
         }
 
-        readUntilSpace(data_file, macAddress, mac_address_size_str);
-        readUntilSpace(data_file, advertisementData, max_packet_size_str);
-        readUntilSpace(data_file, packetCount, max_packet_count_str);
+        do {
+            readUntil(data_file, packets[num_packets].macAddress, mac_address_size_str, ' ');
+            readUntil(data_file, packets[num_packets].advertisementData, max_packet_size_str, ' ');
+            readUntil(data_file, packets[num_packets].packetCount, max_packet_repeat_str, '\n');
 
-        uint64_t macAddressSize = strlen(macAddress);
-        uint64_t advertisementDataSize = strlen(advertisementData);
-        uint64_t packetCountSize = strlen(packetCount);
+            uint64_t macAddressSize = strlen(packets[num_packets].macAddress);
+            uint64_t advertisementDataSize = strlen(packets[num_packets].advertisementData);
+            uint64_t packetCountSize = strlen(packets[num_packets].packetCount);
 
-        packet_count = stringToUint32(packetCount);
-        packet_counter = packet_count;
+            packets[num_packets].packet_count = stringToUint32(packets[num_packets].packetCount);
 
-        // Verify Data.
-        if ((macAddressSize == mac_address_size_str) && (advertisementDataSize < max_packet_size_str) && (packetCountSize < max_packet_count_str) &&
-            hasValidHexPairs(macAddress, macAddressSize / 2) && hasValidHexPairs(advertisementData, advertisementDataSize / 2) && (packet_count > 0) && (packet_count < UINT32_MAX)) {
-            text_packets_sent.set(to_string_dec_uint(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 >= 50) && (packets[num_packets].packet_count < max_packet_repeat_count)) {
+                text_filename.set(truncate(file_path.filename().string(), 12));
 
-            std::string formattedMacAddress = to_string_formatted_mac_address(macAddress);
+            } else {
+                // Did not find any packets.
+                if (num_packets == 0) {
+                    file_path = "";
+                    return;
+                }
 
-            text_mac_address.set(formattedMacAddress);
-
-            std::vector<std::string> strings = splitIntoStrings(advertisementData);
-
-            console.clear(true);
-
-            for (const std::string& str : strings) {
-                console.writeln(str);
+                break;
             }
 
-            text_filename.set(truncate(file_path.filename().string(), 12));
-        } else {
-            // file_error();
-            file_path = "";
-            return;
-        }
+            num_packets++;
+
+        } while (num_packets < max_num_packets);
+
+        update_current_packet(packets[0], 0);
     }
 }
 
+void BLETxView::on_save_file(const std::string value) {
+    auto folder = packet_save_path.parent_path();
+    auto ext = packet_save_path.extension();
+    auto new_path = folder / value + ext;
+
+    saveFile(new_path);
+}
+
 void BLETxView::on_data(uint32_t value, bool is_data) {
     std::string str_console = "";
 
@@ -342,9 +439,30 @@ void BLETxView::on_data(uint32_t value, bool is_data) {
     console.write(str_console);
 }
 
+void BLETxView::update_current_packet(BLETxPacket packet, uint32_t currentIndex) {
+    std::string formattedMacAddress = to_string_formatted_mac_address(packet.macAddress);
+
+    std::vector<std::string> strings = splitIntoStrings(packet.advertisementData);
+
+    text_packet_index.set(to_string_dec_uint(current_packet));
+
+    text_packets_sent.set(to_string_dec_uint(packet.packet_count));
+
+    text_mac_address.set(formattedMacAddress);
+
+    console.clear(true);
+
+    for (const std::string& str : strings) {
+        console.writeln(str);
+    }
+
+    packet_counter = packet.packet_count;
+    current_packet = currentIndex;
+}
+
 void BLETxView::set_parent_rect(const Rect new_parent_rect) {
     View::set_parent_rect(new_parent_rect);
-    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
     console.set_parent_rect(content_rect);
 }
 

firmware/application/apps/ble_tx_app.hpp

@@ -55,9 +55,17 @@ class BLELoggerTx {
 
 namespace ui {
 
+struct BLETxPacket {
+    char macAddress[13];
+    char advertisementData[63];
+    char packetCount[11];
+    uint32_t packet_count;
+};
+
 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,13 +79,16 @@ 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"; };
 
    private:
     void on_data(uint32_t value, bool is_data);
-    void on_tx_progress(const bool done);
     void on_file_changed(const std::filesystem::path& new_file_path);
+    void 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_{
@@ -92,17 +103,20 @@ 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;
-    char macAddress[13] = "010203040506";
-    char advertisementData[63] = "00112233445566778899AABBCCDDEEFF";
-    char packetCount[11] = "0";
+
+    char randomMac[13] = "010203040506";
 
     bool is_running = false;
     uint64_t timer_count{0};
     uint64_t timer_period{256};
     bool repeatLoop = false;
-    uint32_t packet_count{0};
     uint32_t packet_counter{0};
+    uint32_t num_packets{0};
+    uint32_t current_packet{0};
+    bool random_mac = false;
+    bool file_override = false;
 
     enum PKT_TYPE {
         INVALID_TYPE,
@@ -136,12 +150,16 @@ class BLETxView : public View {
 
     static constexpr uint8_t mac_address_size_str{12};
     static constexpr uint8_t max_packet_size_str{62};
-    static constexpr uint8_t max_packet_count_str{10};
-    static constexpr uint32_t max_packet_count{UINT32_MAX};
+    static constexpr uint8_t max_packet_repeat_str{10};
+    static constexpr uint32_t max_packet_repeat_count{UINT32_MAX};
+    static constexpr uint32_t max_num_packets{32};
 
-    PKT_TYPE pduType = {RAW};
+    BLETxPacket packets[max_num_packets];
 
-    static constexpr auto header_height = 8 * 16;
+    PKT_TYPE pduType = {DISCOVERY};
+
+    static constexpr auto header_height = 9 * 16;
+    static constexpr auto switch_button_height = 3 * 16;
 
     Button button_open{
         {0 * 8, 0 * 16, 10 * 8, 2 * 16},
@@ -152,7 +170,13 @@ class BLETxView : public View {
         "-"};
 
     ProgressBar progressbar{
-        {11 * 8, 1 * 16, 12 * 8, 16}};
+        {11 * 8, 1 * 16, 9 * 8, 16}};
+
+    Checkbox check_rand_mac{
+        {21 * 8, 1 * 16},
+        6,
+        "Random",
+        true};
 
     TxFrequencyField field_frequency{
         {0 * 8, 2 * 16},
@@ -200,33 +224,50 @@ class BLETxView : public View {
          {"ADV_IND", ADV_IND},
          {"ADV_DIRECT", ADV_DIRECT_IND},
          {"ADV_NONCONN", ADV_NONCONN_IND},
+         {"ADV_SCAN_IND", ADV_SCAN_IND},
          {"SCAN_REQ", SCAN_REQ},
          {"SCAN_RSP", SCAN_RSP},
          {"CONNECT_REQ", CONNECT_REQ}}};
 
+    Labels label_packet_index{
+        {{0 * 8, 10 * 8}, "Packet Index:", Color::light_grey()}};
+
+    Text text_packet_index{
+        {13 * 8, 5 * 16, 12 * 8, 16},
+        "-"};
+
     Labels label_packets_sent{
-        {{0 * 8, 10 * 8}, "Packets Left:", Color::light_grey()}};
+        {{0 * 8, 12 * 8}, "Packets Left:", Color::light_grey()}};
 
     Text text_packets_sent{
-        {13 * 8, 5 * 16, 10 * 8, 16},
+        {13 * 8, 6 * 16, 12 * 8, 16},
         "-"};
 
     Labels label_mac_address{
-        {{0 * 8, 12 * 8}, "Mac Address:", Color::light_grey()}};
+        {{0 * 8, 14 * 8}, "Mac Address:", Color::light_grey()}};
 
     Text text_mac_address{
-        {12 * 8, 6 * 16, 20 * 8, 16},
+        {12 * 8, 7 * 16, 20 * 8, 16},
         "-"};
 
     Labels label_data_packet{
-        {{0 * 8, 14 * 8}, "Packet Data:", Color::light_grey()}};
+        {{0 * 8, 16 * 8}, "Packet Data:", Color::light_grey()}};
 
     Console console{
-        {0, 7 * 16, 240, 240}};
+        {0, 8 * 16, 240, 240}};
+
+    Button button_save_packet{
+        {1 * 8, 16 * 16, 13 * 8, 2 * 16},
+        "Save Packet"};
+
+    Button button_switch{
+        {16 * 8, 16 * 16, 13 * 8, 2 * 16},
+        "Switch to Rx"};
 
     std::string str_log{""};
     bool logging{true};
     bool logging_done{false};
+    std::string packetFileBuffer{};
 
     std::unique_ptr<BLELoggerTx> logger{};
 

firmware/application/apps/ui_adsb_rx.cpp

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

firmware/application/apps/ui_adsb_rx.hpp

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

firmware/application/apps/ui_btle_rx.cpp

@@ -70,7 +70,7 @@ BTLERxView::BTLERxView(NavigationView& nav)
     };
 
     // Auto-configure modem for LCR RX (will be removed later)
-    baseband::set_btle(channel_number);
+    baseband::set_btlerx(channel_number);
 
     audio::set_rate(audio::Rate::Hz_24000);
     audio::output::start();

firmware/application/apps/ui_debug.cpp

@@ -124,8 +124,8 @@ void TemperatureWidget::paint(Painter& painter) {
 }
 
 TemperatureWidget::temperature_t TemperatureWidget::temperature(const sample_t sensor_value) const {
-    /*It seems to be a temperature difference of 25C*/
-    return -40 + (sensor_value * 4.31) + 25;  // max2837 datasheet temp 25ºC has sensor value: 15
+    // Scaling is different for MAX2837 vs MAX2839 so it's now done in the respective chip-specific module
+    return sensor_value;
 }
 
 std::string TemperatureWidget::temperature_str(const temperature_t temperature) const {

firmware/application/apps/ui_fileman.cpp

@@ -156,7 +156,7 @@ void FileManBaseView::load_directory_contents(const fs::path& dir_path) {
 
     for (const auto& entry : fs::directory_iterator(dir_path, u"*")) {
         // Hide files starting with '.' (hidden / tmp).
-        if (is_hidden_file(entry.path()))
+        if (!show_hidden_files && is_hidden_file(entry.path()))
             continue;
 
         if (fs::is_regular_file(entry.status())) {
@@ -568,6 +568,7 @@ FileManagerView::FileManagerView(
         &button_open_notepad,
         &button_rename_timestamp,
         &button_open_iq_trim,
+        &button_show_hidden_files,
     });
 
     menu_view.on_highlight = [this]() {
@@ -658,6 +659,12 @@ FileManagerView::FileManagerView(
         } else
             nav_.display_modal("IQ Trim", "Not a capture file.");
     };
+
+    button_show_hidden_files.on_select = [this]() {
+        show_hidden_files = !show_hidden_files;
+        button_show_hidden_files.set_color(show_hidden_files ? Color::green() : Color::dark_grey());
+        reload_current();
+    };
 }
 
 }  // namespace ui

firmware/application/apps/ui_fileman.hpp

@@ -104,6 +104,8 @@ class FileManBaseView : public View {
     std::vector<fileman_entry> entry_list{};
     std::vector<uint32_t> saved_index_stack{};
 
+    bool show_hidden_files{false};
+
     Labels labels{
         {{0, 0}, "Path:", Color::light_grey()}};
 
@@ -278,6 +280,12 @@ class FileManagerView : public FileManBaseView {
         {},
         &bitmap_icon_trim,
         Color::orange()};
+
+    NewButton button_show_hidden_files{
+        {13 * 8, 34 * 8, 4 * 8, 32},
+        {},
+        &bitmap_icon_hide,
+        Color::dark_grey()};
 };
 
 } /* namespace ui */

firmware/application/apps/ui_level.cpp

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

firmware/application/apps/ui_recon.cpp

@@ -481,10 +481,9 @@ ReconView::ReconView(NavigationView& nav)
 
     button_remove.on_select = [this](ButtonWithEncoder&) {
         handle_remove_current_item();
-
-        // TODO: refresh UI.
         timer = 0;
         freq_lock = 0;
+        recon_redraw();
     };
 
     button_remove.on_change = [this]() {
@@ -567,7 +566,7 @@ ReconView::ReconView(NavigationView& nav)
     };
 
     button_restart.on_select = [this](Button&) {
-        frequency_file_load(true);
+        frequency_file_load();
         if (frequency_list.size() > 0) {
             if (fwd) {
                 button_dir.set_text("FW>");
@@ -614,7 +613,7 @@ ReconView::ReconView(NavigationView& nav)
             button_scanner_mode.set_text("SCAN");
             button_remove.set_text("DELETE");
         }
-        frequency_file_load(true);
+        frequency_file_load();
         if (autostart) {
             recon_resume();
         } else {
@@ -642,7 +641,7 @@ ReconView::ReconView(NavigationView& nav)
             load_persisted_settings();
             ui_settings.save();
 
-            frequency_file_load(false);
+            frequency_file_load();
             freqlist_cleared_for_ui_action = false;
 
             if (autostart) {
@@ -709,7 +708,7 @@ ReconView::ReconView(NavigationView& nav)
         delete_file(freq_file_path);
     }
 
-    frequency_file_load(false); /* do not stop all at start */
+    frequency_file_load(); /* do not stop all at start */
     if (autostart) {
         recon_resume();
     } else {
@@ -718,7 +717,7 @@ ReconView::ReconView(NavigationView& nav)
     recon_redraw();
 }
 
-void ReconView::frequency_file_load(bool) {
+void ReconView::frequency_file_load() {
     if (field_mode.selected_index_value() != SPEC_MODULATION)
         audio::output::stop();
 
@@ -784,7 +783,7 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
     // hack to reload the list if it was cleared by going into CONFIG
     if (freqlist_cleared_for_ui_action) {
         if (!manual_mode) {
-            frequency_file_load(false);
+            frequency_file_load();
         }
         if (autostart && !user_pause) {
             recon_resume();
@@ -1214,11 +1213,12 @@ void ReconView::handle_remove_current_item() {
     if (frequency_list.size() > 0) {
         current_index = clip<int32_t>(current_index, 0u, frequency_list.size() - 1);
         text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
+        entry = current_entry();
+        freq = entry.frequency_a;
     } else {
         current_index = 0;
         text_cycle.set_text(" ");
     }
-
     update_description();
 }
 

firmware/application/apps/ui_recon.hpp

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

firmware/application/baseband_api.cpp

@@ -149,7 +149,7 @@ void set_aprs(const uint32_t baudrate) {
     send_message(&message);
 }
 
-void set_btle(uint8_t channel_number) {
+void set_btlerx(uint8_t channel_number) {
     const BTLERxConfigureMessage message{
         channel_number};
     send_message(&message);
@@ -278,8 +278,7 @@ void set_pocsag() {
 }
 
 void set_adsb() {
-    const ADSBConfigureMessage message{
-        1};
+    const ADSBConfigureMessage message{};
     send_message(&message);
 }
 

firmware/application/baseband_api.hpp

@@ -72,7 +72,7 @@ void set_afsk(const uint32_t baudrate, const uint32_t word_length, const uint32_
 void set_fsk(const size_t deviation);
 void set_aprs(const uint32_t baudrate);
 
-void set_btle(uint8_t channel_number);
+void set_btlerx(uint8_t channel_number);
 void set_btletx(uint8_t channel_number, char* macAddress, char* advertisementData, uint8_t pduType);
 
 void set_nrf(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word);

firmware/application/bitmap.hpp

@@ -5683,6 +5683,44 @@ static constexpr Bitmap bitmap_icon_trim{
     {16, 16},
     bitmap_icon_trim_data};
 
+static constexpr uint8_t bitmap_icon_hide_data[] = {
+    0x00,
+    0x00,
+    0x00,
+    0x40,
+    0x00,
+    0x20,
+    0xE0,
+    0x17,
+    0x18,
+    0x18,
+    0xC4,
+    0x27,
+    0x62,
+    0x42,
+    0x21,
+    0x85,
+    0xA1,
+    0x84,
+    0x62,
+    0x46,
+    0xA4,
+    0x23,
+    0x18,
+    0x18,
+    0xE8,
+    0x07,
+    0x04,
+    0x00,
+    0x02,
+    0x00,
+    0x00,
+    0x00,
+};
+static constexpr Bitmap bitmap_icon_hide{
+    {16, 16},
+    bitmap_icon_hide_data};
+
 } /* namespace ui */
 
 #endif /*__BITMAP_HPP__*/

firmware/application/de_bruijn.hpp

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

firmware/application/hw/max2837.cpp

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

firmware/application/hw/max2837.hpp

@@ -833,7 +833,7 @@ 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;
 

firmware/application/hw/max2839.cpp

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

firmware/application/hw/max2839.hpp

@@ -692,7 +692,7 @@ 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;
 

firmware/application/hw/max283x.hpp

@@ -131,7 +131,7 @@ 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);
 };

firmware/application/protocols/aprs.cpp

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

firmware/application/radio.cpp

@@ -295,8 +295,8 @@ 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;
+int8_t temp_sense() {
+    return radio::second_if->temp_sense();
 }
 
 } /* namespace second_if */

firmware/application/radio.hpp

@@ -73,7 +73,7 @@ namespace second_if {
 uint32_t register_read(const size_t register_number);
 
 // TODO: This belongs somewhere else.
-uint8_t temp_sense();
+int8_t temp_sense();
 
 } /* namespace second_if */
 

firmware/application/recent_entries.hpp

@@ -24,13 +24,13 @@
 
 #include "ui_widget.hpp"
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <list>
-#include <utility>
 #include <functional>
 #include <iterator>
-#include <algorithm>
+#include <list>
+#include <utility>
 
 template <class Entry>
 using RecentEntries = std::list<Entry>;
@@ -42,6 +42,13 @@ typename ContainerType::const_iterator find(const ContainerType& entries, const
         [key](typename ContainerType::const_reference e) { return e.key() == key; });
 }
 
+template <typename ContainerType, typename Key>
+typename ContainerType::iterator find(ContainerType& entries, const Key key) {
+    return std::find_if(
+        std::begin(entries), std::end(entries),
+        [key](typename ContainerType::const_reference e) { return e.key() == key; });
+}
+
 template <typename ContainerType>
 static void truncate_entries(ContainerType& entries, const size_t entries_max = 64) {
     while (entries.size() > entries_max) {
@@ -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>;

firmware/application/string_format.cpp

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

firmware/application/string_format.hpp

@@ -77,7 +77,7 @@ 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);
 
 /* Scales 'n' to be a value less than 1000. 'base_unit' is the index of the unit from

firmware/application/temperature_logger.hpp

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

firmware/application/ui/ui_rssi.cpp

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

firmware/application/ui/ui_rssi.hpp

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

firmware/application/ui_navigation.cpp

@@ -86,7 +86,7 @@
 #include "ais_app.hpp"
 #include "analog_audio_app.hpp"
 #include "analog_tv_app.hpp"
-#include "ble_app.hpp"
+#include "ble_rx_app.hpp"
 #include "ble_tx_app.hpp"
 #include "capture_app.hpp"
 #include "ert_app.hpp"
@@ -551,7 +551,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", Color::yellow(), &bitmap_icon_btle, [&nav]() { nav.push<BLERxView>(); }},
+        {"BLE Rx", Color::green(), &bitmap_icon_btle, [&nav]() { nav.push<BLERxView>(); }},
         {"ERT Meter", Color::green(), &bitmap_icon_ert, [&nav]() { nav.push<ERTAppView>(); }},
         {"Level", Color::green(), &bitmap_icon_options_radio, [&nav]() { nav.push<LevelView>(); }},
         {"NRF", Color::yellow(), &bitmap_icon_nrf, [&nav]() { nav.push<NRFRxView>(); }},

firmware/baseband/proc_adsbrx.cpp

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

firmware/baseband/proc_adsbrx.hpp

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

firmware/baseband/proc_btlerx.cpp

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

firmware/baseband/proc_btlerx.hpp

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

firmware/common/adsb_frame.hpp

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

firmware/common/dsp_fir_taps.hpp

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

firmware/common/message.hpp

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

firmware/common/ui_widget.cpp

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

firmware/common/ui_widget.hpp

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