V1.9.0 (#1660 )

* Update version.txt * Update past_version.txt
Enable Sample Rate to be spec'd in .ini file for Weather & SubGhzDecoder apps (#1659 )
2026-09-03 13:29:01 +00:00 · 2023-12-22 07:35:54 +13:00 · 2023-12-21 19:33:06 +01:00 · 2023-12-19 22:25:22 +01:00 · 2023-12-19 22:20:13 +01:00 · 2023-12-18 07:35:00 +01:00
200 changed files with 16913 additions and 2066 deletions
@@ -1 +1 @@
-v1.7.4
+v1.8.0
@@ -1 +1 @@
-v1.8.0
+v1.9.0
@@ -1,6 +1,6 @@
 # PortaPack Mayhem

-[![Build Status](https://travis-ci.com/eried/portapack-mayhem.svg?branch=master)](https://travis-ci.com/eried/portapack-mayhem) [![Nightly Release](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml/badge.svg?branch=next)](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml) [![CodeScene Code Health](https://codescene.io/projects/8381/status-badges/code-health)](https://codescene.io/projects/8381) [![GitHub All Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/total)](https://github.com/eried/portapack-mayhem/releases) [![GitHub Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/latest/total)](https://github.com/eried/portapack-mayhem/releases/latest) [![Docker Hub Pulls](https://img.shields.io/docker/pulls/eried/portapack.svg)](https://hub.docker.com/r/eried/portapack) [![Discord Chat](https://img.shields.io/discord/719669764804444213.svg)](https://discord.gg/tuwVMv3)  [![Check bounties!](https://img.shields.io/bountysource/team/portapack-mayhem/activity?color=%2333ccff&label=bountysource%20%28USD%29&style=plastic)](https://www.bountysource.com/teams/portapack-mayhem/issues)
+[![Build Status](https://travis-ci.com/eried/portapack-mayhem.svg?branch=master)](https://travis-ci.com/eried/portapack-mayhem) [![Nightly Release](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml/badge.svg?branch=next)](https://github.com/eried/portapack-mayhem/actions/workflows/create_nightly_release.yml) [![CodeScene Code Health](https://codescene.io/projects/8381/status-badges/code-health)](https://codescene.io/projects/8381) [![GitHub All Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/total)](https://github.com/eried/portapack-mayhem/releases) [![GitHub Releases](https://img.shields.io/github/downloads/eried/portapack-mayhem/latest/total)](https://github.com/eried/portapack-mayhem/releases/latest) [![Docker Hub Pulls](https://img.shields.io/docker/pulls/eried/portapack.svg)](https://hub.docker.com/r/eried/portapack) [![Discord Chat](https://dcbadge.vercel.app/api/server/tuwVMv3?style=flat)](https://discord.gg/tuwVMv3)

 This is a fork of the [Havoc](https://github.com/furrtek/portapack-havoc/) firmware, which itself was a fork of the [PortaPack](https://github.com/sharebrained/portapack-hackrf) firmware, an add-on for the [HackRF](http://greatscottgadgets.com/hackrf/). A fork is a derivate, in this case one that has extra features and fixes when compared to the older versions.

@@ -22,7 +22,7 @@ This repository expands upon the previous work by many people and aims to consta

 :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: Our friends at OpenSourceSDRLab give away five units every three months in our discord (check the badge on top) of their [PortaPack H2](https://www.aliexpress.com/item/4000247041639.html?gatewayAdapt=4itemAdapt), you can support them too by ordering.

 :heavy_check_mark: Another popular option is the clone of the [PortaPack H1](https://s.click.aliexpress.com/e/_Dkbqs2X).

@@ -50,9 +50,11 @@ To support the people behind the hardware, please buy a genuine [HackRF](https:/
 ## What if I really want something specific?
 If what you need can be relevant in general, you can [request a feature](https://github.com/eried/portapack-mayhem/issues/new?labels=enhancement&template=feature_request.md).

-You can create a bounty and invite people to your own bounty. This will incentivize coders to work on a new feature, solving a bug or even writting documentation. Start a bounty by [creating](https://github.com/eried/portapack-mayhem/issues/new/choose) or [choosing](https://github.com/eried/portapack-mayhem/issues/) an existing issue. Then, go to [Bountysource](https://www.bountysource.com/) and post a bounty using the link to that specific [issue](https://www.bountysource.com/teams/portapack-mayhem/issues).
+<del>You can create a bounty and invite people to your own bounty. This will incentivize coders to work on a new feature, solving a bug or even writting documentation. Start a bounty by [creating](https://github.com/eried/portapack-mayhem/issues/new/choose) or [choosing](https://github.com/eried/portapack-mayhem/issues/) an existing issue. Then, go to [Bountysource](https://www.bountysource.com/) and post a bounty using the link to that specific [issue](https://www.bountysource.com/teams/portapack-mayhem/issues).</del>

-Promote your bounty over our Discord by clicking the chat badge on [top](#portapack-mayhem).
+<del>Promote your bounty over our Discord by clicking the chat badge on [top](#portapack-mayhem).</del>
+
+Bountysource has not been reliable lately, so until this changes, please **DO NOT** post a bounty there. Go to our Discord by clicking the chat badge on [top](#portapack-mayhem) and discuss there.

 ## What if I need help?
 First, check the [documentation](https://github.com/eried/portapack-mayhem/wiki). If you find a bug or you think the problem is related to the current repository, please open an [issue](https://github.com/eried/portapack-mayhem/issues/new/choose).
@@ -54,6 +54,7 @@ add_custom_target(

 add_custom_target(
 	program
+	COMMAND ${PROJECT_SOURCE_DIR}/tools/enter_mode.sh hackrf
 	COMMAND dfu-util --device 1fc9:000c --download ${HACKRF_FIRMWARE_DFU_IMAGE} || (exit 0) # We need to add it for dfu-utils v.011 , (in v.09 it is not necessary)
 	COMMAND sleep 3s
 	COMMAND hackrf_spiflash -i -R -w ${FIRMWARE_FILENAME}
@@ -113,6 +113,17 @@ set(CSRC
 	${BOARDSRC}
 	${FATFSSRC}
 	firmware_info.c
+	usb_serial_cdc.c
+	usb_serial_descriptor.c
+	usb_serial_endpoints.c
+	usb_serial_io.c
+	${HACKRF_PATH}/firmware/common/usb.c
+	${HACKRF_PATH}/firmware/common/usb_queue.c
+	${HACKRF_PATH}/firmware/hackrf_usb/usb_device.c
+	${HACKRF_PATH}/firmware/common/usb_request.c
+	${HACKRF_PATH}/firmware/common/usb_standard_request.c
+	${CHIBIOS}/os/various/shell.c
+	${CHIBIOS}/os/various/chprintf.c
 )

 # C++ sources that can be compiled in ARM or THUMB mode depending on the global
@@ -162,6 +173,7 @@ set(CPPSRC
 	${COMMON}/ui_painter.cpp
 	${COMMON}/ui_text.cpp
 	${COMMON}/ui_widget.cpp
+	${COMMON}/ui_language.cpp
 	${COMMON}/utility.cpp
 	${COMMON}/wm8731.cpp
 	${COMMON}/performance_counter.cpp
@@ -190,6 +202,10 @@ set(CPPSRC
 	log_file.cpp
 	metadata_file.cpp
 	portapack.cpp
+	usb_serial_shell.cpp
+	usb_serial_event.cpp
+	usb_serial_thread.cpp
+	usb_serial.cpp
 	qrcodegen.cpp
 	radio.cpp
 	receiver_model.cpp
@@ -243,14 +259,14 @@ set(CPPSRC
 	apps/acars_app.cpp
 	apps/ais_app.cpp
 	apps/analog_audio_app.cpp
-	apps/analog_tv_app.cpp
+	# apps/analog_tv_app.cpp
+	apps/ble_comm_app.cpp
 	apps/ble_rx_app.cpp
 	apps/ble_tx_app.cpp
 	apps/capture_app.cpp
 	apps/ert_app.cpp
 	apps/gps_sim_app.cpp
-	apps/lge_app.cpp
-	apps/lge_app.cpp
+	# apps/lge_app.cpp
 	apps/pocsag_app.cpp
 	# apps/replay_app.cpp
 	apps/soundboard_app.cpp
@@ -263,7 +279,7 @@ set(CPPSRC
 	apps/ui_aprs_tx.cpp
 	apps/ui_bht_tx.cpp
 	apps/ui_btle_rx.cpp
-	apps/ui_coasterp.cpp
+	# apps/ui_coasterp.cpp
 	apps/ui_debug.cpp
 	apps/ui_dfu_menu.cpp
 	apps/ui_encoders.cpp
@@ -272,15 +288,15 @@ set(CPPSRC
 	apps/ui_freqman.cpp
 	apps/ui_fsk_rx.cpp
 	apps/ui_iq_trim.cpp
-	apps/ui_jammer.cpp
+	# apps/ui_jammer.cpp
    # apps/ui_keyfob.cpp
-	apps/ui_lcr.cpp
+	# apps/ui_lcr.cpp
 	apps/ui_level.cpp  
 	apps/ui_looking_glass_app.cpp
 	apps/ui_mictx.cpp
 	apps/ui_modemsetup.cpp
 	apps/ui_morse.cpp
-	apps/ui_nrf_rx.cpp
+	# apps/ui_nrf_rx.cpp
 	# apps/ui_nuoptix.cpp
 	apps/ui_playlist.cpp
 	apps/ui_pocsag_tx.cpp
@@ -300,19 +316,21 @@ set(CPPSRC
 	apps/ui_spectrum_painter.cpp
 	apps/ui_ss_viewer.cpp
 	apps/ui_sstvtx.cpp
+	apps/ui_subghzd.cpp
 	# apps/ui_test.cpp
 	apps/ui_text_editor.cpp
 	apps/ui_tone_search.cpp
 	apps/ui_touch_calibration.cpp
 	apps/ui_touchtunes.cpp
 	apps/ui_view_wav.cpp
+	apps/ui_weatherstation.cpp
 	apps/ui_whipcalc.cpp
 	protocols/aprs.cpp
 	protocols/ax25.cpp
 	protocols/bht.cpp
 	protocols/dcs.cpp
 	protocols/encoders.cpp
-	protocols/lcr.cpp
+	# protocols/lcr.cpp
 	protocols/modems.cpp
 	protocols/rds.cpp
 	# ui_handwrite.cpp
@@ -360,6 +378,9 @@ set(INCDIR ${CMAKE_CURRENT_BINARY_DIR} ${COMMON} ${PORTINC} ${KERNINC} ${TESTINC
 	${HALINC} ${PLATFORMINC} ${BOARDINC}
 	${FATFSINC}
 	${CHIBIOS}/os/various
+	${HACKRF_PATH}/firmware/libopencm3/include
+	${HACKRF_PATH}/firmware/common
+	${HACKRF_PATH}/firmware
 	ui
 	hw
 	apps
@@ -0,0 +1,331 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ble_comm_app.hpp"
+
+#include "ui_modemsetup.hpp"
+
+#include "modems.hpp"
+#include "audio.hpp"
+#include "rtc_time.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "ui_text.hpp"
+
+using namespace portapack;
+using namespace modems;
+
+void BLECommLogger::log_raw_data(const std::string& data) {
+    log_file.write_entry(data);
+}
+
+namespace ui {
+static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
+    uint64_t freq_hz;
+
+    switch (channel_number) {
+        case 37:
+            freq_hz = 2'402'000'000ull;
+            break;
+        case 38:
+            freq_hz = 2'426'000'000ull;
+            break;
+        case 39:
+            freq_hz = 2'480'000'000ull;
+            break;
+        case 0 ... 10:
+            freq_hz = 2'404'000'000ull + channel_number * 2'000'000ull;
+            break;
+        case 11 ... 36:
+            freq_hz = 2'428'000'000ull + (channel_number - 11) * 2'000'000ull;
+            break;
+        default:
+            freq_hz = UINT64_MAX;
+    }
+
+    return freq_hz;
+}
+
+void BLECommView::focus() {
+    options_channel.focus();
+}
+
+BLECommView::BLECommView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&rssi,
+                  &channel,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &options_channel,
+                  &field_frequency,
+                  &label_send_adv,
+                  &button_send_adv,
+                  &check_log,
+                  &label_packets_sent,
+                  &text_packets_sent,
+                  &console});
+
+    field_frequency.set_step(0);
+
+    button_send_adv.on_select = [this](ImageButton&) {
+        this->toggle();
+    };
+
+    check_log.set_value(logging);
+
+    check_log.on_select = [this](Checkbox&, bool v) {
+        str_log = "";
+        logging = v;
+
+        if (logger && logging)
+            logger->append(LOG_ROOT_DIR "/BLELOG_" + to_string_timestamp(rtc_time::now()) + ".TXT");
+    };
+
+    options_channel.on_change = [this](size_t, int32_t i) {
+        // If we selected Auto don't do anything and Auto will handle changing.
+        if (i == 40) {
+            auto_channel = true;
+            return;
+        } else {
+            auto_channel = false;
+        }
+
+        field_frequency.set_value(get_freq_by_channel_number(i));
+        channel_number_rx = i;
+        channel_number_tx = i;
+    };
+
+    options_channel.set_selected_index(3, true);
+
+    logger = std::make_unique<BLECommLogger>();
+
+    // Generate new random Mac Address upon each new startup.
+    generateRandomMacAddress(randomMac);
+
+    // Setup Initial Advertise Packet.
+    advertisePacket = build_adv_packet();
+}
+
+void BLECommView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    console.set_parent_rect(content_rect);
+}
+
+BLECommView::~BLECommView() {
+    receiver_model.disable();
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+bool BLECommView::in_tx_mode() const {
+    return (bool)is_running_tx;
+}
+
+void BLECommView::toggle() {
+    if (in_tx_mode()) {
+        sendAdvertisement(false);
+    } else {
+        sendAdvertisement(true);
+    }
+}
+
+BLETxPacket BLECommView::build_adv_packet() {
+    BLETxPacket bleTxPacket;
+    memset(&bleTxPacket, 0, sizeof(BLETxPacket));
+
+    std::string dataString = "11094861636b524620506f7274617061636b";
+
+    strncpy(bleTxPacket.macAddress, randomMac, 12);
+    strncpy(bleTxPacket.advertisementData, dataString.c_str(), dataString.length());
+
+    // Duty cycle of 40% per 100ms advertisment periods.
+    strncpy(bleTxPacket.packetCount, "80", 3);
+    bleTxPacket.packet_count = 80;
+
+    bleTxPacket.packetType = PKT_TYPE_DISCOVERY;
+
+    return bleTxPacket;
+}
+
+void BLECommView::sendAdvertisement(bool enable) {
+    if (enable) {
+        startTx(advertisePacket);
+        is_adv = true;
+    } else {
+        is_adv = false;
+        stopTx();
+    }
+}
+
+void BLECommView::startTx(BLETxPacket packetToSend) {
+    int randomChannel = channel_number_tx;
+
+    if (auto_channel) {
+        int min = 37;
+        int max = 39;
+
+        randomChannel = min + std::rand() % (max - min + 1);
+
+        field_frequency.set_value(get_freq_by_channel_number(randomChannel));
+    }
+
+    if (!in_tx_mode()) {
+        switch_rx_tx(false);
+
+        currentPacket = packetToSend;
+        packet_counter = currentPacket.packet_count;
+
+        button_send_adv.set_bitmap(&bitmap_stop);
+        baseband::set_btletx(randomChannel, currentPacket.macAddress, currentPacket.advertisementData, currentPacket.packetType);
+        transmitter_model.set_tx_gain(47);
+        transmitter_model.enable();
+
+        is_running_tx = true;
+    } else {
+        baseband::set_btletx(randomChannel, currentPacket.macAddress, currentPacket.advertisementData, currentPacket.packetType);
+    }
+
+    if ((packet_counter % 10) == 0) {
+        text_packets_sent.set(to_string_dec_uint(packet_counter));
+    }
+
+    is_sending = true;
+
+    packet_counter--;
+}
+
+void BLECommView::stopTx() {
+    button_send_adv.set_bitmap(&bitmap_play);
+    text_packets_sent.set(to_string_dec_uint(packet_counter));
+
+    switch_rx_tx(true);
+
+    baseband::set_btlerx(channel_number_rx);
+    receiver_model.enable();
+
+    is_running_tx = false;
+}
+
+void BLECommView::switch_rx_tx(bool inRxMode) {
+    if (inRxMode) {
+        // Start Rx
+        transmitter_model.disable();
+        baseband::shutdown();
+        baseband::run_image(portapack::spi_flash::image_tag_btle_rx);
+    } else {
+        // Start Tx
+        receiver_model.disable();
+        baseband::shutdown();
+        baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+    }
+}
+
+void BLECommView::on_data(BlePacketData* packet) {
+    parse_received_packet(packet, (ADV_PDU_TYPE)packet->type);
+}
+
+// called each 1/60th of second, so 6 = 100ms
+void BLECommView::on_timer() {
+    // Send advertise burst only once every 100ms
+    if (++timer_counter == timer_period) {
+        timer_counter = 0;
+
+        if (!is_adv) {
+            sendAdvertisement(true);
+        }
+    }
+}
+
+void BLECommView::on_tx_progress(const bool done) {
+    if (done) {
+        if (in_tx_mode()) {
+            is_sending = false;
+
+            if (packet_counter == 0) {
+                if (is_adv) {
+                    sendAdvertisement(false);
+                } else {
+                    stopTx();
+                }
+            } else {
+                startTx(currentPacket);
+            }
+        }
+    }
+}
+
+void BLECommView::parse_received_packet(const BlePacketData* packet, ADV_PDU_TYPE pdu_type) {
+    std::string data_string;
+
+    int i;
+
+    for (i = 0; i < packet->dataLen; i++) {
+        data_string += to_string_hex(packet->data[i], 2);
+    }
+
+    receivedPacket.dbValue = packet->max_dB;
+    receivedPacket.timestamp = to_string_timestamp(rtc_time::now());
+    receivedPacket.dataString = data_string;
+
+    receivedPacket.packetData.type = packet->type;
+    receivedPacket.packetData.size = packet->size;
+    receivedPacket.packetData.dataLen = packet->dataLen;
+
+    receivedPacket.packetData.macAddress[0] = packet->macAddress[0];
+    receivedPacket.packetData.macAddress[1] = packet->macAddress[1];
+    receivedPacket.packetData.macAddress[2] = packet->macAddress[2];
+    receivedPacket.packetData.macAddress[3] = packet->macAddress[3];
+    receivedPacket.packetData.macAddress[4] = packet->macAddress[4];
+    receivedPacket.packetData.macAddress[5] = packet->macAddress[5];
+
+    receivedPacket.numHits++;
+
+    for (int i = 0; i < packet->dataLen; i++) {
+        receivedPacket.packetData.data[i] = packet->data[i];
+    }
+
+    if (pdu_type == SCAN_REQ || pdu_type == CONNECT_REQ) {
+        ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)packet->data;
+
+        std::reverse(directed_mac_data->A1, directed_mac_data->A1 + 6);
+        console.clear(true);
+        std::string str_console = "";
+        std::string pduTypeStr = "";
+
+        if (pdu_type == SCAN_REQ) {
+            pduTypeStr += "SCAN_REQ";
+        } else if (pdu_type == CONNECT_REQ) {
+            pduTypeStr += "CONNECT_REQ";
+        }
+
+        str_console += "PACKET TYPE:" + pduTypeStr + "\n";
+        str_console += "MY MAC:" + to_string_formatted_mac_address(randomMac) + "\n";
+        str_console += "SCAN MAC:" + to_string_mac_address(directed_mac_data->A1, 6, false) + "\n";
+        console.write(str_console);
+    }
+}
+
+} /* namespace ui */
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 TJ Baginski
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLE_COMM_APP_H__
+#define __BLE_COMM_APP_H__
+
+#include "ble_rx_app.hpp"
+#include "ble_tx_app.hpp"
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+#include "recent_entries.hpp"
+
+class BLECommLogger {
+   public:
+    Optional<File::Error> append(const std::string& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_raw_data(const std::string& data);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui {
+class BLECommView : public View {
+   public:
+    BLECommView(NavigationView& nav);
+    ~BLECommView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    std::string title() const override { return "BLE Comm"; };
+
+   private:
+    BLETxPacket build_adv_packet();
+    void switch_rx_tx(bool inRxMode);
+    void startTx(BLETxPacket packetToSend);
+    void stopTx();
+    void toggle();
+    bool in_tx_mode() const;
+    void on_timer();
+    void on_data(BlePacketData* packetData);
+    void on_tx_progress(const bool done);
+    void parse_received_packet(const BlePacketData* packet, ADV_PDU_TYPE pdu_type);
+    void sendAdvertisement(bool enable);
+
+    NavigationView& nav_;
+
+    RxRadioState radio_state_rx_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */,
+        ReceiverModel::Mode::WidebandFMAudio};
+
+    TxRadioState radio_state_tx_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */
+    };
+
+    app_settings::SettingsManager settings_{
+        "BLE Comm Tx", app_settings::Mode::RX_TX};
+
+    uint8_t console_color{0};
+    uint32_t prev_value{0};
+
+    uint8_t channel_number_tx = 37;
+    uint8_t channel_number_rx = 37;
+    bool auto_channel = false;
+
+    char randomMac[13] = "010203040506";
+
+    bool is_running_tx = false;
+    bool is_sending = false;
+    bool is_adv = false;
+
+    int16_t timer_period{6};  // Delay each packet by 16ms.
+    int16_t timer_counter = 0;
+    int16_t timer_rx_counter = 0;
+    int16_t timer_rx_period{12};  // Poll Rx for at least 200ms. (TBD)
+
+    uint32_t packet_counter{0};
+    BLETxPacket advertisePacket{};
+    BLETxPacket currentPacket{};
+    BleRecentEntry receivedPacket{};
+
+    static constexpr auto header_height = 5 * 16;
+
+    OptionsField options_channel{
+        {0 * 8, 0 * 8},
+        5,
+        {{"Ch.37 ", 37},
+         {"Ch.38", 38},
+         {"Ch.39", 39},
+         {"Auto", 40}}};
+
+    RxFrequencyField field_frequency{
+        {6 * 8, 0 * 16},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {16 * 8, 0 * 16}};
+
+    LNAGainField field_lna{
+        {18 * 8, 0 * 16}};
+
+    VGAGainField field_vga{
+        {21 * 8, 0 * 16}};
+
+    RSSI rssi{
+        {24 * 8, 0, 6 * 8, 4}};
+
+    Channel channel{
+        {24 * 8, 5, 6 * 8, 4}};
+
+    Labels label_send_adv{
+        {{0 * 8, 2 * 8}, "Send Advertisement:", Color::light_grey()}};
+
+    ImageButton button_send_adv{
+        {21 * 8, 1 * 16, 10 * 8, 2 * 16},
+        &bitmap_play,
+        Color::green(),
+        Color::black()};
+
+    Checkbox check_log{
+        {24 * 8, 2 * 8},
+        3,
+        "Log",
+        true};
+
+    Labels label_packets_sent{
+        {{0 * 8, 4 * 8}, "Packets Left:", Color::light_grey()}};
+
+    Text text_packets_sent{
+        {13 * 8, 2 * 16, 12 * 8, 16},
+        "-"};
+
+    Console console{
+        {0, 4 * 16, 240, 240}};
+
+    std::string str_log{""};
+    bool logging{false};
+
+    std::unique_ptr<BLECommLogger> logger{};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::BlePacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const BLEPacketMessage*>(p);
+            this->on_data(message->packet);
+        }};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.done);
+        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
+};
+
+} /* namespace ui */
+
+#endif /*__UI_AFSK_RX_H__*/
@@ -24,6 +24,8 @@
 #ifndef __BLE_RX_APP_H__
 #define __BLE_RX_APP_H__

+#include "ble_tx_app.hpp"
+
 #include "ui.hpp"
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
@@ -33,6 +35,7 @@
 #include "radio_state.hpp"
 #include "log_file.hpp"
 #include "utility.hpp"
+#include "usb_serial_thread.hpp"

 #include "recent_entries.hpp"

@@ -79,7 +82,11 @@ struct BleRecentEntry {
    std::string timestamp;
    std::string dataString;
    std::string nameString;
+    bool include_name;
    uint16_t numHits;
+    ADV_PDU_TYPE pduType;
+    uint8_t channelNumber;
+    bool entryFound;

    BleRecentEntry()
        : BleRecentEntry{0} {
@@ -93,7 +100,11 @@ struct BleRecentEntry {
          timestamp{},
          dataString{},
          nameString{},
-          numHits{} {
+          include_name{},
+          numHits{},
+          pduType{},
+          channelNumber{},
+          entryFound{} {
    }

    Key key() const {
@@ -118,7 +129,11 @@ class BleRecentEntryDetailView : public View {
   private:
    NavigationView& nav_;
    BleRecentEntry entry_{};
-    void launch_bletx(BleRecentEntry packetEntry);
+    BLETxPacket build_packet();
+    void on_save_file(const std::string value, BLETxPacket packetToSave);
+    bool saveFile(const std::filesystem::path& path, BLETxPacket packetToSave);
+    std::string packetFileBuffer{};
+    std::filesystem::path packet_save_path{u"BLERX/Lists/????.csv"};

    static constexpr uint8_t total_data_lines{5};

@@ -129,10 +144,17 @@ class BleRecentEntryDetailView : public View {
        {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, 2 * 16}, "Len", Color::light_grey()},
-        {{5 * 8, 2 * 16}, "Type", Color::light_grey()},
-        {{10 * 8, 2 * 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{
@@ -143,6 +165,10 @@ class BleRecentEntryDetailView : public View {
        {125, 224, 96, 24},
        "Done"};

+    Button button_save{
+        {72, 264, 96, 24},
+        "Save"};
+
    bool send_updates{false};

    Rect draw_field(
@@ -166,9 +192,17 @@ class BLERxView : public View {
    std::string title() const override { return "BLE RX"; };

   private:
+    std::string build_line_str(BleRecentEntry entry);
+    void on_save_file(const std::string value);
+    bool saveFile(const std::filesystem::path& path);
+    std::unique_ptr<UsbSerialThread> usb_serial_thread{};
    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 on_file_changed(const std::filesystem::path& new_file_path);
+    void file_error();
+    void on_timer();
+    void handle_entries_sort(uint8_t index);
+    void updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type);

    NavigationView& nav_;
    RxRadioState radio_state_{
@@ -176,17 +210,48 @@ class BLERxView : public View {
        4000000 /* bandwidth */,
        4000000 /* sampling rate */,
        ReceiverModel::Mode::WidebandFMAudio};
-    app_settings::SettingsManager settings_{
-        "BLE Rx", app_settings::Mode::RX};

+    uint8_t channel_index{0};
+    uint8_t sort_index{0};
+    std::string filter{};
+    bool logging{false};
+
+    bool name_enable{true};
+    app_settings::SettingsManager settings_{
+        "rx_ble",
+        app_settings::Mode::RX,
+        {
+            {"channel_index"sv, &channel_index},
+            {"sort_index"sv, &sort_index},
+            {"filter"sv, &filter},
+            {"log"sv, &logging},
+            {"name"sv, &name_enable},
+        }};
+
+    std::string str_console = "";
    uint8_t console_color{0};
    uint32_t prev_value{0};
    uint8_t channel_number = 37;
+    bool auto_channel = false;
+
+    int16_t timer_count{0};
+    int16_t timer_period{6};  // 100ms

    std::string filterBuffer{};
-    std::string filter{};
+    std::string listFileBuffer{};
+    std::string headerStr = "Timestamp, MAC Address, Name, Packet Type, Data, Hits, dB, Channel";
+    uint16_t maxLineLength = 140;

-    static constexpr auto header_height = 3 * 16;
+    std::filesystem::path file_path{};
+    uint64_t found_count = 0;
+    uint64_t total_count = 0;
+    std::vector<std::string> searchList{};
+
+    std::filesystem::path find_packet_path{u"BLERX/Find/????.TXT"};
+    std::filesystem::path log_packets_path{u"BLERX/Logs/????.TXT"};
+    std::filesystem::path packet_save_path{u"BLERX/Lists/????.csv"};
+
+    static constexpr auto header_height = 4 * 16;
    static constexpr auto switch_button_height = 3 * 16;

    OptionsField options_channel{
@@ -194,7 +259,8 @@ class BLERxView : public View {
        5,
        {{"Ch.37 ", 37},
         {"Ch.38", 38},
-         {"Ch.39", 39}}};
+         {"Ch.39", 39},
+         {"Auto", 40}}};

    RxFrequencyField field_frequency{
        {6 * 8, 0 * 16},
@@ -228,29 +294,52 @@ class BLERxView : public View {
         {"Name", 4}}};

    Button button_filter{
-        {12 * 8, 3 * 8, 4 * 8, 16},
+        {11 * 8, 3 * 8, 4 * 8, 16},
        "Filter"};

    Checkbox check_log{
-        {20 * 8, 3 * 8},
+        {17 * 8, 3 * 8},
        3,
        "Log",
        true};

+    Checkbox check_name{
+        {23 * 8, 3 * 8},
+        3,
+        "Name",
+        true};
+
+    Button button_find{
+        {0 * 8, 6 * 8, 4 * 8, 16},
+        "Find"};
+
+    Labels label_found{
+        {{5 * 8, 6 * 8}, "Found:", Color::light_grey()}};
+
+    Text text_found_count{
+        {11 * 8, 3 * 16, 20 * 8, 16},
+        "0/0"};
+
    Console console{
        {0, 4 * 16, 240, 240}};

+    Button button_clear_list{
+        {2 * 8, 320 - (16 + 32), 7 * 8, 32},
+        "Clear"};
+
+    Button button_save_list{
+        {11 * 8, 320 - (16 + 32), 11 * 8, 32},
+        "Export CSV"};
+
    Button button_switch{
-        {8 * 8, 16 * 16, 14 * 8, 2 * 16},
-        "Switch to Tx"};
+        {240 - 6 * 8, 320 - (16 + 32), 4 * 8, 32},
+        "Tx"};

    std::string str_log{""};
-    bool logging{false};
-
    std::unique_ptr<BLELogger> logger{};

    BleRecentEntries recent{};
-    BleRecentEntries filterEntries{};
+    BleRecentEntries tempList{};

    const RecentEntriesColumns columns{{
        {"Mac Address", 17},
@@ -258,10 +347,7 @@ class BLERxView : public View {
        {"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,
@@ -269,6 +355,12 @@ class BLERxView : public View {
            const auto message = static_cast<const BLEPacketMessage*>(p);
            this->on_data(message->packet);
        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
 };

 } /* namespace ui */
@@ -67,7 +67,7 @@ std::vector<std::string> splitIntoStrings(const char* input) {

    while (start < length) {
        int remaining = length - start;
-        int chunkSize = (remaining > 30) ? 30 : remaining;
+        int chunkSize = (remaining > 29) ? 29 : remaining;
        result.push_back(std::string(input + start, chunkSize));
        start += chunkSize;
    }
@@ -94,44 +94,6 @@ uint32_t stringToUint32(const std::string& str) {
    return result;
 }

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

@@ -205,11 +167,14 @@ void BLETxView::toggle() {
 }

 void BLETxView::start() {
+    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+    transmitter_model.enable();
+
    // Generate new random Mac Address.
    generateRandomMacAddress(randomMac);

+    // If this is our first run, check file.
    if (!is_active()) {
-        // Check if file is present before continuing.
        File data_file;

        auto error = data_file.open(file_path);
@@ -217,80 +182,142 @@ void BLETxView::start() {
            file_error();
            check_loop.set_value(false);
            return;
-        } else {
-            // Send first or single packet.
-            packet_counter = packets[current_packet].packet_count;
-            progressbar.set_max(packets[current_packet].packet_count);
-            button_play.set_bitmap(&bitmap_stop);
-
-            baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
-            transmitter_model.enable();
-
-            is_running = true;
        }
-    } else {
-        // Send next packet.
-        baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, packets[current_packet].advertisementData, pduType);
+
+        button_play.set_bitmap(&bitmap_stop);
+        is_running = true;
    }

-    if ((packet_counter % 10) == 0) {
-        text_packets_sent.set(to_string_dec_uint(packet_counter));
+    char advertisementData[63] = {0};
+    strcpy(advertisementData, packets[current_packet].advertisementData);
+
+    // TODO: Make this a checkbox.
+    if (!markedBytes.empty()) {
+        for (size_t i = 0; i < strlen(advertisementData); i++) {
+            bool found = false;
+
+            auto it = std::find(markedBytes.begin(), markedBytes.end(), i);
+
+            if (it != markedBytes.end()) {
+                found = true;
+            }
+
+            if (found) {
+                uint8_t hexDigit;
+                switch (marked_data_sequence.selected_index_value()) {
+                    case 0:
+                        hexDigit = marked_counter++;
+                        break;
+                    case 1:
+                        hexDigit = marked_counter--;
+                        break;
+                    case 2: {
+                        uint8_t min = 0x00;
+                        uint8_t max = 0x0F;
+
+                        hexDigit = min + std::rand() % (max - min + 1);
+                    } break;
+                    default:
+                        hexDigit = 0;
+                        break;
+                }
+
+                advertisementData[i] = uint_to_char(hexDigit, 16);
+
+                // Bounding to Hex.
+                if (marked_counter == 16) {
+                    marked_counter = 0;
+                } else if (marked_counter == 255) {
+                    marked_counter = 15;
+                }
+            }
+        }
    }

-    packet_counter--;
-
-    progressbar.set_value(packets[current_packet].packet_count - packet_counter);
+    // Setup next packet configuration.
+    progressbar.set_max(packets[current_packet].packet_count);
+    baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, advertisementData, pduType);
 }

 void BLETxView::stop() {
    transmitter_model.disable();
+    baseband::shutdown();
+
    progressbar.set_value(0);
    button_play.set_bitmap(&bitmap_play);
    check_loop.set_value(false);

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

    is_running = false;
 }

-void BLETxView::on_tx_progress(const bool done) {
-    if (done) {
+void BLETxView::reset() {
+    transmitter_model.disable();
+    baseband::shutdown();
+
+    start();
+}
+
+// called each 1/60th of second, so 6 = 100ms
+void BLETxView::on_timer() {
+    if (++timer_count == timer_period) {
+        timer_count = 0;
+
        if (is_active()) {
            // Reached end of current packet repeats.
            if (packet_counter == 0) {
                // Done sending all packets.
                if (current_packet == (num_packets - 1)) {
+                    current_packet = 0;
+
                    // If looping, restart from beginning.
                    if (check_loop.value()) {
-                        current_packet = 0;
-                        packet_counter = packets[current_packet].packet_count;
-                        update_packet_display(packets[current_packet]);
+                        update_current_packet(packets[current_packet], current_packet);
+                        reset();
                    } else {
                        stop();
                    }
                } else {
                    current_packet++;
-                    packet_counter = packets[current_packet].packet_count;
-                    update_packet_display(packets[current_packet]);
+                    update_current_packet(packets[current_packet], current_packet);
+                    reset();
                }
            } else {
-                if ((timer_count % timer_period) == 0) {
-                    start();
-                }
+                reset();
+            }
+        }
+    }
+
+    if (++auto_channel_counter == auto_channel_period) {
+        auto_channel_counter = 0;
+
+        if (auto_channel) {
+            int min = 37;
+            int max = 39;
+
+            channel_number = min + std::rand() % (max - min + 1);
+
+            field_frequency.set_value(get_freq_by_channel_number(channel_number));
+        }
+    }
+}
+
+void BLETxView::on_tx_progress(const bool done) {
+    if (done) {
+        if (is_active()) {
+            if ((packet_counter % 10) == 0) {
+                text_packets_sent.set(to_string_dec_uint(packet_counter));
            }

-            timer_count++;
+            packet_counter--;
+            progressbar.set_value(packets[current_packet].packet_count - packet_counter);
        }
    }
 }

 BLETxView::BLETxView(NavigationView& nav)
    : nav_{nav} {
-    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
-
    add_children({&button_open,
                  &text_filename,
                  &progressbar,
@@ -303,6 +330,8 @@ BLETxView::BLETxView(NavigationView& nav)
                  &options_speed,
                  &options_channel,
                  &options_adv_type,
+                  &label_marked_data,
+                  &marked_data_sequence,
                  &label_packet_index,
                  &text_packet_index,
                  &label_packets_sent,
@@ -310,9 +339,10 @@ BLETxView::BLETxView(NavigationView& nav)
                  &label_mac_address,
                  &text_mac_address,
                  &label_data_packet,
+                  &dataEditView,
+                  &button_clear_marked,
                  &button_save_packet,
-                  &button_switch,
-                  &console});
+                  &button_switch});

    field_frequency.set_step(0);

@@ -323,12 +353,21 @@ BLETxView::BLETxView(NavigationView& nav)
    };

    options_channel.on_change = [this](size_t, int32_t i) {
+        // If we selected Auto don't do anything and Auto will handle changing.
+        if (i == 40) {
+            auto_channel = true;
+            return;
+        } else {
+            auto_channel = false;
+        }
+
        field_frequency.set_value(get_freq_by_channel_number(i));
        channel_number = i;
    };

    options_speed.on_change = [this](size_t, int32_t i) {
        timer_period = i;
+        timer_count = 0;
    };

    options_adv_type.on_change = [this](size_t, int32_t i) {
@@ -344,8 +383,8 @@ BLETxView::BLETxView(NavigationView& nav)
        random_mac = v;
    };

-    button_open.on_select = [this, &nav](Button&) {
-        auto open_view = nav.push<FileLoadView>(".TXT");
+    button_open.on_select = [this](Button&) {
+        auto open_view = nav_.push<FileLoadView>(".TXT");
        open_view->on_changed = [this](std::filesystem::path new_file_path) {
            on_file_changed(new_file_path);

@@ -364,9 +403,35 @@ BLETxView::BLETxView(NavigationView& nav)
            });
    };

-    button_switch.on_select = [this, &nav](Button&) {
-        nav_.set_on_pop([this]() { nav_.push<BLERxView>(); });
-        nav_.pop();
+    button_switch.on_select = [&nav](Button&) {
+        nav.replace<BLERxView>();
+    };
+
+    dataEditView.on_select = [this] {
+        // Save last selected cursor.
+        cursor_pos.line = dataEditView.line();
+        cursor_pos.col = dataEditView.col();
+
+        // Reject setting newline at index 29.
+        if (cursor_pos.col != 29) {
+            uint16_t dataBytePos = (cursor_pos.line * 29) + cursor_pos.col;
+
+            auto it = std::find(markedBytes.begin(), markedBytes.end(), dataBytePos);
+
+            if (it != markedBytes.end()) {
+                markedBytes.erase(it);
+            } else {
+                markedBytes.push_back(dataBytePos);
+            }
+
+            dataEditView.cursor_mark_selected();
+        }
+    };
+
+    button_clear_marked.on_select = [this](Button&) {
+        marked_counter = 0;
+        markedBytes.clear();
+        dataEditView.cursor_clear_marked();
    };
 }

@@ -375,7 +440,8 @@ BLETxView::BLETxView(
    BLETxPacket packet)
    : BLETxView(nav) {
    packets[0] = packet;
-    update_packet_display(packets[0]);
+
+    update_current_packet(packets[0], 0);

    num_packets = 1;
    file_override = true;
@@ -404,11 +470,10 @@ void BLETxView::on_file_changed(const fs::path& new_file_path) {
            uint64_t packetCountSize = strlen(packets[num_packets].packetCount);

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

            // Verify Data.
            if ((macAddressSize == mac_address_size_str) && (advertisementDataSize < max_packet_size_str) && (packetCountSize < max_packet_repeat_str) &&
-                hasValidHexPairs(packets[num_packets].macAddress, macAddressSize / 2) && hasValidHexPairs(packets[num_packets].advertisementData, advertisementDataSize / 2) && (packets[num_packets].packet_count >= 50) && (packets[num_packets].packet_count < max_packet_repeat_count)) {
+                hasValidHexPairs(packets[num_packets].macAddress, macAddressSize / 2) && hasValidHexPairs(packets[num_packets].advertisementData, advertisementDataSize / 2) && (packets[num_packets].packet_count >= 1) && (packets[num_packets].packet_count < max_packet_repeat_count)) {
                text_filename.set(truncate(file_path.filename().string(), 12));

            } else {
@@ -425,7 +490,7 @@ void BLETxView::on_file_changed(const fs::path& new_file_path) {

        } while (num_packets < max_num_packets);

-        update_packet_display(packets[0]);
+        update_current_packet(packets[0], 0);
    }
 }

@@ -443,11 +508,9 @@ void BLETxView::on_data(uint32_t value, bool is_data) {
    if (is_data) {
        str_console += (char)(value);
    }
-
-    console.write(str_console);
 }

-void BLETxView::update_packet_display(BLETxPacket packet) {
+void BLETxView::update_current_packet(BLETxPacket packet, uint32_t currentIndex) {
    std::string formattedMacAddress = to_string_formatted_mac_address(packet.macAddress);

    std::vector<std::string> strings = splitIntoStrings(packet.advertisementData);
@@ -458,20 +521,39 @@ void BLETxView::update_packet_display(BLETxPacket packet) {

    text_mac_address.set(formattedMacAddress);

-    console.clear(true);
+    packet_counter = packet.packet_count;
+    current_packet = currentIndex;
+
+    dataFile.create(dataTempFilePath);

    for (const std::string& str : strings) {
-        console.writeln(str);
+        dataFile.write(str.c_str(), str.size());
+        dataFile.write("\n", 1);
+        ;
    }
+
+    dataFile.~File();
+
+    auto result = FileWrapper::open(dataTempFilePath);
+
+    if (!result)
+        return;
+
+    dataFileWrapper = *std::move(result);
+
+    dataEditView.set_font_zoom(true);
+    dataEditView.set_file(*dataFileWrapper);
+    dataEditView.redraw(true, true);
 }

 void BLETxView::set_parent_rect(const Rect new_parent_rect) {
    View::set_parent_rect(new_parent_rect);
    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height - switch_button_height};
-    console.set_parent_rect(content_rect);
+    dataEditView.set_parent_rect(content_rect);
 }

 BLETxView::~BLETxView() {
+    delete_file(dataTempFilePath);
    transmitter_model.disable();
    baseband::shutdown();
 }
@@ -28,6 +28,7 @@
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
 #include "ui_transmitter.hpp"
+#include "ui_text_editor.hpp"
 #include "ui_freq_field.hpp"
 #include "ui_record_view.hpp"
 #include "app_settings.hpp"
@@ -55,11 +56,42 @@ class BLELoggerTx {

 namespace ui {

+enum PKT_TYPE {
+    PKT_TYPE_INVALID_TYPE,
+    PKT_TYPE_RAW,
+    PKT_TYPE_DISCOVERY,
+    PKT_TYPE_IBEACON,
+    PKT_TYPE_ADV_IND,
+    PKT_TYPE_ADV_DIRECT_IND,
+    PKT_TYPE_ADV_NONCONN_IND,
+    PKT_TYPE_ADV_SCAN_IND,
+    PKT_TYPE_SCAN_REQ,
+    PKT_TYPE_SCAN_RSP,
+    PKT_TYPE_CONNECT_REQ,
+    PKT_TYPE_LL_DATA,
+    PKT_TYPE_LL_CONNECTION_UPDATE_REQ,
+    PKT_TYPE_LL_CHANNEL_MAP_REQ,
+    PKT_TYPE_LL_TERMINATE_IND,
+    PKT_TYPE_LL_ENC_REQ,
+    PKT_TYPE_LL_ENC_RSP,
+    PKT_TYPE_LL_START_ENC_REQ,
+    PKT_TYPE_LL_START_ENC_RSP,
+    PKT_TYPE_LL_UNKNOWN_RSP,
+    PKT_TYPE_LL_FEATURE_REQ,
+    PKT_TYPE_LL_FEATURE_RSP,
+    PKT_TYPE_LL_PAUSE_ENC_REQ,
+    PKT_TYPE_LL_PAUSE_ENC_RSP,
+    PKT_TYPE_LL_VERSION_IND,
+    PKT_TYPE_LL_REJECT_IND,
+    PKT_TYPE_NUM_PKT_TYPE
+};
+
 struct BLETxPacket {
    char macAddress[13];
    char advertisementData[63];
    char packetCount[11];
    uint32_t packet_count;
+    PKT_TYPE packetType;
 };

 class BLETxView : public View {
@@ -77,6 +109,7 @@ class BLETxView : public View {
    void toggle();
    void start();
    void stop();
+    void reset();
    void handle_replay_thread_done(const uint32_t return_code);
    void file_error();
    bool saveFile(const std::filesystem::path& path);
@@ -84,11 +117,13 @@ class BLETxView : public View {
    std::string title() const override { return "BLE TX"; };

   private:
+    void on_timer();
    void on_data(uint32_t value, bool is_data);
-    void on_tx_progress(const bool done);
    void on_file_changed(const std::filesystem::path& new_file_path);
-    void update_packet_display(BLETxPacket packet);
    void on_save_file(const std::string value);
+    void on_tx_progress(const bool done);
+    void on_random_data_change(std::string value);
+    void update_current_packet(BLETxPacket packet, uint32_t currentIndex);

    NavigationView& nav_;
    TxRadioState radio_state_{
@@ -97,7 +132,7 @@ class BLETxView : public View {
        4'000'000 /* sampling rate */
    };
    app_settings::SettingsManager settings_{
-        "ble_tx_app", app_settings::Mode::TX};
+        "tx_ble", app_settings::Mode::TX};

    uint8_t console_color{0};
    uint32_t prev_value{0};
@@ -105,12 +140,17 @@ class BLETxView : public View {
    std::filesystem::path file_path{};
    std::filesystem::path packet_save_path{u"BLETX/BLETX_????.TXT"};
    uint8_t channel_number = 37;
+    bool auto_channel = false;

    char randomMac[13] = "010203040506";

    bool is_running = false;
-    uint64_t timer_count{0};
-    uint64_t timer_period{256};
+
+    int16_t timer_count{0};
+    int16_t timer_period{1};
+    int16_t auto_channel_counter = 0;
+    int16_t auto_channel_period{6};
+
    bool repeatLoop = false;
    uint32_t packet_counter{0};
    uint32_t num_packets{0};
@@ -118,48 +158,30 @@ class BLETxView : public View {
    bool random_mac = false;
    bool file_override = false;

-    enum PKT_TYPE {
-        INVALID_TYPE,
-        RAW,
-        DISCOVERY,
-        IBEACON,
-        ADV_IND,
-        ADV_DIRECT_IND,
-        ADV_NONCONN_IND,
-        ADV_SCAN_IND,
-        SCAN_REQ,
-        SCAN_RSP,
-        CONNECT_REQ,
-        LL_DATA,
-        LL_CONNECTION_UPDATE_REQ,
-        LL_CHANNEL_MAP_REQ,
-        LL_TERMINATE_IND,
-        LL_ENC_REQ,
-        LL_ENC_RSP,
-        LL_START_ENC_REQ,
-        LL_START_ENC_RSP,
-        LL_UNKNOWN_RSP,
-        LL_FEATURE_REQ,
-        LL_FEATURE_RSP,
-        LL_PAUSE_ENC_REQ,
-        LL_PAUSE_ENC_RSP,
-        LL_VERSION_IND,
-        LL_REJECT_IND,
-        NUM_PKT_TYPE
-    };
+    typedef struct {
+        uint16_t line;
+        uint16_t col;
+    } CursorPos;
+
+    std::unique_ptr<FileWrapper> dataFileWrapper{};
+    File dataFile{};
+    std::filesystem::path dataTempFilePath{u"BLETX/dataFileTemp.TXT"};
+    std::vector<uint16_t> markedBytes{};
+    CursorPos cursor_pos{};
+    uint8_t marked_counter = 0;

    static constexpr uint8_t mac_address_size_str{12};
    static constexpr uint8_t max_packet_size_str{62};
    static constexpr uint8_t max_packet_repeat_str{10};
    static constexpr uint32_t max_packet_repeat_count{UINT32_MAX};
-    static constexpr uint32_t max_num_packets{256};
+    static constexpr uint32_t max_num_packets{32};

    BLETxPacket packets[max_num_packets];

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

-    static constexpr auto header_height = 9 * 16;
-    static constexpr auto switch_button_height = 3 * 16;
+    static constexpr auto header_height = 10 * 16;
+    static constexpr auto switch_button_height = 6 * 16;

    Button button_open{
        {0 * 8, 0 * 16, 10 * 8, 2 * 16},
@@ -175,7 +197,7 @@ class BLETxView : public View {
    Checkbox check_rand_mac{
        {21 * 8, 1 * 16},
        6,
-        "Random",
+        "?? Mac",
        true};

    TxFrequencyField field_frequency{
@@ -204,56 +226,75 @@ class BLETxView : public View {
    OptionsField options_speed{
        {7 * 8, 6 * 8},
        3,
-        {{"1 ", 256},
-         {"2 ", 128},
-         {"3 ", 64},
-         {"4 ", 32},
-         {"5 ", 16}}};
+        {{"1 ", 1},     // 16ms
+         {"2 ", 2},     // 32ms
+         {"3 ", 3},     // 48ms
+         {"4 ", 6},     // 100ms
+         {"5 ", 12}}};  // 200ms

    OptionsField options_channel{
        {11 * 8, 6 * 8},
        5,
        {{"Ch.37 ", 37},
         {"Ch.38", 38},
-         {"Ch.39", 39}}};
+         {"Ch.39", 39},
+         {"Auto", 40}}};

    OptionsField options_adv_type{
        {17 * 8, 6 * 8},
        14,
-        {{"DISCOVERY ", DISCOVERY},
-         {"ADV_IND", ADV_IND},
-         {"ADV_DIRECT", ADV_DIRECT_IND},
-         {"ADV_NONCONN", ADV_NONCONN_IND},
-         {"SCAN_REQ", SCAN_REQ},
-         {"SCAN_RSP", SCAN_RSP},
-         {"CONNECT_REQ", CONNECT_REQ}}};
+        {{"DISCOVERY ", PKT_TYPE_DISCOVERY},
+         {"ADV_IND", PKT_TYPE_ADV_IND},
+         {"ADV_DIRECT", PKT_TYPE_ADV_DIRECT_IND},
+         {"ADV_NONCONN", PKT_TYPE_ADV_NONCONN_IND},
+         {"ADV_SCAN_IND", PKT_TYPE_ADV_SCAN_IND},
+         {"SCAN_REQ", PKT_TYPE_SCAN_REQ},
+         {"SCAN_RSP", PKT_TYPE_SCAN_RSP},
+         {"CONNECT_REQ", PKT_TYPE_CONNECT_REQ}}};
+
+    Labels label_marked_data{
+        {{0 * 8, 4 * 16}, "Marked Data:", Color::light_grey()}};
+
+    OptionsField marked_data_sequence{
+        {12 * 8, 8 * 8},
+        8,
+        {{"Ascend", 0},
+         {"Descend", 1},
+         {"Random", 2}}};

    Labels label_packet_index{
-        {{0 * 8, 10 * 8}, "Packet Index:", Color::light_grey()}};
+        {{0 * 8, 12 * 8}, "Packet Index:", Color::light_grey()}};

    Text text_packet_index{
-        {13 * 8, 5 * 16, 12 * 8, 16},
-        "-"};
-
-    Labels label_packets_sent{
-        {{0 * 8, 12 * 8}, "Packets Left:", Color::light_grey()}};
-
-    Text text_packets_sent{
        {13 * 8, 6 * 16, 12 * 8, 16},
        "-"};

+    Labels label_packets_sent{
+        {{0 * 8, 14 * 8}, "Repeat Count:", Color::light_grey()}};
+
+    Text text_packets_sent{
+        {13 * 8, 7 * 16, 12 * 8, 16},
+        "-"};
+
    Labels label_mac_address{
-        {{0 * 8, 14 * 8}, "Mac Address:", Color::light_grey()}};
+        {{0 * 8, 16 * 8}, "Mac Address:", Color::light_grey()}};

    Text text_mac_address{
-        {12 * 8, 7 * 16, 20 * 8, 16},
+        {12 * 8, 8 * 16, 20 * 8, 16},
        "-"};

    Labels label_data_packet{
-        {{0 * 8, 16 * 8}, "Packet Data:", Color::light_grey()}};
+        {{0 * 8, 9 * 16}, "Packet Data:", Color::light_grey()}};

    Console console{
-        {0, 8 * 16, 240, 240}};
+        {0, 9 * 18, 240, 240}};
+
+    TextViewer dataEditView{
+        {0, 9 * 18, 240, 240}};
+
+    Button button_clear_marked{
+        {1 * 8, 14 * 16, 13 * 8, 3 * 8},
+        "Clear Marked"};

    Button button_save_packet{
        {1 * 8, 16 * 16, 13 * 8, 2 * 16},
@@ -283,6 +324,12 @@ class BLETxView : public View {
            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
            this->on_tx_progress(message.done);
        }};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->on_timer();
+        }};
 };

 } /* namespace ui */
@@ -65,9 +65,13 @@ std::string commodity_type(CommodityType value) {

 } /* namespace ert */

-void ERTLogger::on_packet(const ert::Packet& packet) {
+void ERTLogger::on_packet(const ert::Packet& packet, const uint32_t target_frequency) {
    const auto formatted = packet.symbols_formatted();
-    std::string entry = ert::format::type(packet.type()) + " " + formatted.data + "/" + formatted.errors;
+
+    // TODO: function doesn't take uint64_t, so when >= 1<<32, weirdness will ensue!
+    const auto target_frequency_str = to_string_dec_uint(target_frequency, 10);
+
+    std::string entry = target_frequency_str + " " + ert::format::type(packet.type()) + " " + formatted.data + "/" + formatted.errors;
    log_file.write_entry(packet.received_at(), entry);
 }

@@ -99,10 +103,12 @@ void RecentEntriesTable<ERTRecentEntries>::draw(
    painter.draw_string(target_rect.location(), style, line);
 }

-ERTAppView::ERTAppView(NavigationView&) {
+ERTAppView::ERTAppView(NavigationView& nav)
+    : nav_{nav} {
    baseband::run_image(portapack::spi_flash::image_tag_ert);

    add_children({
+        &field_frequency,
        &field_rf_amp,
        &field_lna,
        &field_vga,
@@ -110,6 +116,8 @@ ERTAppView::ERTAppView(NavigationView&) {
        &recent_entries_view,
    });

+    field_frequency.set_step(1000000);
+
    receiver_model.enable();

    logger = std::make_unique<ERTLogger>();
@@ -134,7 +142,7 @@ void ERTAppView::set_parent_rect(const Rect new_parent_rect) {

 void ERTAppView::on_packet(const ert::Packet& packet) {
    if (logger) {
-        logger->on_packet(packet);
+        logger->on_packet(packet, receiver_model.target_frequency());
    }

    if (packet.crc_ok()) {
@@ -24,6 +24,7 @@

 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
 #include "ui_rssi.hpp"
 #include "ui_channel.hpp"

@@ -95,7 +96,7 @@ class ERTLogger {
        return log_file.append(filename);
    }

-    void on_packet(const ert::Packet& packet);
+    void on_packet(const ert::Packet& packet, const uint32_t target_frequency);

   private:
    LogFile log_file{};
@@ -126,6 +127,7 @@ class ERTAppView : public View {
    ERTRecentEntries recent{};
    std::unique_ptr<ERTLogger> logger{};

+    NavigationView& nav_;
    RxRadioState radio_state_{
        911600000 /* frequency */,
        2500000 /* bandwidth */,
@@ -143,6 +145,10 @@ class ERTAppView : public View {

    static constexpr auto header_height = 1 * 16;

+    RxFrequencyField field_frequency{
+        {5 * 8, 0 * 16},
+        nav_};
+
    RFAmpField field_rf_amp{
        {13 * 8, 0 * 16}};

@@ -34,9 +34,6 @@ namespace tpms {

 namespace format {

-static bool use_kpa = true;
-static bool use_celsius = true;
-
 std::string type(Reading::Type type) {
    return to_string_dec_uint(toUType(type), 2);
 }
@@ -46,11 +43,11 @@ std::string id(TransponderID id) {
 }

 std::string pressure(Pressure pressure) {
-    return to_string_dec_int(use_kpa ? pressure.kilopascal() : pressure.psi(), 3);
+    return to_string_dec_int(units_psi ? pressure.psi() : pressure.kilopascal(), 3);
 }

 std::string temperature(Temperature temperature) {
-    return to_string_dec_int(use_celsius ? temperature.celsius() : temperature.fahrenheit(), 3);
+    return to_string_dec_int(units_fahr ? temperature.fahrenheit() : temperature.celsius(), 3);
 }

 std::string flags(Flags flags) {
@@ -165,18 +162,16 @@ TPMSAppView::TPMSAppView(NavigationView&) {
    options_band.set_by_value(receiver_model.target_frequency());

    options_pressure.on_change = [this](size_t, int32_t i) {
-        tpms::format::use_kpa = !i;
+        tpms::format::units_psi = (bool)i;
        update_view();
    };
-
-    options_pressure.set_selected_index(0, true);
+    options_pressure.set_selected_index(tpms::format::units_psi, true);

    options_temperature.on_change = [this](size_t, int32_t i) {
-        tpms::format::use_celsius = !i;
+        tpms::format::units_fahr = (bool)i;
        update_view();
    };
-
-    options_temperature.set_selected_index(0, true);
+    options_temperature.set_selected_index(tpms::format::units_fahr, true);

    logger = std::make_unique<TPMSLogger>();
    if (logger) {
@@ -37,6 +37,17 @@

 #include "tpms_packet.hpp"

+namespace tpms {
+
+namespace format {
+
+static bool units_psi{false};
+static bool units_fahr{false};
+
+} /* namespace format */
+
+} /* namespace tpms */
+
 namespace std {

 } /* namespace std */
@@ -103,11 +114,17 @@ class TPMSAppView : public View {

   private:
    RxRadioState radio_state_{
-        315000000 /* frequency*/,
+        314950000 /* frequency*/,
        1750000 /* bandwidth */,
        2457600 /* sampling rate */};
+
    app_settings::SettingsManager settings_{
-        "rx_tpms", app_settings::Mode::RX};
+        "rx_tpms",
+        app_settings::Mode::RX,
+        {
+            {"units_psi"sv, &tpms::format::units_psi},
+            {"units_fahr"sv, &tpms::format::units_fahr},
+        }};

    MessageHandlerRegistration message_handler_packet{
        Message::ID::TPMSPacket,
@@ -129,11 +146,12 @@ class TPMSAppView : public View {
        {21 * 8, 5, 6 * 8, 4},
    };

+    // "315 MHz" TPMS sensors transmit at either 314.9 or 315 MHz but we should pick up either
    OptionsField options_band{
        {0 * 8, 0 * 16},
        3,
        {
-            {"315", 315000000},
+            {"315", 314950000},
            {"434", 433920000},
        }};

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

@@ -1,6 +1,7 @@
 /*
 * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
 * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 Kyle Reed
 *
 * This file is part of PortaPack.
 *
@@ -20,21 +21,23 @@
 * Boston, MA 02110-1301, USA.
 */

-#include <strings.h>
+#include <algorithm>

 #include "ui_adsb_rx.hpp"
 #include "ui_alphanum.hpp"

-#include "rtc_time.hpp"
-#include "string_format.hpp"
 #include "baseband_api.hpp"
 #include "portapack_persistent_memory.hpp"
+#include "rtc_time.hpp"
+#include "string_format.hpp"

 using namespace portapack;

 namespace ui {

-bool ac_details_view_active{false};
+static std::string get_map_tag(const AircraftRecentEntry& entry) {
+    return trimr(entry.callsign.empty() ? entry.icao_str : entry.callsign);
+}

 template <>
 void RecentEntriesTable<AircraftRecentEntries>::draw(
@@ -43,23 +46,25 @@ void RecentEntriesTable<AircraftRecentEntries>::draw(
    Painter& painter,
    const Style& style) {
    Color target_color;
-    auto entry_age = entry.age;
    std::string entry_string;

-    // Color decay for flights not being updated anymore
-    if (entry_age < ADSB_CURRENT) {
-        entry_string = "";
-        target_color = Color::green();
-    } else if (entry_age < ADSB_RECENT) {
-        entry_string = STR_COLOR_LIGHT_GREY;
-        target_color = Color::light_grey();
-    } else {
-        entry_string = STR_COLOR_DARK_GREY;
-        target_color = Color::grey();
-    }
+    switch (entry.state) {
+        case ADSBAgeState::Invalid:
+        case ADSBAgeState::Current:
+            entry_string = "";
+            target_color = Color::green();
+            break;
+        case ADSBAgeState::Recent:
+            entry_string = STR_COLOR_LIGHT_GREY;
+            target_color = Color::light_grey();
+            break;
+        default:
+            entry_string = STR_COLOR_DARK_GREY;
+            target_color = Color::grey();
+    };

    entry_string +=
-        (entry.callsign[0] != ' ' ? entry.callsign + " " : entry.icaoStr + "   ") +
+        (entry.callsign.empty() ? entry.icao_str + "   " : entry.callsign + " ") +
        to_string_dec_uint((unsigned int)(entry.pos.altitude / 100), 4) +
        to_string_dec_uint((unsigned int)entry.velo.speed, 4) +
        to_string_dec_uint((unsigned int)(entry.amp >> 9), 4) + " " +
@@ -72,47 +77,59 @@ void RecentEntriesTable<AircraftRecentEntries>::draw(
        entry_string);

    if (entry.pos.valid)
-        painter.draw_bitmap(target_rect.location() + Point(8 * 8, 0), bitmap_target, target_color, style.background);
+        painter.draw_bitmap(target_rect.location() + Point(8 * 8, 0),
+                            bitmap_target, target_color, style.background);
 }

-void ADSBLogger::log_str(std::string& logline) {
-    log_file.write_entry(logline);
+/* ADSBLogger ********************************************/
+
+void ADSBLogger::log(const ADSBLogEntry& log_entry) {
+    std::string log_line;
+    log_line.reserve(100);
+
+    log_line = log_entry.raw_data;
+    log_line += "ICAO:" + log_entry.icao;
+
+    if (!log_entry.callsign.empty())
+        log_line += " " + log_entry.callsign;
+
+    if (log_entry.pos.valid)
+        log_line += " Alt:" + to_string_dec_int(log_entry.pos.altitude) +
+                    " Lat:" + to_string_decimal(log_entry.pos.latitude, 7) +
+                    " Lon:" + to_string_decimal(log_entry.pos.longitude, 7);
+
+    if (log_entry.vel.valid)
+        log_line += " Type:" + to_string_dec_uint(log_entry.vel_type) +
+                    " Hdg:" + to_string_dec_uint(log_entry.vel.heading) +
+                    " Spd: " + to_string_dec_int(log_entry.vel.speed);
+
+    log_file.write_entry(log_line);
 }

-// Aircraft Details
-void ADSBRxAircraftDetailsView::focus() {
-    button_close.focus();
-}
-
-ADSBRxAircraftDetailsView::~ADSBRxAircraftDetailsView() {
-    on_close_();
-}
+/* ADSBRxAircraftDetailsView *****************************/

 ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
    NavigationView& nav,
-    const AircraftRecentEntry& entry,
-    const std::function<void(void)> on_close)
-    : entry_copy(entry),
-      on_close_(on_close) {
-    add_children({&labels,
-                  &text_icao_address,
-                  &text_registration,
-                  &text_manufacturer,
-                  &text_model,
-                  &text_type,
-                  &text_number_of_engines,
-                  &text_engine_type,
-                  &text_owner,
-                  &text_operator,
-                  &button_close});
+    const AircraftRecentEntry& entry) {
+    add_children(
+        {&labels,
+         &text_icao_address,
+         &text_registration,
+         &text_manufacturer,
+         &text_model,
+         &text_type,
+         &text_number_of_engines,
+         &text_engine_type,
+         &text_owner,
+         &text_operator,
+         &button_close});

-    std::unique_ptr<ADSBLogger> logger{};
-
-    icao_code = to_string_hex(entry_copy.ICAO_address, 6);
-    text_icao_address.set(to_string_hex(entry_copy.ICAO_address, 6));
+    text_icao_address.set(entry.icao_str);

    // Try getting the aircraft information from icao24.db
-    return_code = db.retrieve_aircraft_record(&aircraft_record, icao_code);
+    std::database db{};
+    std::database::AircraftDBRecord aircraft_record;
+    auto return_code = db.retrieve_aircraft_record(&aircraft_record, entry.icao_str);
    switch (return_code) {
        case DATABASE_RECORD_FOUND:
            text_registration.set(aircraft_record.aircraft_registration);
@@ -120,6 +137,7 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
            text_model.set(aircraft_record.aircraft_model);
            text_owner.set(aircraft_record.aircraft_owner);
            text_operator.set(aircraft_record.aircraft_operator);
+
            // Check for ICAO type, e.g. L2J
            if (strlen(aircraft_record.icao_type) == 3) {
                switch (aircraft_record.icao_type[0]) {
@@ -142,7 +160,8 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
                        text_type.set("Tilt-wing aircraft");
                        break;
                }
-                text_number_of_engines.set(std::string(1, aircraft_record.icao_type[1]));
+
+                text_number_of_engines.set(std::string{1, aircraft_record.icao_type[1]});
                switch (aircraft_record.icao_type[2]) {
                    case 'P':
                        text_engine_type.set("Piston engine");
@@ -157,8 +176,8 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
                        text_engine_type.set("Electric engine");
                        break;
                }
-
            }
+
            // Check for ICAO type designator
            else if (strlen(aircraft_record.icao_type) == 4) {
                if (strcmp(aircraft_record.icao_type, "SHIP") == 0)
@@ -179,77 +198,49 @@ ADSBRxAircraftDetailsView::ADSBRxAircraftDetailsView(
                    text_type.set("Powered parachute/paraplane");
            }
            break;
+
        case DATABASE_NOT_FOUND:
            text_manufacturer.set("No icao24.db file");
            break;
    }
+
    button_close.on_select = [&nav](Button&) {
-        ac_details_view_active = false;
        nav.pop();
    };
-};
-
-// End of Aicraft details
-
-void ADSBRxDetailsView::focus() {
-    button_see_map.focus();
 }

-void ADSBRxDetailsView::update(const AircraftRecentEntry& entry) {
-    entry_copy = entry;
-    uint32_t age = entry_copy.age;
-
-    if (age < 60)
-        text_last_seen.set(to_string_dec_uint(age) + " seconds ago");
-    else
-        text_last_seen.set(to_string_dec_uint(age / 60) + " minutes ago");
-
-    text_infos.set(entry_copy.info_string);
-    if (entry_copy.velo.heading < 360 && entry_copy.velo.speed >= 0) {  // I don't like this but...
-        text_info2.set("Hdg:" + to_string_dec_uint(entry_copy.velo.heading) + " Spd:" + to_string_dec_int(entry_copy.velo.speed));
-    } else {
-        text_info2.set("");
-    }
-    text_frame_pos_even.set(to_string_hex_array(entry_copy.frame_pos_even.get_raw_data(), 14));
-    text_frame_pos_odd.set(to_string_hex_array(entry_copy.frame_pos_odd.get_raw_data(), 14));
-
-    if (send_updates) {
-        geomap_view->update_tag(trimr(entry.callsign[0] != ' ' ? entry.callsign : to_string_hex(entry.ICAO_address, 6)));
-        geomap_view->update_position(entry_copy.pos.latitude, entry_copy.pos.longitude, entry_copy.velo.heading, entry_copy.pos.altitude);
-    }
+void ADSBRxAircraftDetailsView::focus() {
+    button_close.focus();
 }

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

 ADSBRxDetailsView::ADSBRxDetailsView(
    NavigationView& nav,
-    const AircraftRecentEntry& entry,
-    const std::function<void(void)> on_close)
-    : entry_copy(entry),
-      on_close_(on_close) {
-    add_children({&labels,
-                  &text_icao_address,
-                  &text_callsign,
-                  &text_last_seen,
-                  &text_airline,
-                  &text_country,
-                  &text_infos,
-                  &text_info2,
-                  &text_frame_pos_even,
-                  &text_frame_pos_odd,
-                  &button_aircraft_details,
-                  &button_see_map});
+    const AircraftRecentEntry& entry)
+    : entry_(entry) {
+    add_children(
+        {&labels,
+         &text_icao_address,
+         &text_callsign,
+         &text_last_seen,
+         &text_airline,
+         &text_country,
+         &text_infos,
+         &text_info2,
+         &text_frame_pos_even,
+         &text_frame_pos_odd,
+         &button_aircraft_details,
+         &button_see_map});

-    std::unique_ptr<ADSBLogger> logger{};
-    update(entry_copy);
+    // The following won't change for a given airborne aircraft.
+    // Try getting the airline's name from airlines.db.
+    // NB: Only works once callsign has been read and won't be updated.
+    std::database db;
+    std::database::AirlinesDBRecord airline_record;
+    std::string airline_code = entry_.callsign.substr(0, 3);
+    auto return_code = db.retrieve_airline_record(&airline_record, airline_code);

-    // The following won't (shouldn't !) change for a given airborne aircraft
-    // Try getting the airline's name from airlines.db
-    airline_code = entry_copy.callsign.substr(0, 3);
-    return_code = db.retrieve_airline_record(&airline_record, airline_code);
    switch (return_code) {
        case DATABASE_RECORD_FOUND:
            text_airline.set(airline_record.airline);
@@ -260,34 +251,125 @@ ADSBRxDetailsView::ADSBRxDetailsView(
            break;
    }

-    text_callsign.set(entry_copy.callsign);
-    text_icao_address.set(to_string_hex(entry_copy.ICAO_address, 6));
+    text_icao_address.set(entry_.icao_str);

    button_aircraft_details.on_select = [this, &nav](Button&) {
-        ac_details_view_active = true;
-        aircraft_details_view = nav.push<ADSBRxAircraftDetailsView>(entry_copy, [this]() { send_updates = false; });
-        send_updates = false;
+        aircraft_details_view_ = nav.push<ADSBRxAircraftDetailsView>(entry_);
+        nav.set_on_pop([this]() {
+            aircraft_details_view_ = nullptr;
+            refresh_ui();
+        });
    };

    button_see_map.on_select = [this, &nav](Button&) {
-        if (!send_updates) {  // Prevent recursively launching the map
-            geomap_view = nav.push<GeoMapView>(
-                trimr(entry_copy.callsign[0] != ' ' ? entry_copy.callsign : entry_copy.icaoStr),
-                entry_copy.pos.altitude,
-                GeoPos::alt_unit::FEET,
-                entry_copy.pos.latitude,
-                entry_copy.pos.longitude,
-                entry_copy.velo.heading,
-                [this]() {
-                    send_updates = false;
-                });
-            send_updates = true;
-        }
+        geomap_view_ = nav.push<GeoMapView>(
+            get_map_tag(entry_),
+            entry_.pos.altitude,
+            GeoPos::alt_unit::FEET,
+            entry_.pos.latitude,
+            entry_.pos.longitude,
+            entry_.velo.heading);
+        nav.set_on_pop([this]() {
+            geomap_view_ = nullptr;
+            refresh_ui();
+        });
    };
+
+    refresh_ui();
 };

-void ADSBRxView::focus() {
-    field_vga.focus();
+void ADSBRxDetailsView::focus() {
+    button_see_map.focus();
+}
+
+void ADSBRxDetailsView::update(const AircraftRecentEntry& entry) {
+    entry_ = entry;
+
+    if (aircraft_details_view_) {
+        // AC Details view is showing, nothing to update.
+    } else if (geomap_view_) {
+        // Map is showing, update the current item.
+        geomap_view_->update_tag(get_map_tag(entry_));
+        geomap_view_->update_position(entry.pos.latitude, entry.pos.longitude, entry.velo.heading, entry.pos.altitude);
+    } else {
+        // Details is showing, update details.
+        refresh_ui();
+    }
+}
+
+void ADSBRxDetailsView::clear_map_markers() {
+    if (geomap_view_)
+        geomap_view_->clear_markers();
+}
+
+bool ADSBRxDetailsView::add_map_marker(const AircraftRecentEntry& entry) {
+    // Map not shown, can't add markers.
+    if (!geomap_view_)
+        return false;
+
+    GeoMarker marker{};
+    marker.lon = entry.pos.longitude;
+    marker.lat = entry.pos.latitude;
+    marker.angle = entry.velo.heading;
+    marker.tag = get_map_tag(entry);
+
+    auto markerStored = geomap_view_->store_marker(marker);
+    return markerStored == MARKER_STORED;
+}
+
+void ADSBRxDetailsView::refresh_ui() {
+    auto age = entry_.age;
+    if (age < 60)
+        text_last_seen.set(to_string_dec_uint(age) + " seconds ago");
+    else
+        text_last_seen.set(to_string_dec_uint(age / 60) + " minutes ago");
+
+    text_callsign.set(entry_.callsign);
+    text_infos.set(entry_.info_string);
+    if (entry_.velo.heading < 360 && entry_.velo.speed >= 0)
+        text_info2.set("Hdg:" + to_string_dec_uint(entry_.velo.heading) +
+                       " Spd:" + to_string_dec_int(entry_.velo.speed));
+    else
+        text_info2.set("");
+
+    text_frame_pos_even.set(to_string_hex_array(entry_.frame_pos_even.get_raw_data(), 14));
+    text_frame_pos_odd.set(to_string_hex_array(entry_.frame_pos_odd.get_raw_data(), 14));
+}
+
+/* ADSBRxView ********************************************/
+
+ADSBRxView::ADSBRxView(NavigationView& nav) {
+    baseband::run_image(portapack::spi_flash::image_tag_adsb_rx);
+    add_children(
+        {&labels,
+         &field_lna,
+         &field_vga,
+         &field_rf_amp,
+         &rssi,
+         &recent_entries_view,
+         &status_frame,
+         &status_good_frame});
+
+    recent_entries_view.set_parent_rect({0, 16, 240, 272});
+    recent_entries_view.on_select = [this, &nav](const AircraftRecentEntry& entry) {
+        detail_key = entry.key();
+        details_view = nav.push<ADSBRxDetailsView>(entry);
+
+        nav.set_on_pop([this]() {
+            detail_key = AircraftRecentEntry::invalid_key;
+            details_view = nullptr;
+        });
+    };
+
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        on_tick_second();
+    };
+
+    logger = std::make_unique<ADSBLogger>();
+    logger->append(LOG_ROOT_DIR "/ADSB.TXT");
+
+    receiver_model.enable();
+    baseband::set_adsb();
 }

 ADSBRxView::~ADSBRxView() {
@@ -296,232 +378,185 @@ ADSBRxView::~ADSBRxView() {
    baseband::shutdown();
 }

-AircraftRecentEntry ADSBRxView::find_or_create_entry(uint32_t ICAO_address) {
-    auto it = find(recent, ICAO_address);
-
-    // If not found
-    if (it == std::end(recent)) {
-        recent.emplace_front(ICAO_address);  // Add it
-        it = find(recent, ICAO_address);     // Find it again
-    }
-    return *it;
-}
-
-void ADSBRxView::replace_entry(AircraftRecentEntry& entry) {
-    uint32_t ICAO_address = entry.ICAO_address;
-
-    std::replace_if(
-        recent.begin(), recent.end(),
-        [ICAO_address](const AircraftRecentEntry& compEntry) { return ICAO_address == compEntry.ICAO_address; },
-        entry);
-}
-
-void ADSBRxView::remove_old_entries() {
-    auto it = recent.rbegin();
-    auto end = recent.rend();
-    while (it != end) {
-        if (it->age_state >= 4) {
-            std::advance(it, 1);
-            recent.erase(it.base());
-        } else {
-            break;  // stop looking because the list is sorted
-        }
-    }
-}
-
-void ADSBRxView::sort_entries_by_state() {
-    // Sorting List pn age_state using lambda function as comparator
-    recent.sort([](const AircraftRecentEntry& left, const AircraftRecentEntry& right) { return (left.age_state < right.age_state); });
+void ADSBRxView::focus() {
+    field_vga.focus();
 }

 void ADSBRxView::on_frame(const ADSBFrameMessage* message) {
-    logger = std::make_unique<ADSBLogger>();
-    rtc::RTC datetime;
-    std::string callsign;
-    std::string str_info;
-    std::string logentry;
-
    auto frame = message->frame;
    uint32_t ICAO_address = frame.get_ICAO_address();
+    status_frame.toggle();

-    if (frame.check_CRC() && ICAO_address) {
-        rtcGetTime(&RTCD1, &datetime);
-        auto entry = find_or_create_entry(ICAO_address);
-        frame.set_rx_timestamp(datetime.minute() * 60 + datetime.second());
-        entry.reset_age();
-        if (entry.hits == 0) {
-            entry.amp = message->amp;  // Store amplitude on first hit
-        } else {
-            entry.amp = ((entry.amp * 15) + message->amp) >> 4;  // Update smoothed amplitude on updates
+    // Bad frame, skip it.
+    if (!frame.check_CRC() || ICAO_address == 0)
+        return;
+
+    ADSBLogEntry log_entry;
+    status_good_frame.toggle();
+
+    rtc::RTC datetime;
+    rtcGetTime(&RTCD1, &datetime);
+    frame.set_rx_timestamp(datetime.minute() * 60 + datetime.second());
+
+    // NB: Reference to update entry in-place.
+    auto& entry = find_or_create_entry(ICAO_address);
+    entry.inc_hit();
+    entry.reset_age();
+
+    // Store smoothed amplitude on updates.
+    entry.amp = entry.hits == 0
+                    ? message->amp
+                    : ((entry.amp * 15) + message->amp) >> 4;
+
+    log_entry.raw_data = to_string_hex_array(frame.get_raw_data(), 14);
+    log_entry.icao = entry.icao_str;
+
+    if (frame.get_DF() == DF_ADSB) {
+        uint8_t msg_type = frame.get_msg_type();
+        uint8_t msg_sub = frame.get_msg_sub();
+        uint8_t* raw_data = frame.get_raw_data();
+
+        // 4: // surveillance, altitude reply
+        if ((msg_type >= AIRCRAFT_ID_L) && (msg_type <= AIRCRAFT_ID_H)) {
+            entry.set_callsign(decode_frame_id(frame));
+            log_entry.callsign = entry.callsign;
        }

-        entry.inc_hit();
-        if (logger) {
-            logentry += to_string_hex_array(frame.get_raw_data(), 14) + " ";
-            logentry += "ICAO:" + entry.icaoStr + " ";
-        }
+        // 9:
+        // 18: // Extended squitter/non-transponder
+        // 21: // Comm-B, identity reply
+        // 20: // Comm-B, altitude reply
+        else if (((msg_type >= AIRBORNE_POS_BARO_L) && (msg_type <= AIRBORNE_POS_BARO_H)) ||
+                 ((msg_type >= AIRBORNE_POS_GPS_L) && (msg_type <= AIRBORNE_POS_GPS_H))) {
+            entry.set_frame_pos(frame, raw_data[6] & 4);
+            log_entry.pos = entry.pos;

-        if (frame.get_DF() == DF_ADSB) {
-            uint8_t msg_type = frame.get_msg_type();
-            uint8_t msg_sub = frame.get_msg_sub();
-            uint8_t* raw_data = frame.get_raw_data();
+            if (entry.pos.valid) {
+                std::string str_info =
+                    "Alt:" + to_string_dec_int(entry.pos.altitude) +
+                    " Lat:" + to_string_decimal(entry.pos.latitude, 2) +
+                    " Lon:" + to_string_decimal(entry.pos.longitude, 2);

-            // 4: // surveillance, altitude reply
-            if ((msg_type >= AIRCRAFT_ID_L) && (msg_type <= AIRCRAFT_ID_H)) {
-                callsign = decode_frame_id(frame);
-                entry.set_callsign(callsign);
-                if (logger) {
-                    logentry += callsign + " ";
-                }
+                entry.set_info_string(std::move(str_info));
            }
-            // 9:
-            // 18: { // Extended squitter/non-transponder
-            // 21: // Comm-B, identity reply
-            // 20: // Comm-B, altitude reply
-            else if (((msg_type >= AIRBORNE_POS_BARO_L) && (msg_type <= AIRBORNE_POS_BARO_H)) ||
-                     ((msg_type >= AIRBORNE_POS_GPS_L) && (msg_type <= AIRBORNE_POS_GPS_H))) {
-                entry.set_frame_pos(frame, raw_data[6] & 4);

-                if (entry.pos.valid) {
-                    str_info = "Alt:" + to_string_dec_int(entry.pos.altitude) +
-                               " Lat:" + to_string_decimal(entry.pos.latitude, 2) +
-                               " Lon:" + to_string_decimal(entry.pos.longitude, 2);
-
-                    entry.set_info_string(str_info);
-
-                    if (logger) {
-                        // printing the coordinates in the log file with more
-                        // resolution, as we are not constrained by screen
-                        // real estate there:
-
-                        std::string log_info = "Alt:" + to_string_dec_int(entry.pos.altitude) +
-                                               " Lat:" + to_string_decimal(entry.pos.latitude, 7) +
-                                               " Lon:" + to_string_decimal(entry.pos.longitude, 7);
-                        logentry += log_info + " ";
-                    }
-                }
-            } else if (msg_type == AIRBORNE_VEL && msg_sub >= VEL_GND_SUBSONIC && msg_sub <= VEL_AIR_SUPERSONIC) {
-                entry.set_frame_velo(frame);
-                if (logger) {
-                    logger->append(LOG_ROOT_DIR "/ADSB.TXT");
-                    logentry += "Type:" + to_string_dec_uint(msg_sub) +
-                                " Hdg:" + to_string_dec_uint(entry.velo.heading) +
-                                " Spd: " + to_string_dec_int(entry.velo.speed);
-                }
-            }
-            replace_entry(entry);
-        }  // frame.get_DF() == DF_ADSB
-
-        if (logger) {
-            logger->append(LOG_ROOT_DIR "/ADSB.TXT");
-            // will log each frame in format:
-            // 20171103100227 8DADBEEFDEADBEEFDEADBEEFDEADBEEF ICAO:nnnnnn callsign Alt:nnnnnn Latnnn.nn Lonnnn.nn
-            logger->log_str(logentry);
+        } else if (msg_type == AIRBORNE_VEL && msg_sub >= VEL_GND_SUBSONIC && msg_sub <= VEL_AIR_SUPERSONIC) {
+            entry.set_frame_velo(frame);
+            log_entry.vel = entry.velo;
+            log_entry.vel_type = msg_sub;
        }
    }
+
+    logger->log(log_entry);
 }

 void ADSBRxView::on_tick_second() {
-    if (recent.size() <= 16) {  // Not many entries update everything (16 is one screen full)
-        updateDetailsAndMap(1);
-        updateRecentEntries();
-    } else if (updateState == 0) {  // Even second
-        updateState = 1;
-        updateDetailsAndMap(2);
-    } else {  // Odd second only performed when there are many entries
-        updateState = 0;
-        updateRecentEntries();
+    status_frame.reset();
+    status_good_frame.reset();
+
+    ++tick_count;
+    ++ticks_since_marker_refresh;
+
+    // Small list, update all at once.
+    if (recent.size() <= max_update_entries) {
+        update_recent_entries(/*age_delta*/ 1);
+        refresh_ui();
+        return;
    }
+
+    // Too many items, split update work into two phases:
+    // Entry maintenance and UI update.
+    if ((tick_count & 1) == 0)
+        update_recent_entries(/*age_delta*/ 2);
+    else
+        refresh_ui();
 }

-void ADSBRxView::updateDetailsAndMap(int ageStep) {
-    ui::GeoMarker marker;
-    bool storeNewMarkers = false;
+void ADSBRxView::refresh_ui() {
+    // There's only one ticks handler, but 3 UIs that need to be updated.
+    // This code will dispatch updates to the currently active view.

-    // NB: Temporarily pausing updates in rtc_timer_tick context when viewing AC Details screen (kludge for some Guru faults)
-    // TODO: More targeted blocking of updates in rtc_timer_tick when ADSB processes are running
-    if (ac_details_view_active)
-        return;
+    if (details_view) {
+        // The details view is showing, forward updates to that UI.
+        bool current_updated = false;
+        bool map_needs_update = false;

-    // Sort and truncate the entries, grouped, newest group first
-    sort_entries_by_state();
-    truncate_entries(recent);
-    remove_old_entries();
+        if (details_view->map_active()) {
+            // Is it time to clear and refresh the map's markers?
+            if (ticks_since_marker_refresh >= MARKER_UPDATE_SECONDS) {
+                map_needs_update = true;
+                ticks_since_marker_refresh = 0;
+                details_view->clear_map_markers();
+            }
+        } else {
+            // Refresh map immediately once active.
+            ticks_since_marker_refresh = MARKER_UPDATE_SECONDS;
+        }

-    // Calculate if it is time to update markers
-    if (send_updates && details_view && details_view->geomap_view) {
-        ticksSinceMarkerRefresh += ageStep;
-        if (ticksSinceMarkerRefresh >= MARKER_UPDATE_SECONDS) {  // Update other aircraft every few seconds
-            storeNewMarkers = true;
-            ticksSinceMarkerRefresh = 0;
+        // Process the entries list.
+        for (const auto& entry : recent) {
+            // Found the entry being shown in details view. Update it.
+            if (entry.key() == detail_key) {
+                details_view->update(entry);
+                current_updated = true;
+            }
+
+            // NB: current entry also gets a marker so it shows up if map is panned.
+            if (map_needs_update && entry.pos.valid && entry.state <= ADSBAgeState::Recent) {
+                map_needs_update = details_view->add_map_marker(entry);
+            }
+
+            // Any work left to do?
+            if (current_updated && !map_needs_update)
+                break;
        }
    } else {
-        ticksSinceMarkerRefresh = MARKER_UPDATE_SECONDS;  // Send the markers as soon as the geoview exists
-    }
-
-    // Increment age, and pass updates to the details and map
-    const bool otherMarkersCanBeSent = send_updates && storeNewMarkers && details_view && details_view->geomap_view;  // Save retesting all of this
-    MapMarkerStored markerStored = MARKER_NOT_STORED;
-    if (otherMarkersCanBeSent) {
-        details_view->geomap_view->clear_markers();
-    }
-    // Loop through all entries
-    for (auto& entry : recent) {
-        entry.inc_age(ageStep);
-
-        // Only if there is a details view
-        if (send_updates && details_view) {
-            if (entry.key() == detailed_entry_key)  // Check if the ICAO address match
-            {
-                details_view->update(entry);
-            }
-            // Store if the view is present and the list isn't full
-            // Note -- Storing the selected entry too, in case map panning occurs
-            if (otherMarkersCanBeSent && (markerStored != MARKER_LIST_FULL) && entry.pos.valid && (entry.age_state <= 2)) {
-                marker.lon = entry.pos.longitude;
-                marker.lat = entry.pos.latitude;
-                marker.angle = entry.velo.heading;
-                marker.tag = trimr(entry.callsign[0] != ' ' ? entry.callsign : entry.icaoStr);
-                markerStored = details_view->geomap_view->store_marker(marker);
-            }
-        }
-    }  // Loop through all entries, if only to update the age
-}
-
-void ADSBRxView::updateRecentEntries() {
-    // Redraw the list of aircraft
-    if (!send_updates) {
+        // Main page is the top view. Redraw the entries view.
        recent_entries_view.set_dirty();
    }
 }

-ADSBRxView::ADSBRxView(NavigationView& nav) {
-    baseband::run_image(portapack::spi_flash::image_tag_adsb_rx);
-    add_children({&labels,
-                  &field_lna,
-                  &field_vga,
-                  &field_rf_amp,
-                  &rssi,
-                  &recent_entries_view});
+void ADSBRxView::update_recent_entries(int age_delta) {
+    for (auto& entry : recent)
+        entry.inc_age(age_delta);

-    recent_entries_view.set_parent_rect({0, 16, 240, 272});
-    recent_entries_view.on_select = [this, &nav](const AircraftRecentEntry& entry) {
-        detailed_entry_key = entry.key();
-        details_view = nav.push<ADSBRxDetailsView>(
-            entry,
-            [this]() {
-                send_updates = false;
-            });
-        send_updates = true;
-    };
+    // Sort and truncate the entries, grouped by state, newest first.
+    sort_entries_by_state();
+    truncate_entries(recent);
+    remove_expired_entries();
+}

-    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
-        on_tick_second();
-    };
+AircraftRecentEntry& ADSBRxView::find_or_create_entry(uint32_t ICAO_address) {
+    // Find ...
+    auto it = find(recent, ICAO_address);
+    if (it != recent.end())
+        return *it;

-    baseband::set_adsb();
+    // ... or Create.
+    return recent.emplace_front(ICAO_address);
+}

-    receiver_model.enable();
+void ADSBRxView::sort_entries_by_state() {
+    recent.sort([](const auto& left, const auto& right) {
+        return (left.state < right.state);
+    });
+}
+
+void ADSBRxView::remove_expired_entries() {
+    // NB: Assumes entried are sorted with oldest last.
+    auto it = recent.rbegin();
+    auto end = recent.rend();
+
+    // Find the first !expired entry from the back.
+    while (it != end) {
+        if (it->state != ADSBAgeState::Expired)
+            break;
+
+        std::advance(it, 1);
+    }
+
+    // Remove the range of expired items.
+    recent.erase(it.base(), recent.end());
 }

 } /* namespace ui */
@@ -1,6 +1,7 @@
 /*
 * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
 * Copyright (C) 2017 Furrtek
+ * Copyright (C) 2023 Kyle Reed
 *
 * This file is part of PortaPack.
 *
@@ -21,29 +22,23 @@
 */

 #include "ui.hpp"
-
 #include "ui_receiver.hpp"
 #include "ui_geomap.hpp"
-#include "string_format.hpp"

-#include "file.hpp"
-#include "database.hpp"
-#include "recent_entries.hpp"
-#include "log_file.hpp"
 #include "adsb.hpp"
-#include "message.hpp"
 #include "app_settings.hpp"
-#include "radio_state.hpp"
 #include "crc.hpp"
+#include "database.hpp"
+#include "file.hpp"
+#include "log_file.hpp"
+#include "message.hpp"
+#include "radio_state.hpp"
+#include "recent_entries.hpp"
+#include "string_format.hpp"

 using namespace adsb;

 namespace ui {
-
-#define ADSB_CURRENT 10  // Seconds
-#define ADSB_RECENT 30   // Seconds
-#define ADSB_REMOVE 300  // Used for removing old entries
-
 #define AIRCRAFT_ID_L 1  // aircraft ID message type (lowest type id)
 #define AIRCRAFT_ID_H 4  // aircraft ID message type (highest type id)

@@ -66,8 +61,26 @@ namespace ui {
 #define VEL_AIR_SUBSONIC 3
 #define VEL_AIR_SUPERSONIC 4

-#define O_E_FRAME_TIMEOUT 20  // timeout between odd and even frames
+#define O_E_FRAME_TIMEOUT 20     // timeout between odd and even frames
+#define MARKER_UPDATE_SECONDS 5  // "other" map marker redraw interval

+/* Thresholds (in seconds) that define the transition between ages. */
+struct ADSBAgeLimit {
+    static constexpr int Current = 10;
+    static constexpr int Recent = 30;
+    static constexpr int Expired = 300;
+};
+
+/* Age states used for sorting and drawing recent entries. */
+enum class ADSBAgeState : uint8_t {
+    Invalid,
+    Current,
+    Recent,
+    Old,
+    Expired,
+};
+
+/* Data extracted from ADSB frames. */
 struct AircraftRecentEntry {
    using Key = uint32_t;

@@ -76,30 +89,30 @@ struct AircraftRecentEntry {
    uint32_t ICAO_address{};
    uint16_t hits{0};

-    uint16_t age_state{1};
-    uint32_t age{0};
+    ADSBAgeState state{ADSBAgeState::Invalid};
+    uint32_t age{0};  // In seconds
    uint32_t amp{0};
    adsb_pos pos{false, 0, 0, 0};
    adsb_vel velo{false, 0, 999, 0};
    ADSBFrame frame_pos_even{};
    ADSBFrame frame_pos_odd{};

-    std::string icaoStr{"      "};
-    std::string callsign{"        "};
-    std::string info_string{""};
+    std::string icao_str{};
+    std::string callsign{};
+    std::string info_string{};

-    AircraftRecentEntry(
-        const uint32_t ICAO_address)
+    AircraftRecentEntry(const uint32_t ICAO_address)
        : ICAO_address{ICAO_address} {
-        this->icaoStr = to_string_hex(ICAO_address, 6);
+        this->icao_str = to_string_hex(ICAO_address, 6);
    }

+    /* RecentEntries helpers expect a "key" on every item. */
    Key key() const {
        return ICAO_address;
    }

-    void set_callsign(std::string& new_callsign) {
-        callsign = new_callsign;
+    void set_callsign(std::string new_callsign) {
+        callsign = std::move(new_callsign);
    }

    void inc_hit() {
@@ -122,8 +135,8 @@ struct AircraftRecentEntry {
        velo = decode_frame_velo(frame);
    }

-    void set_info_string(std::string& new_info_string) {
-        info_string = new_info_string;
+    void set_info_string(std::string new_info_string) {
+        info_string = std::move(new_info_string);
    }

    void reset_age() {
@@ -132,59 +145,59 @@ struct AircraftRecentEntry {

    void inc_age(int delta) {
        age += delta;
-        if (age < ADSB_CURRENT) {
-            age_state = pos.valid ? 0 : 1;
-        } else if (age < ADSB_RECENT) {
-            age_state = 2;
-        } else if (age < ADSB_REMOVE) {
-            age_state = 3;
-        } else {
-            age_state = 4;
-        }
+
+        if (age < ADSBAgeLimit::Current)
+            state = pos.valid ? ADSBAgeState::Invalid
+                              : ADSBAgeState::Current;
+
+        else if (age < ADSBAgeLimit::Recent)
+            state = ADSBAgeState::Recent;
+
+        else if (age < ADSBAgeLimit::Expired)
+            state = ADSBAgeState::Old;
+
+        else
+            state = ADSBAgeState::Expired;
    }
 };

+// NB: uses std::list underneath so assuming refs are NOT invalidated.
 using AircraftRecentEntries = RecentEntries<AircraftRecentEntry>;

+/* Holds data for logging. */
+struct ADSBLogEntry {
+    std::string raw_data{};
+    std::string icao{};
+    std::string callsign{};
+    adsb_pos pos{};
+    adsb_vel vel{};
+    uint8_t vel_type{};
+};
+
+// TODO: Make logging optional.
+/* Logs entries to a log file. */
 class ADSBLogger {
   public:
    Optional<File::Error> append(const std::filesystem::path& filename) {
        return log_file.append(filename);
    }
-    void log_str(std::string& logline);
+    void log(const ADSBLogEntry& log_entry);

   private:
    LogFile log_file{};
 };

+/* Shows detailed information about an aircraft. */
 class ADSBRxAircraftDetailsView : public View {
   public:
-    ADSBRxAircraftDetailsView(NavigationView&, const AircraftRecentEntry& entry, const std::function<void(void)> on_close);
-    ~ADSBRxAircraftDetailsView();
-
-    ADSBRxAircraftDetailsView(const ADSBRxAircraftDetailsView&) = delete;
-    ADSBRxAircraftDetailsView(ADSBRxAircraftDetailsView&&) = delete;
-    ADSBRxAircraftDetailsView& operator=(const ADSBRxAircraftDetailsView&) = delete;
-    ADSBRxAircraftDetailsView& operator=(ADSBRxAircraftDetailsView&&) = delete;
+    ADSBRxAircraftDetailsView(
+        NavigationView&,
+        const AircraftRecentEntry& entry);

    void focus() override;
-
-    void update(const AircraftRecentEntry& entry);
-
-    std::string title() const override { return "AC Details"; };
-
-    AircraftRecentEntry get_current_entry() { return entry_copy; }
-
-    std::database::AircraftDBRecord aircraft_record = {};
+    std::string title() const override { return "AC Details"; }

   private:
-    AircraftRecentEntry entry_copy{0};
-    std::function<void(void)> on_close_{};
-    bool send_updates{false};
-    std::database db = {};
-    std::string icao_code = "";
-    int return_code = 0;
-
    Labels labels{
        {{0 * 8, 1 * 16}, "ICAO:", Color::light_grey()},
        {{0 * 8, 2 * 16}, "Registration:", Color::light_grey()},
@@ -237,36 +250,34 @@ class ADSBRxAircraftDetailsView : public View {
        "Back"};
 };

+/* Shows detailed information about an aircraft's flight. */
 class ADSBRxDetailsView : public View {
   public:
-    ADSBRxDetailsView(NavigationView&, const AircraftRecentEntry& entry, const std::function<void(void)> on_close);
-    ~ADSBRxDetailsView();
+    ADSBRxDetailsView(NavigationView&, const AircraftRecentEntry& entry);

    ADSBRxDetailsView(const ADSBRxDetailsView&) = delete;
-    ADSBRxDetailsView(ADSBRxDetailsView&&) = delete;
    ADSBRxDetailsView& operator=(const ADSBRxDetailsView&) = delete;
-    ADSBRxDetailsView& operator=(ADSBRxDetailsView&&) = delete;

    void focus() override;
-
    void update(const AircraftRecentEntry& entry);

-    std::string title() const override { return "Details"; };
+    /* Calls forwarded to map view if shown. */
+    bool map_active() const { return geomap_view_; }
+    void clear_map_markers();
+    /* Adds a marker for the entry to the map. Returns true on success. */
+    bool add_map_marker(const AircraftRecentEntry& entry);

-    AircraftRecentEntry get_current_entry() { return entry_copy; }
-
-    std::database::AirlinesDBRecord airline_record = {};
-
-    GeoMapView* geomap_view{nullptr};
+    std::string title() const override { return "Details"; }

   private:
-    AircraftRecentEntry entry_copy{0};
-    std::function<void(void)> on_close_{};
-    ADSBRxAircraftDetailsView* aircraft_details_view{nullptr};
-    bool send_updates{false};
-    std::database db = {};
-    std::string airline_code = "";
-    int return_code = 0;
+    void refresh_ui();
+
+    GeoMapView* geomap_view_{nullptr};
+    ADSBRxAircraftDetailsView* aircraft_details_view_{nullptr};
+
+    // NB: Keeping a copy so that it doesn't end up dangling
+    // if removed from the recent entries list.
+    AircraftRecentEntry entry_{AircraftRecentEntry::invalid_key};

    Labels labels{
        {{0 * 8, 1 * 16}, "ICAO:", Color::light_grey()},
@@ -321,6 +332,7 @@ class ADSBRxDetailsView : public View {
        "See on map"};
 };

+/* Main ADSB application view and message dispatch. */
 class ADSBRxView : public View {
   public:
    ADSBRxView(NavigationView& nav);
@@ -332,46 +344,52 @@ class ADSBRxView : public View {
    ADSBRxView& operator=(ADSBRxView&&) = delete;

    void focus() override;
-
    std::string title() const override { return "ADS-B RX"; };

-    void replace_entry(AircraftRecentEntry& entry);
-    void remove_old_entries();
-    AircraftRecentEntry find_or_create_entry(uint32_t ICAO_address);
-    void sort_entries_by_state();
-
   private:
    RxRadioState radio_state_{
-        1090000000 /* frequency */,
-        2500000 /* bandwidth */,
-        2000000 /* sampling rate */,
+        1'090'000'000 /* frequency */,
+        2'500'000 /* bandwidth */,
+        2'000'000 /* sampling rate */,
        ReceiverModel::Mode::SpectrumAnalysis};
    app_settings::SettingsManager settings_{
        "rx_adsb", app_settings::Mode::RX};

    std::unique_ptr<ADSBLogger> logger{};
+
+    /* Event Handlers */
    void on_frame(const ADSBFrameMessage* message);
    void on_tick_second();
-    int updateState = {0};
-    void updateRecentEntries();
-    void updateDetailsAndMap(int ageStep);
-
-#define MARKER_UPDATE_SECONDS (5)
-    int ticksSinceMarkerRefresh{MARKER_UPDATE_SECONDS - 1};
-
-    const RecentEntriesColumns columns{{{"ICAO/Call", 9},
-                                        {"Lvl", 3},
-                                        {"Spd", 3},
-                                        {"Amp", 3},
-                                        {"Hit", 3},
-                                        {"Age", 4}}};
-    AircraftRecentEntries recent{};
-    RecentEntriesView<RecentEntries<AircraftRecentEntry>> recent_entries_view{columns, recent};
+    void refresh_ui();

    SignalToken signal_token_tick_second{};
+    uint8_t tick_count = 0;
+    uint16_t ticks_since_marker_refresh{MARKER_UPDATE_SECONDS};
+
+    /* Max number of entries that can be updated in a single pass.
+     * 16 is one screen of recent entries. */
+    static constexpr uint8_t max_update_entries = 16;
+
+    /* Recent Entries */
+    const RecentEntriesColumns columns{
+        {{"ICAO/Call", 9},
+         {"Lvl", 3},
+         {"Spd", 3},
+         {"Amp", 3},
+         {"Hit", 3},
+         {"Age", 4}}};
+    AircraftRecentEntries recent{};
+    RecentEntriesView<AircraftRecentEntries> recent_entries_view{columns, recent};
+
+    /* Entry Management */
+    void update_recent_entries(int age_delta);
+    AircraftRecentEntry& find_or_create_entry(uint32_t ICAO_address);
+    void sort_entries_by_state();
+    void remove_expired_entries();
+
+    /* The key of the entry in the details view if shown. */
+    AircraftRecentEntry::Key detail_key{AircraftRecentEntry::invalid_key};
    ADSBRxDetailsView* details_view{nullptr};
-    uint32_t detailed_entry_key{0};
-    bool send_updates{false};

    Labels labels{
        {{0 * 8, 0 * 8}, "LNA:   VGA:   AMP:", Color::light_grey()}};
@@ -386,7 +404,17 @@ class ADSBRxView : public View {
        {18 * 8, 0 * 16}};

    RSSI rssi{
-        {20 * 8, 4, 10 * 8, 8},
+        {20 * 8, 4, 10 * 7, 8},
+    };
+
+    ActivityDot status_frame{
+        {screen_width - 3, 5, 2, 2},
+        Color::white(),
+    };
+
+    ActivityDot status_good_frame{
+        {screen_width - 3, 9, 2, 2},
+        Color::green(),
    };

    MessageHandlerRegistration message_handler_frame{
@@ -159,11 +159,8 @@ void TemperatureView::focus() {
 /* RegistersWidget *******************************************************/

 RegistersWidget::RegistersWidget(
-    RegistersWidgetConfig&& config,
-    std::function<uint32_t(const size_t register_number)>&& reader)
-    : Widget{},
-      config(std::move(config)),
-      reader(std::move(reader)) {
+    RegistersWidgetConfig&& config)
+    : Widget{}, config(std::move(config)), page_number(0) {
 }

 void RegistersWidget::update() {
@@ -180,7 +177,7 @@ void RegistersWidget::paint(Painter& painter) {
 void RegistersWidget::draw_legend(const Coord left, Painter& painter) {
    const auto pos = screen_pos();

-    for (size_t i = 0; i < config.registers_count; i += config.registers_per_row()) {
+    for (uint32_t i = 0; i < config.registers_count; i += config.registers_per_row()) {
        const Point offset{
            left, static_cast<int>((i / config.registers_per_row()) * row_height)};

@@ -197,12 +194,12 @@ void RegistersWidget::draw_values(
    Painter& painter) {
    const auto pos = screen_pos();

-    for (size_t i = 0; i < config.registers_count; i++) {
+    for (uint32_t i = 0; i < config.registers_count; i++) {
        const Point offset = {
            static_cast<int>(left + config.legend_width() + 8 + (i % config.registers_per_row()) * (config.value_width() + 8)),
            static_cast<int>((i / config.registers_per_row()) * row_height)};

-        const auto value = reader(i);
+        const auto value = reg_read(i);

        const auto text = to_string_hex(value, config.value_length());
        painter.draw_string(
@@ -212,19 +209,61 @@ void RegistersWidget::draw_values(
    }
 }

+uint32_t RegistersWidget::reg_read(const uint32_t register_number) {
+    if (register_number < config.registers_count) {
+        switch (config.chip_type) {
+            case CT_PMEM:
+                return portapack::persistent_memory::pmem_data_word((page_number * config.registers_count + register_number) / 4) >> (register_number % 4 * 8);
+            case CT_RFFC5072:
+                return radio::debug::first_if::register_read(register_number);
+            case CT_MAX283X:
+                return radio::debug::second_if::register_read(register_number);
+            case CT_SI5351:
+                return portapack::clock_generator.read_register(register_number);
+            case CT_AUDIO:
+                return audio::debug::reg_read(register_number);
+        }
+    }
+    return 0xFFFF;
+}
+
+void RegistersWidget::reg_write(const uint32_t register_number, const uint32_t value) {
+    if (register_number < config.registers_count) {
+        switch (config.chip_type) {
+            case CT_PMEM:
+                break;
+            case CT_RFFC5072:
+                radio::debug::first_if::register_write(register_number, value);
+                break;
+            case CT_MAX283X:
+                radio::debug::second_if::register_write(register_number, value);
+                break;
+            case CT_SI5351:
+                portapack::clock_generator.write_register(register_number, value);
+                break;
+            case CT_AUDIO:
+                audio::debug::reg_write(register_number, value);
+                break;
+        }
+    }
+}
+
 /* RegistersView *********************************************************/

 RegistersView::RegistersView(
    NavigationView& nav,
    const std::string& title,
-    RegistersWidgetConfig&& config,
-    std::function<uint32_t(const size_t register_number)>&& reader)
-    : registers_widget{std::move(config), std::move(reader)} {
+    RegistersWidgetConfig&& config)
+    : registers_widget{std::move(config)} {
    add_children({
        &text_title,
        &registers_widget,
        &button_update,
        &button_done,
+        &labels,
+        &field_write_reg_num,
+        &field_write_data_val,
+        &button_write,
    });

    button_update.on_select = [this](Button&) {
@@ -237,6 +276,20 @@ RegistersView::RegistersView(
    text_title.set_parent_rect({(240 - static_cast<int>(title.size()) * 8) / 2, 16,
                                static_cast<int>(title.size()) * 8, 16});
    text_title.set(title);
+
+    field_write_reg_num.on_change = [this](SymField&) {
+        field_write_data_val.set_value(this->registers_widget.reg_read(field_write_reg_num.to_integer()));
+        field_write_data_val.set_dirty();
+    };
+
+    const auto value = registers_widget.reg_read(0);
+    field_write_data_val.set_value(value);
+
+    button_write.set_style(&Styles::red);
+    button_write.on_select = [this](Button&) {
+        this->registers_widget.reg_write(field_write_reg_num.to_integer(), field_write_data_val.to_integer());
+        this->registers_widget.update();
+    };
 }

 void RegistersView::focus() {
@@ -376,18 +429,10 @@ DebugPeripheralsMenuView::DebugPeripheralsMenuView(NavigationView& nav) {
    const char* max283x = hackrf_r9 ? "MAX2839" : "MAX2837";
    const char* si5351x = hackrf_r9 ? "Si5351A" : "Si5351C";
    add_items({
-        {"RFFC5072", ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>(
-                                                                                              "RFFC5072", RegistersWidgetConfig{31, 16},
-                                                                                              [](const size_t register_number) { return radio::debug::first_if::register_read(register_number); }); }},
-        {max283x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, max283x]() { nav.push<RegistersView>(
-                                                                                                    max283x, RegistersWidgetConfig{32, 10},
-                                                                                                    [](const size_t register_number) { return radio::debug::second_if::register_read(register_number); }); }},
-        {si5351x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, si5351x]() { nav.push<RegistersView>(
-                                                                                                    si5351x, RegistersWidgetConfig{96, 8},
-                                                                                                    [](const size_t register_number) { return portapack::clock_generator.read_register(register_number); }); }},
-        {audio::debug::codec_name(), ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>(
-                                                                                                              audio::debug::codec_name(), RegistersWidgetConfig{audio::debug::reg_count(), audio::debug::reg_bits()},
-                                                                                                              [](const size_t register_number) { return audio::debug::reg_read(register_number); }); }},
+        {"RFFC5072", ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>("RFFC5072", RegistersWidgetConfig{CT_RFFC5072, 31, 16}); }},
+        {max283x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, max283x]() { nav.push<RegistersView>(max283x, RegistersWidgetConfig{CT_MAX283X, 32, 10}); }},
+        {si5351x, ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav, si5351x]() { nav.push<RegistersView>(si5351x, RegistersWidgetConfig{CT_SI5351, 96, 8}); }},
+        {audio::debug::codec_name(), ui::Color::dark_cyan(), &bitmap_icon_peripherals_details, [&nav]() { nav.push<RegistersView>(audio::debug::codec_name(), RegistersWidgetConfig{CT_AUDIO, audio::debug::reg_count(), audio::debug::reg_bits()}); }},
    });
    set_max_rows(2);  // allow wider buttons
 }
@@ -402,9 +447,10 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
        {"Buttons Test", ui::Color::dark_cyan(), &bitmap_icon_controls, [&nav]() { nav.push<DebugControlsView>(); }},
        {"Debug Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { portapack::persistent_memory::debug_dump(); }},
        {"M0 Stack Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { stack_dump(); }},
-        {"Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryView>(); }},
-        {"P.Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugPmemView>(); }},
+        {"Memory Dump", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryDumpView>(); }},
+        {"Memory Usage", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugMemoryView>(); }},
        {"Peripherals", ui::Color::dark_cyan(), &bitmap_icon_peripherals, [&nav]() { nav.push<DebugPeripheralsMenuView>(); }},
+        {"Pers. Memory", ui::Color::dark_cyan(), &bitmap_icon_memory, [&nav]() { nav.push<DebugPmemView>(); }},
        //{ "Radio State",	ui::Color::white(),	nullptr,	[&nav](){ nav.push<NotImplementedView>(); } },
        {"SD Card", ui::Color::dark_cyan(), &bitmap_icon_sdcard, [&nav]() { nav.push<SDCardDebugView>(); }},
        {"Temperature", ui::Color::dark_cyan(), &bitmap_icon_temperature, [&nav]() { nav.push<TemperatureView>(); }},
@@ -418,30 +464,53 @@ DebugMenuView::DebugMenuView(NavigationView& nav) {
    set_max_rows(2);  // allow wider buttons
 }

-/* DebugPmemView *********************************************************/
+/* DebugMemoryDumpView *********************************************************/

-uint32_t pmem_checksum(volatile const uint32_t data[63]) {
-    CRC<32> crc{0x04c11db7, 0xffffffff, 0xffffffff};
-    for (size_t i = 0; i < 63; i++) {
-        const auto word = data[i];
-        crc.process_byte((word >> 0) & 0xff);
-        crc.process_byte((word >> 8) & 0xff);
-        crc.process_byte((word >> 16) & 0xff);
-        crc.process_byte((word >> 24) & 0xff);
-    }
-    return crc.checksum();
+DebugMemoryDumpView::DebugMemoryDumpView(NavigationView& nav) {
+    add_children({
+        &button_dump,
+        &button_read,
+        &button_write,
+        &button_done,
+        &labels,
+        &field_starting_address,
+        &field_byte_count,
+        &field_rw_address,
+        &field_data_value,
+    });
+
+    button_done.on_select = [&nav](Button&) { nav.pop(); };
+
+    button_dump.on_select = [this](Button&) {
+        if (field_byte_count.to_integer() != 0)
+            memory_dump((uint32_t*)field_starting_address.to_integer(), ((uint32_t)field_byte_count.to_integer() + 3) / 4, false);
+    };
+
+    button_read.on_select = [this](Button&) {
+        field_data_value.set_value(*(uint32_t*)field_rw_address.to_integer());
+        field_data_value.set_dirty();
+    };
+
+    button_write.set_style(&Styles::red);
+    button_write.on_select = [this](Button&) {
+        *(uint32_t*)field_rw_address.to_integer() = (uint32_t)field_data_value.to_integer();
+    };
 }

-DebugPmemView::DebugPmemView(NavigationView& nav)
-    : data{*reinterpret_cast<pmem_data*>(memory::map::backup_ram.base())}, registers_widget(RegistersWidgetConfig{page_size, 8}, std::bind(&DebugPmemView::registers_widget_feed, this, std::placeholders::_1)) {
-    static_assert(sizeof(pmem_data) == memory::map::backup_ram.size());
+void DebugMemoryDumpView::focus() {
+    button_done.focus();
+}

+/* DebugPmemView *********************************************************/
+
+DebugPmemView::DebugPmemView(NavigationView& nav)
+    : registers_widget(RegistersWidgetConfig{CT_PMEM, page_size, 8}) {
    add_children({&text_page, &registers_widget, &text_checksum, &text_checksum2, &button_ok});

    registers_widget.set_parent_rect({0, 32, 240, 192});

-    text_checksum.set("Size: " + to_string_dec_uint(portapack::persistent_memory::data_size(), 3) + "  CRC: " + to_string_hex(data.check_value, 8));
-    text_checksum2.set("Calculated CRC: " + to_string_hex(pmem_checksum(data.regfile), 8));
+    text_checksum.set("Size: " + to_string_dec_uint(portapack::persistent_memory::data_size(), 3) + "  CRC: " + to_string_hex(portapack::persistent_memory::pmem_stored_checksum(), 8));
+    text_checksum2.set("Calculated CRC: " + to_string_hex(portapack::persistent_memory::pmem_calculated_checksum(), 8));

    button_ok.on_select = [&nav](Button&) {
        nav.pop();
@@ -451,7 +520,7 @@ DebugPmemView::DebugPmemView(NavigationView& nav)
 }

 bool DebugPmemView::on_encoder(const EncoderEvent delta) {
-    page = std::max(0l, std::min((int32_t)page_max, page + delta));
+    registers_widget.set_page(std::max(0ul, std::min((uint32_t)page_count - 1, registers_widget.page() + delta)));

    update();

@@ -463,17 +532,10 @@ void DebugPmemView::focus() {
 }

 void DebugPmemView::update() {
-    text_page.set(to_string_hex(page_size * page, 2) + "+");
+    text_page.set(to_string_hex(registers_widget.page() * page_size, 2) + "+");
    registers_widget.update();
 }

-uint32_t DebugPmemView::registers_widget_feed(const size_t register_number) {
-    if (page_size * page + register_number >= memory::map::backup_ram.size()) {
-        return 0xff;
-    }
-    return data.regfile[(page_size * page + register_number) / 4] >> (register_number % 4 * 8);
-}
-
 /* DebugScreenTest ****************************************************/

 DebugScreenTest::DebugScreenTest(NavigationView& nav)
@@ -48,8 +48,8 @@ class DebugMemoryView : public View {

   private:
    Text text_title{
-        {96, 96, 48, 16},
-        "Memory",
+        {72, 96, 96, 16},
+        "Memory Usage",
    };

    Text text_label_m0_core_free{
@@ -131,9 +131,18 @@ class TemperatureView : public View {
        "Done"};
 };

+typedef enum {
+    CT_PMEM,
+    CT_RFFC5072,
+    CT_MAX283X,
+    CT_SI5351,
+    CT_AUDIO,
+} chip_type_t;
+
 struct RegistersWidgetConfig {
-    size_t registers_count;
-    size_t register_bits;
+    chip_type_t chip_type;
+    uint32_t registers_count;
+    uint32_t register_bits;

    constexpr size_t legend_length() const {
        return (registers_count >= 0x10) ? 2 : 1;
@@ -174,17 +183,21 @@ struct RegistersWidgetConfig {

 class RegistersWidget : public Widget {
   public:
-    RegistersWidget(
-        RegistersWidgetConfig&& config,
-        std::function<uint32_t(const size_t register_number)>&& reader);
+    RegistersWidget(RegistersWidgetConfig&& config);

    void update();

    void paint(Painter& painter) override;

+    uint32_t reg_read(const uint32_t register_number);
+    void reg_write(const uint32_t register_number, const uint32_t value);
+
+    void set_page(int32_t value) { page_number = value; }
+    uint32_t page(void) { return page_number; }
+
   private:
    const RegistersWidgetConfig config;
-    const std::function<uint32_t(const size_t register_number)> reader;
+    uint32_t page_number;

    static constexpr size_t row_height = 16;

@@ -194,11 +207,7 @@ class RegistersWidget : public Widget {

 class RegistersView : public View {
   public:
-    RegistersView(
-        NavigationView& nav,
-        const std::string& title,
-        RegistersWidgetConfig&& config,
-        std::function<uint32_t(const size_t register_number)>&& reader);
+    RegistersView(NavigationView& nav, const std::string& title, RegistersWidgetConfig&& config);

    void focus();

@@ -208,12 +217,30 @@ class RegistersView : public View {
    RegistersWidget registers_widget;

    Button button_update{
-        {16, 256, 96, 24},
+        {16, 280, 96, 24},
        "Update"};

    Button button_done{
-        {128, 256, 96, 24},
+        {128, 280, 96, 24},
        "Done"};
+
+    Button button_write{
+        {144, 248, 80, 20},
+        "Write"};
+
+    Labels labels{
+        {{1 * 8, 248}, "Reg:", Color::light_grey()},
+        {{8 * 8, 248}, "Data:", Color::light_grey()}};
+
+    SymField field_write_reg_num{
+        {5 * 8, 248},
+        2,
+        SymField::Type::Hex};
+
+    SymField field_write_data_val{
+        {13 * 8, 248},
+        4,
+        SymField::Type::Hex};
 };

 class ControlsSwitchesWidget : public Widget {
@@ -274,6 +301,58 @@ class DebugControlsView : public View {
        "Done"};
 };

+class DebugMemoryDumpView : public View {
+   public:
+    DebugMemoryDumpView(NavigationView& nav);
+    void focus() override;
+    std::string title() const override { return "Memory Dump"; };
+
+   private:
+    Button button_dump{
+        {72, 4 * 16, 96, 24},
+        "Dump"};
+
+    Button button_read{
+        {16, 11 * 16, 96, 24},
+        "Read"};
+
+    Button button_write{
+        {128, 11 * 16, 96, 24},
+        "Write"};
+
+    Button button_done{
+        {128, 240, 96, 24},
+        "Done"};
+
+    Labels labels{
+        {{5 * 8, 1 * 16}, "Dump Range to File", Color::yellow()},
+        {{0 * 8, 2 * 16}, "Starting Address: 0x", Color::light_grey()},
+        {{0 * 8, 3 * 16}, "Byte Count:       0x", Color::light_grey()},
+        {{3 * 8, 8 * 16}, "Read/Write Single Word", Color::yellow()},
+        {{0 * 8, 9 * 16}, "Memory Address:   0x", Color::light_grey()},
+        {{0 * 8, 10 * 16}, "Data Value:       0x", Color::light_grey()}};
+
+    SymField field_starting_address{
+        {20 * 8, 2 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_byte_count{
+        {20 * 8, 3 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_rw_address{
+        {20 * 8, 9 * 16},
+        8,
+        SymField::Type::Hex};
+
+    SymField field_data_value{
+        {20 * 8, 10 * 16},
+        8,
+        SymField::Type::Hex};
+};
+
 class DebugPmemView : public View {
   public:
    DebugPmemView(NavigationView& nav);
@@ -282,17 +361,8 @@ class DebugPmemView : public View {
    std::string title() const override { return "P.Mem Debug"; }

   private:
-    struct pmem_data {
-        uint32_t regfile[63];
-        uint32_t check_value;
-    };
-
    static constexpr uint8_t page_size{96};  // Must be multiply of 4 otherwise bit shifting for register view wont work properly
-    static constexpr uint8_t page_max{(portapack::memory::map::backup_ram.size() + page_size - 1) / page_size - 1};
-
-    int32_t page{0};
-
-    volatile const pmem_data& data;
+    static constexpr uint8_t page_count{(portapack::memory::map::backup_ram.size() + page_size - 1) / page_size};

    Text text_page{{16, 16, 208, 16}};

@@ -307,7 +377,6 @@ class DebugPmemView : public View {
    };

    void update();
-    uint32_t registers_widget_feed(const size_t register_number);
 };

 class DebugScreenTest : public View {
@@ -56,13 +56,23 @@ static msg_t ookthread_fn(void* arg) {
        v = (symbol < 2) ? 1 : 0;  // TX on for dot or dash, off for pause
        delay = morse_symbols[symbol];

-        gpio_og_tx.write(v);
+        if (hackrf_r9) {           // r9 has a common PIN 54 for MODE CONTROL TX / RX,  <=r6 has two independent MODE CONTROL pins (TX and RX)
+            gpio_r9_rx.write(!v);  // in hackrf r9 opposite logic "0" means tx , "1" rx = no tx)
+        } else {
+            gpio_og_tx.write(v);  // in hackrf <=r6, "1" means tx , "0" no tx.
+        }
+
        arg_c->on_tx_progress(i, false);

        chThdSleepMilliseconds(delay * arg_c->time_unit_ms);
    }

-    gpio_og_tx.write(0);  // Ensure TX is off
+    if (hackrf_r9) {          // r9 has a common PIN 54 for MODE CONTROL TX / RX,  <=r6 has two independent MODE CONTROL pins (TX and RX)
+        gpio_r9_rx.write(1);  // Hackrf_r9 , common pin,  rx="1" (we ensure TX is off)  / tx="0"
+    } else {
+        gpio_og_tx.write(0);  // Hackrf <=r6 independent TX / RX  pins ,now touching the tx pin ==> Ensure TX is off
+    }
+
    arg_c->on_tx_progress(0, true);
    chThdExit(0);

@@ -121,10 +131,10 @@ bool MorseView::start_tx() {
    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF .already tested in FM morse max tone 9,999k , max dev 150khz
    transmitter_model.enable();

-    if (modulation == CW) {
+    baseband::set_tones_config(transmitter_model.channel_bandwidth(), 0, symbol_count, false, false);
+
+    if (mode_cw) {
        ookthread = chThdCreateStatic(ookthread_wa, sizeof(ookthread_wa), NORMALPRIO + 10, ookthread_fn, this);
-    } else if (modulation == FM) {
-        baseband::set_tones_config(transmitter_model.channel_bandwidth(), 0, symbol_count, false, false);
    }

    return true;
@@ -133,8 +143,8 @@ bool MorseView::start_tx() {
 void MorseView::update_tx_duration() {
    uint32_t duration_ms;

-    time_unit_ms = 1200 / field_speed.value();
-    symbol_count = morse_encode(message, time_unit_ms, field_tone.value(), &time_units);
+    time_unit_ms = 1200 / speed;
+    symbol_count = morse_encode(message, time_unit_ms, tone, &time_units);

    if (symbol_count) {
        duration_ms = time_units * time_unit_ms;
@@ -175,7 +185,7 @@ void MorseView::on_loop_progress(const uint32_t progress, const bool done) {
 }

 void MorseView::set_foxhunt(size_t i) {
-    message = foxhunt_codes[i];
+    message = foxhunt_codes[i - 1];
    buffer = message.c_str();
    text_message.set(message);
    update_tx_duration();
@@ -188,7 +198,7 @@ MorseView::MorseView(

    add_children({&labels,
                  &checkbox_foxhunt,
-                  &options_foxhunt,
+                  &field_foxhunt,
                  &field_speed,
                  &field_tone,
                  &options_modulation,
@@ -200,36 +210,46 @@ MorseView::MorseView(
                  &tx_view});

    // Default settings
-    field_speed.set_value(15);                 // 15wps
-    field_tone.set_value(700);                 // 700Hz FM tone
-    options_modulation.set_selected_index(0);  // CW mode
-    options_loop.set_selected_index(0);        // Off
+    field_speed.set_value(speed);
+    field_tone.set_value(tone);
+    options_modulation.set_by_value(mode_cw);
+    options_loop.set_by_value(loop);
+    checkbox_foxhunt.set_value(foxhunt_mode);
+    field_foxhunt.set_value(foxhunt_code);

    checkbox_foxhunt.on_select = [this](Checkbox&, bool value) {
        foxhunt_mode = value;

        if (foxhunt_mode)
-            set_foxhunt(options_foxhunt.selected_index_value());
+            set_foxhunt(foxhunt_code);
    };

-    options_foxhunt.on_change = [this](size_t i, int32_t) {
+    field_foxhunt.on_change = [this](int32_t value) {
+        foxhunt_code = value;
+
        if (foxhunt_mode)
-            set_foxhunt(i);
+            set_foxhunt(foxhunt_code);
    };

-    options_modulation.on_change = [this](size_t i, int32_t) {
-        modulation = (modulation_t)i;
-    };
-
-    options_loop.on_change = [this](size_t i, uint32_t n) {
+    options_modulation.on_change = [this](size_t i, int32_t value) {
        (void)i;  // avoid unused warning
-        loop = n;
+        mode_cw = (bool)value;
    };

-    field_speed.on_change = [this](int32_t) {
+    options_loop.on_change = [this](size_t i, uint32_t value) {
+        (void)i;  // avoid unused warning
+        loop = value;
+    };
+
+    field_speed.on_change = [this](int32_t value) {
+        speed = value;
        update_tx_duration();
    };

+    field_tone.on_change = [this](int32_t value) {
+        tone = value;
+    };
+
    button_message.on_select = [this, &nav](Button&) {
        this->on_set_text(nav);
    };
@@ -65,7 +65,6 @@ class MorseView : public View {

   private:
    NavigationView& nav_;
-    std::string buffer{"PORTAPACK"};
    std::string message{};
    uint32_t time_units{0};

@@ -74,14 +73,25 @@ class MorseView : public View {
        1750000 /* bandwidth */,
        1536000 /* sampling rate */
    };
-    app_settings::SettingsManager settings_{
-        "tx_morse", app_settings::Mode::TX};

-    enum modulation_t {
-        CW = 0,
-        FM = 1
-    };
-    modulation_t modulation{CW};
+    std::string buffer{"PORTAPACK"};
+    bool mode_cw{true};
+    bool foxhunt_mode{false};
+    uint32_t foxhunt_code{1};
+    uint32_t speed{15};
+    uint32_t tone{700};
+    app_settings::SettingsManager settings_{
+        "tx_morse",
+        app_settings::Mode::TX,
+        {
+            {"message"sv, &buffer},
+            {"foxhunt"sv, &foxhunt_mode},
+            {"foxhunt_code"sv, &foxhunt_code},
+            {"speed"sv, &speed},
+            {"tone"sv, &tone},
+            {"mode_cw"sv, &mode_cw},
+            {"loop"sv, &loop},
+        }};

    bool start_tx();
    void update_tx_duration();
@@ -90,7 +100,6 @@ class MorseView : public View {

    Thread* ookthread{nullptr};
    Thread* loopthread{nullptr};
-    bool foxhunt_mode{false};
    bool run{false};

    Labels labels{
@@ -104,20 +113,12 @@ class MorseView : public View {
        {4 * 8, 16},
        8,
        "Foxhunt:"};
-    OptionsField options_foxhunt{
+    NumberField field_foxhunt{
        {17 * 8, 16 + 4},
-        7,
-        {{"1 (MOE)", 0},
-         {"2 (MOI)", 1},
-         {"3 (MOS)", 2},
-         {"4 (MOH)", 3},
-         {"5 (MO5)", 4},
-         {"6 (MON)", 5},
-         {"7 (MOD)", 6},
-         {"8 (MOB)", 7},
-         {"9 (MO6)", 8},
-         {"X (MO) ", 9},
-         {"T (S) ", 10}}};
+        2,
+        {1, 11},
+        1,
+        ' '};

    NumberField field_speed{
        {10 * 8, 6 * 8},
@@ -136,8 +137,8 @@ class MorseView : public View {
    OptionsField options_modulation{
        {15 * 8, 10 * 8},
        2,
-        {{"CW", 0},
-         {"FM", 1}}};
+        {{"CW", true},
+         {"FM", false}}};

    OptionsField options_loop{
        {9 * 8, 12 * 8},
@@ -343,6 +343,38 @@ void SetUIView::focus() {
    button_save.focus();
 }

+/* SetSDCardView *********************************************/
+
+SetSDCardView::SetSDCardView(NavigationView& nav) {
+    add_children({&labels,
+                  &checkbox_sdcard_speed,
+                  &button_test_sdcard_high_speed,
+                  &text_sdcard_test_status,
+                  &button_save,
+                  &button_cancel});
+
+    checkbox_sdcard_speed.set_value(pmem::config_sdcard_high_speed_io());
+
+    button_test_sdcard_high_speed.on_select = [&nav, this](Button&) {
+        pmem::set_config_sdcard_high_speed_io(true, false);
+        text_sdcard_test_status.set("!! HIGH SPEED MODE ON !!");
+    };
+
+    button_save.on_select = [&nav, this](Button&) {
+        pmem::set_config_sdcard_high_speed_io(checkbox_sdcard_speed.value(), true);
+        send_system_refresh();
+        nav.pop();
+    };
+
+    button_cancel.on_select = [&nav, this](Button&) {
+        nav.pop();
+    };
+}
+
+void SetSDCardView::focus() {
+    button_save.focus();
+}
+
 /* SetConverterSettingsView ******************************/

 SetConverterSettingsView::SetConverterSettingsView(NavigationView& nav) {
@@ -427,7 +459,7 @@ SetFrequencyCorrectionView::SetFrequencyCorrectionView(NavigationView& nav) {
        pmem::set_freq_rx_correction_updown(v);
    };

-    opt_tx_correction_mode.set_by_value(pmem::config_freq_rx_correction_updown());
+    opt_tx_correction_mode.set_by_value(pmem::config_freq_tx_correction_updown());
    opt_tx_correction_mode.on_change = [this](size_t, OptionsField::value_t v) {
        pmem::set_freq_tx_correction_updown(v);
    };
@@ -636,6 +668,7 @@ SettingsMenuView::SettingsMenuView(NavigationView& nav) {
        {"QR Code", ui::Color::dark_cyan(), &bitmap_icon_qr_code, [&nav]() { nav.push<SetQRCodeView>(); }},
        {"Radio", ui::Color::dark_cyan(), &bitmap_icon_options_radio, [&nav]() { nav.push<SetRadioView>(); }},
        {"User Interface", ui::Color::dark_cyan(), &bitmap_icon_options_ui, [&nav]() { nav.push<SetUIView>(); }},
+        {"SD Card", ui::Color::dark_cyan(), &bitmap_icon_sdcard, [&nav]() { nav.push<SetSDCardView>(); }},
    });
    set_max_rows(2);  // allow wider buttons
 }
@@ -306,8 +306,43 @@ class SetUIView : public View {

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

 class SetConverterSettingsView : public View {
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_subghzd.hpp"
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+namespace ui {
+
+void SubGhzDRecentEntryDetailView::update_data() {
+    // set text elements
+    text_type.set(SubGhzDView::getSensorTypeName((FPROTO_SUBGHZD_SENSOR)entry_.sensorType));
+    text_id.set("0x" + to_string_hex(entry_.serial));
+    if (entry_.bits > 0) console.writeln("Bits: " + to_string_dec_uint(entry_.bits));
+    if (entry_.btn != SD_NO_BTN) console.writeln("Btn: " + to_string_dec_uint(entry_.btn));
+    if (entry_.cnt != SD_NO_CNT) console.writeln("Cnt: " + to_string_dec_uint(entry_.cnt));
+
+    if (entry_.data != 0) console.writeln("Data: " + to_string_hex(entry_.data));
+}
+
+SubGhzDRecentEntryDetailView::SubGhzDRecentEntryDetailView(NavigationView& nav, const SubGhzDRecentEntry& entry)
+    : nav_{nav},
+      entry_{entry} {
+    add_children({&button_done,
+                  &text_type,
+                  &text_id,
+                  &console,
+                  &labels});
+
+    button_done.on_select = [&nav](const ui::Button&) {
+        nav.pop();
+    };
+    update_data();
+}
+
+void SubGhzDRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+void SubGhzDView::focus() {
+    field_frequency.focus();
+}
+
+SubGhzDView::SubGhzDView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&rssi,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_frequency,
+                  &button_clear_list,
+                  &recent_entries_view});
+
+    baseband::run_image(portapack::spi_flash::image_tag_subghzd);
+
+    button_clear_list.on_select = [this](Button&) {
+        recent.clear();
+        recent_entries_view.set_dirty();
+    };
+    field_frequency.set_step(100000);
+
+    const Rect content_rect{0, header_height, screen_width, screen_height - header_height};
+    recent_entries_view.set_parent_rect(content_rect);
+    recent_entries_view.on_select = [this](const SubGhzDRecentEntry& entry) {
+        nav_.push<SubGhzDRecentEntryDetailView>(entry);
+    };
+    baseband::set_subghzd_config(0, receiver_model.sampling_rate());  // 0=am
+    receiver_model.enable();
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        on_tick_second();
+    };
+}
+
+void SubGhzDView::on_tick_second() {
+    for (auto& entry : recent) {
+        entry.inc_age(1);
+    }
+    recent_entries_view.set_dirty();
+}
+
+void SubGhzDView::on_data(const SubGhzDDataMessage* data) {
+    SubGhzDRecentEntry key{data->sensorType, data->serial, data->bits, data->data, data->btn, data->cnt};
+    auto matching_recent = find(recent, key.key());
+    if (matching_recent != std::end(recent)) {
+        // Found within. Move to front of list, increment counter.
+        (*matching_recent).reset_age();
+        recent.push_front(*matching_recent);
+        recent.erase(matching_recent);
+    } else {
+        recent.emplace_front(key);
+        truncate_entries(recent, 64);
+    }
+    recent_entries_view.set_dirty();
+}
+
+SubGhzDView::~SubGhzDView() {
+    rtc_time::signal_tick_second -= signal_token_tick_second;
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+const char* SubGhzDView::getSensorTypeName(FPROTO_SUBGHZD_SENSOR type) {
+    switch (type) {
+        case FPS_PRINCETON:
+            return "Princeton";
+        case FPS_BETT:
+            return "Bett";
+        case FPS_CAME:
+            return "Came";
+        case FPS_PRASTEL:
+            return "Prastel";
+        case FPS_AIRFORCE:
+            return "Airforce";
+        case FPS_CAMEATOMO:
+            return "Came Atomo";
+        case FPS_CAMETWEE:
+            return "Came Twee";
+        case FPS_CHAMBCODE:
+            return "Chamb Code";
+        case FPS_CLEMSA:
+            return "Clemsa";
+        case FPS_DOITRAND:
+            return "Doitrand";
+        case FPS_DOOYA:
+            return "Dooya";
+        case FPS_FAAC:
+            return "Faac";
+        case FPS_GATETX:
+            return "Gate TX";
+        case FPS_HOLTEK:
+            return "Holtek";
+        case FPS_HOLTEKHT12X:
+            return "Holtek HT12X";
+        case FPS_HONEYWELL:
+            return "Honeywell";
+        case FPS_HONEYWELLWDB:
+            return "Honeywell Wdb";
+        case FPS_HORMANN:
+            return "Hormann";
+        case FPS_IDO:
+            return "Ido 11x";
+        case FPS_INTERTECHNOV3:
+            return "InterTehcno v3";
+        case FPS_KEELOQ:
+            return "KeeLoq";
+        case FPS_KINGGATESSTYLO4K:
+            return "Kinggate Stylo4K";
+        case FPS_LINEAR:
+            return "Linear";
+        case FPS_LINEARDELTA3:
+            return "Linear Delta3";
+        case FPS_MAGELLAN:
+            return "Magellan";
+        case FPS_MARANTEC:
+            return "Marantec";
+        case FPS_MASTERCODE:
+            return "Mastercode";
+        case FPS_MEGACODE:
+            return "Megacode";
+        case FPS_NERORADIO:
+            return "Nero Radio";
+        case FPS_NERO_SKETCH:
+            return "Nero Sketch";
+        case FPS_NICEFLO:
+            return "Nice Flo";
+        case FPS_NICEFLORS:
+            return "Nice Flor S";
+        case FPS_PHOENIXV2:
+            return "Phoenix V2";
+        case FPS_POWERSMART:
+            return "PowerSmart";
+        case FPS_SECPLUSV1:
+            return "SecPlus V1";
+        case FPS_SECPLUSV2:
+            return "SecPlus V2";
+        case FPS_SMC5326:
+            return "SMC5326";
+        case FPS_STARLINE:
+            return "Star Line";
+        case FPS_X10:
+            return "X10";
+        case FPS_Invalid:
+        default:
+            return "Unknown";
+    }
+}
+
+std::string SubGhzDView::pad_string_with_spaces(int snakes) {
+    std::string paddedStr(snakes, ' ');
+    return paddedStr;
+}
+
+template <>
+void RecentEntriesTable<ui::SubGhzDRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line{};
+    line.reserve(30);
+
+    line = SubGhzDView::getSensorTypeName((FPROTO_SUBGHZD_SENSOR)entry.sensorType);
+    line = line + " " + to_string_hex(entry.serial);
+    if (line.length() < 19) {
+        line += SubGhzDView::pad_string_with_spaces(19 - line.length());
+    } else {
+        line = truncate(line, 19);
+    }
+    std::string ageStr = to_string_dec_uint(entry.age);
+    std::string bitsStr = to_string_dec_uint(entry.bits);
+    line += SubGhzDView::pad_string_with_spaces(5 - bitsStr.length()) + bitsStr;
+    line += SubGhzDView::pad_string_with_spaces(4 - ageStr.length()) + ageStr;
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+}  // namespace ui
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_SUBGHZD_H__
+#define __UI_SUBGHZD_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "utility.hpp"
+#include "recent_entries.hpp"
+
+#include "../baseband/fprotos/subghztypes.hpp"
+
+using namespace ui;
+
+namespace ui {
+
+struct SubGhzDRecentEntry {
+    using Key = uint64_t;
+    static constexpr Key invalid_key = 0x0fffffff;
+    uint8_t sensorType = FPS_Invalid;
+    uint8_t btn = SD_NO_BTN;
+    uint32_t serial = SD_NO_SERIAL;
+    uint16_t bits = 0;
+    uint16_t age = 0;  // updated on each seconds, show how long the signal was last seen
+    uint32_t cnt = SD_NO_CNT;
+    uint64_t data = 0;
+    SubGhzDRecentEntry() {}
+    SubGhzDRecentEntry(
+        uint8_t sensorType,
+        uint32_t serial,
+        uint16_t bits = 0,
+        uint64_t data = 0,
+        uint8_t btn = SD_NO_BTN,
+        uint32_t cnt = SD_NO_CNT)
+        : sensorType{sensorType},
+          btn{btn},
+          serial{serial},
+          bits{bits},
+          cnt{cnt},
+          data{data} {
+    }
+    Key key() const {
+        return (data ^ ((static_cast<uint64_t>(serial) << 32) | (static_cast<uint64_t>(sensorType) & 0xFF) << 0));
+    }
+    void inc_age(int delta) {
+        if (UINT16_MAX - delta > age) age += delta;
+    }
+    void reset_age() {
+        age = 0;
+    }
+};
+using SubGhzDRecentEntries = RecentEntries<SubGhzDRecentEntry>;
+using SubGhzDRecentEntriesView = RecentEntriesView<SubGhzDRecentEntries>;
+
+class SubGhzDView : public View {
+   public:
+    SubGhzDView(NavigationView& nav);
+    ~SubGhzDView();
+
+    void focus() override;
+
+    std::string title() const override { return "SubGhzD"; };
+    static const char* getSensorTypeName(FPROTO_SUBGHZD_SENSOR type);
+    static std::string pad_string_with_spaces(int snakes);
+
+   private:
+    void on_tick_second();
+    void on_data(const SubGhzDDataMessage* data);
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{
+        433'920'000 /* frequency */,
+        1'750'000 /* bandwidth */,
+        4'000'000 /* sampling rate */,
+        ReceiverModel::Mode::AMAudio};
+    app_settings::SettingsManager settings_{
+        "rx_subghzd",
+        app_settings::Mode::RX,
+        {}};
+
+    SubGhzDRecentEntries recent{};
+
+    RFAmpField field_rf_amp{
+        {13 * 8, 0 * 16}};
+    LNAGainField field_lna{
+        {15 * 8, 0 * 16}};
+    VGAGainField field_vga{
+        {18 * 8, 0 * 16}};
+    RSSI rssi{
+        {21 * 8, 0, 6 * 8, 4}};
+    RxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+
+    SignalToken signal_token_tick_second{};
+
+    Button button_clear_list{
+        {0, 16, 7 * 8, 32},
+        "Clear"};
+
+    static constexpr auto header_height = 3 * 16;
+
+    const RecentEntriesColumns columns{{
+        {"Type", 19},
+        {"Bits", 4},
+        {"Age", 3},
+    }};
+    SubGhzDRecentEntriesView recent_entries_view{columns, recent};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::SubGhzDData,
+        [this](Message* const p) {
+            const auto message = static_cast<const SubGhzDDataMessage*>(p);
+            this->on_data(message);
+        }};
+};
+
+class SubGhzDRecentEntryDetailView : public View {
+   public:
+    SubGhzDRecentEntryDetailView(NavigationView& nav, const SubGhzDRecentEntry& entry);
+
+    void update_data();
+    void focus() override;
+
+   private:
+    NavigationView& nav_;
+    SubGhzDRecentEntry entry_{};
+    Text text_type{{0 * 8, 1 * 16, 15 * 8, 16}, "?"};
+    Text text_id{{6 * 8, 2 * 16, 10 * 8, 16}, "?"};
+
+    Console console{
+        {0, 4 * 16, 240, screen_height - (4 * 16) - 36}};
+
+    Labels labels{
+        {{0 * 8, 0 * 16}, "Type:", Color::light_grey()},
+        {{0 * 8, 2 * 16}, "Serial: ", Color::light_grey()},
+        {{0 * 8, 3 * 16}, "Data:", Color::light_grey()},
+    };
+
+    Button button_done{
+        {screen_width - 96 - 4, screen_height - 32 - 12, 96, 32},
+        "Done"};
+};
+
+}  // namespace ui
+
+#endif /*__UI_SUBGHZD_H__*/
@@ -72,6 +72,11 @@ void TextViewer::paint(Painter& painter) {
        paint_state_.redraw_text = false;
    }

+    if (paint_state_.redraw_marked) {
+        paint_marked(painter);
+        paint_state_.redraw_marked = false;
+    }
+
    paint_cursor(painter);
 }

@@ -118,8 +123,9 @@ bool TextViewer::on_encoder(EncoderEvent delta) {
    return updated;
 }

-void TextViewer::redraw(bool redraw_text) {
+void TextViewer::redraw(bool redraw_text, bool redraw_marked) {
    paint_state_.redraw_text = redraw_text;
+    paint_state_.redraw_marked = redraw_marked;
    set_dirty();
 }

@@ -140,6 +146,32 @@ void TextViewer::cursor_end() {
    redraw();
 }

+void TextViewer::cursor_set(uint16_t line, uint16_t col) {
+    cursor_.line = line;
+    cursor_.col = col;
+}
+
+void TextViewer::cursor_mark_selected() {
+    LineColPair newMarker = std::make_pair(cursor_.line, cursor_.col);
+    auto it = std::find(lineColPair.begin(), lineColPair.end(), newMarker);
+
+    if (it != lineColPair.end()) {
+        lineColPair.erase(it);
+    } else {
+        lineColPair.push_back(newMarker);
+    }
+
+    // Mark pending change.
+    cursor_.mark_change = false;
+
+    redraw();
+}
+
+void TextViewer::cursor_clear_marked() {
+    lineColPair.clear();
+    redraw(true, true);
+}
+
 uint16_t TextViewer::line_length() {
    return file_->line_length(cursor_.line);
 }
@@ -247,12 +279,52 @@ void TextViewer::paint_cursor(Painter& painter) {
    };

    if (paint_state_.line != UINT32_MAX)  // only XOR old cursor if it still appears on the screen
-        xor_cursor(paint_state_.line, paint_state_.col);
+    {
+        // Only reset previous cursor if we aren't marking.
+        if (paint_state_.mark_change) {
+            xor_cursor(paint_state_.line, paint_state_.col);
+        }
+    }

    xor_cursor(cursor_.line, cursor_.col);

    paint_state_.line = cursor_.line;
    paint_state_.col = cursor_.col;
+    paint_state_.mark_change = cursor_.mark_change;
+
+    // Reset marking and wait for new change.
+    cursor_.mark_change = true;
+}
+
+void TextViewer::paint_marked(Painter& painter) {
+    auto xor_cursor = [this, &painter](int32_t line, uint16_t col) {
+        int cursor_width = char_width + 1;
+        int x = (col - paint_state_.first_col) * char_width - 1;
+        if (x < 0) {  // cursor is one pixel narrower when in left column
+            cursor_width--;
+            x = 0;
+        }
+        int y = screen_rect().top() + (line - paint_state_.first_line) * char_height;
+
+        // Converting one row at a time to reduce buffer size
+        auto pbuf8 = cursor_.pixel_buffer8;
+        auto pbuf = cursor_.pixel_buffer;
+        for (auto col = 0; col < char_height; col++) {
+            // Annoyingly, read_pixels uses a 24-bit pixel format vs draw_pixels which uses 16-bit
+            portapack::display.read_pixels({x, y + col, cursor_width, 1}, pbuf8, cursor_width);
+            for (auto i = 0; i < cursor_width; i++)
+                pbuf[i] = Color(pbuf8[i].r, pbuf8[i].g, pbuf8[i].b).v ^ 0xFFFF;
+            portapack::display.draw_pixels({x, y + col, cursor_width, 1}, pbuf, cursor_width);
+        }
+    };
+
+    auto it = lineColPair.begin();
+
+    while (it != lineColPair.end()) {
+        LineColPair entry = (LineColPair)*it;
+        xor_cursor(entry.first, entry.second);
+        it++;
+    }
 }

 void TextViewer::reset_file(FileWrapper* file) {
@@ -59,7 +59,7 @@ class TextViewer : public Widget {
    bool on_key(KeyEvent key) override;
    bool on_encoder(EncoderEvent delta) override;

-    void redraw(bool redraw_text = false);
+    void redraw(bool redraw_text = false, bool redraw_marked = false);

    void set_file(FileWrapper& file) { reset_file(&file); }
    void clear_file() { reset_file(); }
@@ -71,6 +71,12 @@ class TextViewer : public Widget {

    void cursor_home();
    void cursor_end();
+    void cursor_set(uint16_t line, uint16_t col);
+    void cursor_mark_selected();
+    void cursor_clear_marked();
+
+    typedef std::pair<uint16_t, uint16_t> LineColPair;
+    std::vector<LineColPair> lineColPair{};

    // Gets the length of the current line.
    uint16_t line_length();
@@ -97,6 +103,7 @@ class TextViewer : public Widget {

    void paint_text(Painter& painter, uint32_t line, uint16_t col);
    void paint_cursor(Painter& painter);
+    void paint_marked(Painter& painter);

    void reset_file(FileWrapper* file = nullptr);

@@ -111,6 +118,8 @@ class TextViewer : public Widget {
        uint32_t first_line{};
        uint16_t first_col{};
        bool redraw_text{true};
+        bool redraw_marked{false};
+        bool mark_change{true};
    } paint_state_{};

    struct {
@@ -121,6 +130,8 @@ class TextViewer : public Widget {
        // Pixel buffer used for cursor XOR'ing - Max cursor width = Max char width + 1
        ColorRGB888 pixel_buffer8[ui::char_width + 1]{};
        Color pixel_buffer[ui::char_width + 1]{};
+
+        bool mark_change{true};
    } cursor_{};
 };

@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_weatherstation.hpp"
+#include "modems.hpp"
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "portapack_persistent_memory.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+namespace ui {
+
+void WeatherRecentEntryDetailView::update_data() {
+    // set text elements
+    text_type.set(WeatherView::getWeatherSensorTypeName((FPROTO_WEATHER_SENSOR)entry_.sensorType));
+    if (entry_.id != WS_NO_ID)
+        text_id.set("0x" + to_string_hex(entry_.id));
+    else
+        text_id.set("-");
+    if (entry_.temp != WS_NO_TEMPERATURE)
+        text_temp.set(weather_units_fahr ? to_string_decimal((entry_.temp * 9 / 5) + 32, 1) + STR_DEGREES_F : to_string_decimal(entry_.temp, 2) + STR_DEGREES_C);
+    else
+        text_temp.set("-");
+    if (entry_.humidity != WS_NO_HUMIDITY)
+        text_hum.set(to_string_dec_uint(entry_.humidity) + "%");
+    else
+        text_hum.set("-");
+    if (entry_.channel != WS_NO_CHANNEL)
+        text_ch.set(to_string_dec_uint(entry_.channel));
+    else
+        text_ch.set("-");
+    if (entry_.battery_low != WS_NO_BATT)
+        text_batt.set(to_string_dec_uint(entry_.battery_low) + " " + ((entry_.battery_low == 0) ? "OK" : "LOW"));
+    else
+        text_batt.set("-");
+    text_age.set(to_string_dec_uint(entry_.age) + " sec");
+}
+
+WeatherRecentEntryDetailView::WeatherRecentEntryDetailView(NavigationView& nav, const WeatherRecentEntry& entry)
+    : nav_{nav},
+      entry_{entry} {
+    add_children({&button_done,
+                  &text_type,
+                  &text_id,
+                  &text_temp,
+                  &text_hum,
+                  &text_ch,
+                  &text_batt,
+                  &text_age,
+                  &labels});
+
+    button_done.on_select = [&nav](const ui::Button&) {
+        nav.pop();
+    };
+    update_data();
+}
+
+void WeatherRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+void WeatherView::focus() {
+    field_frequency.focus();
+}
+
+WeatherView::WeatherView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&rssi,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_frequency,
+                  &options_temperature,
+                  &button_clear_list,
+                  &recent_entries_view});
+
+    baseband::run_image(portapack::spi_flash::image_tag_weather);
+
+    button_clear_list.on_select = [this](Button&) {
+        recent.clear();
+        recent_entries_view.set_dirty();
+    };
+    field_frequency.set_step(100000);
+
+    options_temperature.on_change = [this](size_t, int32_t i) {
+        weather_units_fahr = (bool)i;
+        recent_entries_view.set_dirty();
+    };
+    options_temperature.set_selected_index(weather_units_fahr, false);
+
+    const Rect content_rect{0, header_height, screen_width, screen_height - header_height};
+    recent_entries_view.set_parent_rect(content_rect);
+    recent_entries_view.on_select = [this](const WeatherRecentEntry& entry) {
+        nav_.push<WeatherRecentEntryDetailView>(entry);
+    };
+    baseband::set_subghzd_config(0, receiver_model.sampling_rate());  // 0=am
+    receiver_model.enable();
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        on_tick_second();
+    };
+}
+
+void WeatherView::on_tick_second() {
+    for (auto& entry : recent) {
+        entry.inc_age(1);
+    }
+    recent_entries_view.set_dirty();
+}
+
+void WeatherView::on_data(const WeatherDataMessage* data) {
+    WeatherRecentEntry key{data->sensorType, data->id, data->temp, data->humidity, data->channel, data->battery_low};
+    auto matching_recent = find(recent, key.key());
+    if (matching_recent != std::end(recent)) {
+        // Found within. Move to front of list, increment counter.
+        (*matching_recent).reset_age();
+        recent.push_front(*matching_recent);
+        recent.erase(matching_recent);
+    } else {
+        recent.emplace_front(key);
+        truncate_entries(recent, 64);
+    }
+    recent_entries_view.set_dirty();
+}
+
+WeatherView::~WeatherView() {
+    rtc_time::signal_tick_second -= signal_token_tick_second;
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+const char* WeatherView::getWeatherSensorTypeName(FPROTO_WEATHER_SENSOR type) {
+    switch (type) {
+        case FPW_NexusTH:
+            return "NexusTH";
+        case FPW_Acurite592TXR:
+            return "Acurite592TXR";
+        case FPW_Acurite606TX:
+            return "Acurite606TX";
+        case FPW_Acurite609TX:
+            return "Acurite609TX";
+        case FPW_Ambient:
+            return "Ambient";
+        case FPW_AuriolAhfl:
+            return "AuriolAhfl";
+        case FPW_AuriolTH:
+            return "AuriolTH";
+        case FPW_GTWT02:
+            return "GT-WT02";
+        case FPW_GTWT03:
+            return "GT-WT03";
+        case FPW_INFACTORY:
+            return "InFactory";
+        case FPW_LACROSSETX:
+            return "LaCrosse TX";
+        case FPW_LACROSSETX141thbv2:
+            return "LaCrosse TX141THBv2";
+        case FPW_OREGON2:
+            return "Oregon2";
+        case FPW_OREGON3:
+            return "Oregon3";
+        case FPW_OREGONv1:
+            return "OregonV1";
+        case FPW_THERMOPROTX4:
+            return "ThermoPro TX4";
+        case FPW_TX_8300:
+            return "TX 8300";
+        case FPW_WENDOX_W6726:
+            return "Wendox W6726";
+        case FPW_Acurite986:
+            return "Acurite986";
+
+        case FPW_Invalid:
+        default:
+            return "Unknown";
+    }
+}
+
+std::string WeatherView::pad_string_with_spaces(int snakes) {
+    std::string paddedStr(snakes, ' ');
+    return paddedStr;
+}
+
+template <>
+void RecentEntriesTable<ui::WeatherRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line{};
+    line.reserve(30);
+
+    line = WeatherView::getWeatherSensorTypeName((FPROTO_WEATHER_SENSOR)entry.sensorType);
+    if (line.length() < 10) {
+        line += WeatherView::pad_string_with_spaces(10 - line.length());
+    } else {
+        line = truncate(line, 10);
+    }
+
+    std::string temp = (weather_units_fahr ? to_string_decimal((entry.temp * 9 / 5) + 32, 1) : to_string_decimal(entry.temp, 1));
+    std::string humStr = (entry.humidity != WS_NO_HUMIDITY) ? to_string_dec_uint(entry.humidity) + "%" : "-";
+    std::string chStr = (entry.channel != WS_NO_CHANNEL) ? to_string_dec_uint(entry.channel) : "-";
+    std::string ageStr = to_string_dec_uint(entry.age);
+
+    line += WeatherView::pad_string_with_spaces(6 - temp.length()) + temp;
+    line += WeatherView::pad_string_with_spaces(5 - humStr.length()) + humStr;
+    line += WeatherView::pad_string_with_spaces(4 - chStr.length()) + chStr;
+    line += WeatherView::pad_string_with_spaces(5 - ageStr.length()) + ageStr;
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+}  // namespace ui
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_WEATHER_H__
+#define __UI_WEATHER_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "utility.hpp"
+#include "recent_entries.hpp"
+
+#include "../baseband/fprotos/weathertypes.hpp"
+using namespace ui;
+
+namespace ui {
+
+static bool weather_units_fahr{false};
+
+struct WeatherRecentEntry {
+    using Key = uint64_t;
+    static constexpr Key invalid_key = 0x0fffffff;  // todo calc the invalid all
+    uint8_t sensorType = FPW_Invalid;
+    uint32_t id = WS_NO_ID;
+    float temp = WS_NO_TEMPERATURE;
+    uint8_t humidity = WS_NO_HUMIDITY;
+    uint8_t battery_low = WS_NO_BATT;
+    uint8_t channel = WS_NO_CHANNEL;
+    uint16_t age = 0;  // updated on each seconds, show how long the signal was last seen
+
+    WeatherRecentEntry() {}
+    WeatherRecentEntry(
+        uint8_t sensorType,
+        uint32_t id,
+        float temp,
+        uint8_t humidity,
+        uint8_t channel,
+        uint8_t battery_low = WS_NO_BATT)
+        : sensorType{sensorType},
+          id{id},
+          temp{temp},
+          humidity{humidity},
+          battery_low{battery_low},
+          channel{channel} {
+    }
+    Key key() const {
+        return (((static_cast<uint64_t>(temp * 10) & 0xFFFF) << 48) ^ static_cast<uint64_t>(id) << 24) |
+               (static_cast<uint64_t>(sensorType) & 0xFF) << 16 |
+               (static_cast<uint64_t>(humidity) & 0xFF) << 8 |
+               (static_cast<uint64_t>(battery_low) & 0xF) << 4 |
+               (static_cast<uint64_t>(channel) & 0xF);
+    }
+    void inc_age(int delta) {
+        if (UINT16_MAX - delta > age) age += delta;
+    }
+    void reset_age() {
+        age = 0;
+    }
+};
+using WeatherRecentEntries = RecentEntries<WeatherRecentEntry>;
+using WeatherRecentEntriesView = RecentEntriesView<WeatherRecentEntries>;
+
+class WeatherView : public View {
+   public:
+    WeatherView(NavigationView& nav);
+    ~WeatherView();
+
+    void focus() override;
+
+    std::string title() const override { return "Weather"; };
+    static const char* getWeatherSensorTypeName(FPROTO_WEATHER_SENSOR type);
+    static std::string pad_string_with_spaces(int snakes);
+
+   private:
+    void on_tick_second();
+    void on_data(const WeatherDataMessage* data);
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{
+        433'920'000 /* frequency */,
+        1'750'000 /* bandwidth */,
+        2'000'000 /* sampling rate */,
+        ReceiverModel::Mode::AMAudio};
+    app_settings::SettingsManager settings_{
+        "rx_weather",
+        app_settings::Mode::RX,
+        {
+            {"units_fahr"sv, &weather_units_fahr},
+        }};
+
+    WeatherRecentEntries recent{};
+
+    OptionsField options_temperature{
+        {10 * 8, 0 * 16},
+        2,
+        {{STR_DEGREES_C, 0},
+         {STR_DEGREES_F, 1}}};
+
+    RFAmpField field_rf_amp{
+        {13 * 8, 0 * 16}};
+    LNAGainField field_lna{
+        {15 * 8, 0 * 16}};
+    VGAGainField field_vga{
+        {18 * 8, 0 * 16}};
+    RSSI rssi{
+        {21 * 8, 0, 6 * 8, 4}};
+    RxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+
+    SignalToken signal_token_tick_second{};
+
+    Button button_clear_list{
+        {0, 16, 7 * 8, 32},
+        "Clear"};
+
+    static constexpr auto header_height = 3 * 16;
+
+    const RecentEntriesColumns columns{{
+        {"Type", 10},
+        {"Temp", 5},
+        {"Hum", 4},
+        {"Ch", 3},
+        {"Age", 4},
+    }};
+    WeatherRecentEntriesView recent_entries_view{columns, recent};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::WeatherData,
+        [this](Message* const p) {
+            const auto message = static_cast<const WeatherDataMessage*>(p);
+            this->on_data(message);
+        }};
+};
+
+class WeatherRecentEntryDetailView : public View {
+   public:
+    WeatherRecentEntryDetailView(NavigationView& nav, const WeatherRecentEntry& entry);
+
+    void update_data();
+    void focus() override;
+
+   private:
+    NavigationView& nav_;
+    WeatherRecentEntry entry_{};
+    Text text_type{{10 * 8, 1 * 16, 15 * 8, 16}, "?"};
+    Text text_id{{10 * 8, 2 * 16, 10 * 8, 16}, "?"};
+    Text text_temp{{10 * 8, 3 * 16, 8 * 8, 16}, "?"};
+    Text text_hum{{10 * 8, 4 * 16, 6 * 8, 16}, "?"};
+    Text text_ch{{10 * 8, 5 * 16, 6 * 8, 16}, "?"};
+    Text text_batt{{10 * 8, 6 * 16, 6 * 8, 16}, "?"};
+    Text text_age{{10 * 8, 7 * 16, 10 * 8, 16}, "?"};
+
+    Labels labels{
+        {{0 * 8, 0 * 16}, "Weather Station", Color::light_grey()},
+        {{0 * 8, 1 * 16}, "Type:", Color::light_grey()},
+        {{0 * 8, 2 * 16}, "Id: ", Color::light_grey()},
+        {{0 * 8, 3 * 16}, "Temp:", Color::light_grey()},
+        {{0 * 8, 4 * 16}, "Humidity:", Color::light_grey()},
+        {{0 * 8, 5 * 16}, "Channel:", Color::light_grey()},
+        {{0 * 8, 6 * 16}, "Battery:", Color::light_grey()},
+        {{0 * 8, 7 * 16}, "Age:", Color::light_grey()},
+    };
+
+    Button button_done{
+        {screen_width - 96 - 4, screen_height - 32 - 12, 96, 32},
+        "Done"};
+};
+
+}  // namespace ui
+
+#endif /*__UI_WEATHER_H__*/
@@ -240,6 +240,10 @@ uint32_t reg_read(const size_t register_number) {
    return audio_codec->reg_read(register_number);
 }

+void reg_write(const size_t register_number, uint32_t value) {
+    audio_codec->reg_write(register_number, value);
+}
+
 std::string codec_name() {
    return audio_codec->name();
 }
@@ -59,6 +59,7 @@ class Codec {
    virtual size_t reg_count() const = 0;
    virtual size_t reg_bits() const = 0;
    virtual uint32_t reg_read(const size_t register_number) = 0;
+    virtual void reg_write(const size_t register_number, const uint32_t value) = 0;
 };

 namespace output {
@@ -107,6 +108,7 @@ namespace debug {

 size_t reg_count();
 uint32_t reg_read(const size_t register_number);
+void reg_write(const size_t register_number, uint32_t value);
 std::string codec_name();
 size_t reg_bits();

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

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

@@ -320,6 +319,11 @@ void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bo
    send_message(&message);
 }

+void set_subghzd_config(uint8_t modulation = 0, uint32_t sampling_rate = 0) {
+    const SubGhzFPRxConfigureMessage message{modulation, sampling_rate};
+    send_message(&message);
+}
+
 static bool baseband_image_running = false;

 void run_image(const spi_flash::image_tag_t image_tag) {
@@ -88,6 +88,7 @@ void set_spectrum(const size_t sampling_rate, const size_t trigger);
 void set_siggen_tone(const uint32_t tone);
 void set_siggen_config(const uint32_t bw, const uint32_t shape, const uint32_t duration);
 void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bool update, int32_t bw);
+void set_subghzd_config(uint8_t modulation, uint32_t sampling_rate);
 void request_beep();

 void run_image(const portapack::spi_flash::image_tag_t image_tag);
@@ -1169,20 +1169,20 @@ static constexpr uint8_t bitmap_icon_tpms_data[] = {
    0xEC,
    0x37,
    0x36,
-    0x6C,
-    0x1A,
-    0x58,
-    0x0B,
-    0xD0,
-    0x0B,
-    0xD0,
-    0x0B,
-    0xD0,
-    0x0B,
-    0xD0,
-    0x1A,
-    0x58,
-    0x36,
+    0x6D,
+    0x3A,
+    0x59,
+    0x4B,
+    0xD5,
+    0x8B,
+    0xD3,
+    0xCB,
+    0xD1,
+    0xAB,
+    0xD2,
+    0x9A,
+    0x5C,
+    0xB6,
    0x6C,
    0xEC,
    0x37,
@@ -5721,6 +5721,44 @@ static constexpr Bitmap bitmap_icon_hide{
    {16, 16},
    bitmap_icon_hide_data};

+static constexpr uint8_t bitmap_icon_thermometer_data[] = {
+    0xC0,
+    0x00,
+    0x20,
+    0x01,
+    0x10,
+    0x02,
+    0x10,
+    0x3A,
+    0x10,
+    0x02,
+    0x10,
+    0x1A,
+    0x10,
+    0x02,
+    0xD0,
+    0x3A,
+    0xD0,
+    0x02,
+    0xD0,
+    0x1A,
+    0xD0,
+    0x02,
+    0xE8,
+    0x05,
+    0xE8,
+    0x05,
+    0xC8,
+    0x04,
+    0x10,
+    0x02,
+    0xE0,
+    0x01,
+};
+static constexpr Bitmap bitmap_icon_thermometer{
+    {16, 16},
+    bitmap_icon_thermometer_data};
+
 } /* namespace ui */

 #endif /*__BITMAP_HPP__*/
@@ -21,6 +21,7 @@
 */

 #include <string>
+#include <cstdint>

 #ifndef __DE_BRUIJN_H__
 #define __DE_BRUIJN_H__
@@ -258,38 +258,43 @@ void draw_stack_dump() {
    }
 }

-// Disk I/O in this function doesn't work after a fault
-// Using the stack while dumping the stack isn't ideal, but hopefully anything imporant is still on the call stack.
 bool stack_dump() {
+    uint32_t num_words = &__process_stack_end__ - &__process_stack_base__;
+    return memory_dump(&__process_stack_base__, num_words, true);
+}
+
+bool memory_dump(uint32_t* addr_start, uint32_t num_words, bool stack_flag) {
    Painter painter;
    std::string debug_dir = "DEBUG";
    std::filesystem::path filename{};
-    File stack_dump_file{};
+    File dump_file{};
    bool error;
    std::string str;
+    uint32_t* addr_end;
    uint32_t* p;
    int n{0};
    bool data_found{false};

    make_new_directory(debug_dir);
-    filename = next_filename_matching_pattern(debug_dir + "/STACK_DUMP_????.TXT");
+    filename = next_filename_matching_pattern(debug_dir + "/" + (stack_flag ? "STACK" : "MEMORY") + "_DUMP_????.TXT");
    error = filename.empty();
    if (!error)
-        error = stack_dump_file.create(filename) != 0;
+        error = dump_file.create(filename) != 0;
    if (error) {
        painter.draw_string({16, 320 - 32}, ui::Styles::red, "ERROR DUMPING " + filename.filename().string() + "!");
        return false;
    }

-    for (p = &__process_stack_base__; p < &__process_stack_end__; p++) {
+    addr_end = addr_start + num_words;
+    for (p = addr_start; p < addr_end; p++) {
        // skip past unused stack words
-        if (!data_found) {
+        if (stack_flag && !data_found) {
            if (*p == CRT0_STACKS_FILL_PATTERN)
                continue;
            else {
                data_found = true;
-                auto stack_space_left = p - &__process_stack_base__;
-                stack_dump_file.write_line(to_string_hex((uint32_t)&__process_stack_base__, 8) + ": Unused words " + to_string_dec_uint(stack_space_left));
+                auto stack_space_left = p - addr_start;
+                dump_file.write_line(to_string_hex((uint32_t)addr_start, 8) + ": Unused words " + to_string_dec_uint(stack_space_left));

                // align subsequent lines to start on 16-byte boundaries
                p -= (stack_space_left & 3);
@@ -299,20 +304,20 @@ bool stack_dump() {
        // write address
        if (n++ == 0) {
            str = to_string_hex((uint32_t)p, 8) + ":";
-            stack_dump_file.write(str.data(), 9);
+            dump_file.write(str.data(), 9);
        }

        // write stack dword
        str = " " + to_string_hex(*p, 8);
-        stack_dump_file.write(str.data(), 9);
+        dump_file.write(str.data(), 9);

        if (n == 4) {
-            stack_dump_file.write("\r\n", 2);
+            dump_file.write("\r\n", 2);
            n = 0;
        }
    }

-    painter.draw_string({16, 320 - 32}, ui::Styles::green, filename.filename().string() + " dumped!");
+    painter.draw_string({0, 320 - 16}, ui::Styles::green, filename.filename().string() + " dumped!");
    return true;
 }

@@ -48,5 +48,6 @@ inline uint32_t get_free_stack_space() {
 }

 bool stack_dump();
+bool memory_dump(uint32_t* addr_start, uint32_t num_words, bool stack_flag);

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

@@ -24,6 +24,7 @@
 #define __UI_AFSK_RX_H__

 #include "ui.hpp"
+#include "ui_language.hpp"
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
 #include "ui_freq_field.hpp"
@@ -92,16 +93,16 @@ class AFSKRxView : public View {
    Checkbox check_log{
        {0 * 8, 1 * 16},
        3,
-        "LOG",
+        LanguageHelper::currentMessages[LANG_LOG],
        false};

    Text text_debug{
        {0 * 8, 12 + 2 * 16, screen_width, 16},
-        "DEBUG"};
+        LanguageHelper::currentMessages[LANG_DEBUG]};

    Button button_modem_setup{
        {screen_width - 12 * 8, 1 * 16, 96, 24},
-        "Modem setup"};
+        LanguageHelper::currentMessages[LANG_MODEM_SETUP]};

    Console console{
        {0, 4 * 16, 240, screen_width}};
@@ -37,7 +37,7 @@ using namespace tonekey;

 #include "string_format.hpp"

-namespace ui {
+namespace ui::external_app::analogtv {

 /* AnalogTvView *******************************************************/

@@ -192,10 +192,11 @@ void AnalogTvView::update_modulation(const ReceiverModel::Mode modulation) {

    baseband::shutdown();

-    portapack::spi_flash::image_tag_t image_tag;
-    image_tag = portapack::spi_flash::image_tag_am_tv;
+    // portapack::spi_flash::image_tag_t image_tag; //moved to ext app, disabled
+    // image_tag = portapack::spi_flash::image_tag_am_tv;

-    baseband::run_image(image_tag);
+    // baseband::run_image(image_tag);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());  // moved the baseband too

    receiver_model.set_modulation(modulation);
    receiver_model.set_sampling_rate(2000000);
@@ -203,4 +204,4 @@ void AnalogTvView::update_modulation(const ReceiverModel::Mode modulation) {
    receiver_model.enable();
 }

-} /* namespace ui */
+}  // namespace ui::external_app::analogtv
@@ -36,7 +36,7 @@

 #include "tone_key.hpp"

-namespace ui {
+namespace ui::external_app::analogtv {

 class AnalogTvView : public View {
   public:
@@ -111,6 +111,6 @@ class AnalogTvView : public View {
    void update_modulation(const ReceiverModel::Mode modulation);
 };

-} /* namespace ui */
+}  // namespace ui::external_app::analogtv

 #endif /*__ANALOG_TV_APP_H__*/
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "analog_tv_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::analogtv {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<AnalogTvView>();
+}
+}  // namespace ui::external_app::analogtv
+
+extern "C" {
+
+__attribute__((section(".external_app.app_analogtv.application_information"), used)) application_information_t _application_information_analogtv = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::analogtv::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Analog TV",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xFE,
+        0x7F,
+        0x03,
+        0xC0,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0xAB,
+        0xCA,
+        0x53,
+        0xD5,
+        0x03,
+        0xC0,
+        0xFF,
+        0xFF,
+        0xFB,
+        0xD7,
+        0xFE,
+        0x7F,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::RX,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_am_tv */ {'P', 'A', 'M', 'T'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_blespam.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::blespam {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<BLESpamView>();
+}
+}  // namespace ui::external_app::blespam
+
+extern "C" {
+
+__attribute__((section(".external_app.app_blespam.application_information"), used)) application_information_t _application_information_blespam = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::blespam::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "BLESpam",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xF8,
+        0x1F,
+        0x04,
+        0x20,
+        0x02,
+        0x40,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xAB,
+        0xDF,
+        0xAB,
+        0xDF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::TX,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_afsk_rx */ {'P', 'B', 'T', 'T'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+// Code from https://github.com/Flipper-XFW/Xtreme-Apps/tree/04c3a60093e2c2378e79498b4505aa8072980a42/ble_spam/protocols
+// Thanks for the work of the original creators!
+// Saying thanks in the main view!
+
+#ifndef __UI_BLESPAM_H__
+#define __UI_BLESPAM_H__
+
+#include "ui.hpp"
+#include "ui_language.hpp"
+#include "ui_navigation.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_record_view.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+#include "utility.hpp"
+
+using namespace ui;
+
+namespace ui::external_app::blespam {
+
+enum ATK_TYPE {
+    ATK_ANDROID,
+    ATK_IOS,
+    ATK_IOS_CRASH,
+    ATK_WINDOWS,
+    ATK_SAMSUNG
+};
+enum PKT_TYPE {
+    PKT_TYPE_INVALID_TYPE,
+    PKT_TYPE_RAW,
+    PKT_TYPE_DISCOVERY,
+    PKT_TYPE_IBEACON,
+    PKT_TYPE_ADV_IND,
+    PKT_TYPE_ADV_DIRECT_IND,
+    PKT_TYPE_ADV_NONCONN_IND,
+    PKT_TYPE_ADV_SCAN_IND,
+    PKT_TYPE_SCAN_REQ,
+    PKT_TYPE_SCAN_RSP,
+    PKT_TYPE_CONNECT_REQ,
+    PKT_TYPE_LL_DATA,
+    PKT_TYPE_LL_CONNECTION_UPDATE_REQ,
+    PKT_TYPE_LL_CHANNEL_MAP_REQ,
+    PKT_TYPE_LL_TERMINATE_IND,
+    PKT_TYPE_LL_ENC_REQ,
+    PKT_TYPE_LL_ENC_RSP,
+    PKT_TYPE_LL_START_ENC_REQ,
+    PKT_TYPE_LL_START_ENC_RSP,
+    PKT_TYPE_LL_UNKNOWN_RSP,
+    PKT_TYPE_LL_FEATURE_REQ,
+    PKT_TYPE_LL_FEATURE_RSP,
+    PKT_TYPE_LL_PAUSE_ENC_REQ,
+    PKT_TYPE_LL_PAUSE_ENC_RSP,
+    PKT_TYPE_LL_VERSION_IND,
+    PKT_TYPE_LL_REJECT_IND,
+    PKT_TYPE_NUM_PKT_TYPE
+};
+
+class BLESpamView : public View {
+   public:
+    BLESpamView(NavigationView& nav);
+    ~BLESpamView();
+
+    void focus() override;
+
+    std::string title() const override {
+        return "BLESpam";
+    };
+
+   private:
+    NavigationView& nav_;
+    TxRadioState radio_state_{
+        2'402'000'000 /* frequency */,
+        4'000'000 /* bandwidth */,
+        4'000'000 /* sampling rate */
+    };
+    TxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+    TransmitterView2 tx_view{
+        {11 * 8, 0 * 16},
+        /*short_ui*/ true};
+    app_settings::SettingsManager settings_{
+        "tx_blespam", app_settings::Mode::TX};
+
+    Button button_startstop{
+        {0, 3 * 16, 96, 24},
+        LanguageHelper::currentMessages[LANG_START]};
+    Checkbox chk_randdev{{100, 16}, 10, "Rnd device", true};
+
+    Console console{
+        {0, 70, 240, 220}};
+
+    OptionsField options_atkmode{
+        {0 * 8, 2 * 8},
+        10,
+        {{"Android", 0},
+         {"iOs", 1},
+         {"iOs crash", 2},
+         {"Windows", 3},
+         {"Samsung", 4}}};
+
+    bool is_running{false};
+
+    uint8_t counter = 0;         // for packet change
+    uint8_t displayCounter = 0;  // for packet display
+
+    ATK_TYPE attackType = ATK_ANDROID;
+
+    bool randomMac{true};
+    bool randomDev{true};
+
+    uint8_t channel_number = 37;
+    char mac[13] = "010203040507";
+    char advertisementData[63] = {"03032CFE06162CFED5A59E020AB4\0"};
+    PKT_TYPE pduType = {PKT_TYPE_DISCOVERY};
+
+    void start();
+    void stop();
+    void reset();
+    void createFastPairPacket();
+    void createIosPacket(bool crash);
+    void createSamsungPacket();
+    void createWindowsPacket();
+    void changePacket(bool forced);
+    void on_tx_progress(const bool done);
+
+    uint64_t get_freq_by_channel_number(uint8_t channel_number);
+    void randomizeMac();
+    void randomChn();
+
+    void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len);
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.done);
+        }};
+
+    // continuity
+
+    typedef enum {
+        PayloadModeRandom,
+        PayloadModeValue,
+        PayloadModeBruteforce,
+    } PayloadMode;
+
+    typedef enum {
+        ContinuityTypeAirDrop = 0x05,
+        ContinuityTypeProximityPair = 0x07,
+        ContinuityTypeAirplayTarget = 0x09,
+        ContinuityTypeHandoff = 0x0C,
+        ContinuityTypeTetheringSource = 0x0E,
+        ContinuityTypeNearbyAction = 0x0F,
+        ContinuityTypeNearbyInfo = 0x10,
+
+        ContinuityTypeCustomCrash,
+        ContinuityTypeCOUNT
+    } ContinuityType;
+
+    typedef enum {
+        ContinuityPpBruteforceModel,
+        ContinuityPpBruteforceColor,
+    } ContinuityPpBruteforce;
+
+    typedef struct {
+        uint8_t value;
+        // const char* name;
+    } ContinuityColor;
+
+    static const uint8_t pp_prefixes_count;
+
+    static const uint8_t na_actions_count;
+    static const uint8_t pp_models_count;
+    static const ContinuityColor colors_beats_studio_buds_[];
+    static const ContinuityColor colors_beats_fit_pro[];
+    static const ContinuityColor colors_beats_studio_pro[];
+    static const ContinuityColor colors_beats_studio_3[];
+    static const ContinuityColor colors_beats_x[];
+    static const ContinuityColor colors_beats_studio_buds[];
+    static const ContinuityColor colors_beats_solo_pro[];
+    static const ContinuityColor colors_powerbeats_pro[];
+    static const ContinuityColor colors_powerbeats_3[];
+    static const ContinuityColor colors_beats_solo_3[];
+    static const ContinuityColor colors_beats_flex[];
+    static const ContinuityColor colors_airpods_max[];
+    static const ContinuityColor colors_white[];
+    typedef struct {
+        uint16_t value;
+        // const char* name;
+        const ContinuityColor* colors;
+        const uint8_t colors_count;
+    } contiModels;
+    static const contiModels pp_models[];
+    typedef struct {
+        uint8_t value;
+    } contiU8;
+    static const contiU8 pp_prefixes[];
+    static const contiU8 na_actions[];
+
+    // fastpair:
+
+    static const uint16_t fastpairModels_count;
+    typedef struct {
+        uint32_t value;
+        const char* name;  // could be moved too
+    } fpUi32;
+    static const fpUi32 fastpairModels[];
+
+    // easysetup:
+    static const uint8_t watch_models_count;
+    typedef struct {
+        uint8_t value;
+    } easyU8;
+    typedef struct {
+        uint32_t value;
+    } easyU32;
+    typedef enum {
+        EasysetupTypeBuds = 0x01,  // Skip 0 as it means unset
+        EasysetupTypeWatch,
+        EasysetupTypeCOUNT,
+    } EasysetupType;
+    static const easyU8 watch_models[];
+    static const uint8_t buds_models_count;
+    static const easyU32 buds_models[];
+};
+};  // namespace ui::external_app::blespam
+
+#endif /*__UI_BLESPAM_H__*/
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_coasterp.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::coasterp {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<CoasterPagerView>();
+}
+}  // namespace ui::external_app::coasterp
+
+extern "C" {
+
+__attribute__((section(".external_app.app_coasterp.application_information"), used)) application_information_t _application_information_coasterp = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::coasterp::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "BurgerPgr",
+    /*.bitmap_data = */ {
+
+        0x00,
+        0x00,
+        0xE0,
+        0x07,
+        0xF8,
+        0x1F,
+        0xFC,
+        0x3F,
+        0xFE,
+        0x7F,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x00,
+        0x00,
+        0x55,
+        0x55,
+        0xAA,
+        0xAA,
+        0x55,
+        0x55,
+        0x00,
+        0x00,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFE,
+        0x7F,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::TX,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_fsktx */ {'P', 'F', 'S', 'K'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -30,7 +30,7 @@

 using namespace portapack;

-namespace ui {
+namespace ui::external_app::coasterp {

 void CoasterPagerView::focus() {
    sym_data.focus();
@@ -131,4 +131,4 @@ CoasterPagerView::CoasterPagerView(NavigationView& nav) {
    };
 }

-} /* namespace ui */
+} /* namespace ui::external_app::coasterp */
@@ -21,6 +21,7 @@
 */

 #include "ui.hpp"
+#include "ui_language.hpp"
 #include "ui_widget.hpp"
 #include "ui_navigation.hpp"
 #include "ui_transmitter.hpp"
@@ -31,7 +32,7 @@
 #include "radio_state.hpp"
 #include "portapack.hpp"

-namespace ui {
+namespace ui::external_app::coasterp {

 class CoasterPagerView : public View {
   public:
@@ -65,7 +66,7 @@ class CoasterPagerView : public View {

    Labels labels{
        {{1 * 8, 3 * 8}, "Syscall pager TX beta", Color::light_grey()},
-        {{1 * 8, 8 * 8}, "Data:", Color::light_grey()}};
+        {{1 * 8, 8 * 8}, LanguageHelper::currentMessages[LANG_DATADP], Color::light_grey()}};

    SymField sym_data{
        {7 * 8, 8 * 8},
@@ -75,7 +76,7 @@ class CoasterPagerView : public View {
    Checkbox checkbox_scan{
        {10 * 8, 14 * 8},
        4,
-        "Scan"};
+        LanguageHelper::currentMessages[LANG_SCAN]};

    /*
    ProgressBar progressbar {
@@ -99,4 +100,4 @@ class CoasterPagerView : public View {
        }};
 };

-} /* namespace ui */
+} /* namespace ui::external_app::coasterp */
@@ -15,6 +15,35 @@ set(EXTCPPSRC
 	#font_viewer
 	external/font_viewer/main.cpp
 	external/font_viewer/ui_font_viewer.cpp
+
+	#blespam
+	external/blespam/main.cpp
+	external/blespam/ui_blespam.cpp
+	
+	#analogtv
+	external/analogtv/main.cpp
+	external/analogtv/analog_tv_app.cpp
+
+	#nrf_rx
+	external/nrf_rx/main.cpp
+	external/nrf_rx/ui_nrf_rx.cpp
+
+	#coasterp
+	external/coasterp/main.cpp
+	external/coasterp/ui_coasterp.cpp
+
+	#lge
+	external/lge/main.cpp
+	external/lge/lge_app.cpp
+	
+	#lcr
+	external/lcr/main.cpp
+	external/lcr/ui_lcr.cpp
+	
+		
+	#lcr
+	external/jammer/main.cpp
+	external/jammer/ui_jammer.cpp
 )

 set(EXTAPPLIST
@@ -22,4 +51,11 @@ set(EXTAPPLIST
 	afsk_rx
 	calculator
 	font_viewer
+	blespam
+	nrf_rx
+	analogtv
+	coasterp
+	lge
+	lcr
+	jammer
 )
@@ -21,6 +21,13 @@ MEMORY
    ram_external_app_afsk_rx    (rwx) : org = 0xEEEA0000, len = 32k
    ram_external_app_calculator (rwx) : org = 0xEEEB0000, len = 32k
    ram_external_app_font_viewer(rwx) : org = 0xEEEC0000, len = 32k
+    ram_external_app_blespam(rwx) : org = 0xEEED0000, len = 32k
+    ram_external_app_analogtv(rwx) : org = 0xEEEE0000, len = 32k
+    ram_external_app_nrf_rx(rwx) : org = 0xEEEF0000, len = 32k
+    ram_external_app_coasterp(rwx) : org = 0xEEF00000, len = 32k
+    ram_external_app_lge(rwx) : org = 0xEEF10000, len = 32k
+    ram_external_app_lcr(rwx) : org = 0xEEF20000, len = 32k
+    ram_external_app_jammer(rwx) : org = 0xEEF30000, len = 32k
 }

 SECTIONS
@@ -48,4 +55,51 @@ SECTIONS
        KEEP(*(.external_app.app_font_viewer.application_information));
        *(*ui*external_app*font_viewer*);
    } > ram_external_app_font_viewer
+
+    
+    .external_app_blespam : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_blespam.application_information));
+        *(*ui*external_app*blespam*);
+    } > ram_external_app_blespam
+
+    .external_app_analogtv : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_analogtv.application_information));
+        *(*ui*external_app*analogtv*);
+    } > ram_external_app_analogtv
+
+    .external_app_nrf_rx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_nrf_rx.application_information));
+        *(*ui*external_app*nrf_rx*);
+    } > ram_external_app_nrf_rx
+ 
+     .external_app_coasterp : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_coasterp.application_information));
+        *(*ui*external_app*coasterp*);
+    } > ram_external_app_coasterp
+    
+    .external_app_lge : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_lge.application_information));
+        *(*ui*external_app*lge*);
+    } > ram_external_app_lge
+ 
+
+     .external_app_lcr : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_lcr.application_information));
+        *(*ui*external_app*lcr*);
+    } > ram_external_app_lcr
+ 
+
+     .external_app_jammer : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_jammer.application_information));
+        *(*ui*external_app*jammer*);
+    } > ram_external_app_jammer
+ 
+
 }
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_jammer.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::jammer {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<JammerView>();
+}
+}  // namespace ui::external_app::jammer
+
+extern "C" {
+
+__attribute__((section(".external_app.app_jammer.application_information"), used)) application_information_t _application_information_jammer = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::jammer::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Jammer",
+    /*.bitmap_data = */ {
+        0xE0,
+        0x07,
+        0xF8,
+        0x1F,
+        0x1C,
+        0x38,
+        0x0E,
+        0x78,
+        0x06,
+        0x7C,
+        0x03,
+        0xCE,
+        0x03,
+        0xC7,
+        0x83,
+        0xC3,
+        0xC3,
+        0xC1,
+        0xE3,
+        0xC0,
+        0x73,
+        0xC0,
+        0x3E,
+        0x60,
+        0x1E,
+        0x70,
+        0x1C,
+        0x38,
+        0xF8,
+        0x1F,
+        0xE0,
+        0x07,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::TX,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_jammer */ {'P', 'J', 'A', 'M'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -29,7 +29,7 @@

 using namespace portapack;

-namespace ui {
+namespace ui::external_app::jammer {

 void RangeView::focus() {
    check_enabled.focus();
@@ -331,7 +331,8 @@ JammerView::JammerView(
    NavigationView& nav)
    : nav_{nav} {
    Rect view_rect = {0, 3 * 8, 240, 80};
-    baseband::run_image(portapack::spi_flash::image_tag_jammer);
+    // baseband::run_image(portapack::spi_flash::image_tag_jammer);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());

    add_children({&tab_view,
                  &view_range_a,
@@ -372,4 +373,4 @@ JammerView::JammerView(
    };
 }

-} /* namespace ui */
+}  // namespace ui::external_app::jammer
@@ -33,7 +33,7 @@

 using namespace jammer;

-namespace ui {
+namespace ui::external_app::jammer {

 class RangeView : public View {
   public:
@@ -242,4 +242,4 @@ class JammerView : public View {
        }};
 };

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

-#include "lcr.hpp"
 #include "baseband_api.hpp"
 #include "string_format.hpp"

@@ -31,7 +30,7 @@

 using namespace portapack;

-namespace ui {
+namespace ui::external_app::lcr {

 void LCRView::focus() {
    button_set_rgsb.focus();
@@ -42,6 +41,49 @@ LCRView::~LCRView() {
    baseband::shutdown();
 }

+std::string LCRView::generate_message(std::string rgsb, std::vector<std::string> litterals, size_t option_ec) {
+    const std::string ec_lut[4] = {"A", "J", "N", "S"};  // Eclairage (Auto, Jour, Nuit)
+    char eom[3] = {3, 0, 0};                             // EOM and space for checksum
+    uint8_t i;
+    std::string lcr_message{127, 127, 127, 127, 127, 127, 127, 5};  // 5/15 ? Modem sync and SOM
+    char checksum = 0;
+
+    // Pad litterals to 7 chars (not required ?)
+    for (auto& litteral : litterals)
+        while (litteral.length() < 7)
+            litteral += ' ';
+
+    // Compose LCR message
+    lcr_message += rgsb;
+    lcr_message += "PA ";
+
+    i = 1;
+    for (auto& litteral : litterals) {
+        lcr_message += "AM=";
+        lcr_message += to_string_dec_uint(i, 1);
+        lcr_message += " AF=\"";
+        lcr_message += litteral;
+        lcr_message += "\" CL=0 ";
+        i++;
+    }
+
+    lcr_message += "EC=";
+    lcr_message += ec_lut[option_ec];
+    lcr_message += " SAB=0";
+
+    // Checksum
+    i = 7;  // Skip modem sync
+    while (lcr_message[i])
+        checksum ^= lcr_message[i++];
+    checksum ^= eom[0];  // EOM char
+    checksum &= 0x7F;    // Trim
+    eom[1] = checksum;
+
+    lcr_message += eom;
+
+    return lcr_message;
+}
+
 /*
 // Recap: frequency @ baudrate
 final_str = to_string_short_freq(persistent_memory::tuned_frequency());
@@ -53,7 +95,7 @@ text_recap.set(final_str);*/

 void LCRView::update_progress() {
    if (tx_mode == IDLE) {
-        text_status.set("Ready");
+        text_status.set(LanguageHelper::currentMessages[LANG_READY]);
        progress.set_value(0);
    } else {
        std::string progress_str = to_string_dec_uint(repeat_index) + "/" + to_string_dec_uint(persistent_memory::modem_repeat()) +
@@ -125,7 +167,7 @@ void LCRView::start_tx(const bool scan) {
            litterals_list.push_back(litteral[i]);
    }

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

    /* It is AFSK modulation , measuring original fw 1.7.4 spectrum BW is just around 30khz , NBFM */
    transmitter_model.set_baseband_bandwidth(1'750'000);  // Min TX LPF 1M75, same spectrum as previous fw 1.7.4
@@ -269,4 +311,4 @@ LCRView::LCRView(NavigationView& nav) {
    };
 }

-} /* namespace ui */
+} /* namespace ui::external_app::lcr */
@@ -21,6 +21,7 @@
 */

 #include "ui.hpp"
+#include "ui_language.hpp"
 #include "ui_widget.hpp"
 #include "ui_textentry.hpp"
 #include "ui_transmitter.hpp"
@@ -31,7 +32,7 @@
 #include "app_settings.hpp"
 #include "radio_state.hpp"

-namespace ui {
+namespace ui::external_app::lcr {

 #define LCR_MAX_AM 5

@@ -101,6 +102,7 @@ class LCRView : public View {
    void start_tx(const bool scan);
    void on_tx_progress(const uint32_t progress, const bool done);
    void on_button_set_am(NavigationView& nav, int16_t button_id);
+    std::string generate_message(std::string rgsb, std::vector<std::string> litterals, size_t option_ec);

    Labels labels{
        {{0, 8}, "EC:     RGSB:", Color::light_grey()},
@@ -125,11 +127,11 @@ class LCRView : public View {
    Checkbox check_scan{
        {22 * 8, 4},
        4,
-        "Scan"};
+        LanguageHelper::currentMessages[LANG_SCAN]};

    Button button_modem_setup{
        {1 * 8, 4 * 8 + 2, 14 * 8, 24},
-        "Modem setup"};
+        LanguageHelper::currentMessages[LANG_MODEM_SETUP]};
    OptionsField options_scanlist{
        {22 * 8, 4 * 8},
        6,
@@ -137,11 +139,11 @@ class LCRView : public View {

    Button button_clear{
        {22 * 8, 8 * 8, 7 * 8, 19 * 8},
-        "CLEAR"};
+        LanguageHelper::currentMessages[LANG_CLEAR]};

    Text text_status{
        {2 * 8, 27 * 8 + 4, 26 * 8, 16},
-        "Ready"};
+        LanguageHelper::currentMessages[LANG_READY]};
    ProgressBar progress{
        {2 * 8, 29 * 8 + 4, 26 * 8, 16}};

@@ -158,4 +160,4 @@ class LCRView : public View {
        }};
 };

-} /* namespace ui */
+} /* namespace ui::external_app::lcr */
@@ -36,7 +36,7 @@

 using namespace portapack;

-namespace ui {
+namespace ui::external_app::lge {

 void LGEView::focus() {
    options_frame.focus();
@@ -354,4 +354,4 @@ LGEView::LGEView(NavigationView& nav) {
    };
 }

-} /* namespace ui */
+} /* namespace ui::external_app::lge */
@@ -21,6 +21,7 @@
 */

 #include "ui.hpp"
+#include "ui_language.hpp"
 #include "ui_widget.hpp"
 #include "ui_navigation.hpp"
 #include "ui_transmitter.hpp"
@@ -32,7 +33,7 @@
 #include "app_settings.hpp"
 #include "radio_state.hpp"

-namespace ui {
+namespace ui::external_app::lge {

 class LGEView : public View {
   public:
@@ -105,7 +106,7 @@ class LGEView : public View {
         {"Set nickname", 1},
         {"Set team", 2},
         {"Brdcst nick", 3},
-         {"Start", 4},
+         {LanguageHelper::currentMessages[LANG_START], 4},
         {"Game over", 5},
         {"Set vest", 6}}};

@@ -185,4 +186,4 @@ class LGEView : public View {
        }};
 };

-} /* namespace ui */
+} /* namespace ui::external_app::lge */
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "lge_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::lge {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<LGEView>();
+}
+}  // namespace ui::external_app::lge
+
+extern "C" {
+
+__attribute__((section(".external_app.app_lge.application_information"), used)) application_information_t _application_information_lge = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::lge::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "LGE",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x80,
+        0x00,
+        0xA4,
+        0x12,
+        0xA8,
+        0x0A,
+        0xD0,
+        0x05,
+        0xEC,
+        0x1B,
+        0xF0,
+        0x07,
+        0xFE,
+        0xFF,
+        0xF0,
+        0x07,
+        0xEC,
+        0x1B,
+        0xD0,
+        0x05,
+        0xA8,
+        0x0A,
+        0xA4,
+        0x12,
+        0x80,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::TX,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_fsktx */ {'P', 'F', 'S', 'K'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_nrf_rx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::nrf_rx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<NRFRxView>();
+}
+}  // namespace ui::external_app::nrf_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_nrf_rx.application_information"), used)) application_information_t _application_information_nrf_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::nrf_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "NRF",
+    /*.bitmap_data = */ {
+
+        0x00,
+        0x01,
+        0x00,
+        0x01,
+        0x00,
+        0x01,
+        0x00,
+        0x01,
+        0x00,
+        0x01,
+        0x00,
+        0x01,
+        0x00,
+        0x01,
+        0xF8,
+        0x3F,
+        0xFC,
+        0x7F,
+        0xFC,
+        0x7F,
+        0xDC,
+        0x7F,
+        0x8C,
+        0x6B,
+        0xDC,
+        0x7F,
+        0xFC,
+        0x7F,
+        0xFC,
+        0x7F,
+        0xF8,
+        0x3F,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::RX,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_nrf_rx */ {'P', 'N', 'R', 'R'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -34,7 +34,7 @@
 using namespace portapack;
 using namespace modems;

-namespace ui {
+namespace ui::external_app::nrf_rx {

 void NRFRxView::focus() {
    field_frequency.focus();
@@ -42,7 +42,8 @@ void NRFRxView::focus() {

 NRFRxView::NRFRxView(NavigationView& nav)
    : nav_{nav} {
-    baseband::run_image(portapack::spi_flash::image_tag_nrf_rx);
+    // baseband::run_image(portapack::spi_flash::image_tag_nrf_rx);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());

    add_children({&rssi,
                  &channel,
@@ -130,4 +131,4 @@ NRFRxView::~NRFRxView() {
    baseband::shutdown();
 }

-} /* namespace ui */
+}  // namespace ui::external_app::nrf_rx
@@ -25,6 +25,7 @@
 #define __UI_NRF_RX_H__

 #include "ui.hpp"
+#include "ui_language.hpp"
 #include "ui_navigation.hpp"
 #include "ui_receiver.hpp"
 #include "ui_freq_field.hpp"
@@ -34,7 +35,7 @@

 #include "utility.hpp"

-namespace ui {
+namespace ui::external_app::nrf_rx {

 class NRFRxView : public View {
   public:
@@ -77,7 +78,7 @@ class NRFRxView : public View {

    Button button_modem_setup{
        {240 - 12 * 8, 1 * 16, 96, 24},
-        "Modem setup"};
+        LanguageHelper::currentMessages[LANG_MODEM_SETUP]};

    Console console{
        {0, 4 * 16, 240, 240}};
@@ -90,6 +91,6 @@ class NRFRxView : public View {
        }};
 };

-} /* namespace ui */
+} /* namespace ui::external_app::nrf_rx */

 #endif /*__UI_NRF_RX_H__*/
@@ -285,7 +285,7 @@
 *          buffers.
 */
 #if !defined(SERIAL_BUFFERS_SIZE) || defined(__DOXYGEN__)
-#define SERIAL_BUFFERS_SIZE 16
+#define SERIAL_BUFFERS_SIZE 64
 #endif

 /*===========================================================================*/
@@ -342,7 +342,7 @@ int8_t MAX2837::temp_sense() {
    _map.r.rx_top.ts_adc_trigger = 0;
    flush_one(Register::RX_TOP);

-    return value * 4.31 - 6;  // reg value is 0 to 31; possible return range is -6 C to 127 C
+    return std::min(127, (int)(value * 4.31 - 40));  // reg value is 0 to 31; possible return range is -40 C to 127 C
 }

 }  // namespace max2837
@@ -836,6 +836,7 @@ class MAX2837 : public MAX283x {
    int8_t temp_sense() override;

    reg_t read(const address_t reg_num) override;
+    void write(const address_t reg_num, const reg_t value) override;

   private:
    spi::arbiter::Target& _target;
@@ -845,8 +846,6 @@ class MAX2837 : public MAX283x {

    void flush_one(const Register reg);

-    void write(const address_t reg_num, const reg_t value);
-
    void write(const Register reg, const reg_t value);
    reg_t read(const Register reg);

@@ -372,7 +372,7 @@ int8_t MAX2839::temp_sense() {
    _map.r.rx_top_2.ts_adc_trigger = 0;
    flush_one(Register::RX_TOP_2);

-    return value * 4.31 - 75;  // reg value is 0 to 31; possible return range is -75 C to 58 C
+    return std::min(127, (int)(value * 4.31 - 40));  // reg value is 0 to 31; possible return range is -40 C to 127 C
 }

 }  // namespace max2839
@@ -695,6 +695,7 @@ class MAX2839 : public MAX283x {
    int8_t temp_sense() override;

    reg_t read(const address_t reg_num) override;
+    void write(const address_t reg_num, const reg_t value) override;

   private:
    spi::arbiter::Target& _target;
@@ -704,8 +705,6 @@ class MAX2839 : public MAX283x {

    void flush_one(const Register reg);

-    void write(const address_t reg_num, const reg_t value);
-
    void write(const Register reg, const reg_t value);
    reg_t read(const Register reg);

@@ -134,6 +134,7 @@ class MAX283x {
    virtual int8_t temp_sense();

    virtual reg_t read(const address_t reg_num);
+    virtual void write(const address_t reg_num, const reg_t value);
 };

 }  // namespace max283x
@@ -841,6 +841,7 @@ class RFFC507x {
    void set_gpo1(const bool new_value);

    reg_t read(const address_t reg_num);
+    void write(const address_t reg_num, const reg_t value);

   private:
    spi::SPI _bus{};
@@ -848,8 +849,6 @@ class RFFC507x {
    RegisterMap _map{default_hackrf_one};
    DirtyRegisters<Register, reg_count> _dirty{};

-    void write(const address_t reg_num, const reg_t value);
-
    void write(const Register reg, const reg_t value);
    reg_t read(const Register reg);

@@ -122,6 +122,8 @@ static bool touch_update() {
 }

 static uint8_t switches_raw = 0;
+static uint8_t injected_switch = 0;
+static uint8_t injected_encoder = 0;

 /* The raw data is not packed in a way that makes looping over it easy.
 * One option would be an accessor helper (RawSwitch). Another option
@@ -170,8 +172,11 @@ static bool encoder_update(const uint8_t raw) {

 static bool encoder_read() {
    const auto delta = encoder.update(
-        encoder_debounce[0].state(),
-        encoder_debounce[1].state());
+        encoder_debounce[0].state() | (injected_encoder == 1),
+        encoder_debounce[1].state() | (injected_encoder == 2));
+
+    if (injected_encoder > 0)
+        injected_encoder = 0;

    if (delta != 0) {
        encoder_position += delta;
@@ -186,10 +191,10 @@ void timer0_callback(GPTDriver* const) {
    if (touch_update()) event_mask |= EVT_MASK_TOUCH;

    switches_raw = swizzled_switches();
-    if (switches_update(switches_raw))
+    if (switches_update(switches_raw) || (injected_switch > 0))
        event_mask |= EVT_MASK_SWITCHES;

-    if (encoder_update(switches_raw) && encoder_read())
+    if (encoder_update(switches_raw) || encoder_read())
        event_mask |= EVT_MASK_ENCODER;

    /* Signal event loop */
@@ -238,6 +243,13 @@ SwitchesState get_switches_state() {
    for (size_t i = 0; i < result.size(); i++)
        result[i] = switch_debounce[i].state();

+    if (injected_switch > 0 && injected_switch <= 6) {
+        result[injected_switch - 1] = 1;
+        injected_switch = 0xff;
+    } else if (injected_switch == 0xff) {
+        injected_switch = 0x00;
+    }
+
    return result;
 }

@@ -277,5 +289,12 @@ uint8_t switches() {
    return switches_raw;
 }

+void inject_switch(uint8_t button) {
+    if (button <= 6)
+        injected_switch = button;
+    else if (button > 6)
+        injected_encoder = button - 6;
+}
+
 }  // namespace debug
 }  // namespace control
@@ -56,6 +56,7 @@ namespace control {
 namespace debug {

 uint8_t switches();
+void inject_switch(uint8_t);

 }  // namespace debug
 }  // namespace control
@@ -186,6 +186,8 @@ int main(void) {
        sdcStop(&SDCD1);

        portapack::shutdown();
+    } else {
+        config_mode_clear();
    }

    m4_init(portapack::spi_flash::image_tag_hackrf, portapack::memory::map::m4_code_hackrf, true);
@@ -70,6 +70,7 @@ lcd::ILI9341 display;

 I2C i2c0(&I2CD0);
 SPI ssp1(&SPID2);
+portapack::USBSerial usb_serial;

 si5351::Si5351 clock_generator{
    i2c0, hackrf::one::si5351_i2c_address};
@@ -368,7 +369,7 @@ static void shutdown_base() {
 *
 * XTAL_OSC = powered down
 *
- * PLL0USB = powered down
+ * PLL0USB = XTAL, 480 MHz
 * PLL0AUDIO = GP_CLKIN, Fcco=491.52 MHz, Fout=12.288 MHz
 * PLL1 =
 * 	OG: GP_CLKIN * 10 = 200 MHz
@@ -464,9 +465,25 @@ bool init() {
    /* Remove /2P divider from PLL1 output to achieve full speed */
    cgu::pll1::direct();

+    usb_serial.initialize();
+
    i2c0.start(i2c_config_fast_clock);
    chThdSleepMilliseconds(10);

+    /* Check if portapack is attached by checking if any of the two audio chips is present. */
+    systime_t timeout = 50;
+    uint8_t wm8731_reset_command[] = {0x0f, 0x00};
+    if (i2c0.transmit(0x1a /* wm8731 */, wm8731_reset_command, 2, timeout) == false) {
+        audio_codec_ak4951.reset();
+        uint8_t ak4951_init_command[] = {0x00, 0x00};
+        i2c0.transmit(0x12 /* ak4951 */, ak4951_init_command, 2, timeout);
+        chThdSleepMilliseconds(10);
+        if (i2c0.transmit(0x12 /* ak4951 */, ak4951_init_command, 2, timeout) == false) {
+            shutdown_base();
+            return false;
+        }
+    }
+
    touch::adc::init();
    controls_init();
    chThdSleepMilliseconds(10);
@@ -31,6 +31,7 @@
 #include "si5351.hpp"
 #include "lcd_ili9341.hpp"
 #include "backlight.hpp"
+#include "usb_serial.hpp"

 #include "radio.hpp"
 #include "clock_manager.hpp"
@@ -46,6 +47,7 @@ extern lcd::ILI9341 display;

 extern I2C i2c0;
 extern SPI ssp1;
+extern portapack::USBSerial usb_serial;

 extern si5351::Si5351 clock_generator;
 extern ClockManager clock_manager;
@@ -20,6 +20,8 @@
 * Boston, MA 02110-1301, USA.
 */

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

@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
- * Copyright (C) 2016 Furrtek
- *
- * This file is part of PortaPack.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-
-#include "lcr.hpp"
-#include "string_format.hpp"
-
-namespace lcr {
-
-std::string generate_message(std::string rgsb, std::vector<std::string> litterals, size_t option_ec) {
-    const std::string ec_lut[4] = {"A", "J", "N", "S"};  // Eclairage (Auto, Jour, Nuit)
-    char eom[3] = {3, 0, 0};                             // EOM and space for checksum
-    uint8_t i;
-    std::string lcr_message{127, 127, 127, 127, 127, 127, 127, 5};  // 5/15 ? Modem sync and SOM
-    char checksum = 0;
-
-    // Pad litterals to 7 chars (not required ?)
-    for (auto& litteral : litterals)
-        while (litteral.length() < 7)
-            litteral += ' ';
-
-    // Compose LCR message
-    lcr_message += rgsb;
-    lcr_message += "PA ";
-
-    i = 1;
-    for (auto& litteral : litterals) {
-        lcr_message += "AM=";
-        lcr_message += to_string_dec_uint(i, 1);
-        lcr_message += " AF=\"";
-        lcr_message += litteral;
-        lcr_message += "\" CL=0 ";
-        i++;
-    }
-
-    lcr_message += "EC=";
-    lcr_message += ec_lut[option_ec];
-    lcr_message += " SAB=0";
-
-    // Checksum
-    i = 7;  // Skip modem sync
-    while (lcr_message[i])
-        checksum ^= lcr_message[i++];
-    checksum ^= eom[0];  // EOM char
-    checksum &= 0x7F;    // Trim
-    eom[1] = checksum;
-
-    lcr_message += eom;
-
-    return lcr_message;
-}
-
-} /* namespace lcr */
@@ -61,7 +61,7 @@ static constexpr SPIConfig ssp_config_max283x = {
    .ssport = gpio_max283x_select.port(),
    .sspad = gpio_max283x_select.pad(),
    .cr0 =
-        CR0_CLOCKRATE(ssp_scr(ssp1_pclk_f, ssp1_cpsr, max283x_spi_f)) | CR0_FRFSPI | CR0_DSS16BIT,
+        CR0_CLOCKRATE(ssp_scr(ssp1_pclk_f, ssp1_cpsr, max283x_spi_f) + 3) | CR0_FRFSPI | CR0_DSS16BIT,
    .cpsr = ssp1_cpsr,
 };

@@ -287,6 +287,10 @@ uint32_t register_read(const size_t register_number) {
    return radio::first_if.read(register_number);
 }

+void register_write(const size_t register_number, uint32_t value) {
+    radio::first_if.write(register_number, value);
+}
+
 } /* namespace first_if */

 namespace second_if {
@@ -295,6 +299,10 @@ uint32_t register_read(const size_t register_number) {
    return radio::second_if->read(register_number);
 }

+void register_write(const size_t register_number, uint32_t value) {
+    radio::second_if->write(register_number, value);
+}
+
 int8_t temp_sense() {
    return radio::second_if->temp_sense();
 }
@@ -65,12 +65,14 @@ namespace debug {
 namespace first_if {

 uint32_t register_read(const size_t register_number);
+void register_write(const size_t register_number, uint32_t value);

 } /* namespace first_if */

 namespace second_if {

 uint32_t register_read(const size_t register_number);
+void register_write(const size_t register_number, uint32_t value);

 // TODO: This belongs somewhere else.
 int8_t temp_sense();
@@ -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>;
@@ -253,7 +253,7 @@ std::string to_string_hex(uint64_t value, int32_t length) {

 std::string to_string_hex_array(uint8_t* array, int32_t length) {
    std::string str_return;
-    str_return.reserve(length);
+    str_return.reserve(length * 2);

    for (uint8_t i = 0; i < length; i++)
        str_return += to_string_hex(array[i], 2);
@@ -337,6 +337,46 @@ std::string to_string_formatted_mac_address(const char* macAddress) {
    return formattedAddress;
 }

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

 /* Scales 'n' to be a value less than 1000. 'base_unit' is the index of the unit from
 * 'unit_prefix' that 'n' is in initially. 3 is the index of the '1s' unit. */
@@ -38,7 +38,7 @@
 #include "ui_aprs_tx.hpp"
 #include "ui_bht_tx.hpp"
 #include "ui_btle_rx.hpp"
-#include "ui_coasterp.hpp"
+// #include "ui_coasterp.hpp" //moved to ext
 #include "ui_debug.hpp"
 #include "ui_encoders.hpp"
 #include "ui_fileman.hpp"
@@ -47,14 +47,14 @@
 #include "ui_freqman.hpp"
 #include "ui_fsk_rx.hpp"
 #include "ui_iq_trim.hpp"
-#include "ui_jammer.hpp"
-// #include "ui_keyfob.hpp"
-#include "ui_lcr.hpp"
+// #include "ui_jammer.hpp" //moved to ext
+//  #include "ui_keyfob.hpp"
+//  #include "ui_lcr.hpp"
 #include "ui_level.hpp"
 #include "ui_looking_glass_app.hpp"
 #include "ui_mictx.hpp"
 #include "ui_morse.hpp"
-#include "ui_nrf_rx.hpp"
+// #include "ui_nrf_rx.hpp" //moved to ext
 // #include "ui_numbers.hpp"
 // #include "ui_nuoptix.hpp"
 // #include "ui_playdead.hpp"
@@ -79,19 +79,22 @@
 #include "ui_tone_search.hpp"
 #include "ui_touchtunes.hpp"
 #include "ui_view_wav.hpp"
+#include "ui_weatherstation.hpp"
+#include "ui_subghzd.hpp"
 #include "ui_whipcalc.hpp"
 #include "ui_external_items_menu_loader.hpp"

 // #include "acars_app.hpp"
 #include "ais_app.hpp"
 #include "analog_audio_app.hpp"
-#include "analog_tv_app.hpp"
+// #include "analog_tv_app.hpp" //moved to ext
+#include "ble_comm_app.hpp"
 #include "ble_rx_app.hpp"
 #include "ble_tx_app.hpp"
 #include "capture_app.hpp"
 #include "ert_app.hpp"
 #include "gps_sim_app.hpp"
-#include "lge_app.hpp"
+// #include "lge_app.hpp" //moved to ext
 #include "pocsag_app.hpp"
 #include "replay_app.hpp"
 #include "soundboard_app.hpp"
@@ -170,6 +173,9 @@ SystemStatusView::SystemStatusView(
        pmem::load_persistent_settings_from_file();
    }

+    // force apply of selected sdcard speed override at UI startup
+    pmem::set_config_sdcard_high_speed_io(pmem::config_sdcard_high_speed_io(), false);
+
    button_back.id = -1;  // Special ID used by FocusManager
    title.set_style(&Styles::bg_dark_grey);

@@ -547,19 +553,22 @@ ReceiversMenuView::ReceiversMenuView(NavigationView& nav) {
        // {"ACARS", Color::yellow(), &bitmap_icon_adsb, [&nav](){ nav.push<ACARSAppView>(); }},
        {"ADS-B", Color::green(), &bitmap_icon_adsb, [&nav]() { nav.push<ADSBRxView>(); }},
        {"AIS Boats", Color::green(), &bitmap_icon_ais, [&nav]() { nav.push<AISAppView>(); }},
-        {"Analog TV", Color::yellow(), &bitmap_icon_sstv, [&nav]() { nav.push<AnalogTvView>(); }},
+        //{"Analog TV", Color::yellow(), &bitmap_icon_sstv, [&nav]() { nav.push<AnalogTvView>(); }}, //moved to ext
        {"APRS", Color::green(), &bitmap_icon_aprs, [&nav]() { nav.push<APRSRXView>(); }},
        {"Audio", Color::green(), &bitmap_icon_speaker, [&nav]() { nav.push<AnalogAudioView>(); }},
        //{"BTLE", Color::yellow(), &bitmap_icon_btle, [&nav]() { nav.push<BTLERxView>(); }},
+        //{"BLE Comm", ui::Color::orange(), &bitmap_icon_btle, [&nav]() { nav.push<BLECommView>(); }},
        {"BLE Rx", Color::green(), &bitmap_icon_btle, [&nav]() { nav.push<BLERxView>(); }},
        {"ERT Meter", Color::green(), &bitmap_icon_ert, [&nav]() { nav.push<ERTAppView>(); }},
        {"Level", Color::green(), &bitmap_icon_options_radio, [&nav]() { nav.push<LevelView>(); }},
-        {"NRF", Color::yellow(), &bitmap_icon_nrf, [&nav]() { nav.push<NRFRxView>(); }},
+        //{"NRF", Color::yellow(), &bitmap_icon_nrf, [&nav]() { nav.push<NRFRxView>(); }}, //moved to ext
        {"POCSAG", Color::green(), &bitmap_icon_pocsag, [&nav]() { nav.push<POCSAGAppView>(); }},
        {"Radiosnde", Color::green(), &bitmap_icon_sonde, [&nav]() { nav.push<SondeView>(); }},
        {"Recon", Color::green(), &bitmap_icon_scanner, [&nav]() { nav.push<ReconView>(); }},
        {"Search", Color::yellow(), &bitmap_icon_search, [&nav]() { nav.push<SearchView>(); }},
        {"TPMS Cars", Color::green(), &bitmap_icon_tpms, [&nav]() { nav.push<TPMSAppView>(); }},
+        {"Weather", Color::green(), &bitmap_icon_thermometer, [&nav]() { nav.push<WeatherView>(); }},
+        {"SubGhzD", Color::yellow(), &bitmap_icon_remote, [&nav]() { nav.push<SubGhzDView>(); }},
        // {"FSK RX", Color::yellow(), &bitmap_icon_remote, [&nav]() { nav.push<FskxRxMainView>(); }},
        // {"DMR", Color::dark_grey(), &bitmap_icon_dmr, [&nav](){ nav.push<NotImplementedView>(); }},
        // {"SIGFOX", Color::dark_grey(), &bitmap_icon_fox, [&nav](){ nav.push<NotImplementedView>(); }},
@@ -584,11 +593,11 @@ TransmittersMenuView::TransmittersMenuView(NavigationView& nav) {
        {"APRS TX", ui::Color::green(), &bitmap_icon_aprs, [&nav]() { nav.push<APRSTXView>(); }},
        {"BHT Xy/EP", ui::Color::green(), &bitmap_icon_bht, [&nav]() { nav.push<BHTView>(); }},
        {"BLE Tx", ui::Color::green(), &bitmap_icon_btle, [&nav]() { nav.push<BLETxView>(); }},
-        {"BurgerPgr", ui::Color::yellow(), &bitmap_icon_burger, [&nav]() { nav.push<CoasterPagerView>(); }},
+        // {"BurgerPgr", ui::Color::yellow(), &bitmap_icon_burger, [&nav]() { nav.push<CoasterPagerView>(); }}, //moved to ext
        {"GPS Sim", ui::Color::green(), &bitmap_icon_gps_sim, [&nav]() { nav.push<GpsSimAppView>(); }},
-        {"Jammer", ui::Color::green(), &bitmap_icon_jammer, [&nav]() { nav.push<JammerView>(); }},
+        //{"Jammer", ui::Color::green(), &bitmap_icon_jammer, [&nav]() { nav.push<JammerView>(); }}, //moved to ext
        // { "Key fob", ui::Color::orange(), &bitmap_icon_keyfob, [&nav](){ nav.push<KeyfobView>(); }},
-        {"LGE", ui::Color::yellow(), &bitmap_icon_lge, [&nav]() { nav.push<LGEView>(); }},
+        // {"LGE", ui::Color::yellow(), &bitmap_icon_lge, [&nav]() { nav.push<LGEView>(); }}, //moved to ext
        {"Morse", ui::Color::green(), &bitmap_icon_morse, [&nav]() { nav.push<MorseView>(); }},
        // { "Nuoptix DTMF", ui::Color::green(), &bitmap_icon_nuoptix, [&nav](){ nav.push<NuoptixView>(); }},
        {"OOK", ui::Color::yellow(), &bitmap_icon_remote, [&nav]() { nav.push<EncodersView>(); }},
@@ -597,7 +606,7 @@ TransmittersMenuView::TransmittersMenuView(NavigationView& nav) {
        {"Soundbrd", ui::Color::green(), &bitmap_icon_soundboard, [&nav]() { nav.push<SoundBoardView>(); }},
        {"S.Painter", ui::Color::orange(), &bitmap_icon_paint, [&nav]() { nav.push<SpectrumPainterView>(); }},
        {"SSTV", ui::Color::green(), &bitmap_icon_sstv, [&nav]() { nav.push<SSTVTXView>(); }},
-        {"TEDI/LCR", ui::Color::yellow(), &bitmap_icon_lcr, [&nav]() { nav.push<LCRView>(); }},
+        // {"TEDI/LCR", ui::Color::yellow(), &bitmap_icon_lcr, [&nav]() { nav.push<LCRView>(); }}, //moved to ext
        {"TouchTune", ui::Color::green(), &bitmap_icon_touchtunes, [&nav]() { nav.push<TouchTunesView>(); }},
    });

@@ -0,0 +1,97 @@
+extern "C" {
+#include "usb_serial_io.h"
+#include "usb_serial_cdc.h"
+}
+
+#include "usb_serial_shell.hpp"
+#include "usb_serial.hpp"
+#include "portapack.hpp"
+
+#include <libopencm3/cm3/common.h>
+#include <libopencm3/lpc43xx/usb.h>
+
+namespace portapack {
+
+void USBSerial::initialize() {
+    enable_xtal();
+    disable_pll0();
+
+    setup_pll0();
+    enable_pll0();
+
+    setup_usb_clock();
+    setup_usb_serial_controller();
+
+    init_serial_usb_driver(&SUSBD1);
+    shellInit();
+}
+
+void USBSerial::dispatch() {
+    if (!connected)
+        return;
+
+    if (shell_created == false) {
+        shell_created = true;
+        create_shell();
+    }
+
+    bulk_out_receive();
+}
+
+void USBSerial::on_channel_opened() {
+    connected = true;
+}
+
+void USBSerial::on_channel_closed() {
+    connected = false;
+}
+
+void USBSerial::enable_xtal() {
+    LPC_CGU->XTAL_OSC_CTRL.ENABLE = 0;
+    LPC_CGU->XTAL_OSC_CTRL.HF = 0;
+}
+
+void USBSerial::disable_pll0() {
+    LPC_CGU->PLL0USB_CTRL.PD = 1;
+    LPC_CGU->PLL0USB_CTRL.AUTOBLOCK = 1;
+
+    LPC_CGU->PLL0USB_CTRL.BYPASS = 0;
+    LPC_CGU->PLL0USB_CTRL.DIRECTI = 0;
+    LPC_CGU->PLL0USB_CTRL.DIRECTO = 0;
+    LPC_CGU->PLL0USB_CTRL.CLKEN = 0;
+    LPC_CGU->PLL0USB_CTRL.FRM = 0;
+    LPC_CGU->PLL0USB_CTRL.CLK_SEL = 0x06;  // 12MHz internal XTAL
+}
+
+void USBSerial::setup_pll0() {
+    /* use XTAL_OSC as clock source for PLL0USB */
+
+    while (LPC_CGU->PLL0USB_STAT.LOCK) {
+    }
+
+    // /* configure PLL0USB to produce 480 MHz clock from 12 MHz XTAL_OSC */
+    // /* Values from User Manual v1.4 Table 94, for 12MHz oscillator. */
+    LPC_CGU->PLL0USB_MDIV = 0x06167FFA;
+    LPC_CGU->PLL0USB_NP_DIV = 0x00302062;
+    LPC_CGU->PLL0USB_CTRL.PD = 1;
+    LPC_CGU->PLL0USB_CTRL.DIRECTI = 1;
+    LPC_CGU->PLL0USB_CTRL.DIRECTO = 1;
+    LPC_CGU->PLL0USB_CTRL.CLKEN = 1;
+}
+
+void USBSerial::enable_pll0() {
+    // /* power on PLL0USB and wait until stable */
+    LPC_CGU->PLL0USB_CTRL.PD = 0;
+
+    while (!LPC_CGU->PLL0USB_STAT.LOCK) {
+    }
+}
+
+void USBSerial::setup_usb_clock() {
+    /* use PLL0USB as clock source for USB0 */
+    LPC_CGU->BASE_USB0_CLK.AUTOBLOCK = 1;
+    LPC_CGU->BASE_USB0_CLK.CLK_SEL = 0x07;
+    LPC_CGU->BASE_USB0_CLK.PD = 0;
+}
+
+}  // namespace portapack
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "ch.h"
+#include "hal.h"
+
+namespace portapack {
+
+class USBSerial {
+   public:
+    void initialize();
+    void dispatch();
+    void on_channel_opened();
+    void on_channel_closed();
+
+   private:
+    void enable_xtal();
+    void disable_pll0();
+    void setup_pll0();
+    void enable_pll0();
+
+    void setup_usb_clock();
+
+    bool connected{false};
+    bool shell_created{false};
+};
+
+}  // namespace portapack
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usb_serial_cdc.h"
+#include "usb_serial_endpoints.h"
+#include "usb_serial_event.hpp"
+
+extern void usb0_isr(void);
+CH_IRQ_HANDLER(USB0_IRQHandler) {
+    CH_IRQ_PROLOGUE();
+    usb0_isr();
+    CH_IRQ_EPILOGUE();
+}
+
+uint32_t __ldrex(volatile uint32_t* addr) {
+    __disable_irq();
+    return *addr;
+}
+
+uint32_t __strex(uint32_t val, volatile uint32_t* addr) {
+    (void)val;
+    (void)addr;
+
+    *addr = val;
+    __enable_irq();
+    return 0;
+}
+
+void nvic_enable_irq(uint8_t irqn) {
+    NVIC_ISER(irqn / 32) = (1 << (irqn % 32));
+}
+
+void usb_configuration_changed(usb_device_t* const device) {
+    (void)device;
+
+    usb_endpoint_init(&usb_endpoint_int_in);
+    usb_endpoint_init(&usb_endpoint_bulk_in);
+    usb_endpoint_init(&usb_endpoint_bulk_out);
+}
+
+void setup_usb_serial_controller(void) {
+    usb_set_configuration_changed_cb(usb_configuration_changed);
+    usb_peripheral_reset();
+
+    usb_device_init(0, &usb_device);
+
+    usb_queue_init(&usb_endpoint_control_out_queue);
+    usb_queue_init(&usb_endpoint_control_in_queue);
+    usb_queue_init(&usb_endpoint_int_in_queue);
+    usb_queue_init(&usb_endpoint_bulk_out_queue);
+    usb_queue_init(&usb_endpoint_bulk_in_queue);
+
+    usb_endpoint_init(&usb_endpoint_control_out);
+    usb_endpoint_init(&usb_endpoint_control_in);
+
+    usb_run(&usb_device);
+}
+
+const usb_request_handlers_t usb_request_handlers = {
+    .standard = usb_standard_request,
+    .class = usb_class_request,
+    .vendor = 0,
+    .reserved = 0};
+
+usb_request_status_t usb_class_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) {
+    usb_request_status_t status = USB_REQUEST_STATUS_STALL;
+
+    volatile uint8_t request = endpoint->setup.request;
+
+    if (request == 0x21)  // GET LINE CODING REQUEST
+        return usb_get_line_coding_request(endpoint, stage);
+
+    if (request == 0x22)  // SET CONTROL LINE STATE REQUEST
+        return usb_set_control_line_state_request(endpoint, stage);
+
+    if (request == 0x20)  // SET LINE CODING REQUEST
+        return usb_set_line_coding_request(endpoint, stage);
+
+    return USB_REQUEST_STATUS_OK;
+
+    return status;
+}
+
+usb_request_status_t usb_get_line_coding_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        usb_transfer_schedule_block(
+            endpoint->in,
+            &endpoint->buffer,
+            0,
+            NULL,
+            NULL);
+    } else if (stage == USB_TRANSFER_STAGE_DATA) {
+        usb_transfer_schedule_ack(endpoint->out);
+    }
+
+    return USB_REQUEST_STATUS_OK;
+}
+usb_request_status_t usb_set_control_line_state_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        // if (endpoint->setup.value == 3) {
+        on_channel_opened();
+        //} else {
+        //    on_channel_closed();
+        //}
+
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_set_line_coding_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        usb_transfer_schedule_block(
+            endpoint->out,
+            &endpoint->buffer,
+            32,
+            NULL,
+            NULL);
+    } else if (stage == USB_TRANSFER_STAGE_DATA) {
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+
+    return USB_REQUEST_STATUS_OK;
+}
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "ch.h"
+#include "hal.h"
+
+#ifndef __cplusplus
+#pragma GCC diagnostic push
+// external code, so ignore warnings
+#pragma GCC diagnostic ignored "-Wstrict-prototypes"
+
+#include <common/usb.h>
+#include <common/usb_request.h>
+#include <common/usb_standard_request.h>
+#include <hackrf_usb/usb_device.h>
+#include <hackrf_usb/usb_endpoint.h>
+
+#pragma GCC diagnostic pop
+
+usb_request_status_t usb_class_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage);
+usb_request_status_t usb_get_line_coding_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage);
+usb_request_status_t usb_set_control_line_state_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage);
+usb_request_status_t usb_set_line_coding_request(usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage);
+#endif
+
+void setup_usb_serial_controller(void);
@@ -0,0 +1,339 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usb_serial_descriptor.h"
+
+#include "usb_serial_endpoints.h"
+
+#define USB_VENDOR_ID (0x1D50)
+#define USB_PRODUCT_ID (0x6018)
+#define USB_API_VERSION (0x0100)
+
+#define USB_WORD(x) (x & 0xFF), ((x >> 8) & 0xFF)
+#define USB_MAX_PACKET0 (64)
+#define USB_MAX_PACKET_BULK_FS (64)
+#define USB_MAX_PACKET_BULK_HS (64)
+#define USB_STRING_LANGID (0x0409)
+
+uint8_t usb_descriptor_device[] = {
+    18,                          // bLength
+    USB_DESCRIPTOR_TYPE_DEVICE,  // bDescriptorType
+    USB_WORD(0x0200),            // bcdUSB
+    0xef,                        // bDeviceClass
+    0x02,                        // bDeviceSubClass
+    0x01,                        // bDeviceProtocol
+    USB_MAX_PACKET0,             // bMaxPacketSize0
+    USB_WORD(USB_VENDOR_ID),     // idVendor
+    USB_WORD(USB_PRODUCT_ID),    // idProduct
+    USB_WORD(USB_API_VERSION),   // bcdDevice
+    0x01,                        // iManufacturer
+    0x02,                        // iProduct
+    0x03,                        // iSerialNumber
+    0x01                         // bNumConfigurations
+};
+
+uint8_t usb_descriptor_device_qualifier[] = {
+    10,                                    // bLength
+    USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER,  // bDescriptorType
+    USB_WORD(0x0200),                      // bcdUSB
+    0xef,                                  // bDeviceClass
+    0x02,                                  // bDeviceSubClass
+    0x01,                                  // bDeviceProtocol
+    USB_MAX_PACKET0,                       // bMaxPacketSize0
+    0x01,                                  // bNumOtherSpeedConfigurations
+    0x00                                   // bReserved
+};
+
+uint8_t usb_descriptor_configuration_full_speed[] = {
+    9,                                                   // bLength
+    USB_DESCRIPTOR_TYPE_CONFIGURATION,                   // bDescriptorType
+    USB_WORD((16 + 8 + 9 + 5 + 5 + 4 + 5 + 9 + 7 + 7)),  // wTotalLength
+    0x02,                                                // bNumInterfaces
+    0x01,                                                // bConfigurationValue
+    0x00,                                                // iConfiguration
+    0x80,                                                // bmAttributes: USB-powered
+    250,                                                 // bMaxPower: 500mA
+
+    8,    // bLength
+    0xb,  // bDescriptorType
+    0,
+    2,
+    0x02,
+    0x02,
+    0x00,
+    4,
+
+    9,                              // bLength
+    USB_DESCRIPTOR_TYPE_INTERFACE,  // bDescriptorType
+    0x00,                           // bInterfaceNumber
+    0x00,                           // bAlternateSetting
+    0x01,                           // bNumEndpoints
+    0x02,                           // bInterfaceClass: vendor-specific
+    0x02,                           // bInterfaceSubClass
+    0x00,                           // bInterfaceProtocol: vendor-specific
+    0x04,                           // iInterface
+
+    5,
+    0x24,  // ACM
+    0x00,
+    USB_WORD(0x0110),
+
+    5,
+    0x24,
+    0x01,
+    0x00,
+    0x01,
+
+    4,
+    0x24,
+    0x02,
+    0x02,
+
+    5,
+    0x24,
+    0x06,
+    0x00,
+    0x01,
+
+    7,                             // bLength
+    USB_DESCRIPTOR_TYPE_ENDPOINT,  // bDescriptorType
+    USB_INT_IN_EP_ADDR,            // bEndpointAddress
+    0x03,                          // bmAttributes: BULK
+    USB_WORD(16),                  // wMaxPacketSize
+    0xFF,                          // bInterval: no NAK
+
+    9,                              // bLength
+    USB_DESCRIPTOR_TYPE_INTERFACE,  // bDescriptorType
+    0x01,                           // bInterfaceNumber
+    0x00,                           // bAlternateSetting
+    0x02,                           // bNumEndpoints
+    0x0a,                           // bInterfaceClass: vendor-specific
+    0x00,                           // bInterfaceSubClass
+    0x00,                           // bInterfaceProtocol: vendor-specific
+    0x00,                           // iInterface
+
+    7,                                 // bLength
+    USB_DESCRIPTOR_TYPE_ENDPOINT,      // bDescriptorType
+    USB_BULK_OUT_EP_ADDR,              // bEndpointAddress
+    0x02,                              // bmAttributes: BULK
+    USB_WORD(USB_MAX_PACKET_BULK_FS),  // wMaxPacketSize
+    0x01,                              // bInterval: no NAK
+
+    7,                                 // bLength
+    USB_DESCRIPTOR_TYPE_ENDPOINT,      // bDescriptorType
+    USB_BULK_IN_EP_ADDR,               // bEndpointAddress
+    0x02,                              // bmAttributes: BULK
+    USB_WORD(USB_MAX_PACKET_BULK_FS),  // wMaxPacketSize
+    0x01,                              // bInterval: NAK
+
+    0,  // TERMINATOR
+};
+
+uint8_t usb_descriptor_configuration_high_speed[] = {
+    9,                                                   // bLength
+    USB_DESCRIPTOR_TYPE_CONFIGURATION,                   // bDescriptorType
+    USB_WORD((16 + 8 + 9 + 5 + 5 + 4 + 5 + 9 + 7 + 7)),  // wTotalLength
+    0x02,                                                // bNumInterfaces
+    0x01,                                                // bConfigurationValue
+    0x00,                                                // iConfiguration
+    0x80,                                                // bmAttributes: USB-powered
+    250,                                                 // bMaxPower: 500mA
+
+    8,    // bLength
+    0xb,  // bDescriptorType
+    0,
+    2,
+    0x02,
+    0x02,
+    0x00,
+    4,
+
+    9,                              // bLength
+    USB_DESCRIPTOR_TYPE_INTERFACE,  // bDescriptorType
+    0x00,                           // bInterfaceNumber
+    0x00,                           // bAlternateSetting
+    0x01,                           // bNumEndpoints
+    0x02,                           // bInterfaceClass: vendor-specific
+    0x02,                           // bInterfaceSubClass
+    0x00,                           // bInterfaceProtocol: vendor-specific
+    0x04,                           // iInterface
+
+    5,
+    0x24,
+    0x00,
+    USB_WORD(0x0110),
+
+    5,
+    0x24,
+    0x01,
+    0x00,
+    0x01,
+
+    4,
+    0x24,
+    0x02,
+    0x02,
+
+    5,
+    0x24,
+    0x06,
+    0x00,
+    0x01,
+
+    7,                             // bLength
+    USB_DESCRIPTOR_TYPE_ENDPOINT,  // bDescriptorType
+    USB_INT_IN_EP_ADDR,            // bEndpointAddress
+    0x03,                          // bmAttributes: BULK
+    USB_WORD(16),                  // wMaxPacketSize
+    0xFF,                          // bInterval: no NAK
+
+    9,                              // bLength
+    USB_DESCRIPTOR_TYPE_INTERFACE,  // bDescriptorType
+    0x01,                           // bInterfaceNumber
+    0x00,                           // bAlternateSetting
+    0x02,                           // bNumEndpoints
+    0x0a,                           // bInterfaceClass: vendor-specific
+    0x00,                           // bInterfaceSubClass
+    0x00,                           // bInterfaceProtocol: vendor-specific
+    0x00,                           // iInterface
+
+    7,                                 // bLength
+    USB_DESCRIPTOR_TYPE_ENDPOINT,      // bDescriptorType
+    USB_BULK_OUT_EP_ADDR,              // bEndpointAddress
+    0x02,                              // bmAttributes: BULK
+    USB_WORD(USB_MAX_PACKET_BULK_HS),  // wMaxPacketSize
+    0x01,                              // bInterval: no NAK
+
+    7,                                 // bLength
+    USB_DESCRIPTOR_TYPE_ENDPOINT,      // bDescriptorType
+    USB_BULK_IN_EP_ADDR,               // bEndpointAddress
+    0x02,                              // bmAttributes: BULK
+    USB_WORD(USB_MAX_PACKET_BULK_HS),  // wMaxPacketSize
+    0x01,                              // bInterval: NAK
+
+    0,  // TERMINATOR
+};
+
+uint8_t usb_descriptor_string_languages[] = {
+    0x04,                         // bLength
+    USB_DESCRIPTOR_TYPE_STRING,   // bDescriptorType
+    USB_WORD(USB_STRING_LANGID),  // wLANGID
+};
+
+// clang-format off
+uint8_t usb_descriptor_string_manufacturer[] = {
+ 	40,                         // bLength
+ 	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+ 	'G', 0x00,
+ 	'r', 0x00,
+ 	'e', 0x00,
+ 	'a', 0x00,
+ 	't', 0x00,
+ 	' ', 0x00,
+ 	'S', 0x00,
+ 	'c', 0x00,
+ 	'o', 0x00,
+ 	't', 0x00,
+ 	't', 0x00,
+ 	' ', 0x00,
+ 	'G', 0x00,
+ 	'a', 0x00,
+ 	'd', 0x00,
+ 	'g', 0x00,
+ 	'e', 0x00,
+ 	't', 0x00,
+ 	's', 0x00,
+ };
+
+ uint8_t usb_descriptor_string_product[] = {
+ 	43,                         // bLength
+ 	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+ 	'P', 0x00,
+ 	'o', 0x00,
+ 	'r', 0x00,
+ 	't', 0x00,
+ 	'a', 0x00,
+ 	'P', 0x00,
+ 	'a', 0x00,
+ 	'c', 0x00,
+ 	'k', 0x00,
+ 	' ', 0x00,
+ 	'M', 0x00,
+ 	'a', 0x00,
+ 	'y', 0x00,
+ 	'h', 0x00,
+ 	'e', 0x00,
+ 	'm', 0x00,
+ };
+ 
+ uint8_t usb_descriptor_string_config_description[] = {
+ 	24,                         // bLength
+ 	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+ 	'T', 0x00,
+ 	'r', 0x00,
+ 	'a', 0x00,
+ 	'n', 0x00,
+ 	's', 0x00,
+ 	'c', 0x00,
+ 	'e', 0x00,
+ 	'i', 0x00,
+ 	'v', 0x00,
+ 	'e', 0x00,
+ 	'r', 0x00,
+ };
+
+ uint8_t usb_descriptor_string_serial_number[USB_DESCRIPTOR_STRING_SERIAL_BUF_LEN];
+
+ uint8_t* usb_descriptor_strings[] = {
+ 	usb_descriptor_string_languages,
+ 	usb_descriptor_string_manufacturer,
+ 	usb_descriptor_string_product,
+ 	usb_descriptor_string_config_description,
+ 	usb_descriptor_string_serial_number,
+ 	0, // TERMINATOR
+ };
+
+ uint8_t wcid_string_descriptor[] = {
+ 	18,                          // bLength
+ 	USB_DESCRIPTOR_TYPE_STRING,  // bDescriptorType
+ 	'M', 0x00,
+ 	'S', 0x00,
+ 	'F', 0x00,
+ 	'T', 0x00,
+ 	'1', 0x00,
+ 	'0', 0x00,
+ 	'0', 0x00,
+ 	USB_WCID_VENDOR_REQ, // vendor request code for further descriptor
+ 	0x00
+ };
+ 
+ uint8_t wcid_feature_descriptor[] = {
+ 	0x28, 0x00, 0x00, 0x00,                  // bLength
+ 	USB_WORD(0x0100),                        // WCID version
+ 	USB_WORD(0x0004),                        // WICD descriptor index
+ 	0x01,                                    // bNumSections
+ 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,      // Reserved
+ 	0x00,                                    // bInterfaceNumber
+ 	0x01,                                    // Reserved
+ 	'W', 'I', 'N', 'U', 'S', 'B', 0x00,0x00, // Compatible ID, padded with zeros
+ 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Sub-compatible ID
+ 	0x00,0x00,0x00,0x00,0x00,0x00            // Reserved
+ };
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "ch.h"
+#include "hal.h"
+
+extern uint8_t usb_descriptor_device[];
+extern uint8_t usb_descriptor_device_qualifier[];
+extern uint8_t usb_descriptor_configuration_full_speed[];
+extern uint8_t usb_descriptor_configuration_high_speed[];
+extern uint8_t usb_descriptor_string_languages[];
+extern uint8_t usb_descriptor_string_manufacturer[];
+extern uint8_t usb_descriptor_string_product[];
+
+#define USB_DESCRIPTOR_STRING_SERIAL_LEN 32
+#define USB_DESCRIPTOR_STRING_SERIAL_BUF_LEN \
+    (USB_DESCRIPTOR_STRING_SERIAL_LEN * 2 + 2) /* UTF-16LE */
+extern uint8_t usb_descriptor_string_serial_number[];
+
+extern uint8_t* usb_descriptor_strings[];
+
+#define USB_WCID_VENDOR_REQ 0x19
+extern uint8_t wcid_string_descriptor[];
+extern uint8_t wcid_feature_descriptor[];
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usb_serial_endpoints.h"
+
+#pragma GCC diagnostic push
+// external code, so ignore warnings
+#pragma GCC diagnostic ignored "-Wstrict-prototypes"
+
+#include <common/usb.h>
+#include <common/usb_request.h>
+#include <common/usb_standard_request.h>
+#include <hackrf_usb/usb_device.h>
+#include <hackrf_usb/usb_endpoint.h>
+
+#pragma GCC diagnostic pop
+
+usb_endpoint_t usb_endpoint_control_out = {
+    .address = USB_CONTROL_OUT_EP_ADDR,
+    .device = &usb_device,
+    .in = &usb_endpoint_control_in,
+    .out = &usb_endpoint_control_out,
+    .setup_complete = usb_setup_complete,
+    .transfer_complete = usb_control_out_complete,
+};
+USB_DEFINE_QUEUE(usb_endpoint_control_out, 4);
+
+usb_endpoint_t usb_endpoint_control_in = {
+    .address = USB_CONTROL_IN_EP_ADDR,
+    .device = &usb_device,
+    .in = &usb_endpoint_control_in,
+    .out = &usb_endpoint_control_out,
+    .setup_complete = 0,
+    .transfer_complete = usb_control_in_complete,
+};
+static USB_DEFINE_QUEUE(usb_endpoint_control_in, 4);
+
+usb_endpoint_t usb_endpoint_int_in = {
+    .address = USB_INT_IN_EP_ADDR,
+    .device = &usb_device,
+    .in = &usb_endpoint_int_in,
+    .out = 0,
+    .setup_complete = 0,
+    .transfer_complete = usb_queue_transfer_complete};
+static USB_DEFINE_QUEUE(usb_endpoint_int_in, 1);
+
+usb_endpoint_t usb_endpoint_bulk_in = {
+    .address = USB_BULK_IN_EP_ADDR,
+    .device = &usb_device,
+    .in = &usb_endpoint_bulk_in,
+    .out = 0,
+    .setup_complete = 0,
+    .transfer_complete = usb_queue_transfer_complete};
+static USB_DEFINE_QUEUE(usb_endpoint_bulk_in, 1);
+
+usb_endpoint_t usb_endpoint_bulk_out = {
+    .address = USB_BULK_OUT_EP_ADDR,
+    .device = &usb_device,
+    .in = 0,
+    .out = &usb_endpoint_bulk_out,
+    .setup_complete = 0,
+    .transfer_complete = usb_queue_transfer_complete};
+static USB_DEFINE_QUEUE(usb_endpoint_bulk_out, 1);
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "ch.h"
+#include "hal.h"
+
+#include <usb_type.h>
+#include <usb_queue.h>
+
+#define USB_CONTROL_IN_EP_ADDR (0x80)
+#define USB_CONTROL_OUT_EP_ADDR (0x00)
+
+#define USB_INT_IN_EP_ADDR (0x82)
+
+#define USB_BULK_OUT_EP_ADDR (0x01)
+#define USB_BULK_IN_EP_ADDR (0x81)
+
+extern usb_endpoint_t usb_endpoint_control_out;
+extern USB_DECLARE_QUEUE(usb_endpoint_control_out);
+
+extern usb_endpoint_t usb_endpoint_control_in;
+extern USB_DECLARE_QUEUE(usb_endpoint_control_in);
+
+extern usb_endpoint_t usb_endpoint_int_in;
+extern USB_DECLARE_QUEUE(usb_endpoint_int_in);
+
+extern usb_endpoint_t usb_endpoint_bulk_in;
+extern USB_DECLARE_QUEUE(usb_endpoint_bulk_in);
+
+extern usb_endpoint_t usb_endpoint_bulk_out;
+extern USB_DECLARE_QUEUE(usb_endpoint_bulk_out);
@@ -1,6 +1,5 @@
 /*
- * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
- * Copyright (C) 2016 Furrtek
+ * Copyright (C) 2023 Bernd Herzog
 *
 * This file is part of PortaPack.
 *
@@ -20,18 +19,16 @@
 * Boston, MA 02110-1301, USA.
 */

-#include "ui.hpp"
-#include <cstring>
-#include <string>
-#include <vector>
+#include "usb_serial_event.hpp"

-#ifndef __LCR_H__
-#define __LCR_H__
+#include "portapack.hpp"

-namespace lcr {
+extern "C" {
+void on_channel_opened() {
+    portapack::usb_serial.on_channel_opened();
+}

-std::string generate_message(std::string rgsb, std::vector<std::string> litterals, size_t option_ec);
-
-} /* namespace lcr */
-
-#endif /*__LCR_H__*/
+void on_channel_closed() {
+    portapack::usb_serial.on_channel_closed();
+}
+}
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "ch.h"
+#include "hal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void on_channel_opened(void);
+void on_channel_closed(void);
+#ifdef __cplusplus
+}
+#endif
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usb_serial_io.h"
+
+#include "usb_serial_endpoints.h"
+
+#pragma GCC diagnostic push
+// external code, so ignore warnings
+#pragma GCC diagnostic ignored "-Wstrict-prototypes"
+
+#include <common/usb.h>
+#include <common/usb_request.h>
+#include <common/usb_standard_request.h>
+#include <hackrf_usb/usb_device.h>
+#include <hackrf_usb/usb_endpoint.h>
+
+#pragma GCC diagnostic pop
+
+#include <usb_request.h>
+#include <string.h>
+
+SerialUSBDriver SUSBD1;
+
+void bulk_out_receive(void) {
+    int ret;
+    do {
+        ret = usb_transfer_schedule(
+            &usb_endpoint_bulk_out,
+            &usb_endpoint_bulk_out.buffer[0],
+            32,
+            serial_bulk_transfer_complete,
+            NULL);
+
+    } while (ret != -1);
+}
+
+void serial_bulk_transfer_complete(void* user_data, unsigned int bytes_transferred) {
+    (void)user_data;
+
+    chSysLockFromIsr();
+
+    for (unsigned int i = 0; i < bytes_transferred; i++) {
+        msg_t ret;
+        do {
+            ret = chIQPutI(&SUSBD1.iqueue, usb_endpoint_bulk_out.buffer[i]);
+            if (ret == Q_FULL)
+                chThdSleepMilliseconds(1);
+
+        } while (ret == Q_FULL);
+    }
+
+    chSysUnlockFromIsr();
+}
+
+static void onotify(GenericQueue* qp) {
+    SerialUSBDriver* sdp = chQGetLink(qp);
+    uint8_t buff[64];
+    int n = chOQGetFullI(&sdp->oqueue);
+    if (n > 64) n = 64;  // don't overflow
+    if (n > 0) {
+        for (int i = 0; i < n; i++) {
+            buff[i] = chOQGetI(&sdp->oqueue);
+        }
+
+        int ret;
+        chSysUnlock();
+        do {
+            ret = usb_transfer_schedule(
+                &usb_endpoint_bulk_in,
+                &buff[0],
+                n,
+                NULL,
+                NULL);
+
+            if (ret == -1)
+                chThdSleepMilliseconds(1);
+
+        } while (ret == -1);
+        chSysLock();
+    }
+}
+
+static size_t write(void* ip, const uint8_t* bp, size_t n) {
+    return chOQWriteTimeout(&((SerialUSBDriver*)ip)->oqueue, bp,
+                            n, TIME_INFINITE);
+}
+
+static size_t read(void* ip, uint8_t* bp, size_t n) {
+    return chIQReadTimeout(&((SerialUSBDriver*)ip)->iqueue, bp,
+                           n, TIME_INFINITE);
+}
+
+static msg_t put(void* ip, uint8_t b) {
+    return chOQPutTimeout(&((SerialUSBDriver*)ip)->oqueue, b, TIME_INFINITE);
+}
+
+static msg_t get(void* ip) {
+    return chIQGetTimeout(&((SerialUSBDriver*)ip)->iqueue, TIME_INFINITE);
+}
+
+static msg_t putt(void* ip, uint8_t b, systime_t timeout) {
+    return chOQPutTimeout(&((SerialUSBDriver*)ip)->oqueue, b, timeout);
+}
+
+static msg_t gett(void* ip, systime_t timeout) {
+    return chIQGetTimeout(&((SerialUSBDriver*)ip)->iqueue, timeout);
+}
+
+static size_t writet(void* ip, const uint8_t* bp, size_t n, systime_t time) {
+    return chOQWriteTimeout(&((SerialUSBDriver*)ip)->oqueue, bp, n, time);
+}
+
+static size_t readt(void* ip, uint8_t* bp, size_t n, systime_t time) {
+    return chIQReadTimeout(&((SerialUSBDriver*)ip)->iqueue, bp, n, time);
+}
+
+static const struct SerialUSBDriverVMT vmt = {
+    write, read, put, get,
+    putt, gett, writet, readt};
+
+void init_serial_usb_driver(SerialUSBDriver* sdp) {
+    sdp->vmt = &vmt;
+    chIQInit(&sdp->iqueue, sdp->ib, SERIAL_BUFFERS_SIZE, NULL, sdp);
+    chOQInit(&sdp->oqueue, sdp->ob, SERIAL_BUFFERS_SIZE, onotify, sdp);
+}
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "ch.h"
+#include "hal.h"
+
+struct SerialUSBDriverVMT {
+    _base_asynchronous_channel_methods
+};
+
+struct SerialUSBDriver {
+    /** @brief Virtual Methods Table.*/
+    const struct SerialUSBDriverVMT* vmt;
+    InputQueue iqueue;               /* Output queue.*/
+    OutputQueue oqueue;              /* Input circular buffer.*/
+    uint8_t ib[SERIAL_BUFFERS_SIZE]; /* Output circular buffer.*/
+    uint8_t ob[SERIAL_BUFFERS_SIZE];
+};
+
+typedef struct SerialUSBDriver SerialUSBDriver;
+
+extern SerialUSBDriver SUSBD1;
+
+void init_serial_usb_driver(SerialUSBDriver* sdp);
+void bulk_out_receive(void);
+void serial_bulk_transfer_complete(void* user_data, unsigned int bytes_transferred);
@@ -0,0 +1,510 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usb_serial_shell.hpp"
+#include "event_m0.hpp"
+#include "baseband_api.hpp"
+#include "core_control.hpp"
+#include "bitmap.hpp"
+#include "png_writer.hpp"
+#include "irq_controls.hpp"
+
+#include "usb_serial_io.h"
+#include "ff.h"
+#include "chprintf.h"
+#include "chqueues.h"
+
+#include <string>
+#include <codecvt>
+#include <cstring>
+#include <locale>
+
+#define SHELL_WA_SIZE THD_WA_SIZE(1024 * 3)
+#define palOutputPad(port, pad) (LPC_GPIO->DIR[(port)] |= 1 << (pad))
+
+// queue handler from ch
+static msg_t qwait(GenericQueue* qp, systime_t time) {
+    if (TIME_IMMEDIATE == time)
+        return Q_TIMEOUT;
+    currp->p_u.wtobjp = qp;
+    queue_insert(currp, &qp->q_waiting);
+    return chSchGoSleepTimeoutS(THD_STATE_WTQUEUE, time);
+}
+
+// This function fills the output buffer, and sends all data in 1 packet
+static size_t fillOBuffer(OutputQueue* oqp, const uint8_t* bp, size_t n) {
+    qnotify_t nfy = oqp->q_notify;
+    size_t w = 0;
+
+    chDbgCheck(n > 0, "chOQWriteTimeout");
+    chSysLock();
+    while (TRUE) {
+        while (chOQIsFullI(oqp)) {
+            if (qwait((GenericQueue*)oqp, TIME_INFINITE) != Q_OK) {
+                chSysUnlock();
+                return w;
+            }
+        }
+        while (!chOQIsFullI(oqp) && n > 0) {
+            oqp->q_counter--;
+            *oqp->q_wrptr++ = *bp++;
+            if (oqp->q_wrptr >= oqp->q_top)
+                oqp->q_wrptr = oqp->q_buffer;
+            w++;
+            --n;
+        }
+        if (nfy) nfy(oqp);
+
+        chSysUnlock(); /* Gives a preemption chance in a controlled point.*/
+        if (n == 0) return w;
+        chSysLock();
+    }
+}
+
+static void cmd_reboot(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)chp;
+    (void)argc;
+    (void)argv;
+
+    m4_request_shutdown();
+    chThdSleepMilliseconds(50);
+
+    LPC_RGU->RESET_CTRL[0] = (1 << 0);
+}
+
+static void cmd_dfu(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)chp;
+    (void)argc;
+    (void)argv;
+
+    m4_request_shutdown();
+    chThdSleepMilliseconds(50);
+
+    LPC_SCU->SFSP2_8 = (LPC_SCU->SFSP2_8 & ~(7)) | 4;
+    palOutputPad(5, 7);
+    palSetPad(5, 7);
+
+    LPC_RGU->RESET_CTRL[0] = (1 << 0);
+}
+
+static void cmd_hackrf(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)chp;
+    (void)argc;
+    (void)argv;
+
+    m4_request_shutdown();
+    chThdSleepMilliseconds(50);
+    EventDispatcher::request_stop();
+}
+
+static void cmd_sd_over_usb(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)chp;
+    (void)argc;
+    (void)argv;
+
+    ui::Painter painter;
+    painter.fill_rectangle(
+        {0, 0, portapack::display.width(), portapack::display.height()},
+        ui::Color::black());
+
+    painter.draw_bitmap(
+        {portapack::display.width() / 2 - 8, portapack::display.height() / 2 - 8},
+        ui::bitmap_icon_hackrf,
+        ui::Color::yellow(),
+        ui::Color::black());
+
+    sdcDisconnect(&SDCD1);
+    sdcStop(&SDCD1);
+
+    m4_request_shutdown();
+    chThdSleepMilliseconds(50);
+    portapack::shutdown(true);
+    m4_init(portapack::spi_flash::image_tag_usb_sd, portapack::memory::map::m4_code, false);
+    m0_halt();
+}
+
+std::filesystem::path path_from_string8(char* path) {
+    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv;
+    return conv.from_bytes(path);
+}
+
+static void cmd_flash(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "Usage: flash /FIRMWARE/portapack-h1_h2-mayhem.bin\r\n");
+        return;
+    }
+
+    auto path = path_from_string8(argv[0]);
+    size_t filename_length = strlen(argv[0]);
+
+    if (!std::filesystem::file_exists(path)) {
+        chprintf(chp, "file not found.\r\n");
+        return;
+    }
+
+    std::memcpy(&shared_memory.bb_data.data[0], path.c_str(), (filename_length + 1) * 2);
+
+    m4_request_shutdown();
+    chThdSleepMilliseconds(50);
+    m4_init(portapack::spi_flash::image_tag_flash_utility, portapack::memory::map::m4_code, false);
+    m0_halt();
+}
+
+static void cmd_screenshot(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
+
+    ensure_directory("SCREENSHOTS");
+    auto path = next_filename_matching_pattern(u"SCREENSHOTS/SCR_????.PNG");
+
+    if (path.empty())
+        return;
+
+    PNGWriter png;
+    auto error = png.create(path);
+    if (error)
+        return;
+
+    for (int i = 0; i < ui::screen_height; i++) {
+        std::array<ui::ColorRGB888, ui::screen_width> row;
+        portapack::display.read_pixels({0, i, ui::screen_width, 1}, row);
+        png.write_scanline(row);
+    }
+
+    chprintf(chp, "generated %s\r\n", path.string().c_str());
+}
+
+// gives full color.
+static void cmd_screenframe(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
+
+    for (int i = 0; i < ui::screen_height; i++) {
+        std::array<ui::ColorRGB888, ui::screen_width> row;
+        portapack::display.read_pixels({0, i, ui::screen_width, 1}, row);
+        for (int px = 0; px < ui::screen_width; px += 5) {
+            char buffer[5 * 3 * 2];
+            sprintf(buffer, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", row[px].r, row[px].g, row[px].b, row[px + 1].r, row[px + 1].g, row[px + 1].b, row[px + 2].r, row[px + 2].g, row[px + 2].b, row[px + 3].r, row[px + 3].g, row[px + 3].b, row[px + 4].r, row[px + 4].g, row[px + 4].b);
+            fillOBuffer(&((SerialUSBDriver*)chp)->oqueue, (const uint8_t*)buffer, 5 * 3 * 2);
+        }
+        chprintf(chp, "\r\n");
+    }
+    chprintf(chp, "ok\r\n");
+}
+
+static char getChrFromRgb(uint8_t r, uint8_t g, uint8_t b) {
+    uint8_t chR = r >> 6;  // 3bit
+    uint8_t chG = g >> 6;  // 3bit
+    uint8_t chB = b >> 6;  // 3bit
+    uint8_t res = chR << 4 | chG << 2 | chB;
+    res += 32;
+    return res;
+}
+
+// sends only 1 byte (printable only) per pixel, so around 96 colors
+static void cmd_screenframeshort(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
+
+    for (int y = 0; y < ui::screen_height; y++) {
+        std::array<ui::ColorRGB888, ui::screen_width> row;
+        portapack::display.read_pixels({0, y, ui::screen_width, 1}, row);
+        for (int px = 0; px < ui::screen_width; px += 60) {
+            char buffer[60];
+            for (int i = 0; i < 60; ++i) {
+                buffer[i] = getChrFromRgb(row[px + i].r, row[px + i].g, row[px + i].b);
+            }
+            fillOBuffer(&((SerialUSBDriver*)chp)->oqueue, (const uint8_t*)buffer, 60);
+        }
+        chprintf(chp, "\r\n");
+    }
+
+    chprintf(chp, "ok\r\n");
+}
+static void cmd_write_memory(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 2) {
+        chprintf(chp, "usage: write_memory <address> <value (1 or 4 bytes)>\r\n");
+        chprintf(chp, "example: write_memory 0x40004008 0x00000002\r\n");
+        return;
+    }
+
+    int value_length = strlen(argv[1]);
+    if (value_length != 10 && value_length != 4) {
+        chprintf(chp, "usage: write_memory <address> <value (1 or 4 bytes)>\r\n");
+        chprintf(chp, "example: write_memory 0x40004008 0x00000002\r\n");
+        return;
+    }
+
+    uint32_t address = (uint32_t)strtol(argv[0], NULL, 16);
+    uint32_t value = (uint32_t)strtol(argv[1], NULL, 16);
+
+    if (value_length == 10) {
+        uint32_t* data_pointer = (uint32_t*)address;
+        *data_pointer = value;
+    } else {
+        uint8_t* data_pointer = (uint8_t*)address;
+        *data_pointer = (uint8_t)value;
+    }
+
+    chprintf(chp, "ok\r\n");
+}
+
+static void cmd_read_memory(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: read_memory 0x40004008\r\n");
+        return;
+    }
+
+    int address = (int)strtol(argv[0], NULL, 16);
+    uint32_t* data_pointer = (uint32_t*)address;
+
+    chprintf(chp, "%x\r\n", *data_pointer);
+}
+
+static void cmd_button(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: button 1\r\n");
+        return;
+    }
+
+    int button = (int)strtol(argv[0], NULL, 10);
+    if (button < 1 || button > 8) {
+        chprintf(chp, "usage: button <number 1 to 8>\r\n");
+        return;
+    }
+
+    control::debug::inject_switch(button);
+
+    chprintf(chp, "ok\r\n");
+}
+
+static void cmd_sd_list_dir(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: ls /\r\n");
+        return;
+    }
+
+    auto path = path_from_string8(argv[0]);
+
+    for (const auto& entry : std::filesystem::directory_iterator(path, "*")) {
+        if (std::filesystem::is_directory(entry.status())) {
+            chprintf(chp, "%s/\r\n", entry.path().string().c_str());
+        } else if (std::filesystem::is_regular_file(entry.status())) {
+            chprintf(chp, "%s\r\n", entry.path().string().c_str());
+        } else {
+            chprintf(chp, "%s *\r\n", entry.path().string().c_str());
+        }
+    }
+}
+
+static void cmd_sd_delete(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: rm <path>\r\n");
+        return;
+    }
+
+    auto path = path_from_string8(argv[0]);
+
+    if (!std::filesystem::file_exists(path)) {
+        chprintf(chp, "file not found.\r\n");
+        return;
+    }
+
+    delete_file(path);
+
+    chprintf(chp, "ok\r\n");
+}
+
+File* shell_file = nullptr;
+
+static void cmd_sd_filesize(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: filesize <path>\r\n");
+        return;
+    }
+    auto path = path_from_string8(argv[0]);
+    FILINFO res;
+    auto stat = f_stat(path.tchar(), &res);
+    if (stat == FR_OK) {
+        chprintf(chp, "%lu\r\n", res.fsize);
+        chprintf(chp, "ok\r\n");
+    } else {
+        chprintf(chp, "error\r\n");
+    }
+}
+
+static void cmd_sd_open(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: open <path>\r\n");
+        return;
+    }
+
+    if (shell_file != nullptr) {
+        chprintf(chp, "file already open\r\n");
+        return;
+    }
+
+    auto path = path_from_string8(argv[0]);
+    shell_file = new File();
+    shell_file->open(path, false, true);
+
+    chprintf(chp, "ok\r\n");
+}
+
+static void cmd_sd_seek(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: seek <offset>\r\n");
+        return;
+    }
+
+    if (shell_file == nullptr) {
+        chprintf(chp, "no open file\r\n");
+        return;
+    }
+
+    int address = (int)strtol(argv[0], NULL, 10);
+    shell_file->seek(address);
+
+    chprintf(chp, "ok\r\n");
+}
+
+static void cmd_sd_close(BaseSequentialStream* chp, int argc, char* argv[]) {
+    (void)argv;
+
+    if (argc != 0) {
+        chprintf(chp, "usage: close\r\n");
+        return;
+    }
+
+    if (shell_file == nullptr) {
+        chprintf(chp, "no open file\r\n");
+        return;
+    }
+
+    delete shell_file;
+    shell_file = nullptr;
+
+    chprintf(chp, "ok\r\n");
+}
+
+static void cmd_sd_read(BaseSequentialStream* chp, int argc, char* argv[]) {
+    if (argc != 1) {
+        chprintf(chp, "usage: read <number of bytes>\r\n");
+        return;
+    }
+
+    if (shell_file == nullptr) {
+        chprintf(chp, "no open file\r\n");
+        return;
+    }
+
+    int size = (int)strtol(argv[0], NULL, 10);
+
+    uint8_t buffer[16];
+
+    do {
+        File::Size bytes_to_read = size > 16 ? 16 : size;
+        auto bytes_read = shell_file->read(buffer, bytes_to_read);
+        if (bytes_read.is_error()) {
+            chprintf(chp, "error %d\r\n", bytes_read.error());
+            return;
+        }
+
+        for (size_t i = 0; i < bytes_read.value(); i++)
+            chprintf(chp, "%02X", buffer[i]);
+
+        chprintf(chp, "\r\n");
+
+        if (bytes_to_read != bytes_read.value())
+            return;
+
+        size -= bytes_to_read;
+    } while (size > 0);
+    chprintf(chp, "ok\r\n");
+}
+
+static void cmd_sd_write(BaseSequentialStream* chp, int argc, char* argv[]) {
+    const char* usage = "usage: write 0123456789ABCDEF\r\n";
+    if (argc != 1) {
+        chprintf(chp, usage);
+        return;
+    }
+
+    if (shell_file == nullptr) {
+        chprintf(chp, "no open file\r\n");
+        return;
+    }
+
+    size_t data_string_len = strlen(argv[0]);
+    if (data_string_len % 2 != 0) {
+        chprintf(chp, usage);
+        return;
+    }
+
+    for (size_t i = 0; i < data_string_len; i++) {
+        char c = argv[0][i];
+        if ((c < '0' || c > '9') && (c < 'A' || c > 'F')) {
+            chprintf(chp, usage);
+            return;
+        }
+    }
+
+    char buffer[3] = {0, 0, 0};
+
+    for (size_t i = 0; i < data_string_len / 2; i++) {
+        buffer[0] = argv[0][i * 2];
+        buffer[1] = argv[0][i * 2 + 1];
+        uint8_t value = (uint8_t)strtol(buffer, NULL, 16);
+        shell_file->write(&value, 1);
+    }
+
+    chprintf(chp, "ok\r\n");
+}
+
+static const ShellCommand commands[] = {
+    {"reboot", cmd_reboot},
+    {"dfu", cmd_dfu},
+    {"hackrf", cmd_hackrf},
+    {"sd_over_usb", cmd_sd_over_usb},
+    {"flash", cmd_flash},
+    {"screenshot", cmd_screenshot},
+    {"screenframe", cmd_screenframe},
+    {"screenframeshort", cmd_screenframeshort},
+    {"write_memory", cmd_write_memory},
+    {"read_memory", cmd_read_memory},
+    {"button", cmd_button},
+    {"ls", cmd_sd_list_dir},
+    {"rm", cmd_sd_delete},
+    {"open", cmd_sd_open},
+    {"seek", cmd_sd_seek},
+    {"close", cmd_sd_close},
+    {"read", cmd_sd_read},
+    {"write", cmd_sd_write},
+    {"filesize", cmd_sd_filesize},
+    {NULL, NULL}};
+
+static const ShellConfig shell_cfg1 = {
+    (BaseSequentialStream*)&SUSBD1,
+    commands};
+
+void create_shell() {
+    shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
+}
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "ch.h"
+#include "hal.h"
+
+#include "shell.h"
+
+void create_shell(void);
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "usb_serial_thread.hpp"
+#include "buffer_exchange.hpp"
+
+// UsbSerialThread //////////////////////////////////////////////////////////
+
+UsbSerialThread::UsbSerialThread() {
+    create_thread();
+}
+
+UsbSerialThread::~UsbSerialThread() {
+    stop();
+}
+
+void UsbSerialThread::create_thread() {
+    thread = chThdCreateFromHeap(NULL, 1024, NORMALPRIO + 10, UsbSerialThread::static_fn, this);
+}
+
+void UsbSerialThread::stop() {
+    if (thread) {
+        chThdTerminate(thread);
+        chThdWait(thread);
+        thread = nullptr;
+    }
+}
+
+msg_t UsbSerialThread::static_fn(void* arg) {
+    auto obj = static_cast<UsbSerialThread*>(arg);
+    obj->run();
+    return 0;
+}
+
+void UsbSerialThread::run() {
+    while (!chThdShouldTerminate()) {
+        if (str_ready) {
+            str_ready = false;
+            chprintf((BaseSequentialStream*)&SUSBD1, serial_str.c_str());
+        }
+
+        chThdSleepMilliseconds(50);
+    }
+}
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __USB_SERIAL_THREAD_H__
+#define __USB_SERIAL_THREAD_H__
+
+#include "ch.h"
+
+#include "event_m0.hpp"
+
+#include "io.hpp"
+#include "optional.hpp"
+
+#include "chprintf.h"
+#include "usb_serial_io.h"
+
+#include <cstdint>
+#include <cstddef>
+#include <utility>
+
+class UsbSerialThread {
+   public:
+    UsbSerialThread();
+    ~UsbSerialThread();
+
+    void stop();
+
+    UsbSerialThread(const UsbSerialThread&) = delete;
+    UsbSerialThread(UsbSerialThread&&) = delete;
+    UsbSerialThread& operator=(const UsbSerialThread&) = delete;
+    UsbSerialThread& operator=(UsbSerialThread&&) = delete;
+    bool str_ready = false;
+    std::string serial_str{};
+
+   private:
+    Thread* thread{nullptr};
+    static msg_t static_fn(void* arg);
+    void run();
+    void create_thread();
+};
+
+#endif /*__CAPTURE_THREAD_H__*/
@@ -347,12 +347,6 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PAPR aprsrx)

-### NRF RX
-
-set(MODE_CPPSRC
-	proc_nrfrx.cpp
-)
-DeclareTargets(PNRR nrfrx)

 ### BTLE RX

@@ -382,12 +376,6 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PAMA am_audio)

-### AM TV
-
-set(MODE_CPPSRC
-	proc_am_tv.cpp
-)
-DeclareTargets(PAMT am_tv)

 ### Audio transmit

@@ -431,12 +419,6 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PFSR fskrx)

-### Jammer
-
-set(MODE_CPPSRC
-	proc_jammer.cpp
-)
-DeclareTargets(PJAM jammer)

 ### Microphone transmit

@@ -550,6 +532,21 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PWFM wfm_audio)

+### SubGhz Decoders 
+
+set(MODE_CPPSRC
+	proc_subghzd.cpp
+)
+DeclareTargets(PSGD subghzd)
+
+
+### Weather Stations
+set(MODE_CPPSRC
+	proc_weather.cpp
+)
+DeclareTargets(PWTH weather)
+
+
 ### Flash Utility

 include(${CHIBIOS_PORTAPACK}/os/various/fatfs_bindings/fatfs.cmake)
@@ -618,6 +615,28 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PAFR afskrx)

+### NRF RX
+
+set(MODE_CPPSRC
+	proc_nrfrx.cpp
+)
+DeclareTargets(PNRR nrfrx)
+
+
+### Jammer
+
+set(MODE_CPPSRC
+	proc_jammer.cpp
+)
+DeclareTargets(PJAM jammer)
+
+### AM TV
+
+set(MODE_CPPSRC
+	proc_am_tv.cpp
+)
+DeclareTargets(PAMT am_tv)
+
 ### Test

 set(MODE_CPPSRC
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jLynx	53bbf74f4d	V1.9.0 (#1660 ) * Update version.txt * Update past_version.txt	2023-12-22 07:35:54 +13:00
Mark Thompson	19a66fac20	Enable Sample Rate to be spec'd in .ini file for Weather & SubGhzDecoder apps (#1659 )	2023-12-21 19:33:06 +01:00
Totoo	36e1b9a36e	Portapack USB screen tx (#1653 ) * implemented 2 screen read functions, and haxfixed windows usb bug * Support up to 64 byte per packet for faster tx * Added filesize command	2023-12-19 22:25:22 +01:00
Netro	1ca9288bbe	initial USB serial thread integrated to BLE RX (#1651 )	2023-12-19 22:20:13 +01:00
Mark Thompson	4ca2d1e352	Fix compile error (#1650 )	2023-12-18 07:35:00 +01:00
gullradriel	0b11730835	fix wrong direction in tx freq correction (#1649 ) Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-12-17 18:47:20 -06:00
Bernd Herzog	6069145b68	Usb serial (#1648 ) * enabled usb clock * added usb stack to application * fixed pll0usb clock setup * implemented serial usb handshake * implemented serial communication * integrated chibios shell * implemented device reset * implemented enter dfu mode * implemented hackrf mode command * implemented flash command * implemented memory manipulation * implemented button control * fixed mode change * improved reset behavior * implemented directory commands * implemented file commands * improved data communication * refactorings	2023-12-17 17:20:35 +01:00
Totoo	2ccda5aebd	Subghz decoder (#1646 ) * Initial commit - wip * Half part of the transition of baseband processor. * More SGD * WIP, Weather refactor, UI improv * Rename * Added 4msps, and fixes * Fixes * princeton working * Renamed proc_weather, bc now multifunctional * Proto: bett * FPS_CAME = 4, FPS_PRASTEL = 5, FPS_AIRFORCE = 6, * Came Atomo, fixes * Separate weather and sgd, bc of baseband size limit * Fix display * Save space * More protos * Dooya proto added * More protos * add protos * More protos * Move weather to ext app * nw * Revert "Move weather to ext app" This reverts commit `8a84aac2f5`. * revert * Fix merge * Better naming * More protos * More protos * Add protos * Fix warning * Add NeroRadio * more protos * more protos * More protos * Shrink a bit * fixes * More protos * Nicer code * Fix naming * Fix format * Remove unused * Fix some protos, that needs a LOOOONG part with the same lo/high * Modify key calculation	2023-12-16 16:37:51 -06:00
Totoo	02810bf527	Move Jammer ext app (with baseband image too) (#1647 )	2023-12-15 20:18:21 +01:00
Totoo	b58ee761a1	Move more apps + language module (#1643 ) * CoasterP to ext (Burger pager) * LGE to ext app * Solve compiler literal removal with centralizing common string literals.	2023-12-12 16:55:50 +01:00
Totoo	5b9d898202	Fix oregon2 weather protocol (#1642 )	2023-12-12 06:45:56 +01:00
Totoo	5f8e44e7b7	NRF RX to ext app (#1641 ) * NFR Rx to ext app	2023-12-11 11:57:04 +01:00
Totoo	ec80859d93	AnalogTV to ext (#1638 )	2023-12-11 08:55:07 +01:00
Totoo	5e9d92d65c	Set sr to 4m (#1636 ) * Set sr to 4m * Rename variable	2023-12-10 23:40:11 +01:00
Mark Thompson	c3bb9c0a16	Weather display beautification (#1635 )	2023-12-10 17:57:21 +01:00
Netro	bd475e6f9c	BLE RX - Find From File Initial Commit. (#1627 ) * initial work * Handling capping count only at total count * Adding logging back in	2023-12-09 18:02:00 +01:00
Mark Thompson	0f1708d8fd	Increase SSP timing margin for MAX2839 registers (#1632 )	2023-12-09 14:09:20 +01:00
Mark Thompson	efa0e270ad	Updated Weather & TPMS app icons (#1630 )	2023-12-09 09:25:41 +01:00
Totoo	ff882024d4	Ble spam improvements (#1626 ) * Much faster ble spam tx * Better Android handling	2023-12-09 09:24:02 +01:00
Brumi-2021	60d95447fb	Improved sensitivity/selectivity Weather App (#1628 )	2023-12-08 21:33:48 +01:00
Mark Thompson	a474bf8fe3	Add files via upload (#1629 )	2023-12-08 19:20:59 +01:00
Totoo	1bf0d2b3e6	BLE spam ext app (#1624 ) * BLESpam ext app first release * Ios partly added * Fix missing! * Maybe fix Ios * Add comment * Fixes * Added samsung and windows * cleaning a bit * Partial size fix * Move continuity to blespam namespace. * Optimize code layout, so not using fw space * Ui changes	2023-12-06 08:35:23 -05:00
Mark Thompson	ea02d98a59	Preserve BLE RX app settings across runs, and changed BLE app settings file names (#1622 ) * Add files via upload * Add files via upload * Add files via upload	2023-12-04 12:06:07 -05:00
Mark Thompson	9624d7b429	Fix compiler warning (#1620 )	2023-12-03 08:19:04 +01:00
Totoo	4f440055cb	Fix to_string_hex_array string reserve (#1619 )	2023-12-02 16:42:09 -06:00
Netro	7354ba8fd5	Random data selection feature done. (#1617 )	2023-12-02 08:05:29 +01:00
Netro	b7b4a10485	Refined Tx Random Data (Still WIP) (#1616 ) * managing initial cursor * work on adding marked cursors	2023-11-30 21:57:22 +01:00
Totoo	cca0e18f5a	Weather improvements (#1615 ) * Added Acurite986 protocol * Added signal age * Added myself to about screen	2023-11-30 12:36:59 +01:00
Netro	8846926b68	BLE TX: use text viewer to inject rand data WIP (#1613 )	2023-11-29 18:54:17 +01:00
Mark Thompson	7ceefb1b81	Weather app tweaks (#1610 ) * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Add files via upload	2023-11-29 10:37:01 -06:00
Erwin Ried	861f684d00	Discord icon/invite more clear on top (#1612 )	2023-11-29 13:22:51 +01:00
Erwin Ried	17b146b960	Update README.md (#1611 )	2023-11-29 11:23:27 +01:00
Totoo	02251eeeb4	Added weather station app with 18 protocol parsers (#1607 ) * Added weather station app with 18 protocol parsers * Fix button and formatting * Set BW to 1.75m, changed to us in dsp part	2023-11-28 21:11:30 +01:00
Netro	c486572d3d	BLE TX; Added feature to randomize found substring in data (#1609 )	2023-11-28 21:11:07 +01:00
Netro	a6ed6e3099	BLE RX: Making auto channel timer independent of packet events. (#1608 )	2023-11-28 18:18:15 +01:00
Netro	175e5e2e8c	BLE: Minor improvements to fix occasional not start on tx app first time. (#1605 )	2023-11-27 21:59:29 +01:00
Mark Thompson	7bc27038be	Save Morse app settings (#1602 )	2023-11-26 12:17:23 +01:00
Brumi-2021	609bf3219f	solve Morse_TX_App latch up in r9 (#1601 )	2023-11-25 01:01:52 +01:00
Mark Thompson	bdbd616a84	added a frequency field to the ERT app	2023-11-24 09:25:50 +01:00
Mark Thompson	1cbe5cb293	Save TPMS units in App Settings and tune frequency (#1598 )	2023-11-21 18:44:10 +01:00
gullradriel	df6003c08f	fix button label (#1597 ) Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-20 12:09:47 -05:00
Netro	50fcbf0f5a	BLE: added deleting and renaming temp file (#1596 )	2023-11-20 08:37:56 +01:00
Netro	5a1676a0b9	BLE List improvements (#1595 ) * WIP on add to save list * Added rewriting existing lines and appending new to same file. * format * not looking on new file. * Added temp list due to some issue of recent being updated during save I was receiving a system halt and this seems to fix it. Needs more testing though. * clang format * Stored entries backward. Fix. * Update file working, need to replace temp file though.	2023-11-19 20:53:53 -05:00
gullradriel	309f2fbd2c	support for a sdcard speed option (#1594 ) * support for a sdcard speed option * trying to link sdio_cclk_set from file * changed io to IO in checkbox text * changed order so high speed option is read after pmem is restored from sd * test button * took out unneeded comment * force behavior of test button --------- Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-19 08:08:29 -06:00
gullradriel	650aacfaa7	BLE RX: added clear list button (#1593 ) * added clear list button * Bigger buttons and text * Change case on labels --------- Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-18 16:32:52 -05:00
Mark Thompson	8655027a5b	Fixed SPI Read timing issue affecting MAX283x chips (#1590 ) * Slowed SPI timing to MAX283x by 20% * Fix temperature scaling	2023-11-18 09:50:57 -06:00
Mark Thompson	de937f02d4	Added Memory Dump app for Debug (#1588 ) * Add files via upload * Add files via upload * Added single word read/write support * Add files via upload	2023-11-18 07:16:56 -06:00
Mark Thompson	2c0446e83d	Improved Focus Manager navigation (#1589 ) * Focus manager navigation fix * Add files via upload	2023-11-18 06:58:38 -06:00
Netro	9e6699d8cc	Fixed name. (#1586 )	2023-11-17 13:28:09 -05:00
Mark Thompson	ef92c5bc0a	Enhanced Debug -> Peripherals app to allow direct register modification (#1584 ) * Add files via upload * Add files via upload * Add files via upload * Add files via upload * Clang * Clang * Tweak position of field on screen * Reverted text on Write button per reviewer feedback	2023-11-17 12:10:11 -06:00
Netro	10f6600f52	No need limit to 50 since we moved to min 16ms send times. (#1583 )	2023-11-16 21:28:22 +01:00
Netro	aeb607e73b	BLE Rx Save List / Save packet from BLE Rx (#1582 ) * Added Tx Save from Rx Details View * Added saving of current list	2023-11-16 20:00:52 +01:00
Netro	8479d2edf0	BLE Comm WIP (#1578 ) * Initial BLE Comm commit. * SCAN_RSP MAC was reversed. * Added Auto Channel Hop. * Improvements to Tx to better handle timers. * Auto channel and more work on timers. * more advertisement numbers.	2023-11-16 14:46:45 +01:00
Bernd Herzog	d2e9a8dc06	Hackrf mode when no pp attached (#1580 ) * added portapack presence detection * adjusted timeout * fixed ak4951 initialisation	2023-11-14 12:22:26 +01:00
Netro	4571cb0b61	BLE Rx Refactoring / Cleanup (#1577 ) , also added showing MAC for Scan_Rsp Adv_Direct	2023-11-12 19:10:53 +01:00
gullradriel	351f7b13b3	BTLE RX: fix for name disappearing (#1575 ) * Fix for name disappearing * cleanings --------- Co-authored-by: GullCode <gullradriel@hotmail.com>	2023-11-12 09:59:36 -05:00
Netro	5953cb57b0	Rx parsing fix (#1573 ) * restored mistakenly quoted code * removed unneeded line. * added parsing for other PDU Types and added PDU Type label. * added missing SCAN_IND	2023-11-12 08:54:04 +01:00
Brumi-2021	b60b873428	Changing BLTE FIR filter to improve RX sensitivity (#1574 )	2023-11-11 20:43:10 -05:00
Netro	a3249cae26	BLE Rx/Tx App Cleanup (#1570 ) * Showing highest dB first * Including namestring in search * Using replace seems to work better. * bletx cleanup * removing pop * pop is needed on this view. * cleanup switching * reduce to 1 entry list * Setting to use the name of BLE with a toggle checkbox. * Removed &nav reference. * Removing const * Fixed issue with memory being run out when switching from a previous app * Fixed not setting updated progressbar for each new packet.	2023-11-11 20:46:51 +01:00
Kyle Reed	f7f784c0f4	Cleanup dead code in the ADSB RX proc (#1572 ) * Cleanup dead code in the ADSB RX proc * Fix comments * Formatting	2023-11-10 11:38:06 -08:00
Kyle Reed	f4f538f69b	ADSB RX App cleanup (#1569 ) * WIP refactoring/gardening * WIP cleanup, adding status dots * Rename ageStep * WIP Cleanup * Wrapping up ADSB refactor/cleanup. * Don't initialize strings to " " * Better map refresh * Fix colorization of recent entries * Fit and finish	2023-11-10 08:22:29 -08:00
Netro	bbd1a5a2ef	Changing filter on ble rx. Seems to work better? (#1568 )	2023-11-08 19:22:57 +01:00
Nemanja Nedeljković	bc71238046	Patch build for gcc 13.2.0 (#1567 )	2023-11-08 19:22:26 +01:00
Netro	a9df9dde69	BLE Rx parsing improvements (#1566 ) * Running simple state machine to better catch in between buffers. * Fixed buffer size 2048 was too large for a decimated before only containing 512 (2048/4 Decimation) Bytes. * attempt at trying to minimize uncleared str buffers	2023-11-07 18:10:18 +01:00