Beep on search find something.

Beep on search find something. Solves #2643

.github/workflows/past_version.txt

@@ -1 +1 @@
-v2.0.2
+v2.1.0

.github/workflows/version.txt

@@ -1 +1 @@
-v2.1.0
+v2.2.0

.gitignore

@@ -62,6 +62,7 @@ cmake-build-debug/
 .vscode
 .idea
 *.swp
+.claude
 
 # VSCodium extensions
 .history

firmware/application/CMakeLists.txt

@@ -270,13 +270,10 @@ set(CPPSRC
 	ui/ui_bmpview.cpp
 	apps/ais_app.cpp
 	apps/analog_audio_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/pocsag_app.cpp
-	apps/soundboard_app.cpp
 	apps/ui_about_simple.cpp
 	apps/ui_adsb_rx.cpp
 	apps/ui_aprs_rx.cpp

firmware/application/apps/ais_app.cpp

@@ -301,7 +301,7 @@ AISRecentEntryDetailView::AISRecentEntryDetailView(NavigationView& nav) {
             ais::format::text(entry_.name),
             0,
             GeoPos::alt_unit::METERS,
-            GeoPos::spd_unit::NONE,
+            GeoPos::spd_unit::KNOTS,
             ais::format::latlon_float(entry_.last_position.latitude.normalized()),
             ais::format::latlon_float(entry_.last_position.longitude.normalized()),
             entry_.last_position.true_heading,
@@ -324,7 +324,31 @@ AISRecentEntryDetailView& AISRecentEntryDetailView::operator=(const AISRecentEnt
 
 void AISRecentEntryDetailView::update_position() {
     if (send_updates)
-        geomap_view->update_position(ais::format::latlon_float(entry_.last_position.latitude.normalized()), ais::format::latlon_float(entry_.last_position.longitude.normalized()), (float)entry_.last_position.true_heading, 0, entry_.last_position.speed_over_ground);
+        geomap_view->update_position(ais::format::latlon_float(entry_.last_position.latitude.normalized()), ais::format::latlon_float(entry_.last_position.longitude.normalized()), (float)entry_.last_position.true_heading, 0, entry_.last_position.speed_over_ground > 1022 ? 0 : entry_.last_position.speed_over_ground / 10);
+}
+
+bool AISRecentEntryDetailView::add_map_marker(const AISRecentEntry& entry) {
+    if (geomap_view && send_updates) {
+        GeoMarker marker{};
+        marker.lon = ais::format::latlon_float(entry.last_position.longitude.normalized());
+        marker.lat = ais::format::latlon_float(entry.last_position.latitude.normalized());
+        marker.angle = entry.last_position.true_heading;
+        marker.tag = entry.call_sign.empty() ? to_string_dec_uint(entry.mmsi) : entry.call_sign;
+        auto markerStored = geomap_view->store_marker(marker);
+        return markerStored == MARKER_STORED;
+    }
+    return false;
+}
+void AISRecentEntryDetailView::update_map_markers(AISRecentEntries& entries) {
+    if (geomap_view && send_updates) {
+        geomap_view->clear_markers();
+        for (const auto& entry : entries) {
+            // if (entry.last_position.latitude.is_valid() && entry.last_position.longitude.is_valid()) {
+            add_map_marker(entry);
+            // }
+        }
+        update_position();  // to update view
+    }
 }
 
 void AISRecentEntryDetailView::focus() {
@@ -415,14 +439,30 @@ AISAppView::AISAppView(NavigationView& nav)
         audio::set_rate(audio::Rate::Hz_24000);
         audio::output::start();
     }
+
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        on_tick_second();
+    };
 }
 
 AISAppView::~AISAppView() {
+    rtc_time::signal_tick_second -= signal_token_tick_second;
     audio::output::stop();
     receiver_model.disable();
     baseband::shutdown();
 }
 
+void AISAppView::on_tick_second() {
+    ++timer_seconds;
+    if (timer_seconds % 10 == 0) {
+        if (recent_entry_detail_view.hidden()) return;
+        if (got_new_packet) {
+            got_new_packet = false;
+            recent_entry_detail_view.update_map_markers(recent);
+        }
+    }
+}
+
 void AISAppView::focus() {
     options_channel.focus();
 }
@@ -438,7 +478,7 @@ void AISAppView::on_packet(const ais::Packet& packet) {
     if (logger) {
         logger->on_packet(packet);
     }
-
+    got_new_packet = true;
     auto& entry = ::on_packet(recent, packet.source_id());
     entry.update(packet);
     recent_entries_view.set_dirty();
@@ -461,6 +501,7 @@ void AISAppView::on_show_detail(const AISRecentEntry& entry) {
     recent_entry_detail_view.hidden(false);
     recent_entry_detail_view.set_entry(entry);
     recent_entry_detail_view.focus();
+    recent_entry_detail_view.update_map_markers(recent);
 }
 
 } /* namespace ui */

firmware/application/apps/ais_app.hpp

@@ -125,10 +125,14 @@ class AISRecentEntryDetailView : public View {
     void update_position();
     void focus() override;
     void paint(Painter&) override;
+    bool add_map_marker(const AISRecentEntry& entry);
+    void update_map_markers(AISRecentEntries& entries);
 
     AISRecentEntryDetailView(const AISRecentEntryDetailView& Entry);
     AISRecentEntryDetailView& operator=(const AISRecentEntryDetailView& Entry);
 
+    GeoMapView* get_geomap_view() { return geomap_view; }
+
    private:
     AISRecentEntry entry_{};
 
@@ -215,6 +219,9 @@ class AISAppView : public View {
     Channel channel{
         {21 * 8, 5, 6 * 8, 4},
     };
+    SignalToken signal_token_tick_second{};
+    uint8_t timer_seconds = 0;
+    bool got_new_packet{false};  // got any new packet since latest screen update?
 
     MessageHandlerRegistration message_handler_packet{
         Message::ID::AISPacket,
@@ -229,6 +236,7 @@ class AISAppView : public View {
     void on_packet(const ais::Packet& packet);
     void on_show_list();
     void on_show_detail(const AISRecentEntry& entry);
+    void on_tick_second();
 };
 
 } /* namespace ui */

firmware/application/apps/ble_comm_app.cpp

@@ -69,7 +69,7 @@ static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
 }
 
 void BLECommView::focus() {
-    options_channel.focus();
+    field_frequency.focus();
 }
 
 BLECommView::BLECommView(NavigationView& nav)
@@ -79,10 +79,7 @@ BLECommView::BLECommView(NavigationView& nav)
                   &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,
@@ -90,10 +87,6 @@ BLECommView::BLECommView(NavigationView& nav)
 
     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) {
@@ -104,27 +97,8 @@ BLECommView::BLECommView(NavigationView& nav)
             logger->append(logs_dir.string() + "/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();
 }
@@ -145,86 +119,66 @@ 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);
+    std::string dataString = "02010603030F1807084861636B5246";
     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;
+    strncpy(bleTxPacket.packetCount, "1", 2);
+    bleTxPacket.packet_count = 1;
 
-    bleTxPacket.packetType = PKT_TYPE_DISCOVERY;
+    bleTxPacket.pduType = PKT_TYPE_ADV_IND;
 
     return bleTxPacket;
 }
 
-void BLECommView::sendAdvertisement(bool enable) {
-    if (enable) {
-        startTx(advertisePacket);
-        is_adv = true;
-    } else {
-        is_adv = false;
-        stopTx();
-    }
+void BLECommView::sendAdvertisement(void) {
+    startTx(advertisePacket);
+    ble_state = Ble_State_Advertising;
 }
 
 void BLECommView::startTx(BLETxPacket packetToSend) {
-    int randomChannel = channel_number_tx;
+    switch_rx_tx(false);
 
-    if (auto_channel) {
-        int min = 37;
-        int max = 39;
+    currentPacket = packetToSend;
+    packet_counter = currentPacket.packet_count;
 
-        randomChannel = min + std::rand() % (max - min + 1);
-
-        field_frequency.set_value(get_freq_by_channel_number(randomChannel));
+    switch (advCount) {
+        case 0:
+            channel_number_tx = 37;
+            break;
+        case 1:
+            channel_number_tx = 38;
+            break;
+        case 2:
+            channel_number_tx = 39;
+            break;
     }
 
-    if (!in_tx_mode()) {
-        switch_rx_tx(false);
+    field_frequency.set_value(get_freq_by_channel_number(37));
 
-        currentPacket = packetToSend;
-        packet_counter = currentPacket.packet_count;
+    advCount++;
 
-        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 (advCount == 3) {
+        advCount = 0;
     }
 
-    if ((packet_counter % 10) == 0) {
-        text_packets_sent.set(to_string_dec_uint(packet_counter));
-    }
+    baseband::set_btletx(37, deviceMAC, currentPacket.advertisementData, currentPacket.pduType);
+    transmitter_model.set_tx_gain(47);
+    transmitter_model.enable();
 
-    is_sending = true;
-
-    packet_counter--;
+    is_running_tx = true;
 }
 
 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);
+    field_frequency.set_value(get_freq_by_channel_number(channel_number_rx));
     receiver_model.enable();
 
     is_running_tx = false;
@@ -248,14 +202,12 @@ 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);
+        if (ble_state == Ble_State_Receiving || ble_state == Ble_State_Idle) {
+            sendAdvertisement();
         }
     }
 }
@@ -263,17 +215,18 @@ void BLECommView::on_timer() {
 void BLECommView::on_tx_progress(const bool done) {
     if (done) {
         if (in_tx_mode()) {
-            is_sending = false;
+            ble_state = Ble_State_Receiving;
 
-            if (packet_counter == 0) {
-                if (is_adv) {
-                    sendAdvertisement(false);
-                } else {
-                    stopTx();
-                }
-            } else {
-                startTx(currentPacket);
-            }
+            timer_counter = 0;
+            timer_period = 12;
+
+            stopTx();
+
+            // else
+            // {
+            //     startTx(advertisePacket);
+            //     advCount++;
+            // }
         }
     }
 }
@@ -309,23 +262,28 @@ void BLECommView::parse_received_packet(const BlePacketData* packet, ADV_PDU_TYP
     }
 
     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";
-        }
+            ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)packet->data;
 
-        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);
+            std::reverse(directed_mac_data->A1, directed_mac_data->A1 + 6);
+            std::string directedMAC = to_string_mac_address(directed_mac_data->A1, 6, false);
+
+            // Compare directed MAC Hex with the device MAC.
+            if (1) {
+                // std::string str_console = "Received SCAN_REQ from directed MAC: " + directedMAC + "\n";
+                // console.clear(true);
+                // console.writeln(str_console);
+            }
+        } else if (pdu_type == CONNECT_REQ) {
+            ADV_PDU_PAYLOAD_TYPE_5* connectReq = (ADV_PDU_PAYLOAD_TYPE_5*)packet->data;
+
+            std::reverse(connectReq->AdvA, connectReq->AdvA + 6);
+            std::string directedMAC = to_string_mac_address(connectReq->AdvA, 6, false);
+
+            std::string str_console = "Received CONNECT_REQ from directed MAC: " + directedMAC + "\n";
+            console.clear(true);
+            console.writeln(str_console);
+        }
     }
 }
 

firmware/application/apps/ble_comm_app.hpp

@@ -76,7 +76,16 @@ class BLECommView : public View {
     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);
+    void sendAdvertisement(void);
+
+    typedef enum {
+        Ble_State_Idle = 0,
+        Ble_State_Advertising = 1,
+        Ble_State_Receiving = 2,
+        Ble_State_Sending = 3
+    } BleState;
+
+    BleState ble_state{Ble_State_Idle};
 
     NavigationView& nav_;
 
@@ -101,8 +110,9 @@ class BLECommView : public View {
     uint8_t channel_number_tx = 37;
     uint8_t channel_number_rx = 37;
     bool auto_channel = false;
+    uint8_t advCount = 0;
 
-    char randomMac[13] = "010203040506";
+    char deviceMAC[13] = "C23456789ABC";
 
     bool is_running_tx = false;
     bool is_sending = false;
@@ -111,7 +121,7 @@ class BLECommView : public View {
     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)
+    int16_t timer_rx_period{12};  // Poll Rx for at least 150ms. (TBD)
 
     uint32_t packet_counter{0};
     BLETxPacket advertisePacket{};
@@ -147,15 +157,6 @@ class BLECommView : public View {
     Channel channel{
         {24 * 8, 5, 6 * 8, 4}};
 
-    Labels label_send_adv{
-        {{0 * 8, 2 * 8}, "Send Advertisement:", Theme::getInstance()->fg_light->foreground}};
-
-    ImageButton button_send_adv{
-        {21 * 8, 1 * 16, 10 * 8, 2 * 16},
-        &bitmap_play,
-        Theme::getInstance()->fg_green->foreground,
-        Theme::getInstance()->fg_green->background};
-
     Checkbox check_log{
         {24 * 8, 2 * 8},
         3,

firmware/application/apps/ble_rx_app.cpp

@@ -36,6 +36,8 @@
 #include "ui_textentry.hpp"
 #include "usb_serial_asyncmsg.hpp"
 
+#include <string_view>
+
 using namespace portapack;
 using namespace modems;
 namespace fs = std::filesystem;
@@ -68,22 +70,6 @@ uint64_t copy_mac_address_to_uint64(const uint8_t* macAddress) {
     return result;
 }
 
-void reverse_byte_array(uint8_t* arr, int length) {
-    int start = 0;
-    int end = length - 1;
-
-    while (start < end) {
-        // Swap elements at start and end
-        uint8_t temp = arr[start];
-        arr[start] = arr[end];
-        arr[end] = temp;
-
-        // Move the indices towards the center
-        start++;
-        end--;
-    }
-}
-
 MAC_VENDOR_STATUS lookup_mac_vendor_status(const uint8_t* mac_address, std::string& vendor_name) {
     static bool db_checked = false;
     static bool db_exists = false;
@@ -128,6 +114,22 @@ std::string lookup_mac_vendor(const uint8_t* mac_address) {
     return vendor_name;
 }
 
+void reverse_byte_array(uint8_t* arr, int length) {
+    int start = 0;
+    int end = length - 1;
+
+    while (start < end) {
+        // Swap elements at start and end
+        uint8_t temp = arr[start];
+        arr[start] = arr[end];
+        arr[end] = temp;
+
+        // Move the indices towards the center
+        start++;
+        end--;
+    }
+}
+
 namespace ui {
 
 std::string pdu_type_to_string(ADV_PDU_TYPE type) {
@@ -195,8 +197,15 @@ void RecentEntriesTable<BleRecentEntries>::draw(
         line = to_string_mac_address(entry.packetData.macAddress, 6, false);
     }
 
+    std::string hitsStr;
+
+    if (!entry.informationString.empty()) {
+        hitsStr = entry.informationString;
+    } else {
+        hitsStr = to_string_dec_int(entry.numHits);
+    }
+
     // Pushing single digit values down right justified.
-    std::string hitsStr = to_string_dec_int(entry.numHits);
     int hitsDigits = hitsStr.length();
     uint8_t hits_spacing = 8 - hitsDigits;
 
@@ -232,15 +241,14 @@ BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const Bl
 
     text_mac_address.set(to_string_mac_address(entry.packetData.macAddress, 6, false));
     text_pdu_type.set(pdu_type_to_string(entry.pduType));
-    std::string vendor_name = lookup_mac_vendor(entry.packetData.macAddress);
-    text_vendor.set(vendor_name);
+    text_vendor.set(entry.vendor_name.empty() ? lookup_mac_vendor(entry.packetData.macAddress) : entry.vendor_name);
 
     button_done.on_select = [&nav](const ui::Button&) {
         nav.pop();
     };
 
     button_send.on_select = [this, &nav](const ui::Button&) {
-        auto packetToSend = build_packet();
+        auto packetToSend = build_packet(entry_);
         nav.set_on_pop([packetToSend, &nav]() {
             nav.replace<BLETxView>(packetToSend);
         });
@@ -248,7 +256,7 @@ BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const Bl
     };
 
     button_save.on_select = [this, &nav](const ui::Button&) {
-        auto packetToSave = build_packet();
+        auto packetToSave = build_packet(entry_);
 
         packetFileBuffer = "";
         text_prompt(
@@ -424,12 +432,11 @@ void BleRecentEntryDetailView::set_entry(const BleRecentEntry& entry) {
     entry_ = entry;
     text_mac_address.set(to_string_mac_address(entry.packetData.macAddress, 6, false));
     text_pdu_type.set(pdu_type_to_string(entry.pduType));
-    std::string vendor_name = lookup_mac_vendor(entry.packetData.macAddress);
-    text_vendor.set(vendor_name);
+    text_vendor.set(entry.vendor_name.empty() ? lookup_mac_vendor(entry.packetData.macAddress) : entry.vendor_name);
     set_dirty();
 }
 
-BLETxPacket BleRecentEntryDetailView::build_packet() {
+BLETxPacket BleRecentEntryDetailView::build_packet(BleRecentEntry entry_) {
     BLETxPacket bleTxPacket;
     memset(&bleTxPacket, 0, sizeof(BLETxPacket));
 
@@ -437,8 +444,8 @@ BLETxPacket BleRecentEntryDetailView::build_packet() {
 
     strncpy(bleTxPacket.macAddress, macAddressStr.c_str(), 12);
     strncpy(bleTxPacket.advertisementData, entry_.dataString.c_str(), entry_.packetData.dataLen * 2);
-    strncpy(bleTxPacket.packetCount, "50", 3);
-    bleTxPacket.packet_count = 50;
+    strncpy(bleTxPacket.packetCount, "10", 3);
+    bleTxPacket.packet_count = 10;
 
     return bleTxPacket;
 }
@@ -488,16 +495,18 @@ BLERxView::BLERxView(NavigationView& nav)
                   &field_vga,
                   &options_channel,
                   &field_frequency,
-                  &check_log,
-                  &button_find,
-                  &check_name,
                   &label_sort,
                   &options_sort,
-                  &label_found,
-                  &text_found_count,
-                  &check_serial_log,
                   &button_filter,
                   &options_filter,
+                  &check_name,
+                  &check_log,
+                  &check_serial_log,
+                  &check_unique,
+                  &check_duplicate_packets,
+                  &button_find,
+                  &label_found,
+                  &text_found_count,
                   &button_save_list,
                   &button_clear_list,
                   &button_switch,
@@ -509,6 +518,29 @@ BLERxView::BLERxView(NavigationView& nav)
         nav_.push<BleRecentEntryDetailView>(entry);
     };
 
+    ensure_directory(find_packet_path);
+    ensure_directory(log_packets_path);
+    ensure_directory(packet_save_path);
+
+    // ------------------------------------------------------------------------------
+    // Handle Check Boxes
+    // ------------------------------------------------------------------------------
+    logger = std::make_unique<BLELogger>();
+
+    check_name.on_select = [this](Checkbox&, bool v) {
+        name_enable = v;
+        // update the include_name instance variable value of each entry in recent entries
+        setAllMembersToValue(recent, &BleRecentEntry::include_name, v);
+        recent_entries_view.set_dirty();
+    };
+
+    check_log.on_select = [this](Checkbox&, bool v) {
+        logging = v;
+
+        if (logger && logging)
+            logger->append(bletx_dir.string() + "/Packets/BLETx_" + to_string_timestamp(rtc_time::now()) + ".TXT");
+    };
+
     check_serial_log.on_select = [this](Checkbox&, bool v) {
         serial_logging = v;
         if (v) {
@@ -517,12 +549,28 @@ BLERxView::BLERxView(NavigationView& nav)
             portapack::async_tx_enabled = false;
         }
     };
+
+    check_unique.on_select = [this](Checkbox&, bool v) {
+        uniqueParsing = v;
+        recent.clear();
+        recent_entries_view.set_dirty();
+    };
+
+    check_duplicate_packets.on_select = [this](Checkbox&, bool v) {
+        duplicatePackets = v;
+        recent.clear();
+        recent_entries_view.set_dirty();
+    };
+
+    check_name.set_value(name_enable);
+    check_log.set_value(logging);
     check_serial_log.set_value(serial_logging);
+    check_unique.set_value(uniqueParsing);
+    check_duplicate_packets.set_value(duplicatePackets);
 
-    ensure_directory(find_packet_path);
-    ensure_directory(log_packets_path);
-    ensure_directory(packet_save_path);
-
+    // ------------------------------------------------------------------------------
+    // Handle Buttons
+    // ------------------------------------------------------------------------------
     filterBuffer = filter;
 
     button_filter.on_select = [this](Button&) {
@@ -536,17 +584,6 @@ BLERxView::BLERxView(NavigationView& nav)
             });
     };
 
-    logger = std::make_unique<BLELogger>();
-
-    check_log.on_select = [this](Checkbox&, bool v) {
-        str_log = "";
-        logging = v;
-
-        if (logger && logging)
-            logger->append(blerx_dir.string() + "/Logs/BLELOG_" + to_string_timestamp(rtc_time::now()) + ".TXT");
-    };
-    check_log.set_value(logging);
-
     button_save_list.on_select = [this, &nav](const ui::Button&) {
         listFileBuffer = "";
         text_prompt(
@@ -561,23 +598,25 @@ BLERxView::BLERxView(NavigationView& nav)
 
     button_clear_list.on_select = [this](Button&) {
         recent.clear();
+        recent_entries_view.set_dirty();
     };
 
     button_switch.on_select = [&nav](Button&) {
         nav.replace<BLETxView>();
     };
 
-    field_frequency.set_step(0);
-
-    check_name.set_value(name_enable);
-
-    check_name.on_select = [this](Checkbox&, bool v) {
-        name_enable = v;
-        // update the include_name instance variable value of each entry in recent entries
-        setAllMembersToValue(recent, &BleRecentEntry::include_name, v);
-        recent_entries_view.set_dirty();
+    button_find.on_select = [this](Button&) {
+        auto open_view = nav_.push<FileLoadView>(".TXT");
+        open_view->on_changed = [this](std::filesystem::path new_file_path) {
+            on_file_changed(new_file_path);
+        };
     };
 
+    // ------------------------------------------------------------------------------
+    // Handle Options
+    // ------------------------------------------------------------------------------
+    field_frequency.set_step(0);
+
     options_channel.on_change = [this](size_t index, int32_t v) {
         channel_index = (uint8_t)index;
 
@@ -601,23 +640,16 @@ BLERxView::BLERxView(NavigationView& nav)
     };
 
     options_filter.on_change = [this](size_t index, int32_t v) {
+        (void)v;
         filter_index = (uint8_t)index;
-        handle_filter_options(v);
+        recent.clear();
+        recent_entries_view.set_dirty();
     };
 
     options_channel.set_selected_index(channel_index, true);
     options_sort.set_selected_index(sort_index, true);
     options_filter.set_selected_index(filter_index, true);
 
-    button_find.on_select = [this](Button&) {
-        auto open_view = nav_.push<FileLoadView>(".TXT");
-        open_view->on_changed = [this](std::filesystem::path new_file_path) {
-            on_file_changed(new_file_path);
-
-            // nav_.set_on_pop([this]() { button_play.focus(); });
-        };
-    };
-
     // Auto-configure modem for LCR RX (will be removed later)
     baseband::set_btlerx(channel_number);
 
@@ -775,77 +807,87 @@ bool BLERxView::saveFile(const std::filesystem::path& path) {
 }
 
 void BLERxView::on_data(BlePacketData* packet) {
-    if (!logging) {
-        str_log = "";
-    }
-
-    str_console += pdu_type_to_string((ADV_PDU_TYPE)packet->type);
-    str_console += " Len:";
-    str_console += to_string_dec_uint(packet->size);
-    str_console += " Mac:";
-    str_console += to_string_mac_address(packet->macAddress, 6, false);
-    str_console += " Data:";
-
-    int i;
-
-    for (i = 0; i < packet->dataLen; i++) {
-        str_console += to_string_hex(packet->data[i], 2);
-    }
-
-    uint64_t macAddressEncoded = copy_mac_address_to_uint64(packet->macAddress);
+    uint64_t uniqueKeyEncoded = copy_mac_address_to_uint64(packet->macAddress);
 
     // Start of Packet stuffing.
     // Masking off the top 2 bytes to avoid invalid keys.
-    auto& entry = ::on_packet(recent, macAddressEncoded & 0xFFFFFFFFFFFF);
-    updateEntry(packet, entry, (ADV_PDU_TYPE)packet->type);
 
-    // Add entries if they meet the criteria.
-    // auto value = filter;
-    // resetFilteredEntries(recent, [&value](const BleRecentEntry& entry) {
-    //     return (entry.dataString.find(value) == std::string::npos) && (entry.nameString.find(value) == std::string::npos);
-    // });
-    handle_filter_options(options_filter.selected_index());
+    uint64_t key = (uniqueKeyEncoded & 0xFFFFFFFFFFFF);
 
-    handle_entries_sort(options_sort.selected_index());
+    if (duplicatePackets) {
+        key |= ((uint64_t)packet->type) << 48;
+    }
+
+    // If found store into tempEntry to modify.
+    auto it = find(recent, key);
+    if (it != recent.end()) {
+        recent.push_front(*it);
+        recent.erase(it);
+    } else {
+        recent.emplace_front(key);
+        truncate_entries(recent);
+    }
+
+    if (updateEntry(packet, recent.front(), (ADV_PDU_TYPE)packet->type)) {
+        if (!searchList.empty()) {
+            auto it = searchList.begin();
+
+            while (it != searchList.end()) {
+                std::string searchStr = (std::string)*it;
+
+                if (recent.front().dataString.find(searchStr) != std::string::npos) {
+                    searchList.erase(it);
+                    found_count++;
+                    break;
+                }
+
+                it++;
+            }
+
+            text_found_count.set(to_string_dec_uint(found_count) + "/" + to_string_dec_uint(total_count));
+        }
+
+        // Packets were updated, resort the list.
+        handle_entries_sort(options_sort.selected_index());
+    } else {
+        recent.pop_front();
+    }
+
+    log_ble_packet(packet);
+}
+
+void BLERxView::log_ble_packet(BlePacketData* packet) {
+    if ((logger && logging) || serial_logging) {
+        str_console = "";
+        str_console += pdu_type_to_string((ADV_PDU_TYPE)packet->type);
+        str_console += " Len:";
+        str_console += to_string_dec_uint(packet->size);
+        str_console += " Mac:";
+        str_console += to_string_mac_address(packet->macAddress, 6, false);
+        str_console += " Data:";
+
+        int i;
+
+        for (i = 0; i < packet->dataLen; i++) {
+            str_console += to_string_hex(packet->data[i], 2);
+        }
+    }
 
     // Log at End of Packet.
     if (logger && logging) {
-        logger->log_raw_data(str_console + "\r\n");
+        logger->log_raw_data(str_console);
     }
 
     if (serial_logging) {
         UsbSerialAsyncmsg::asyncmsg(str_console);  // new line handled there, no need here.
     }
-    str_console = "";
-
-    if (!searchList.empty()) {
-        auto it = searchList.begin();
-
-        while (it != searchList.end()) {
-            std::string searchStr = (std::string)*it;
-
-            if (entry.dataString.find(searchStr) != std::string::npos) {
-                searchList.erase(it);
-                found_count++;
-                break;
-            }
-
-            it++;
-        }
-
-        text_found_count.set(to_string_dec_uint(found_count) + "/" + to_string_dec_uint(total_count));
-    }
 }
 
 void BLERxView::on_filter_change(std::string value) {
     // New filter? Reset list from recent entries.
     if (filter != value) {
-        // resetFilteredEntries(recent, [&value](const BleRecentEntry& entry) {
-        //     // return (entry.dataString.find(value) == std::string::npos) && (entry.nameString.find(value) == std::string::npos);
-        //     return (entry.dataString.find(value) == std::string::npos) && (entry.nameString.find(value) == std::string::npos) && (to_string_mac_address(entry.packetData.macAddress, 6, false).find(value) == std::string::npos);
-        // });
         filter = value;
-        handle_filter_options(options_filter.selected_index());
+        recent.clear();
     }
 }
 
@@ -897,13 +939,10 @@ void BLERxView::on_timer() {
         timer_count = 0;
 
         if (auto_channel) {
-            int min = 37;
-            int max = 39;
+            field_frequency.set_value(get_freq_by_channel_number(channel_number));
+            baseband::set_btlerx(channel_number);
 
-            int randomChannel = min + std::rand() % (max - min + 1);
-
-            field_frequency.set_value(get_freq_by_channel_number(randomChannel));
-            baseband::set_btlerx(randomChannel);
+            channel_number = (channel_number < 39) ? channel_number + 1 : 37;
         }
     }
     if (ble_rx_error != BLE_RX_NO_ERROR) {
@@ -924,7 +963,7 @@ void BLERxView::handle_entries_sort(uint8_t index) {
     switch (index) {
         case 0:
             sortEntriesBy(
-                recent, [](const BleRecentEntry& entry) { return entry.macAddress; }, true);
+                recent, [](const BleRecentEntry& entry) { return entry.uniqueKey & 0xFFFFFFFFFFFF; }, true);
             break;
         case 1:
             sortEntriesBy(
@@ -942,6 +981,10 @@ void BLERxView::handle_entries_sort(uint8_t index) {
             sortEntriesBy(
                 recent, [](const BleRecentEntry& entry) { return entry.nameString; }, true);
             break;
+        case 5:
+            sortEntriesBy(
+                recent, [](const BleRecentEntry& entry) { return entry.informationString; }, true);
+            break;
         default:
             break;
     }
@@ -949,21 +992,31 @@ void BLERxView::handle_entries_sort(uint8_t index) {
     recent_entries_view.set_dirty();
 }
 
-void BLERxView::handle_filter_options(uint8_t index) {
-    auto value = filter;
+bool BLERxView::handle_filter_options(uint8_t index, const BleRecentEntry& entry) {
+    const std::string& value = filter;  // no copy
+    if (value.empty()) return true;
+
     switch (index) {
-        case 0:  // filter by Data
-            resetFilteredEntries(recent, [&value](const BleRecentEntry& entry) {
-                return (entry.dataString.find(value) == std::string::npos) && (entry.nameString.find(value) == std::string::npos);
-            });
-            break;
-        case 1:  // filter by MAC address (All caps: e.g. AA:BB:CC:DD:EE:FF)
-            resetFilteredEntries(recent, [&value](const BleRecentEntry& entry) {
-                return (to_string_mac_address(entry.packetData.macAddress, 6, false).find(value) == std::string::npos);
-            });
-            break;
+        case 0:  // Data OR Name
+            return std::string_view(entry.dataString).find(value) != std::string_view::npos || std::string_view(entry.nameString).find(value) != std::string_view::npos;
+
+        case 1:  // MAC
+            return std::string_view(to_string_mac_address(entry.packetData.macAddress, 6, false)).find(value) != std::string_view::npos;
+
+        case 2:  // Name
+            return std::string_view(entry.nameString).find(value) != std::string_view::npos;
+
+        case 3:  // Info
+            return std::string_view(entry.informationString).find(value) != std::string_view::npos;
+
+        case 4:  // Vendor
+            return std::string_view(entry.vendor_name).find(value) != std::string_view::npos;
+
+        case 5:  // Channel (string once, not per call)
+            return std::string_view(to_string_dec_int(entry.channelNumber)).find(value) != std::string_view::npos;
+
         default:
-            break;
+            return true;
     }
 }
 
@@ -979,77 +1032,214 @@ BLERxView::~BLERxView() {
     baseband::shutdown();
 }
 
-void BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type) {
+bool BLERxView::updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type) {
     std::string data_string;
 
-    int i;
-
-    for (i = 0; i < packet->dataLen; i++) {
-        data_string += to_string_hex(packet->data[i], 2);
-    }
-
-    entry.dbValue = packet->max_dB;
-    entry.timestamp = to_string_timestamp(rtc_time::now());
-    entry.dataString = data_string;
-
-    entry.packetData.type = packet->type;
-    entry.packetData.size = packet->size;
-    entry.packetData.dataLen = packet->dataLen;
-
-    // Mac Address of sender.
-    entry.packetData.macAddress[0] = packet->macAddress[0];
-    entry.packetData.macAddress[1] = packet->macAddress[1];
-    entry.packetData.macAddress[2] = packet->macAddress[2];
-    entry.packetData.macAddress[3] = packet->macAddress[3];
-    entry.packetData.macAddress[4] = packet->macAddress[4];
-    entry.packetData.macAddress[5] = packet->macAddress[5];
-
-    entry.numHits++;
-    entry.pduType = pdu_type;
-    entry.channelNumber = channel_number;
-
-    if (entry.vendor_status == MAC_VENDOR_UNKNOWN) {
-        std::string vendor_name;
-        entry.vendor_status = lookup_mac_vendor_status(entry.packetData.macAddress, vendor_name);
-    }
-
-    // Parse Data Section into buffer to be interpretted later.
-    for (int i = 0; i < packet->dataLen; i++) {
-        entry.packetData.data[i] = packet->data[i];
-    }
-
-    entry.include_name = check_name.value();
+    bool success = false;
 
     // Only parse name for advertisment packets and empty name entries
-    if ((pdu_type == ADV_IND || pdu_type == ADV_NONCONN_IND || pdu_type == SCAN_RSP || pdu_type == ADV_SCAN_IND) && entry.nameString.empty()) {
-        ADV_PDU_PAYLOAD_TYPE_0_2_4_6* advertiseData = (ADV_PDU_PAYLOAD_TYPE_0_2_4_6*)entry.packetData.data;
+    if (pdu_type == ADV_IND || pdu_type == ADV_NONCONN_IND || pdu_type == SCAN_RSP || pdu_type == ADV_SCAN_IND) {
+        if (uniqueParsing) {
+            success = parse_tracking_beacon_data(packet->data, packet->dataLen, entry.nameString, entry.informationString);
+        }
 
-        uint8_t currentByte = 0;
-        uint8_t length = 0;
-        uint8_t type = 0;
-
-        std::string decoded_data;
-        for (currentByte = 0; (currentByte < entry.packetData.dataLen);) {
-            length = advertiseData->Data[currentByte++];
-            type = advertiseData->Data[currentByte++];
-
-            // Subtract 1 because type is part of the length.
-            for (int i = 0; i < length - 1; i++) {
-                // parse the name of bluetooth device: 0x08->Shortened Local Name; 0x09->Complete Local Name
-                if (type == 0x08 || type == 0x09) {
-                    decoded_data += (char)advertiseData->Data[currentByte];
-                }
-                currentByte++;
-            }
-            if (!decoded_data.empty()) {
-                entry.nameString = std::move(decoded_data);
-                break;
-            }
+        if (!success && !uniqueParsing) {
+            success = parse_beacon_data(packet->data, packet->dataLen, entry.nameString, entry.informationString);
         }
     } else if (pdu_type == ADV_DIRECT_IND || pdu_type == SCAN_REQ) {
-        ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)entry.packetData.data;
-        reverse_byte_array(directed_mac_data->A1, 6);
+        if (!uniqueParsing) {
+            ADV_PDU_PAYLOAD_TYPE_1_3* directed_mac_data = (ADV_PDU_PAYLOAD_TYPE_1_3*)packet->data;
+            reverse_byte_array(directed_mac_data->A1, 6);
+            success = true;
+        }
     }
+
+    if (success) {
+        int i;
+
+        for (i = 0; i < packet->dataLen; i++) {
+            data_string += to_string_hex(packet->data[i], 2);
+        }
+
+        entry.dbValue = packet->max_dB - (receiver_model.lna() + receiver_model.vga() + (receiver_model.rf_amp() ? 14 : 0));
+        entry.timestamp = to_string_timestamp(rtc_time::now());
+        entry.dataString = data_string;
+
+        entry.packetData.type = packet->type;
+        entry.packetData.size = packet->size;
+        entry.packetData.dataLen = packet->dataLen;
+
+        // Mac Address of sender.
+        entry.packetData.macAddress[0] = packet->macAddress[0];
+        entry.packetData.macAddress[1] = packet->macAddress[1];
+        entry.packetData.macAddress[2] = packet->macAddress[2];
+        entry.packetData.macAddress[3] = packet->macAddress[3];
+        entry.packetData.macAddress[4] = packet->macAddress[4];
+        entry.packetData.macAddress[5] = packet->macAddress[5];
+
+        entry.pduType = pdu_type;
+        entry.channelNumber = channel_number;
+        entry.numHits++;
+
+        if (entry.vendor_status == MAC_VENDOR_UNKNOWN) {
+            entry.vendor_status = lookup_mac_vendor_status(entry.packetData.macAddress, entry.vendor_name);
+        }
+
+        // Parse Data Section into buffer to be interpretted later.
+        for (int i = 0; i < packet->dataLen; i++) {
+            entry.packetData.data[i] = packet->data[i];
+        }
+
+        entry.include_name = check_name.value();
+    }
+
+    return handle_filter_options(options_filter.selected_index(), entry) && success;
+}
+
+bool BLERxView::parse_tracking_beacon_data(const uint8_t* data, uint8_t length, std::string& nameString, std::string& informationString) {
+    uint8_t currentByte, currentLength, currentType = 0;
+
+    for (currentByte = 0; currentByte < length;) {
+        currentLength = data[currentByte++];
+        currentType = data[currentByte++];
+
+        // Manufacturer Specific Data (0xFF)
+        if (currentType == 0xFF && currentLength >= 4) {
+            uint16_t companyID = data[currentByte] | (data[currentByte + 1] << 8);
+
+            // Apple AirTag / Find My
+            if (companyID == 0x004C && currentLength >= 6) {
+                uint8_t appleType = data[currentByte + 2];
+                uint8_t appleLen = data[currentByte + 3];
+                if (appleType == 0x12 && appleLen == 0x19 && currentLength >= 4 + appleLen) {
+                    nameString.assign("Apple AirTag");
+                    informationString.assign("Find My");
+                    return true;
+                } else if (appleType == 0x02 && appleLen == 0x15) {
+                    uint16_t major = (data[currentByte + 20] << 8) | data[currentByte + 21];
+                    uint16_t minor = (data[currentByte + 22] << 8) | data[currentByte + 23];
+
+                    nameString.assign("iBeacon");
+                    informationString.assign(to_string_hex(major) + to_string_hex(minor));
+                    return true;
+                }
+            }
+        }
+        // Services
+        else if ((currentType == 0x02 || currentType == 0x03) && currentLength >= 3) {
+            for (int u = 0; u < currentLength - 1; u += 2) {
+                uint16_t uuid16 = data[currentByte + u] | (data[currentByte + u + 1] << 8);
+                if (uuid16 == 0x1802) {  // Immediate Alert Service = Find Me Profile
+                    nameString.assign("FindMe");
+                    informationString.assign("IAS");
+                    return true;
+                }
+            }
+        }
+        // Service Data
+        else if (currentType == 0x16 && currentLength >= 3) {
+            uint16_t uuid16 = data[currentByte] | (data[currentByte + 1] << 8);
+
+            switch (uuid16) {
+                case 0xFD59: {  // Samsung SmartTag - Unregistered
+                    nameString.assign("Samsung SmartTag");
+                    informationString.assign("Unreg");
+                    return true;
+                }
+                case 0xFD5A: {  // Samsung SmartTag - Registered
+                    nameString.assign("Samsung SmartTag");
+                    informationString.assign("Reg");
+                    return true;
+                }
+                case 0xFD84: {
+                    if (currentByte + 2 < length) {
+                        uint8_t model = data[currentByte + 2];
+                        switch (model) {
+                            case 0x01:
+                                informationString.assign("Mate");
+                                break;
+                            case 0x02:
+                                informationString.assign("Pro");
+                                break;
+                            case 0x03:
+                                informationString.assign("Slim");
+                                break;
+                            case 0x04:
+                                informationString.assign("Sticker");
+                                break;
+                            default:
+                                informationString.assign("Unknown");
+                                break;
+                        }
+                    }
+                    nameString.assign("Tile");
+                    return true;
+                }
+                case 0xFEAA: {
+                    if (currentByte + 2 < length) {
+                        uint8_t frameType = data[currentByte + 2];
+                        switch (frameType) {
+                            case 0x00:
+                                informationString.assign("UID");
+                                break;
+                            case 0x10:
+                                informationString.assign("URL");
+                                break;
+                            case 0x20:
+                                informationString.assign("TLM");
+                                break;
+                            case 0x30:
+                                informationString.assign("EID");
+                                break;
+                            default:
+                                informationString.assign("Unknown");
+                                break;
+                        }
+                    }
+                    nameString.assign("Eddystone");
+                    return true;
+                }
+            }
+        }
+
+        currentByte += (currentLength - 1);
+    }
+
+    return false;
+}
+
+bool BLERxView::parse_beacon_data(const uint8_t* data, uint8_t length, std::string& nameString, std::string& informationString) {
+    uint8_t currentByte, currentLength, currentType = 0;
+    std::string tempName = "";
+
+    for (currentByte = 0; currentByte < length;) {
+        currentLength = data[currentByte++];
+        currentType = data[currentByte++];
+
+        // Subtract 1 because type is part of the length.
+        for (int i = 0; ((i < currentLength - 1) && (currentByte < length)); i++) {
+            // parse the name of bluetooth device: 0x08->Shortened Local Name; 0x09->Complete Local Name
+            if (currentType == 0x08 || currentType == 0x09) {
+                tempName += (char)data[currentByte];
+            }
+            currentByte++;
+        }
+
+        if (!tempName.empty()) {
+            nameString = tempName;
+            break;
+        }
+    }
+
+    informationString = "";
+
+    if (!informationString.empty()) {
+        // Option to change title of Hits Column.
+        // Setting to default for now.
+        columns.set(1, "Hits", 7);
+    }
+
+    return true;
 }
 
 } /* namespace ui */

firmware/application/apps/ble_rx_app.hpp

@@ -71,7 +71,8 @@ typedef enum {
     RESERVED5 = 12,
     RESERVED6 = 13,
     RESERVED7 = 14,
-    RESERVED8 = 15
+    RESERVED8 = 15,
+    UNKNOWN = 16
 } ADV_PDU_TYPE;
 
 typedef enum {
@@ -84,19 +85,21 @@ typedef enum {
 struct BleRecentEntry {
     using Key = uint64_t;
 
-    static constexpr Key invalid_key = 0xffffffff;
+    static constexpr Key invalid_key = 0xFFFFFFFFFFFFF;
 
-    uint64_t macAddress;
+    uint64_t uniqueKey;
     int dbValue;
     BlePacketData packetData;
     std::string timestamp;
     std::string dataString;
     std::string nameString;
+    std::string informationString;
     bool include_name;
     uint16_t numHits;
     ADV_PDU_TYPE pduType;
     uint8_t channelNumber;
     MAC_VENDOR_STATUS vendor_status;
+    std::string vendor_name;
     bool entryFound;
 
     BleRecentEntry()
@@ -104,23 +107,25 @@ struct BleRecentEntry {
     }
 
     BleRecentEntry(
-        const uint64_t macAddress)
-        : macAddress{macAddress},
+        const uint64_t uniqueKey)
+        : uniqueKey{uniqueKey},
           dbValue{},
           packetData{},
           timestamp{},
           dataString{},
           nameString{},
+          informationString{},
           include_name{},
           numHits{},
           pduType{},
           channelNumber{},
           vendor_status{MAC_VENDOR_UNKNOWN},
+          vendor_name{},
           entryFound{} {
     }
 
     Key key() const {
-        return macAddress;
+        return uniqueKey;
     }
 };
 
@@ -137,11 +142,11 @@ class BleRecentEntryDetailView : public View {
     void update_data();
     void focus() override;
     void paint(Painter&) override;
+    static BLETxPacket build_packet(BleRecentEntry entry_);
 
    private:
     NavigationView& nav_;
     BleRecentEntry entry_{};
-    BLETxPacket build_packet();
     void on_save_file(const std::string value, BLETxPacket packetToSave);
     bool saveFile(const std::filesystem::path& path, BLETxPacket packetToSave);
     std::string packetFileBuffer{};
@@ -216,15 +221,19 @@ class BLERxView : public View {
     bool saveFile(const std::filesystem::path& path);
     std::unique_ptr<UsbSerialThread> usb_serial_thread{};
     void on_data(BlePacketData* packetData);
+    void log_ble_packet(BlePacketData* packet);
     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 handle_filter_options(uint8_t index);
-    void updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type);
+    bool handle_filter_options(uint8_t index, const BleRecentEntry& entry);
+    bool updateEntry(const BlePacketData* packet, BleRecentEntry& entry, ADV_PDU_TYPE pdu_type);
+    bool parse_beacon_data(const uint8_t* data, uint8_t length, std::string& nameString, std::string& informationString);
+    bool parse_tracking_beacon_data(const uint8_t* data, uint8_t length, std::string& nameString, std::string& informationString);
 
     NavigationView& nav_;
+
     RxRadioState radio_state_{
         2402000000 /* frequency */,
         4000000 /* bandwidth */,
@@ -234,6 +243,8 @@ class BLERxView : public View {
     uint8_t channel_index{0};
     uint8_t sort_index{0};
     uint8_t filter_index{0};
+    bool uniqueParsing = false;
+    bool duplicatePackets = false;
     std::string filter{};
     bool logging{false};
     bool serial_logging{false};
@@ -252,6 +263,8 @@ class BLERxView : public View {
             // disabled to always start without USB serial activated until we can make it non blocking if not connected
             // {"serial_log"sv, &serial_logging},
             {"name"sv, &name_enable},
+            {"unique_parsing"sv, &uniqueParsing},
+            {"duplicate_packets"sv, &duplicatePackets},
         }};
 
     std::string str_console = "";
@@ -261,7 +274,7 @@ class BLERxView : public View {
     bool auto_channel = false;
 
     int16_t timer_count{0};
-    int16_t timer_period{6};  // 100ms
+    int16_t timer_period{1};  // 25ms
 
     std::string filterBuffer{};
     std::string listFileBuffer{};
@@ -277,7 +290,7 @@ class BLERxView : public View {
     std::filesystem::path log_packets_path{blerx_dir / u"Logs/????.TXT"};
     std::filesystem::path packet_save_path{blerx_dir / u"Lists/????.csv"};
 
-    static constexpr auto header_height = 9 * 8;
+    static constexpr auto header_height = 12 * 8;
     static constexpr auto switch_button_height = 3 * 16;
 
     OptionsField options_channel{
@@ -317,7 +330,8 @@ class BLERxView : public View {
          {"Hits", 1},
          {"dB", 2},
          {"Time", 3},
-         {"Name", 4}}};
+         {"Name", 4},
+         {"Info", 5}}};
 
     Button button_filter{
         {11 * 8, 2 * 8, 7 * 8, 16},
@@ -325,9 +339,13 @@ class BLERxView : public View {
 
     OptionsField options_filter{
         {18 * 8 + 2, 2 * 8},
-        4,
+        7,
         {{"Data", 0},
-         {"MAC", 1}}};
+         {"MAC", 1},
+         {"Name", 2},
+         {"Info", 3},
+         {"Vendor", 4},
+         {"Channel", 5}}};
 
     Checkbox check_log{
         {10 * 8, 4 * 8 + 2},
@@ -341,36 +359,45 @@ class BLERxView : public View {
         "Name",
         true};
 
-    Button button_find{
-        {0 * 8, 7 * 8 - 2, 4 * 8, 16},
-        "Find"};
-
-    Labels label_found{
-        {{5 * 8, 7 * 8 - 2}, "Found:", Theme::getInstance()->fg_light->foreground}};
-
-    Text text_found_count{
-        {11 * 8, 7 * 8 - 2, 20 * 8, 16},
-        "0/0"};
-
     Checkbox check_serial_log{
         {18 * 8 + 2, 4 * 8 + 2},
         7,
         "USB Log",
         true};
 
-    // Console console{
-    //     {0, 10 * 8, screen_height, screen_height-80}};
+    Checkbox check_unique{
+        {0 * 8 + 2, 7 * 8 + 2},
+        7,
+        "Unique",
+        true};
+
+    Checkbox check_duplicate_packets{
+        {10 * 8 + 2, 7 * 8 + 2},
+        7,
+        "Duplicate",
+        true};
+
+    Button button_find{
+        {0 * 8, 10 * 8 - 2, 4 * 8, 16},
+        "Find"};
+
+    Labels label_found{
+        {{5 * 8, 10 * 8 - 2}, "Found:", Theme::getInstance()->fg_light->foreground}};
+
+    Text text_found_count{
+        {11 * 8, 10 * 8 - 2, 20 * 8, 16},
+        "0/0"};
 
     Button button_clear_list{
-        {2 * 8, screen_height - (16 + 32), 7 * 8, 32},
+        {2 * 8, 320 - (16 + 32), 7 * 8, 32},
         "Clear"};
 
     Button button_save_list{
-        {11 * 8, screen_height - (16 + 32), 11 * 8, 32},
+        {11 * 8, 320 - (16 + 32), 11 * 8, 32},
         "Export CSV"};
 
     Button button_switch{
-        {screen_width - 6 * 8, screen_height - (16 + 32), 4 * 8, 32},
+        {240 - 6 * 8, 320 - (16 + 32), 4 * 8, 32},
         "Tx"};
 
     std::string str_log{""};
@@ -379,10 +406,10 @@ class BLERxView : public View {
     BleRecentEntries recent{};
     BleRecentEntries tempList{};
 
-    const RecentEntriesColumns columns{{
-        {"Mac Address", 17},
+    RecentEntriesColumns columns{{
+        {"Name", 17},
         {"Hits", 7},
-        {"dB", 4},
+        {"dBm", 4},
     }};
 
     BleRecentEntriesView recent_entries_view{columns, recent};

firmware/application/apps/ble_tx_app.cpp

@@ -35,6 +35,7 @@
 #include "rtc_time.hpp"
 #include "string_format.hpp"
 #include "file_path.hpp"
+#include "usb_serial_asyncmsg.hpp"
 
 using namespace portapack;
 using namespace modems;
@@ -123,6 +124,31 @@ static std::uint64_t get_freq_by_channel_number(uint8_t channel_number) {
 
 namespace ui {
 
+PKT_TYPE get_pkt_type_from_string(const std::string& type_str) {
+    if (type_str == "RAW") {
+        return PKT_TYPE_RAW;
+    } else if (type_str == "DISCOVERY") {
+        return PKT_TYPE_DISCOVERY;
+    } else if (type_str == "IBEACON") {
+        return PKT_TYPE_IBEACON;
+    } else if (type_str == "ADV_IND") {
+        return PKT_TYPE_ADV_IND;
+    } else if (type_str == "ADV_DIRECT_IND") {
+        return PKT_TYPE_ADV_DIRECT_IND;
+    } else if (type_str == "ADV_NONCONN_IND") {
+        return PKT_TYPE_ADV_NONCONN_IND;
+    } else if (type_str == "ADV_SCAN_IND") {
+        return PKT_TYPE_ADV_SCAN_IND;
+    } else if (type_str == "SCAN_REQ") {
+        return PKT_TYPE_SCAN_REQ;
+    } else if (type_str == "SCAN_RSP") {
+        return PKT_TYPE_SCAN_RSP;
+    } else if (type_str == "CONNECT_REQ") {
+        return PKT_TYPE_CONNECT_REQ;
+    }
+    return PKT_TYPE_INVALID_TYPE;
+}
+
 void BLETxView::focus() {
     button_open.focus();
 }
@@ -167,28 +193,11 @@ void BLETxView::toggle() {
     }
 }
 
-void BLETxView::start() {
-    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
-    transmitter_model.enable();
-
+void BLETxView::send_packet() {
     // Generate new random Mac Address.
+    transmitter_model.enable();
     generateRandomMacAddress(randomMac);
 
-    // If this is our first run, check file.
-    if (!is_active()) {
-        File data_file;
-
-        auto error = data_file.open(file_path);
-        if (error && !file_override) {
-            file_error();
-            check_loop.set_value(false);
-            return;
-        }
-
-        button_play.set_bitmap(&bitmap_stop);
-        is_running = true;
-    }
-
     char advertisementData[63] = {0};
     strcpy(advertisementData, packets[current_packet].advertisementData);
 
@@ -235,9 +244,28 @@ void BLETxView::start() {
         }
     }
 
-    // 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);
+    progressbar.set_value(packets[current_packet].packet_count - packet_counter);
+    text_packets_sent.set(to_string_dec_uint(packet_counter));
+
+    baseband::set_btletx(channel_number, random_mac ? randomMac : packets[current_packet].macAddress, advertisementData, packets[current_packet].pduType);
+
+    packetDone = false;
+}
+
+void BLETxView::start() {
+    if (file_path.empty()) {
+        file_error();
+        check_loop.set_value(false);
+        return;
+    }
+
+    baseband::run_image(portapack::spi_flash::image_tag_btle_tx);
+    transmitter_model.enable();
+
+    button_play.set_bitmap(&bitmap_stop);
+    is_running = true;
+
+    send_packet();
 }
 
 void BLETxView::stop() {
@@ -253,73 +281,77 @@ void BLETxView::stop() {
     is_running = false;
 }
 
-void BLETxView::reset() {
-    transmitter_model.disable();
-    baseband::shutdown();
-
-    start();
-}
-
 // called each 1/60th of second, so 6 = 100ms
 void BLETxView::on_timer() {
     if (++timer_count == timer_period) {
         timer_count = 0;
 
-        if (is_active()) {
-            // Reached end of current packet repeats.
-            if (packet_counter == 0) {
-                // Done sending all packets.
-                if (current_packet == (num_packets - 1)) {
-                    current_packet = 0;
-
-                    // If looping, restart from beginning.
-                    if (check_loop.value()) {
-                        update_current_packet(packets[current_packet], current_packet);
-                        reset();
-                    } else {
-                        stop();
-                    }
-                } else {
-                    current_packet++;
-                    update_current_packet(packets[current_packet], current_packet);
-                    reset();
-                }
-            } else {
-                reset();
-            }
-        }
-    }
-
-    if (++auto_channel_counter == auto_channel_period) {
-        auto_channel_counter = 0;
-
-        if (auto_channel) {
-            int min = 37;
-            int max = 39;
-
-            channel_number = min + std::rand() % (max - min + 1);
-
-            field_frequency.set_value(get_freq_by_channel_number(channel_number));
+        if (is_active() && packetDone) {
+            send_packet();
         }
     }
 }
 
-void BLETxView::on_tx_progress(const bool done) {
+void BLETxView::on_tx_progress(const bool done, uint32_t progress) {
+    // TODO: make use of progress variable
+    (void)progress;
     if (done) {
         if (is_active()) {
-            if ((packet_counter % 10) == 0) {
-                text_packets_sent.set(to_string_dec_uint(packet_counter));
-            }
+            transmitter_model.disable();
+            if (auto_channel) {
+                switch (advCount) {
+                    case 0:
+                        channel_number = 37;
+                        break;
+                    case 1:
+                        channel_number = 38;
+                        break;
+                    case 2:
+                        channel_number = 39;
+                        break;
+                }
 
-            packet_counter--;
-            progressbar.set_value(packets[current_packet].packet_count - packet_counter);
+                field_frequency.set_value(get_freq_by_channel_number(channel_number));
+
+                if (advCount == 3) {
+                    channel_number = 37;
+                    packet_counter--;
+                    packetDone = true;
+                    advCount = 0;
+                } else {
+                    send_packet();
+                    advCount++;
+                }
+            } else {
+                packet_counter--;
+                packetDone = true;
+            }
+        }
+
+        // Reached end of current packet repeats.
+        if (packet_counter == 0) {
+            // Done sending all packets.
+            if (current_packet == (num_packets - 1)) {
+                current_packet = 0;
+
+                // If looping, restart from beginning.
+                if (check_loop.value()) {
+                    update_current_packet(packets[current_packet], current_packet);
+                } else {
+                    stop();
+                }
+            } else {
+                current_packet++;
+                update_current_packet(packets[current_packet], current_packet);
+            }
         }
     }
 }
 
 BLETxView::BLETxView(NavigationView& nav)
     : nav_{nav} {
-    add_children({&button_open,
+    add_children({&dataEditView,
+                  &button_open,
                   &text_filename,
                   &progressbar,
                   &check_rand_mac,
@@ -330,7 +362,6 @@ BLETxView::BLETxView(NavigationView& nav)
                   &label_speed,
                   &options_speed,
                   &options_channel,
-                  &options_adv_type,
                   &label_marked_data,
                   &marked_data_sequence,
                   &label_packet_index,
@@ -340,7 +371,6 @@ BLETxView::BLETxView(NavigationView& nav)
                   &label_mac_address,
                   &text_mac_address,
                   &label_data_packet,
-                  &dataEditView,
                   &button_clear_marked,
                   &button_save_packet,
                   &button_switch});
@@ -371,13 +401,8 @@ BLETxView::BLETxView(NavigationView& nav)
         timer_count = 0;
     };
 
-    options_adv_type.on_change = [this](size_t, int32_t i) {
-        pduType = (PKT_TYPE)i;
-    };
-
     options_speed.set_selected_index(0);
-    options_channel.set_selected_index(0);
-    options_adv_type.set_selected_index(0);
+    options_channel.set_selected_index(3);
 
     check_rand_mac.set_value(false);
     check_rand_mac.on_select = [this](Checkbox&, bool v) {
@@ -430,6 +455,23 @@ BLETxView::BLETxView(NavigationView& nav)
         }
     };
 
+    dataEditView.on_change = [this](uint8_t value) {
+        // Reject setting newline at index 29.
+        if (cursor_pos.col != 29) {
+            uint16_t dataBytePos = (cursor_pos.line * 29) + cursor_pos.col;
+
+            packets[current_packet].advertisementData[dataBytePos] = uint_to_char(value, 16);
+
+            update_current_packet(packets[current_packet], current_packet);
+        }
+    };
+
+    dataEditView.on_cursor_moved = [this]() {
+        // Save last selected cursor.
+        cursor_pos.line = dataEditView.line();
+        cursor_pos.col = dataEditView.col();
+    };
+
     button_clear_marked.on_select = [this](Button&) {
         marked_counter = 0;
         markedBytes.clear();
@@ -465,17 +507,25 @@ void BLETxView::on_file_changed(const fs::path& new_file_path) {
         do {
             readUntil(data_file, packets[num_packets].macAddress, mac_address_size_str, ' ');
             readUntil(data_file, packets[num_packets].advertisementData, max_packet_size_str, ' ');
+            readUntil(data_file, packets[num_packets].packetType, max_packet_type_str, ' ');
             readUntil(data_file, packets[num_packets].packetCount, max_packet_repeat_str, '\n');
 
             uint64_t macAddressSize = strlen(packets[num_packets].macAddress);
             uint64_t advertisementDataSize = strlen(packets[num_packets].advertisementData);
             uint64_t packetCountSize = strlen(packets[num_packets].packetCount);
+            uint64_t packetTypeSize = strlen(packets[num_packets].packetType);
 
             packets[num_packets].packet_count = stringToUint32(packets[num_packets].packetCount);
+            packets[num_packets].pduType = (PKT_TYPE)get_pkt_type_from_string(packets[num_packets].packetType);
 
             // Verify Data.
-            if ((macAddressSize == mac_address_size_str) && (advertisementDataSize < max_packet_size_str) && (packetCountSize < max_packet_repeat_str) &&
-                hasValidHexPairs(packets[num_packets].macAddress, macAddressSize / 2) && hasValidHexPairs(packets[num_packets].advertisementData, advertisementDataSize / 2) && (packets[num_packets].packet_count >= 1) && (packets[num_packets].packet_count < max_packet_repeat_count)) {
+            if ((macAddressSize == mac_address_size_str) &&
+                (advertisementDataSize < max_packet_size_str) &&
+                (packetCountSize < max_packet_repeat_str) &&
+                hasValidHexPairs(packets[num_packets].macAddress, macAddressSize / 2) &&
+                hasValidHexPairs(packets[num_packets].advertisementData, advertisementDataSize / 2) &&
+                (packets[num_packets].packet_count >= 1) && (packets[num_packets].packet_count < max_packet_repeat_count) &&
+                (packetTypeSize <= max_packet_type_str)) {
                 text_filename.set(truncate(file_path.filename().string(), 12));
 
             } else {
@@ -493,6 +543,8 @@ void BLETxView::on_file_changed(const fs::path& new_file_path) {
         } while (num_packets < max_num_packets);
 
         update_current_packet(packets[0], 0);
+
+        data_file.close();
     }
 }
 
@@ -523,6 +575,8 @@ void BLETxView::update_current_packet(BLETxPacket packet, uint32_t currentIndex)
 
     text_mac_address.set(formattedMacAddress);
 
+    progressbar.set_max(packet.packet_count);
+
     packet_counter = packet.packet_count;
     current_packet = currentIndex;
 
@@ -531,10 +585,9 @@ void BLETxView::update_current_packet(BLETxPacket packet, uint32_t currentIndex)
     for (const std::string& str : strings) {
         dataFile.write(str.c_str(), str.size());
         dataFile.write("\n", 1);
-        ;
     }
 
-    dataFile.~File();
+    dataFile.close();
 
     auto result = FileWrapper::open(dataTempFilePath);
 
@@ -546,6 +599,7 @@ void BLETxView::update_current_packet(BLETxPacket packet, uint32_t currentIndex)
     dataEditView.set_font_zoom(true);
     dataEditView.set_file(*dataFileWrapper);
     dataEditView.redraw(true, true);
+    dataEditView.cursor_set(cursor_pos.line, cursor_pos.col);
 }
 
 void BLETxView::set_parent_rect(const Rect new_parent_rect) {

firmware/application/apps/ble_tx_app.hpp

@@ -38,6 +38,8 @@
 #include "utility.hpp"
 #include "file_path.hpp"
 
+#include "ble_tx_app.hpp"
+
 #include "recent_entries.hpp"
 
 #include <string>
@@ -91,8 +93,9 @@ struct BLETxPacket {
     char macAddress[13];
     char advertisementData[63];
     char packetCount[11];
+    char packetType[17];
     uint32_t packet_count;
-    PKT_TYPE packetType;
+    PKT_TYPE pduType;
 };
 
 class BLETxView : public View {
@@ -109,8 +112,8 @@ class BLETxView : public View {
     bool is_active() const;
     void toggle();
     void start();
+    void send_packet();
     void stop();
-    void reset();
     void handle_replay_thread_done(const uint32_t return_code);
     void file_error();
     bool saveFile(const std::filesystem::path& path);
@@ -122,7 +125,7 @@ class BLETxView : public View {
     void on_data(uint32_t value, bool is_data);
     void on_file_changed(const std::filesystem::path& new_file_path);
     void on_save_file(const std::string value);
-    void on_tx_progress(const bool done);
+    void on_tx_progress(const bool done, uint32_t progress);
     void on_random_data_change(std::string value);
     void update_current_packet(BLETxPacket packet, uint32_t currentIndex);
 
@@ -156,6 +159,8 @@ class BLETxView : public View {
     uint32_t packet_counter{0};
     uint32_t num_packets{0};
     uint32_t current_packet{0};
+    uint8_t packetTxCount{0};
+    bool packetDone = false;
     bool random_mac = false;
     bool file_override = false;
 
@@ -170,17 +175,17 @@ class BLETxView : public View {
     std::vector<uint16_t> markedBytes{};
     CursorPos cursor_pos{};
     uint8_t marked_counter = 0;
+    uint8_t advCount = 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 uint8_t max_packet_type_str{16};
     static constexpr uint32_t max_packet_repeat_count{UINT32_MAX};
     static constexpr uint32_t max_num_packets{32};
 
     BLETxPacket packets[max_num_packets];
 
-    PKT_TYPE pduType = {PKT_TYPE_DISCOVERY};
-
     static constexpr auto header_height = 10 * 16;
     static constexpr auto switch_button_height = 6 * 16;
 
@@ -216,7 +221,7 @@ class BLETxView : public View {
         true};
 
     ImageButton button_play{
-        {screen_width - 2 * 8, 2 * 16, 2 * 8, 1 * 16},
+        {28 * 8, 2 * 16, 2 * 8, 1 * 16},
         &bitmap_play,
         Theme::getInstance()->fg_green->foreground,
         Theme::getInstance()->fg_green->background};
@@ -227,11 +232,11 @@ class BLETxView : public View {
     OptionsField options_speed{
         {7 * 8, 6 * 8},
         3,
-        {{"1 ", 1},     // 16ms
-         {"2 ", 2},     // 32ms
-         {"3 ", 3},     // 48ms
-         {"4 ", 6},     // 100ms
-         {"5 ", 12}}};  // 200ms
+        {{"1 ", 2},     // 25ms
+         {"2 ", 4},     // 50ms
+         {"3 ", 6},     // 75ms
+         {"4 ", 8},     // 100ms
+         {"5 ", 12}}};  // 150ms
 
     OptionsField options_channel{
         {11 * 8, 6 * 8},
@@ -287,11 +292,8 @@ class BLETxView : public View {
     Labels label_data_packet{
         {{0 * 8, 9 * 16}, "Packet Data:", Theme::getInstance()->fg_light->foreground}};
 
-    Console console{
-        {0, 9 * 18, screen_width, screen_height - 80}};
-
     TextViewer dataEditView{
-        {0, 9 * 18, screen_width, screen_height - 80}};
+        {0, 9 * 18, 240, 240}};
 
     Button button_clear_marked{
         {1 * 8, 14 * 16, 13 * 8, 3 * 8},
@@ -323,7 +325,7 @@ class BLETxView : public View {
         Message::ID::TXProgress,
         [this](const Message* const p) {
             const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
-            this->on_tx_progress(message.done);
+            this->on_tx_progress(message.done, message.progress);
         }};
 
     MessageHandlerRegistration message_handler_frame_sync{

firmware/application/apps/ui_adsb_rx.cpp

@@ -635,14 +635,14 @@ void ADSBRxView::refresh_ui() {
 
         if (details_view->map_active()) {
             // Is it time to clear and refresh the map's markers?
-            if (ticks_since_marker_refresh >= MARKER_UPDATE_SECONDS) {
+            if (ticks_since_marker_refresh >= (details_view->get_map_type() == MAP_TYPE_OSM ? MARKER_UPDATE_SECONDS_OSM : MARKER_UPDATE_SECONDS_BIN)) {
                 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;
+            ticks_since_marker_refresh = MARKER_UPDATE_SECONDS_OSM;  // this is the bigger, so set it to force
         }
 
         // Process the entries list.

firmware/application/apps/ui_adsb_rx.hpp

@@ -64,8 +64,9 @@ 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 MARKER_UPDATE_SECONDS 5  // "other" map marker redraw interval
+#define O_E_FRAME_TIMEOUT 20          // timeout between odd and even frames
+#define MARKER_UPDATE_SECONDS_OSM 10  // "other" map marker redraw interval for osm
+#define MARKER_UPDATE_SECONDS_BIN 5   // "other" map marker redraw interval for bin map
 
 /* Thresholds (in seconds) that define the transition between ages. */
 struct ADSBAgeLimit {
@@ -277,6 +278,13 @@ class ADSBRxDetailsView : public View {
 
     std::string title() const override { return "Details"; }
 
+    MapType get_map_type() {
+        if (geomap_view_)
+            return geomap_view_->get_map_type();
+        else
+            return MapType::MAP_TYPE_BIN;  // default
+    }
+
    private:
     void refresh_ui();
     void on_gps(const GPSPosDataMessage* msg);
@@ -388,7 +396,7 @@ class ADSBRxView : public View {
 
     SignalToken signal_token_tick_second{};
     uint8_t tick_count = 0;
-    uint16_t ticks_since_marker_refresh{MARKER_UPDATE_SECONDS};
+    uint16_t ticks_since_marker_refresh{MARKER_UPDATE_SECONDS_OSM};
 
     /* Max number of entries that can be updated in a single pass.
      * 16 is one screen of recent entries. */

firmware/application/apps/ui_aprs_rx.cpp

@@ -247,8 +247,8 @@ APRSTableView::APRSTableView(NavigationView& nav, Rect parent_rec)
 
     details_view.hidden(true);
 
-    recent_entries_view.set_parent_rect({0, 0, screen_width, screen_width - 40});
-    details_view.set_parent_rect({0, 0, screen_width, screen_width - 40});
+    recent_entries_view.set_parent_rect({0, 0, screen_width, screen_height - 40});
+    details_view.set_parent_rect({0, 0, screen_width, screen_height - 40});
 
     recent_entries_view.on_select = [this](const APRSRecentEntry& entry) {
         this->on_show_detail(entry);

firmware/application/apps/ui_fileman.cpp

@@ -228,6 +228,8 @@ void FileManBaseView::load_directory_contents(const fs::path& dir_path) {
 
     text_current.set(dir_path.empty() ? "(sd root)" : truncate(dir_path, 24));
 
+    // Collect all entries first
+    std::list<fileman_entry> all_entries;
     for (const auto& entry : fs::directory_iterator(dir_path, u"*")) {
         // Hide files starting with '.' (hidden / tmp).
         if (!show_hidden_files && is_hidden_file(entry.path()))
@@ -235,36 +237,40 @@ void FileManBaseView::load_directory_contents(const fs::path& dir_path) {
 
         if (fs::is_regular_file(entry.status())) {
             if (!filtering || path_iequal(entry.path().extension(), extension_filter) || (cxx_file && is_cxx_capture_file(entry.path())))
-                insert_sorted(entry_list, {entry.path().string(), (uint32_t)entry.size(), false});
+                insert_sorted(all_entries, {entry.path().string(), (uint32_t)entry.size(), false});
         } else if (fs::is_directory(entry.status())) {
-            insert_sorted(entry_list, {entry.path().string(), 0, true});
+            insert_sorted(all_entries, {entry.path().string(), 0, true});
         }
     }
 
-    // paginating
-    auto list_size = entry_list.size();
-    nb_pages = 1 + (list_size / items_per_page);
-    size_t start = pagination * items_per_page;
-    size_t stop = start + items_per_page;
-    if (list_size > start) {
-        if (list_size < stop)
-            stop = list_size;
-        entry_list.erase(std::next(entry_list.begin(), stop), entry_list.end());
-        entry_list.erase(entry_list.begin(), std::next(entry_list.begin(), start));
+    // Calculate pagination
+    nb_pages = (all_entries.size() + items_per_page - 1) / items_per_page;
+    if (nb_pages == 0) nb_pages = 1;
+
+    size_t start_idx = pagination * items_per_page;
+    size_t end_idx = std::min(start_idx + items_per_page, all_entries.size());
+
+    // Add "parent" directory if not at the root and on first page
+    if (!dir_path.empty() && pagination == 0) {
+        entry_list.push_back({parent_dir_path.string(), 0, true});
     }
 
-    // Add "parent" directory if not at the root.
-    if (!dir_path.empty() && pagination == 0)
-        entry_list.insert(entry_list.begin(), {parent_dir_path.string(), 0, true});
-
-    // add next page
-    if (list_size > start + items_per_page) {
-        entry_list.push_back({str_next, (uint32_t)pagination + 1, true});
-    }
-
-    // add prev page
+    // Add prev page navigation if not on first page
     if (pagination > 0) {
-        entry_list.insert(entry_list.begin(), {str_back, (uint32_t)pagination - 1, true});
+        entry_list.push_back({str_back, (uint32_t)pagination - 1, true});
+    }
+
+    // Add entries for current page
+    auto it = all_entries.begin();
+    std::advance(it, start_idx);
+
+    for (size_t i = start_idx; i < end_idx && it != all_entries.end(); i++, ++it) {
+        entry_list.push_back(*it);
+    }
+
+    // Add next page navigation if not on last page
+    if (end_idx < all_entries.size()) {
+        entry_list.push_back({str_next, (uint32_t)pagination + 1, true});
     }
 }
 
@@ -320,30 +326,49 @@ void FileManBaseView::focus() {
     } else {
         menu_view.focus();
     }
+
+    // Set menu to the correct page and select the correct item
+    menu_view.set_highlighted(prev_highlight % items_per_page);
 }
 
+// Push directory - store the global index (page * items_per_page + local_index)
 void FileManBaseView::push_dir(const fs::path& path) {
     if (path == parent_dir_path) {
         pop_dir();
     } else {
+        // Save global index (combines page number and item position)
+        saved_index_stack.push_back(menu_view.highlighted_index() + (pagination * items_per_page));
+
         current_path /= path;
-        saved_index_stack.push_back(menu_view.highlighted_index());
-        menu_view.set_highlighted(0);
-        reload_current(true);
+        reload_current(true);  // Reset pagination when entering new directory
     }
 }
 
 void FileManBaseView::pop_dir() {
-    if (saved_index_stack.empty())
+    if (current_path.empty()) {
         return;
+    }
 
+    // Move to parent directory
     current_path = current_path.parent_path();
-    reload_current(true);
-    menu_view.set_highlighted(saved_index_stack.back());
-    saved_index_stack.pop_back();
+
+    // Restore the previous global index if available
+    if (!saved_index_stack.empty()) {
+        uint32_t global_index = saved_index_stack.back();
+        saved_index_stack.pop_back();
+
+        // Calculate pagination from global index
+        pagination = global_index / items_per_page;
+
+        // Calculate local index within the page
+        prev_highlight = global_index % items_per_page;
+        restoring_navigation = true;
+    }
+
+    reload_current(false);  // Important: don't reset pagination
 }
 
-std::string get_extension(std::string t) {
+std::string FileManBaseView::get_extension(const std::string& t) const {
     const auto index = t.find_last_of(u'.');
     if (index == t.npos) {
         return {};
@@ -372,7 +397,9 @@ void FileManBaseView::refresh_list() {
     if (on_refresh_widgets)
         on_refresh_widgets(false);
 
-    prev_highlight = menu_view.highlighted_index();
+    if (!restoring_navigation) {
+        prev_highlight = menu_view.highlighted_index();
+    }
     menu_view.clear();
 
     for (const auto& entry : entry_list) {
@@ -411,10 +438,14 @@ void FileManBaseView::refresh_list() {
     }
 
     menu_view.set_highlighted(prev_highlight);
+    restoring_navigation = false;
 }
 
 void FileManBaseView::reload_current(bool reset_pagination) {
-    if (reset_pagination) pagination = 0;
+    // Only reset pagination if explicitly requested
+    if (reset_pagination) {
+        pagination = 0;
+    }
     load_directory_contents(current_path);
     refresh_list();
 }
@@ -489,63 +520,6 @@ void FileLoadView::refresh_widgets(const bool) {
     set_dirty();
 }
 
-/* FileSaveView **************************************************************/
-/*
-FileSaveView::FileSaveView(
-        NavigationView& nav,
-        const fs::path& path,
-        const fs::path& file
-) : nav_{ nav },
-        path_{ path },
-        file_{ file }
-{
-        add_children({
-                &text_path,
-                &button_edit_path,
-                &text_name,
-                &button_edit_name,
-                &button_save,
-                &button_cancel,
-        });
-
-        button_edit_path.on_select = [this](Button&) {
-                buffer_ = path_.string();
-                text_prompt(nav_, buffer_, max_filename_length,ENTER_KEYBOARD_MODE_ALPHA,
-                        [this](std::string&) {
-                                path_ = buffer_;
-                                refresh_widgets();
-                        });
-        };
-
-        button_edit_name.on_select = [this](Button&) {
-                buffer_ = file_.string();
-                text_prompt(nav_, buffer_, max_filename_length,ENTER_KEYBOARD_MODE_ALPHA,
-                        [this](std::string&) {
-                                file_ = buffer_;
-                                refresh_widgets();
-                        });
-        };
-
-        button_save.on_select = [this](Button&) {
-                if (on_save)
-                        on_save(path_ / file_);
-                else
-                        nav_.pop();
-        };
-
-        button_cancel.on_select = [this](Button&) {
-                nav_.pop();
-        };
-
-        refresh_widgets();
-}
-
-void FileSaveView::refresh_widgets() {
-        text_path.set(truncate(path_, 30));
-        text_name.set(truncate(file_, 30));
-        set_dirty();
-}
-*/
 /* FileManagerView ***********************************************************/
 
 void FileManagerView::refresh_widgets(const bool v) {

firmware/application/apps/ui_fileman.hpp

@@ -64,6 +64,7 @@ class FileManBaseView : public View {
     uint32_t prev_highlight = 0;
     uint8_t pagination = 0;
     uint8_t nb_pages = 1;
+    bool restoring_navigation = false;
     static constexpr size_t max_filename_length = 20;
     static constexpr size_t max_items_loaded = 75;  // too memory hungry, so won't sort it
     static constexpr size_t items_per_page = 20;
@@ -96,6 +97,7 @@ class FileManBaseView : public View {
     void load_directory_contents(const std::filesystem::path& dir_path);
     void load_directory_contents_unordered(const std::filesystem::path& dir_path, size_t file_cnt);
     const file_assoc_t& get_assoc(const std::filesystem::path& ext) const;
+    std::string get_extension(const std::string& t) const;
     void copy_waterfall(std::filesystem::path path);
 
     NavigationView& nav_;

firmware/application/apps/ui_mictx.cpp

@@ -446,6 +446,8 @@ MicTXView::MicTXView(
     field_frequency.set_value(tx_frequency);
 
     // TODO: would be nice if frequency step was configurable in this app
+    // but now, make it a bit lower
+    receiver_model.set_frequency_step(12'500);  // set freq step to 12.5kHz
     field_frequency.set_step(receiver_model.frequency_step());
 
     // WARNING: transmitter_model.set_target_frequency() and receiver_model.set_target_frequency() both update the same tuning freq, but one has an offset!

firmware/application/apps/ui_search.cpp

@@ -26,11 +26,17 @@
 #include "binder.hpp"
 #include "string_format.hpp"
 #include "ui_freqman.hpp"
+#include "audio.hpp"
 
 using namespace portapack;
+namespace pmem = portapack::persistent_memory;
 
 namespace ui {
 
+void SearchLogger::log_data(SearchRecentEntry& data) {
+    log_file.write_entry(";" + to_string_short_freq(data.frequency) + ";" + std::to_string(data.duration));
+}
+
 template <>
 void RecentEntriesTable<SearchRecentEntries>::draw(
     const Entry& entry,
@@ -75,6 +81,7 @@ SearchView::SearchView(
                   &check_snap,
                   &options_snap,
                   &big_display,
+                  &check_log,
                   &recent_entries_view});
 
     baseband::set_spectrum(SEARCH_SLICE_WIDTH, 31);
@@ -100,6 +107,14 @@ SearchView::SearchView(
         on_range_changed();
     });
 
+    check_log.on_select = [this](Checkbox&, bool v) {
+        logging = v;
+        if (logging) {
+            logger.append(logs_dir.string() + "/SEARCH_" + to_string_timestamp(rtc_time::now()) + ".CSV");
+            logger.write_header();
+        }
+    };
+
     bind(field_threshold, settings_.power_threshold);
     bind(check_snap, settings_.snap_search);
     bind(options_snap, settings_.snap_step);
@@ -108,9 +123,15 @@ SearchView::SearchView(
 
     on_range_changed();
     receiver_model.enable();
+
+    if (pmem::beep_on_packets()) {
+        audio::set_rate(audio::Rate::Hz_24000);
+        audio::output::start();
+    }
 }
 
 SearchView::~SearchView() {
+    audio::output::stop();
     receiver_model.disable();
     baseband::shutdown();
 }
@@ -192,7 +213,9 @@ void SearchView::do_detection() {
 
                         locked = true;
                         locked_bin = bin_max;
-
+                        if (pmem::beep_on_packets()) {
+                            baseband::request_audio_beep(1000, 24000, 60);
+                        }
                         // TODO: open Audio.
                     } else
                         text_infos.set("Out of range");
@@ -210,6 +233,7 @@ void SearchView::do_detection() {
 
                 auto& entry = ::on_packet(recent, resolved_frequency);
                 entry.set_duration(duration);
+                if (logging) logger.log_data(entry);
                 recent_entries_view.set_dirty();
 
                 text_infos.set("Listening");

firmware/application/apps/ui_search.hpp

@@ -26,6 +26,8 @@
 #include "radio_state.hpp"
 #include "gradient.hpp"
 #include "ui_receiver.hpp"
+#include "log_file.hpp"
+#include "file_path.hpp"
 
 namespace ui {
 
@@ -70,6 +72,21 @@ struct SearchRecentEntry {
 
 using SearchRecentEntries = RecentEntries<SearchRecentEntry>;
 
+class SearchLogger {
+   public:
+    Optional<File::Error> append(const std::filesystem::path& filename) {
+        return log_file.append(filename);
+    }
+
+    void log_data(SearchRecentEntry& data);
+    void write_header() {
+        log_file.write_raw("Time;Freq;Duration;");
+    }
+
+   private:
+    LogFile log_file{};
+};
+
 class SearchView : public View {
    public:
     SearchView(NavigationView& nav);
@@ -148,6 +165,8 @@ class SearchView : public View {
     uint16_t locked_bin = 0;
     uint8_t search_counter = 0;
     bool locked = false;
+    bool logging = false;
+    SearchLogger logger{};
 
     void do_detection();
     void do_timers();
@@ -169,6 +188,12 @@ class SearchView : public View {
         {{1 * 8, 25 * 8}, "Accuracy +/-4.9kHz", Theme::getInstance()->fg_light->foreground},
         {{26 * 8, 25 * 8}, "MHz", Theme::getInstance()->fg_light->foreground}};
 
+    Checkbox check_log{
+        {24 * 8, 10 * 8},
+        3,
+        "LOG",
+        true};
+
     FrequencyField field_frequency_min{
         {1 * 8, 1 * 16}};
     FrequencyField field_frequency_max{

firmware/application/apps/ui_settings.cpp

@@ -6,7 +6,7 @@
  * Copyright (C) 2024 Mark Thompson
  * Copyright (C) 2024 u-foka
  * Copyright (C) 2024 HTotoo
- * Copyleft (ɔ) 2024 zxkmm under GPL license
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/apps/ui_settings.hpp

@@ -5,7 +5,7 @@
  * Copyright (C) 2023 Kyle Reed
  * Copyright (C) 2024 Mark Thompson
  * Copyright (C) 2024 u-foka
- * Copyleft (ɔ) 2024 zxkmm under GPL license
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/apps/ui_sonde.cpp

@@ -54,6 +54,7 @@ SondeView::SondeView(NavigationView& nav)
                   &field_lna,
                   &field_vga,
                   &rssi,
+                  &channel,
                   &field_volume,
                   &check_log,
                   &check_crc,

firmware/application/apps/ui_sonde.hpp

@@ -118,6 +118,9 @@ class SondeView : public View {
 
     RSSI rssi{
         {21 * 8, 0, 6 * 8, 4}};
+    Channel channel{
+        {21 * 8, 5, 6 * 8, 4},
+    };
 
     AudioVolumeField field_volume{
         {screen_width - 2 * 8, 0 * 16}};

firmware/application/apps/ui_standalone_view.cpp

@@ -27,6 +27,9 @@
 
 #include "ui_font_fixed_5x8.hpp"
 #include "ui_font_fixed_8x16.hpp"
+#include "portapack.hpp"
+
+#include "file.hpp"
 
 namespace ui {
 
@@ -93,8 +96,90 @@ bool i2c_read(uint8_t* cmd, size_t cmd_len, uint8_t* data, size_t data_len) {
     return dev->i2c_read(cmd, cmd_len, data, data_len);
 }
 
+// v3
+//  Version 3
+FRESULT ext_f_open(FIL* fp, const TCHAR* path, BYTE mode) {
+    return f_open(fp, path, mode);
+}
+FRESULT ext_f_close(FIL* fp) {
+    return f_close(fp);
+}
+FRESULT ext_f_read(FIL* fp, void* buff, UINT btr, UINT* br) {
+    return f_read(fp, buff, btr, br);
+}
+FRESULT ext_f_write(FIL* fp, const void* buff, UINT btw, UINT* bw) {
+    return f_write(fp, buff, btw, bw);
+}
+FRESULT ext_f_lseek(FIL* fp, FSIZE_t ofs) {
+    return f_lseek(fp, ofs);
+}
+FRESULT ext_f_truncate(FIL* fp) {
+    return f_truncate(fp);
+}
+FRESULT ext_f_sync(FIL* fp) {
+    return f_sync(fp);
+}
+FRESULT ext_f_opendir(DIR* dp, const TCHAR* path) {
+    return f_opendir(dp, path);
+}
+FRESULT ext_f_closedir(DIR* dp) {
+    return f_closedir(dp);
+}
+FRESULT ext_f_readdir(DIR* dp, FILINFO* fno) {
+    return f_readdir(dp, fno);
+}
+FRESULT ext_f_findfirst(DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern) {
+    return f_findfirst(dp, fno, path, pattern);
+}
+FRESULT ext_f_findnext(DIR* dp, FILINFO* fno) {
+    return f_findnext(dp, fno);
+}
+FRESULT ext_f_mkdir(const TCHAR* path) {
+    return f_mkdir(path);
+}
+FRESULT ext_f_unlink(const TCHAR* path) {
+    return f_unlink(path);
+}
+FRESULT ext_f_rename(const TCHAR* path_old, const TCHAR* path_new) {
+    return f_rename(path_old, path_new);
+}
+FRESULT ext_f_stat(const TCHAR* path, FILINFO* fno) {
+    return f_stat(path, fno);
+}
+FRESULT ext_f_utime(const TCHAR* path, const FILINFO* fno) {
+    return f_utime(path, fno);
+}
+FRESULT ext_f_getfree(const TCHAR* path, DWORD* nclst, FATFS** fatfs) {
+    return f_getfree(path, nclst, fatfs);
+}
+FRESULT ext_f_mount(FATFS* fs, const TCHAR* path, BYTE opt) {
+    return f_mount(fs, path, opt);
+}
+int ext_f_putc(TCHAR c, FIL* fp) {
+    return f_putc(c, fp);
+}
+int ext_f_puts(const TCHAR* str, FIL* cp) {
+    return f_puts(str, cp);
+}
+int ext_f_printf(FIL* fp, const TCHAR* str, ...) {
+    return f_printf(fp, str);
+}
+TCHAR* ext_f_gets(TCHAR* buff, int len, FIL* fp) {
+    return f_gets(buff, len, fp);
+}
+void ext_draw_pixels(const ui::Rect r, const ui::Color* const colors, const size_t count) {
+    portapack::display.draw_pixels(r, colors, count);
+}
+void ext_draw_pixel(const ui::Point p, const ui::Color color) {
+    portapack::display.draw_pixel(p, color);
+}
+
 StandaloneView* standaloneView = nullptr;
 
+void exit_app() {
+    if (standaloneView) standaloneView->exit();
+}
+
 void set_dirty() {
     if (standaloneView != nullptr)
         standaloneView->set_dirty();
@@ -121,6 +206,33 @@ standalone_application_api_t api = {
     /* .i2c_read = */ &i2c_read,
     /* .panic = */ &chDbgPanic,
     /* .set_dirty = */ &set_dirty,
+    // Version 3
+    .f_open = &ext_f_open,
+    .f_close = &ext_f_close,
+    .f_read = &ext_f_read,
+    .f_write = &ext_f_write,
+    .f_lseek = &ext_f_lseek,
+    .f_truncate = &ext_f_truncate,
+    .f_sync = &ext_f_sync,
+    .f_opendir = &ext_f_opendir,
+    .f_closedir = &ext_f_closedir,
+    .f_readdir = &ext_f_readdir,
+    .f_findfirst = &ext_f_findfirst,
+    .f_findnext = &ext_f_findnext,
+    .f_mkdir = &ext_f_mkdir,
+    .f_unlink = &ext_f_unlink,
+    .f_rename = &ext_f_rename,
+    .f_stat = &ext_f_stat,
+    .f_utime = &ext_f_utime,
+    .f_getfree = &ext_f_getfree,
+    .f_mount = &ext_f_mount,
+    .f_putc = &ext_f_putc,
+    .f_puts = &ext_f_puts,
+    .f_printf = &ext_f_printf,
+    .f_gets = &ext_f_gets,
+    .draw_pixels = &ext_draw_pixels,
+    .draw_pixel = &ext_draw_pixel,
+    .exit_app = &exit_app,
 };
 
 StandaloneView::StandaloneView(NavigationView& nav, uint8_t* app_image)
@@ -158,22 +270,21 @@ bool StandaloneView::on_key(const KeyEvent key) {
     if (get_application_information()->header_version > 1) {
         return get_application_information()->OnKeyEvent((uint8_t)key);
     }
-
-    return false;
+    return true;
 }
 
 bool StandaloneView::on_encoder(const EncoderEvent event) {
     if (get_application_information()->header_version > 1) {
         return get_application_information()->OnEncoder((int32_t)event);
     }
-    return false;
+    return true;
 }
 
 bool StandaloneView::on_touch(const TouchEvent event) {
     if (get_application_information()->header_version > 1) {
         get_application_information()->OnTouchEvent(event.point.x(), event.point.y(), (uint32_t)event.type);
     }
-    return true;
+    return false;
 }
 
 bool StandaloneView::on_keyboard(const KeyboardEvent event) {
@@ -202,4 +313,8 @@ void StandaloneView::on_before_detach() {
     context().focus_manager().clearMirror();
 }
 
+void StandaloneView::exit() {
+    nav_.pop();
+}
+
 }  // namespace ui

firmware/application/apps/ui_standalone_view.hpp

@@ -51,6 +51,8 @@ class StandaloneView : public View {
 
     void frame_sync();
 
+    void exit();
+
    private:
     bool initialized = false;
     NavigationView& nav_;

firmware/application/apps/ui_subghzd.cpp

@@ -84,6 +84,7 @@ void SubGhzDView::focus() {
 SubGhzDView::SubGhzDView(NavigationView& nav)
     : nav_{nav} {
     add_children({&rssi,
+                  &channel,
                   &field_rf_amp,
                   &field_lna,
                   &field_vga,

firmware/application/apps/ui_subghzd.hpp

@@ -129,6 +129,9 @@ class SubGhzDView : public View {
         {18 * 8, 0 * 16}};
     RSSI rssi{
         {21 * 8, 0, 6 * 8, 4}};
+    Channel channel{
+        {21 * 8, 5, 6 * 8, 4},
+    };
     RxFrequencyField field_frequency{
         {0 * 8, 0 * 16},
         nav_};

firmware/application/apps/ui_text_editor.cpp

@@ -26,6 +26,7 @@
 
 #include "log_file.hpp"
 #include "string_format.hpp"
+#include "irq_controls.hpp"
 
 using namespace portapack;
 namespace fs = std::filesystem;
@@ -81,21 +82,75 @@ void TextViewer::paint(Painter& painter) {
     paint_cursor(painter);
 }
 
+void TextViewer::enable_long_press() {
+    // Enable long press on "Select".
+    SwitchesState config;
+    config[toUType(Switch::Sel)] = true;
+    set_switches_long_press_config(config);
+}
+
+void TextViewer::on_focus() {
+    enable_long_press();
+}
+
 bool TextViewer::on_key(const KeyEvent key) {
     int16_t delta_col = 0;
     int16_t delta_line = 0;
 
-    if (key == KeyEvent::Left)
-        delta_col = -1;
-    else if (key == KeyEvent::Right)
-        delta_col = 1;
-    else if (key == KeyEvent::Up)
-        delta_line = -1;
-    else if (key == KeyEvent::Down)
-        delta_line = 1;
-    else if (key == KeyEvent::Select && on_select) {
-        on_select();
-        return true;
+    if (key == KeyEvent::Select) {
+        // Toggle 'digit' mode with long-press.
+        if (digit_mode_ || key_is_long_pressed(key)) {
+            digit_mode_ = !digit_mode_;
+            set_dirty();
+            return true;
+        }
+    }
+
+    if (digit_mode_) {
+        switch (key) {
+            case KeyEvent::Left:
+                delta_col = -1;
+                break;
+            case KeyEvent::Right:
+                delta_col = 1;
+                break;
+            case KeyEvent::Up:
+                set_value(value_ == 0x0F ? 0x00 : value_ + 1);
+                break;
+            case KeyEvent::Down:
+                set_value(value_ == 0x00 ? 0x0F : value_ - 1);
+                break;
+            default:
+                return false;
+        }
+
+        if (delta_col == 0 && delta_line == 0) {
+            return true;
+        }
+    } else {
+        switch (key) {
+            case KeyEvent::Left:
+                delta_col = -1;
+                break;
+            case KeyEvent::Right:
+                delta_col = 1;
+                break;
+            case KeyEvent::Up:
+                delta_line = -1;
+                break;
+            case KeyEvent::Down:
+                delta_line = 1;
+                break;
+            case KeyEvent::Select: {
+                if (on_select) {
+                    on_select();
+                    return true;
+                }
+                break;
+            }
+            default:
+                return false;
+        }
     }
 
     // Always allow cursor direction to be updated.
@@ -111,19 +166,42 @@ bool TextViewer::on_key(const KeyEvent key) {
 bool TextViewer::on_encoder(EncoderEvent delta) {
     bool updated = false;
 
-    if (cursor_.dir == ScrollDirection::Horizontal)
-        updated = apply_scrolling_constraints(0, delta);
-    else {
-        delta *= 16;
-        updated = apply_scrolling_constraints(delta, 0);
+    if (digit_mode_) {
+        if (delta > 0) {
+            set_value(value_ == 0x0F ? 0x00 : value_ + 1);
+        } else if (delta < 0) {
+            set_value(value_ == 0x00 ? 0x0F : value_ - 1);
+        }
+
+        updated = true;
+    } else {
+        if (cursor_.dir == ScrollDirection::Horizontal) {
+            updated = apply_scrolling_constraints(0, delta);
+        } else {
+            delta *= 16;
+            updated = apply_scrolling_constraints(delta, 0);
+        }
+
+        if (updated) {
+            redraw();
+        }
     }
 
-    if (updated)
-        redraw();
-
     return updated;
 }
 
+void TextViewer::set_value(uint8_t new_value) {
+    if (new_value != value_) {
+        value_ = new_value;
+
+        if (on_change) {
+            on_change(value_);
+        }
+
+        set_dirty();
+    }
+}
+
 void TextViewer::redraw(bool redraw_text, bool redraw_marked) {
     paint_state_.redraw_text = redraw_text;
     paint_state_.redraw_marked = redraw_marked;

firmware/application/apps/ui_text_editor.hpp

@@ -54,10 +54,13 @@ class TextViewer : public Widget {
 
     std::function<void()> on_select{};
     std::function<void()> on_cursor_moved{};
+    std::function<void(uint8_t)> on_change{};
 
     void paint(Painter& painter) override;
     bool on_key(KeyEvent key) override;
     bool on_encoder(EncoderEvent delta) override;
+    void set_value(uint8_t new_value);
+    void on_focus() override;
 
     void redraw(bool redraw_text = false, bool redraw_marked = false);
 
@@ -74,6 +77,7 @@ class TextViewer : public Widget {
     void cursor_set(uint16_t line, uint16_t col);
     void cursor_mark_selected();
     void cursor_clear_marked();
+    void enable_long_press();
 
     typedef std::pair<uint16_t, uint16_t> LineColPair;
     std::vector<LineColPair> lineColPair{};
@@ -95,6 +99,9 @@ class TextViewer : public Widget {
     int8_t char_height{};
     uint8_t max_line{};
     uint8_t max_col{};
+    bool digit_mode_{false};
+    uint8_t value_{0};
+    bool allow_digit_mode_{true};
 
     /* Returns true if the cursor was updated. */
     bool apply_scrolling_constraints(

firmware/application/apps/ui_weatherstation.cpp

@@ -107,6 +107,7 @@ void WeatherView::focus() {
 WeatherView::WeatherView(NavigationView& nav)
     : nav_{nav} {
     add_children({&rssi,
+                  &channel,
                   &field_rf_amp,
                   &field_lna,
                   &field_vga,

firmware/application/apps/ui_weatherstation.hpp

@@ -147,6 +147,9 @@ class WeatherView : public View {
         {18 * 8, 0 * 16}};
     RSSI rssi{
         {21 * 8, 0, 6 * 8, 4}};
+    Channel channel{
+        {21 * 8, 5, 6 * 8, 4},
+    };
 
     AudioVolumeField field_volume{
         {screen_width - 2 * 8, 0 * 16}};

firmware/application/baseband_api.cpp

@@ -186,13 +186,14 @@ void set_nrf(const uint32_t baudrate, const uint32_t word_length, const uint32_t
     send_message(&message);
 }
 
-void set_fsk(const size_t deviation) {
+void set_fsk(const uint8_t samplesPerSymbol, const uint32_t syncWord, const uint8_t syncWordLength, const uint32_t preamble, const uint8_t preambleLength, uint16_t numDataBytes) {
     const FSKRxConfigureMessage message{
-        taps_200k_decim_0,
-        taps_16k0_decim_1,
-        taps_11k0_channel,
-        2,
-        deviation};
+        samplesPerSymbol,
+        syncWord,
+        syncWordLength,
+        preamble,
+        preambleLength,
+        numDataBytes};
 
     send_message(&message);
 }

firmware/application/baseband_api.hpp

@@ -80,7 +80,7 @@ void set_pitch_rssi(int32_t avg, bool enabled);
 void set_afsk_data(const uint32_t afsk_samples_per_bit, const uint32_t afsk_phase_inc_mark, const uint32_t afsk_phase_inc_space, const uint8_t afsk_repeat, const uint32_t afsk_bw, const uint8_t symbol_count);
 void kill_afsk();
 void set_afsk(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word);
-void set_fsk(const size_t deviation);
+void set_fsk(const uint32_t samplesPerSymbol, const uint32_t syncWord, const uint8_t syncWordLength, const uint32_t preamble, const uint8_t preambleLength, uint16_t numDataBytes);
 void set_aprs(const uint32_t baudrate);
 
 void set_btlerx(uint8_t channel_number);

firmware/application/external/app_manager/ui_app_manager.cpp

@@ -1,5 +1,5 @@
 /*
- * copyleft spammingdramaqueen
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/app_manager/ui_app_manager.hpp

@@ -1,5 +1,5 @@
 /*
- * copyleft spammingdramaqueen
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/battleship/main.cpp

@@ -0,0 +1,55 @@
+/*
+ * ------------------------------------------------------------
+ * |  Made by RocketGod                                       |
+ * |  Find me at https://betaskynet.com                       |
+ * |  Argh matey!                                             |
+ * ------------------------------------------------------------
+ */
+
+#include "ui.hpp"
+#include "ui_battleship.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::battleship {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<BattleshipView>();
+}
+}  // namespace ui::external_app::battleship
+
+extern "C" {
+
+__attribute__((section(".external_app.app_battleship.application_information"), used)) application_information_t _application_information_battleship = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::battleship::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Battleship",
+    /*.bitmap_data = */ {
+        // Pirate galleon - 16x16
+        0x80, 0x00,  // ........#.......
+        0x80, 0x00,  // ........#.......
+        0x80, 0x00,  // ........#.......
+        0xC0, 0x01,  // .......###......
+        0xE0, 0x03,  // ......#####.....
+        0xF0, 0x07,  // .....#######....
+        0xF8, 0x0F,  // ....#########...
+        0xFC, 0x1F,  // ...###########..
+        0xFE, 0x3F,  // ..#############.
+        0x00, 0x01,  // .......#........
+        0x00, 0x01,  // .......#........
+        0x00, 0x01,  // .......#........
+        0xFC, 0x3F,  // ..############..
+        0xFE, 0x7F,  // .##############.
+        0xFF, 0xFF,  // ################
+        0xFC, 0x3F,  // ..############..
+    },
+    /*.icon_color = */ ui::Color::blue().v,
+    /*.menu_location = */ app_location_t::GAMES,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = */ {'P', 'P', 'O', '2'},  // Use POCSAG2 baseband (larger than FSKTX)
+    /*.m4_app_offset = */ 0x00000000,         // will be filled at compile time
+};
+}

firmware/application/external/battleship/ui_battleship.hpp

@@ -0,0 +1,250 @@
+/*
+ * ------------------------------------------------------------
+ * |  Made by RocketGod                                       |
+ * |  Find me at https://betaskynet.com                       |
+ * |  Argh matey!                                             |
+ * ------------------------------------------------------------
+ */
+
+#ifndef __UI_BATTLESHIP_H__
+#define __UI_BATTLESHIP_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "audio.hpp"
+#include "message.hpp"
+#include "pocsag.hpp"
+
+#include <array>
+
+namespace ui::external_app::battleship {
+
+constexpr uint8_t GRID_SIZE = 10;
+constexpr uint8_t CELL_SIZE = 24;
+constexpr uint8_t GRID_OFFSET_X = 0;
+constexpr uint8_t GRID_OFFSET_Y = 32;
+
+enum class ShipType : uint8_t {
+    CARRIER = 5,
+    BATTLESHIP = 4,
+    CRUISER = 3,
+    SUBMARINE = 3,
+    DESTROYER = 2
+};
+
+enum class GameState : uint8_t {
+    MENU,
+    PLACING_SHIPS,
+    WAITING_FOR_OPPONENT,
+    MY_TURN,
+    OPPONENT_TURN,
+    GAME_OVER
+};
+
+enum class CellState : uint8_t {
+    EMPTY,
+    SHIP,
+    HIT,
+    MISS,
+    SUNK
+};
+
+enum class MessageType : uint8_t {
+    READY,
+    SHOT,
+    HIT,
+    MISS,
+    SUNK,
+    WIN
+};
+
+struct Ship {
+    ShipType type;
+    uint8_t x;
+    uint8_t y;
+    bool horizontal;
+    uint8_t hits;
+    bool placed;
+
+    uint8_t size() const {
+        return static_cast<uint8_t>(type);
+    }
+
+    bool is_sunk() const {
+        return hits >= size();
+    }
+};
+
+struct GameMessage {
+    MessageType type;
+    uint8_t x;
+    uint8_t y;
+};
+
+class BattleshipView : public View {
+   public:
+    BattleshipView(NavigationView& nav);
+    ~BattleshipView();
+
+    void focus() override;
+    void paint(Painter& painter) override;
+    bool on_touch(const TouchEvent event) override;
+    bool on_encoder(const EncoderEvent delta) override;
+    bool on_key(const KeyEvent key) override;
+
+    std::string title() const override { return "Battleship"; }
+
+   private:
+    NavigationView& nav_;
+
+    RxRadioState rx_radio_state_{
+        433920000 /* frequency */,
+        1750000 /* bandwidth */,
+        2280000 /* sampling rate */
+    };
+
+    TxRadioState tx_radio_state_{
+        433920000 /* frequency */,
+        1750000 /* bandwidth */,
+        2280000 /* sampling rate */
+    };
+
+    // Settings
+    bool sound_enabled{true};
+    bool rf_amp_enabled{false};
+    uint8_t lna_gain{24};
+    uint8_t vga_gain{24};
+    uint8_t tx_gain{35};
+
+    app_settings::SettingsManager settings_{
+        "battleship",
+        app_settings::Mode::RX_TX,
+        {{"rx_freq"sv, &rx_frequency},
+         {"tx_freq"sv, &tx_frequency},
+         {"rf_amp"sv, &rf_amp_enabled}}};
+
+    GameState game_state{GameState::MENU};
+    bool is_red_team{false};
+    bool opponent_ready{false};
+    uint8_t wins{0};
+    uint8_t losses{0};
+
+    std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE> my_grid{};
+    std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE> enemy_grid{};
+
+    std::string current_status{"Choose your team!"};
+    std::string current_score{"W:0 L:0"};
+
+    std::array<Ship, 5> my_ships{};
+    uint8_t current_ship_index{0};
+    bool placing_horizontal{true};
+    uint8_t ships_remaining{5};
+    uint8_t enemy_ships_remaining{5};
+
+    uint8_t cursor_x{0};
+    uint8_t cursor_y{0};
+    uint8_t target_x{0};
+    uint8_t target_y{0};
+    bool touch_enabled{true};
+
+    uint32_t tx_frequency{433920000};
+    uint32_t rx_frequency{433920000};
+    bool is_transmitting{false};
+
+    // POCSAG decoding state
+    pocsag::EccContainer ecc{};
+    pocsag::POCSAGState pocsag_state{&ecc};
+    uint32_t last_address{0};
+
+    // UI Elements - Menu/Settings Screen
+    Text text_title{{60, 2, 120, 24}, "BATTLESHIP"};
+    Text text_subtitle{{40, 20, 160, 16}, "Naval Combat Game"};
+
+    Rectangle rect_radio_settings{{12, 40, 216, 118}, Color::dark_grey()};
+    Text label_radio{{17, 45, 100, 16}, "RADIO SETUP"};
+    ButtonWithEncoder button_frequency{{17, 65, 11 * 8, 20}, ""};
+
+    // Radio controls
+    Text label_rf_amp{{17, 90, 35, 16}, "AMP:"};
+    Checkbox checkbox_rf_amp{{55, 90}, 3, "", false};
+
+    Text label_lna{{17, 118, 30, 16}, "LNA:"};
+    NumberField field_lna{{50, 118}, 2, {0, 40}, 8, ' '};
+
+    Text label_vga{{90, 118, 30, 16}, "VGA:"};
+    NumberField field_vga{{125, 118}, 2, {0, 62}, 8, ' '};
+
+    Text label_tx_gain{{155, 118, 25, 16}, "TX:"};
+    NumberField field_tx_gain{{185, 118}, 2, {0, 47}, 8, ' '};
+
+    Rectangle rect_audio_settings{{12, 164, 216, 45}, Color::dark_grey()};
+    Text label_audio{{17, 169, 80, 16}, "AUDIO"};
+    Checkbox checkbox_sound{{17, 187}, 8, "Sound On", true};
+    Text label_volume{{110, 187, 50, 16}, "Volume:"};
+    AudioVolumeField field_volume{{165, 187}};
+
+    Rectangle rect_team_selection{{12, 217, 216, 75}, Color::dark_grey()};
+    Text label_team{{17, 222, 110, 16}, "SELECT TEAM"};
+    Button button_red_team{{25, 242, 85, 45}, "RED\nTEAM"};
+    Button button_blue_team{{130, 242, 85, 45}, "BLUE\nTEAM"};
+
+    // In-game UI elements
+    RSSI rssi{{21 * 8, 0, 6 * 8, 4}};
+    Text text_status{{10, 16, 220, 16}, ""};
+    Text text_score{{170, 16, 60, 16}, ""};
+    Button button_rotate{{10, 265, 65, 32}, "Rotate"};
+    Button button_place{{82, 265, 65, 32}, "Place"};
+    Button button_fire{{82, 265, 65, 32}, "Fire!"};
+    Button button_menu{{155, 265, 65, 32}, "Menu"};
+
+    // Methods
+    void init_game();
+    void reset_game();
+    void start_team(bool red);
+    void setup_ships();
+    void draw_menu_screen(Painter& painter);
+    void draw_grid(Painter& painter, uint8_t grid_x, uint8_t grid_y, const std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE>& grid, bool show_ships, bool is_offense_grid = false);
+    void draw_cell(Painter& painter, uint8_t cell_x, uint8_t cell_y, CellState state, bool show_ships, bool is_offense_grid, bool is_cursor);
+    void draw_ship_preview(Painter& painter);
+    void place_ship();
+    bool can_place_ship(uint8_t x, uint8_t y, uint8_t size, bool horizontal);
+    void fire_at_position();
+    void process_shot(uint8_t x, uint8_t y);
+    void update_score();
+    bool is_cursor_at(uint8_t x, uint8_t y, bool is_offense_grid);
+
+    void send_message(const GameMessage& msg);
+    void process_message(const std::string& message);
+    bool parse_coords(const std::string& coords, uint8_t& x, uint8_t& y);
+    void mark_ship_sunk(uint8_t x, uint8_t y, std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE>& grid);
+
+    void configure_radio_tx();
+    void configure_radio_rx();
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::POCSAGPacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const POCSAGPacketMessage*>(p);
+            on_pocsag_packet(message);
+        }};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = static_cast<const TXProgressMessage*>(p);
+            on_tx_progress(message->progress, message->done);
+        }};
+
+    void on_pocsag_packet(const POCSAGPacketMessage* message);
+    void on_tx_progress(const uint32_t progress, const bool done);
+};
+
+}  // namespace ui::external_app::battleship
+
+#endif

firmware/application/external/blackjack/main.cpp

@@ -0,0 +1,53 @@
+/*
+ * Blackjack Game for Portapack Mayhem
+ * Ported / Enhanced / Graphically made awesome by RocketGod (https://betaskynet.com)
+ * Based on BlackJack 83 for TI Calculator by Harper Maddox (was written in Assembly)
+ */
+
+#include "ui.hpp"
+#include "ui_blackjack.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::blackjack {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<BlackjackView>();
+}
+}  // namespace ui::external_app::blackjack
+
+extern "C" {
+
+__attribute__((section(".external_app.app_blackjack.application_information"), used)) application_information_t _application_information_blackjack = {
+    (uint8_t*)0x00000000,
+    ui::external_app::blackjack::initialize_app,
+    CURRENT_HEADER_VERSION,
+    VERSION_MD5,
+
+    "Blackjack",
+    {
+        // Diamond icon 16x16
+        0x00, 0x00,  // ................
+        0x80, 0x01,  // .......##.......
+        0xC0, 0x03,  // ......####......
+        0xE0, 0x07,  // .....######.....
+        0xF0, 0x0F,  // ....########....
+        0xF8, 0x1F,  // ...##########...
+        0xFC, 0x3F,  // ..############..
+        0xFE, 0x7F,  // .##############.
+        0xFE, 0x7F,  // .##############.
+        0xFC, 0x3F,  // ..############..
+        0xF8, 0x1F,  // ...##########...
+        0xF0, 0x0F,  // ....########....
+        0xE0, 0x07,  // .....######.....
+        0xC0, 0x03,  // ......####......
+        0x80, 0x01,  // .......##.......
+        0x00, 0x00,  // ................
+    },
+    ui::Color::red().v,  // Red color for diamonds
+    app_location_t::GAMES,
+    -1,
+
+    {0, 0, 0, 0},
+    0x00000000,
+};
+}

firmware/application/external/blackjack/ui_blackjack.cpp

@@ -0,0 +1,727 @@
+/*
+ * Blackjack Game for Portapack Mayhem
+ * Ported / Enhanced / Graphically made awesome by RocketGod (https://betaskynet.com)
+ * Based on BlackJack 83 for TI Calculator by Harper Maddox (was written in Assembly)
+ */
+
+#include "ui_blackjack.hpp"
+
+namespace ui::external_app::blackjack {
+
+// Global variables
+static BlackjackView* current_instance = nullptr;
+static Callback game_update_callback = nullptr;
+static uint32_t game_update_timeout = 0;
+static uint32_t game_update_counter = 0;
+static Painter painter;
+
+void check_game_timer() {
+    if (game_update_callback) {
+        if (++game_update_counter >= game_update_timeout) {
+            game_update_counter = 0;
+            game_update_callback();
+        }
+    }
+}
+
+void Ticker::attach(Callback func, double delay_sec) {
+    game_update_callback = func;
+    game_update_timeout = delay_sec * 60;
+}
+
+void Ticker::detach() {
+    game_update_callback = nullptr;
+}
+
+void game_timer_check() {
+    if (current_instance) {
+        current_instance->update_game();
+    }
+}
+
+BlackjackView::BlackjackView(NavigationView& nav)
+    : nav_{nav}, game_timer{} {
+    add_children({&dummy});
+    current_instance = this;
+    game_timer.attach(&game_timer_check, 1.0 / 60.0);
+}
+
+BlackjackView::~BlackjackView() {
+    current_instance = nullptr;
+}
+
+void BlackjackView::on_show() {
+    draw_menu_static();
+}
+
+void BlackjackView::paint(Painter& painter) {
+    (void)painter;
+
+    if (!initialized) {
+        initialized = true;
+        std::srand(LPC_RTC->CTIME0);
+        init_deck();
+    }
+}
+
+void BlackjackView::frame_sync() {
+    check_game_timer();
+    set_dirty();
+}
+
+void BlackjackView::clear_screen() {
+    painter.fill_rectangle({0, 0, 240, 320}, Color::black());
+}
+
+void BlackjackView::init_deck() {
+    // Initialize deck with card values 0-51
+    // 0-12 = Spades (A-K), 13-25 = Hearts, 26-38 = Diamonds, 39-51 = Clubs
+    for (int i = 0; i < 52; i++) {
+        deck[i] = i;
+    }
+    shuffle_deck();
+}
+
+void BlackjackView::shuffle_deck() {
+    // Simple shuffle using random swaps
+    for (int i = 51; i > 0; i--) {
+        int j = rand() % (i + 1);
+        uint8_t temp = deck[i];
+        deck[i] = deck[j];
+        deck[j] = temp;
+    }
+    deck_position = 0;
+}
+
+uint8_t BlackjackView::draw_card() {
+    if (deck_position >= 52) {
+        shuffle_deck();
+    }
+    return deck[deck_position++];
+}
+
+int BlackjackView::get_card_value(uint8_t card) {
+    int value = (card % 13) + 1;  // 1-13
+    if (value > 10) value = 10;   // Face cards worth 10
+    return value;
+}
+
+uint8_t BlackjackView::get_card_suit(uint8_t card) {
+    return card / 13;  // 0=Spades, 1=Hearts, 2=Diamonds, 3=Clubs
+}
+
+std::string BlackjackView::get_card_string(uint8_t card) {
+    int value = (card % 13) + 1;
+    std::string result;
+
+    if (value == 1)
+        result = "A";
+    else if (value == 11)
+        result = "J";
+    else if (value == 12)
+        result = "Q";
+    else if (value == 13)
+        result = "K";
+    else if (value == 10)
+        result = "10";  // Special case for 10
+    else
+        result = std::to_string(value);
+
+    return result;
+}
+
+int BlackjackView::calculate_hand_value(uint8_t* cards, uint8_t count) {
+    int value = 0;
+    int aces = 0;
+
+    for (uint8_t i = 0; i < count; i++) {
+        int card_val = get_card_value(cards[i]);
+        if (card_val == 1) {
+            aces++;
+            value += 1;
+        } else {
+            value += card_val;
+        }
+    }
+
+    // Convert aces from 1 to 11 if beneficial
+    while (aces > 0 && value + 10 <= 21) {
+        value += 10;
+        aces--;
+    }
+
+    return value;
+}
+
+void BlackjackView::deal_cards() {
+    // Clear hands
+    player_card_count = 0;
+    dealer_card_count = 0;
+
+    // Deal initial cards
+    player_cards[player_card_count++] = draw_card();
+    dealer_cards[dealer_card_count++] = draw_card();
+    player_cards[player_card_count++] = draw_card();
+    dealer_cards[dealer_card_count++] = draw_card();
+
+    dealer_hidden = true;
+    game_state = GameState::PLAYING;
+}
+
+void BlackjackView::player_hit() {
+    if (player_card_count < MAX_CARDS_IN_HAND) {
+        player_cards[player_card_count++] = draw_card();
+
+        int value = calculate_hand_value(player_cards, player_card_count);
+        if (value > 21) {
+            // Bust!
+            cash = (cash >= bet) ? cash - bet : 0;
+            losses++;
+            game_state = GameState::GAME_OVER;
+        }
+    }
+}
+
+void BlackjackView::player_stay() {
+    dealer_hidden = false;
+    game_state = GameState::DEALER_TURN;
+    dealer_timer = 0;
+}
+
+void BlackjackView::dealer_turn() {
+    int dealer_value = calculate_hand_value(dealer_cards, dealer_card_count);
+
+    if (dealer_value < 17 && dealer_card_count < MAX_CARDS_IN_HAND) {
+        dealer_cards[dealer_card_count++] = draw_card();
+    } else {
+        check_game_over();
+    }
+}
+
+void BlackjackView::check_game_over() {
+    int player_value = calculate_hand_value(player_cards, player_card_count);
+    int dealer_value = calculate_hand_value(dealer_cards, dealer_card_count);
+
+    if (player_value > 21) {
+        // Player bust (already handled)
+    } else if (dealer_value > 21) {
+        // Dealer bust - player wins
+        cash += bet;
+        wins++;
+    } else if (player_value > dealer_value) {
+        // Player wins
+        cash += bet;
+        wins++;
+    } else if (player_value < dealer_value) {
+        // Dealer wins
+        cash = (cash >= bet) ? cash - bet : 0;
+        losses++;
+    }
+    // Else it's a tie - no money changes hands
+
+    if (cash > high_score) {
+        high_score = cash;
+    }
+
+    game_state = GameState::GAME_OVER;
+}
+
+void BlackjackView::update_game() {
+    switch (game_state) {
+        case GameState::MENU:
+            draw_menu();
+            break;
+
+        case GameState::BETTING:
+            draw_betting();
+            break;
+
+        case GameState::PLAYING:
+            draw_game();
+            break;
+
+        case GameState::DEALER_TURN:
+            if (++dealer_timer >= 60) {  // 1 second delay
+                dealer_timer = 0;
+                dealer_turn();
+            }
+            draw_game();
+            break;
+
+        case GameState::GAME_OVER:
+            draw_game();
+            break;
+
+        case GameState::STATS:
+            draw_stats();
+            break;
+    }
+}
+
+void BlackjackView::draw_menu_static() {
+    clear_screen();
+
+    auto style_title = *ui::Theme::getInstance()->fg_green;
+    auto style_text = *ui::Theme::getInstance()->fg_light;
+    auto style_rules = *ui::Theme::getInstance()->fg_cyan;
+
+    painter.draw_string({84, 20}, style_title, "BLACKJACK");
+
+    // Draw rules
+    painter.draw_string({70, 55}, style_rules, "-- RULES --");
+    painter.draw_string({61, 75}, style_text, "Get close to 21");
+    painter.draw_string({61, 90}, style_text, "without going over");
+    painter.draw_string({61, 110}, style_text, "Dealer hits on 16");
+    painter.draw_string({61, 125}, style_text, "Dealer stays on 17");
+    painter.draw_string({61, 145}, style_text, "Blackjack pays 1:1");
+
+    // Controls
+    painter.draw_string({65, 175}, style_rules, "-- CONTROLS --");
+    painter.draw_string({61, 195}, style_text, "SELECT: Start/Hit");
+    painter.draw_string({61, 210}, style_text, "LEFT: Stats");
+    painter.draw_string({61, 225}, style_text, "RIGHT: Exit/Stay");
+
+    // Draw high score
+    painter.draw_string({61, 250}, style_text, "High Score: $" + std::to_string(high_score));
+}
+
+void BlackjackView::draw_menu() {
+    // Only handle the flashing text animation
+    if (++blink_counter >= 30) {
+        blink_counter = 0;
+        blink_state = !blink_state;
+
+        if (blink_state) {
+            auto style = *ui::Theme::getInstance()->fg_yellow;
+            painter.draw_string({55, 280}, style, "* PRESS SELECT *");
+        } else {
+            // Clear just the text area
+            painter.fill_rectangle({55, 278, 130, 20}, Color::black());
+        }
+    }
+}
+
+void BlackjackView::draw_stats() {
+    clear_screen();
+
+    auto style_title = *ui::Theme::getInstance()->fg_green;
+    auto style_text = *ui::Theme::getInstance()->fg_light;
+    auto style_value = *ui::Theme::getInstance()->fg_yellow;
+
+    painter.draw_string({75, 30}, style_title, "STATISTICS");
+
+    painter.draw_string({30, 80}, style_text, "Wins:");
+    painter.draw_string({150, 80}, style_value, std::to_string(wins));
+
+    painter.draw_string({30, 100}, style_text, "Losses:");
+    painter.draw_string({150, 100}, style_value, std::to_string(losses));
+
+    // Win percentage
+    uint32_t total = wins + losses;
+    if (total > 0) {
+        uint32_t win_pct = (wins * 100) / total;
+        painter.draw_string({30, 120}, style_text, "Win %:");
+        painter.draw_string({150, 120}, style_value, std::to_string(win_pct) + "%");
+    }
+
+    painter.draw_string({30, 160}, style_text, "High Score:");
+    painter.draw_string({150, 160}, style_value, "$" + std::to_string(high_score));
+
+    painter.draw_string({30, 180}, style_text, "Cash:");
+    painter.draw_string({150, 180}, style_value, "$" + std::to_string(cash));
+
+    painter.draw_string({40, 250}, style_text, "SELECT: Back");
+}
+
+void BlackjackView::draw_betting() {
+    static uint32_t last_bet = 0;
+    static bool betting_drawn = false;
+
+    if (!betting_drawn) {
+        clear_screen();
+
+        auto style_title = *ui::Theme::getInstance()->fg_green;
+        auto style_text = *ui::Theme::getInstance()->fg_light;
+
+        painter.draw_string({70, 40}, style_title, "PLACE BET");
+        painter.draw_string({30, 80}, style_text, "Cash: $" + std::to_string(cash));
+
+        painter.draw_string({30, 140}, style_text, "ENCODER: +/- $10");
+        painter.draw_string({30, 160}, style_text, "SELECT: Deal");
+
+        betting_drawn = true;
+        last_bet = 0;
+    }
+
+    // Update bet display
+    if (bet != last_bet) {
+        painter.fill_rectangle({30, 110, 150, 20}, Color::black());
+        painter.draw_string({30, 110}, *ui::Theme::getInstance()->fg_yellow, "Bet: $" + std::to_string(bet));
+        last_bet = bet;
+    }
+}
+
+void BlackjackView::draw_game() {
+    static int last_player_count = -1;
+    static int last_dealer_count = -1;
+    static GameState last_game_state = GameState::MENU;
+    static uint32_t last_bet = 0;
+
+    // Clear and redraw if hands changed or game state changed
+    if (player_card_count != last_player_count || dealer_card_count != last_dealer_count || game_state != last_game_state) {
+        clear_screen();
+
+        auto style = *ui::Theme::getInstance()->fg_green;
+        painter.draw_string({10, 10}, style, "Cash: $" + std::to_string(cash));
+        painter.draw_string({140, 10}, style, "Bet: $" + std::to_string(bet));
+
+        // Draw dealer hand with value next to label
+        auto style_value = *ui::Theme::getInstance()->fg_yellow;
+        painter.draw_string({10, 45}, *ui::Theme::getInstance()->fg_light, "Dealer:");
+        if (!dealer_hidden || game_state == GameState::GAME_OVER) {
+            int dealer_value = calculate_hand_value(dealer_cards, dealer_card_count);
+            painter.draw_string({70, 45}, style_value, "(" + std::to_string(dealer_value) + ")");
+        }
+        draw_hand(10, 65, dealer_cards, dealer_card_count, true);
+
+        // Draw player hand with value next to label
+        painter.draw_string({10, 165}, *ui::Theme::getInstance()->fg_light, "You:");
+        int player_value = calculate_hand_value(player_cards, player_card_count);
+        painter.draw_string({50, 165}, style_value, "(" + std::to_string(player_value) + ")");
+        draw_hand(10, 185, player_cards, player_card_count, false);
+
+        // Draw controls or result
+        if (game_state == GameState::PLAYING) {
+            auto style_text = *ui::Theme::getInstance()->fg_light;
+            painter.draw_string({30, 290}, style_text, "SELECT: Hit");
+            painter.draw_string({130, 290}, style_text, "RIGHT: Stay");
+        } else if (game_state == GameState::GAME_OVER) {
+            const Style* style_result = ui::Theme::getInstance()->fg_yellow;
+            std::string result;
+
+            if (player_value > 21) {
+                result = "BUST! You Lose";
+                style_result = ui::Theme::getInstance()->fg_red;
+            } else if (calculate_hand_value(dealer_cards, dealer_card_count) > 21) {
+                result = "Dealer Bust! Win!";
+                style_result = ui::Theme::getInstance()->fg_green;
+            } else if (player_value > calculate_hand_value(dealer_cards, dealer_card_count)) {
+                result = "You Win!";
+                style_result = ui::Theme::getInstance()->fg_green;
+            } else if (player_value < calculate_hand_value(dealer_cards, dealer_card_count)) {
+                result = "You Lose";
+                style_result = ui::Theme::getInstance()->fg_red;
+            } else {
+                result = "Push (Tie)";
+            }
+
+            // Draw result
+            painter.draw_string({60, 270}, *style_result, result);
+
+            // Draw compact bet selector in top right area
+            auto style_bet = *ui::Theme::getInstance()->fg_cyan;
+            painter.draw_string({140, 25}, style_bet, "Next: $" + std::to_string(bet));
+
+            // Show controls
+            painter.draw_string({10, 290}, *ui::Theme::getInstance()->fg_light, "SELECT: Deal  ENC: +/-");
+        }
+
+        last_player_count = player_card_count;
+        last_dealer_count = dealer_card_count;
+        last_game_state = game_state;
+        last_bet = bet;
+    } else if (game_state == GameState::GAME_OVER && bet != last_bet) {
+        // Only update the bet display when it changes
+        painter.fill_rectangle({140, 25, 90, 16}, Color::black());
+        painter.draw_string({140, 25}, *ui::Theme::getInstance()->fg_cyan, "Next: $" + std::to_string(bet));
+        last_bet = bet;
+    }
+}
+
+void BlackjackView::draw_suit_symbol(int x, int y, uint8_t suit, Color color, bool large) {
+    if (large) {
+        // Large suit symbols for center of card
+        switch (suit) {
+            case 0:  // Spades
+                // Top curve
+                painter.fill_rectangle({x + 9, y + 4, 2, 2}, color);
+                painter.fill_rectangle({x + 8, y + 5, 4, 2}, color);
+                painter.fill_rectangle({x + 7, y + 6, 6, 2}, color);
+                painter.fill_rectangle({x + 6, y + 7, 8, 2}, color);
+                painter.fill_rectangle({x + 5, y + 8, 10, 2}, color);
+                painter.fill_rectangle({x + 4, y + 9, 12, 2}, color);
+                painter.fill_rectangle({x + 3, y + 10, 14, 2}, color);
+                painter.fill_rectangle({x + 2, y + 11, 16, 2}, color);
+                painter.fill_rectangle({x + 1, y + 12, 18, 2}, color);
+                painter.fill_rectangle({x + 0, y + 13, 20, 3}, color);
+                painter.fill_rectangle({x + 1, y + 16, 18, 2}, color);
+                painter.fill_rectangle({x + 2, y + 17, 16, 1}, color);
+                painter.fill_rectangle({x + 3, y + 18, 14, 1}, color);
+                // Stem
+                painter.fill_rectangle({x + 9, y + 19, 2, 4}, color);
+                painter.fill_rectangle({x + 8, y + 22, 4, 1}, color);
+                painter.fill_rectangle({x + 7, y + 23, 6, 1}, color);
+                painter.fill_rectangle({x + 6, y + 24, 8, 1}, color);
+                break;
+
+            case 1:  // Hearts
+                // Left bump
+                painter.fill_rectangle({x + 3, y + 5, 4, 2}, color);
+                painter.fill_rectangle({x + 2, y + 6, 6, 2}, color);
+                painter.fill_rectangle({x + 1, y + 7, 8, 3}, color);
+                painter.fill_rectangle({x + 0, y + 9, 9, 3}, color);
+                // Right bump
+                painter.fill_rectangle({x + 13, y + 5, 4, 2}, color);
+                painter.fill_rectangle({x + 12, y + 6, 6, 2}, color);
+                painter.fill_rectangle({x + 11, y + 7, 8, 3}, color);
+                painter.fill_rectangle({x + 11, y + 9, 9, 3}, color);
+                // Body
+                painter.fill_rectangle({x + 1, y + 11, 18, 3}, color);
+                painter.fill_rectangle({x + 2, y + 14, 16, 2}, color);
+                painter.fill_rectangle({x + 3, y + 16, 14, 2}, color);
+                painter.fill_rectangle({x + 4, y + 18, 12, 1}, color);
+                painter.fill_rectangle({x + 5, y + 19, 10, 1}, color);
+                painter.fill_rectangle({x + 6, y + 20, 8, 1}, color);
+                painter.fill_rectangle({x + 7, y + 21, 6, 1}, color);
+                painter.fill_rectangle({x + 8, y + 22, 4, 1}, color);
+                painter.fill_rectangle({x + 9, y + 23, 2, 1}, color);
+                break;
+
+            case 2:  // Diamonds
+                painter.fill_rectangle({x + 10, y + 3, 1, 1}, color);
+                painter.fill_rectangle({x + 9, y + 4, 3, 1}, color);
+                painter.fill_rectangle({x + 8, y + 5, 5, 1}, color);
+                painter.fill_rectangle({x + 7, y + 6, 7, 1}, color);
+                painter.fill_rectangle({x + 6, y + 7, 9, 1}, color);
+                painter.fill_rectangle({x + 5, y + 8, 11, 1}, color);
+                painter.fill_rectangle({x + 4, y + 9, 13, 1}, color);
+                painter.fill_rectangle({x + 3, y + 10, 15, 1}, color);
+                painter.fill_rectangle({x + 2, y + 11, 17, 1}, color);
+                painter.fill_rectangle({x + 1, y + 12, 19, 1}, color);
+                painter.fill_rectangle({x + 0, y + 13, 21, 1}, color);
+                painter.fill_rectangle({x + 1, y + 14, 19, 1}, color);
+                painter.fill_rectangle({x + 2, y + 15, 17, 1}, color);
+                painter.fill_rectangle({x + 3, y + 16, 15, 1}, color);
+                painter.fill_rectangle({x + 4, y + 17, 13, 1}, color);
+                painter.fill_rectangle({x + 5, y + 18, 11, 1}, color);
+                painter.fill_rectangle({x + 6, y + 19, 9, 1}, color);
+                painter.fill_rectangle({x + 7, y + 20, 7, 1}, color);
+                painter.fill_rectangle({x + 8, y + 21, 5, 1}, color);
+                painter.fill_rectangle({x + 9, y + 22, 3, 1}, color);
+                painter.fill_rectangle({x + 10, y + 23, 1, 1}, color);
+                break;
+
+            case 3:  // Clubs
+                // Center circle
+                painter.fill_rectangle({x + 8, y + 8, 5, 1}, color);
+                painter.fill_rectangle({x + 7, y + 9, 7, 3}, color);
+                painter.fill_rectangle({x + 8, y + 12, 5, 1}, color);
+                // Left circle
+                painter.fill_rectangle({x + 3, y + 11, 4, 1}, color);
+                painter.fill_rectangle({x + 2, y + 12, 6, 3}, color);
+                painter.fill_rectangle({x + 3, y + 15, 4, 1}, color);
+                // Right circle
+                painter.fill_rectangle({x + 14, y + 11, 4, 1}, color);
+                painter.fill_rectangle({x + 13, y + 12, 6, 3}, color);
+                painter.fill_rectangle({x + 14, y + 15, 4, 1}, color);
+                // Connect circles
+                painter.fill_rectangle({x + 6, y + 13, 9, 2}, color);
+                // Stem
+                painter.fill_rectangle({x + 9, y + 16, 3, 4}, color);
+                painter.fill_rectangle({x + 8, y + 19, 5, 1}, color);
+                painter.fill_rectangle({x + 7, y + 20, 7, 1}, color);
+                painter.fill_rectangle({x + 6, y + 21, 9, 1}, color);
+                break;
+        }
+    } else {
+        // Small suit symbols
+        switch (suit) {
+            case 0:  // Spades - small
+                painter.fill_rectangle({x + 2, y + 1, 3, 3}, color);
+                painter.fill_rectangle({x + 1, y + 3, 5, 2}, color);
+                painter.fill_rectangle({x + 3, y + 5, 1, 2}, color);
+                break;
+
+            case 1:  // Hearts - small
+                painter.fill_rectangle({x + 1, y + 1, 2, 2}, color);
+                painter.fill_rectangle({x + 4, y + 1, 2, 2}, color);
+                painter.fill_rectangle({x + 1, y + 2, 5, 2}, color);
+                painter.fill_rectangle({x + 2, y + 4, 3, 1}, color);
+                painter.fill_rectangle({x + 3, y + 5, 1, 1}, color);
+                break;
+
+            case 2:  // Diamonds - small
+                painter.fill_rectangle({x + 3, y + 1, 1, 1}, color);
+                painter.fill_rectangle({x + 2, y + 2, 3, 1}, color);
+                painter.fill_rectangle({x + 1, y + 3, 5, 1}, color);
+                painter.fill_rectangle({x + 2, y + 4, 3, 1}, color);
+                painter.fill_rectangle({x + 3, y + 5, 1, 1}, color);
+                break;
+
+            case 3:  // Clubs - small
+                painter.fill_rectangle({x + 3, y + 1, 2, 2}, color);
+                painter.fill_rectangle({x + 1, y + 3, 2, 2}, color);
+                painter.fill_rectangle({x + 4, y + 3, 2, 2}, color);
+                painter.fill_rectangle({x + 3, y + 5, 2, 2}, color);
+                break;
+        }
+    }
+}
+
+void BlackjackView::draw_card(int x, int y, uint8_t card, bool hidden) {
+    const int width = 60;
+    const int height = 80;
+
+    // Draw card background
+    painter.fill_rectangle({x, y, width, height}, Color::white());
+    painter.draw_rectangle({x, y, width, height}, Color::black());
+    painter.draw_rectangle({x + 1, y + 1, width - 2, height - 2}, Color::grey());  // Inner border
+
+    if (hidden) {
+        // Draw card back pattern - diagonal lines
+        for (int i = 4; i < width - 4; i += 6) {
+            for (int j = 4; j < height - 4; j += 6) {
+                painter.fill_rectangle({x + i, y + j, 3, 3}, Color::blue());
+                painter.fill_rectangle({x + i + 3, y + j + 3, 3, 3}, Color::red());
+            }
+        }
+    } else {
+        // Draw card value
+        uint8_t suit = get_card_suit(card);
+        Color suit_color = (suit == 1 || suit == 2) ? Color::red() : Color::black();
+
+        const auto* base_style = ui::Theme::getInstance()->fg_light;
+        Style card_style{
+            .font = base_style->font,
+            .background = Color::white(),
+            .foreground = suit_color};
+
+        std::string value_str = get_card_string(card);
+
+        // Draw value in top-left corner
+        painter.draw_string({x + 4, y + 4}, card_style, value_str);
+
+        // Draw small suit symbol next to value
+        int suit_x = (value_str == "10") ? x + 20 : x + 12;
+        draw_suit_symbol(suit_x, y + 4, suit, suit_color, false);
+
+        // Draw value in bottom-right corner
+        int bottom_x = (value_str == "10") ? x + width - 24 : x + width - 16;
+        painter.draw_string({bottom_x, y + height - 18}, card_style, value_str);
+
+        // Draw small suit symbol in bottom-right
+        draw_suit_symbol(x + width - 10, y + height - 16, suit, suit_color, false);
+
+        // Draw large suit symbol in center
+        draw_suit_symbol(x + 20, y + 28, suit, suit_color, true);
+    }
+}
+
+void BlackjackView::draw_hand(int x, int y, uint8_t* cards, uint8_t count, bool is_dealer) {
+    // Calculate total width needed
+    const int card_width = 60;
+    const int overlap = 40;         // Amount of overlap when cards need to fit
+    const int max_width = 230 - x;  // Available width on screen
+
+    int spacing;
+    if (count == 1) {
+        spacing = 0;
+    } else if (count == 2) {
+        spacing = card_width + 5;  // Small gap for 2 cards
+    } else {
+        // Calculate spacing to fit all cards
+        int total_overlap_width = card_width + (count - 1) * overlap;
+        if (total_overlap_width <= max_width) {
+            spacing = overlap;
+        } else {
+            // Need more overlap to fit
+            spacing = (max_width - card_width) / (count - 1);
+        }
+    }
+
+    for (uint8_t i = 0; i < count; i++) {
+        bool hide = is_dealer && dealer_hidden && i == 1;
+        int card_x = x + (i * spacing);
+        draw_card(card_x, y, cards[i], hide);
+    }
+}
+
+bool BlackjackView::on_key(const KeyEvent key) {
+    if (key == KeyEvent::Select) {
+        switch (game_state) {
+            case GameState::MENU:
+                if (cash < 10) {
+                    cash = 100;  // Reset if broke - maybe should provide https://gamblersanonymous.org/ link if they also lost their wife and house
+                    wins = 0;
+                    losses = 0;
+                }
+                game_state = GameState::BETTING;
+                break;
+
+            case GameState::BETTING:
+                deal_cards();
+                break;
+
+            case GameState::PLAYING:
+                player_hit();
+                break;
+
+            case GameState::GAME_OVER:
+                // Deal new hand with current bet
+                if (cash >= bet) {
+                    deal_cards();
+                } else if (cash >= 10) {
+                    // Not enough for current bet, reduce to what they can afford
+                    bet = 10;
+                    deal_cards();
+                } else {
+                    // Broke, reset game
+                    cash = 100;
+                    wins = 0;
+                    losses = 0;
+                    game_state = GameState::MENU;
+                    draw_menu_static();
+                }
+                break;
+
+            case GameState::STATS:
+                game_state = GameState::MENU;
+                draw_menu_static();
+                break;
+
+            default:
+                break;
+        }
+        return true;
+    } else if (key == KeyEvent::Left) {
+        if (game_state == GameState::MENU) {
+            game_state = GameState::STATS;
+        }
+        return true;
+    } else if (key == KeyEvent::Right) {
+        if (game_state == GameState::MENU) {
+            nav_.pop();
+            return true;
+        } else if (game_state == GameState::PLAYING) {
+            player_stay();
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool BlackjackView::on_encoder(const EncoderEvent delta) {
+    if (game_state == GameState::BETTING || game_state == GameState::GAME_OVER) {
+        if (delta > 0 && bet + 10 <= cash) {
+            bet += 10;
+        } else if (delta < 0 && bet >= 20) {
+            bet -= 10;
+        }
+        return true;
+    }
+
+    return false;
+}
+
+}  // namespace ui::external_app::blackjack

firmware/application/external/blackjack/ui_blackjack.hpp

@@ -0,0 +1,156 @@
+/*
+ * Blackjack Game for Portapack Mayhem
+ * Ported / Enhanced / Graphically made awesome by RocketGod (https://betaskynet.com)
+ * Based on BlackJack 83 for TI Calculator by Harper Maddox (was written in Assembly)
+ */
+
+#ifndef __UI_BLACKJACK_H__
+#define __UI_BLACKJACK_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "event_m0.hpp"
+#include "message.hpp"
+#include "irq_controls.hpp"
+#include "random.hpp"
+#include "lpc43xx_cpp.hpp"
+#include "ui_widget.hpp"
+#include "app_settings.hpp"
+#include <string>
+#include <vector>
+
+namespace ui::external_app::blackjack {
+
+// Game states
+enum class GameState {
+    MENU,
+    BETTING,
+    PLAYING,
+    DEALER_TURN,
+    GAME_OVER,
+    STATS
+};
+
+// Card structure
+struct Card {
+    uint8_t value;  // 1-13 (Ace=1, Jack=11, Queen=12, King=13)
+    uint8_t suit;   // 0=Spades, 1=Hearts, 2=Diamonds, 3=Clubs
+
+    Card()
+        : value(0), suit(0) {}
+    Card(uint8_t v, uint8_t s)
+        : value(v), suit(s) {}
+};
+
+// Timer class
+using Callback = void (*)(void);
+
+class Ticker {
+   public:
+    Ticker() = default;
+    void attach(Callback func, double delay_sec);
+    void detach();
+};
+
+// Function declarations
+void check_game_timer();
+void game_timer_check();
+
+class BlackjackView : public View {
+   public:
+    BlackjackView(NavigationView& nav);
+    ~BlackjackView();
+
+    void on_show() override;
+    std::string title() const override { return "Blackjack"; }
+    void focus() override { dummy.focus(); }
+    void paint(Painter& painter) override;
+    void frame_sync();
+    bool on_encoder(const EncoderEvent event) override;
+    bool on_key(KeyEvent key) override;
+
+    // Public for timer callback
+    GameState game_state = GameState::MENU;
+    void update_game();
+
+   private:
+    NavigationView& nav_;
+    bool initialized = false;
+
+    // Game variables
+    static constexpr uint8_t MAX_CARDS_IN_HAND = 11;  // Maximum possible cards before bust
+    uint8_t deck[52];
+    uint8_t deck_position = 0;
+
+    uint8_t player_cards[MAX_CARDS_IN_HAND];
+    uint8_t player_card_count = 0;
+
+    uint8_t dealer_cards[MAX_CARDS_IN_HAND];
+    uint8_t dealer_card_count = 0;
+
+    // Game state variables
+    uint32_t cash = 100;
+    uint32_t bet = 10;
+    uint32_t wins = 0;
+    uint32_t losses = 0;
+    uint32_t high_score = 100;
+    bool dealer_hidden = true;
+
+    // UI state
+    uint8_t menu_selection = 0;
+    bool blink_state = true;
+    uint32_t blink_counter = 0;
+    uint32_t dealer_timer = 0;
+
+    // Timer
+    Ticker game_timer;
+
+    // Methods
+    void init_deck();
+    void shuffle_deck();
+    uint8_t draw_card();
+    void deal_cards();
+    int calculate_hand_value(uint8_t* cards, uint8_t count);
+    int get_card_value(uint8_t card);
+    uint8_t get_card_suit(uint8_t card);
+    std::string get_card_string(uint8_t card);
+    void player_hit();
+    void player_stay();
+    void dealer_turn();
+    void check_game_over();
+    void reset_game();
+
+    // Drawing methods
+    void draw_menu();
+    void draw_menu_static();
+    void draw_stats();
+    void draw_game();
+    void draw_betting();
+    void draw_card(int x, int y, uint8_t card, bool hidden = false);
+    void draw_hand(int x, int y, uint8_t* cards, uint8_t count, bool is_dealer = false);
+    void draw_suit_symbol(int x, int y, uint8_t suit, Color color, bool large);
+    void clear_screen();
+
+    // Settings
+    app_settings::SettingsManager settings_{
+        "blackjack",
+        app_settings::Mode::NO_RF,
+        {{"cash"sv, &cash},
+         {"wins"sv, &wins},
+         {"losses"sv, &losses},
+         {"highscore"sv, &high_score}}};
+
+    Button dummy{
+        {240, 0, 0, 0},
+        ""};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->frame_sync();
+        }};
+};
+
+}  // namespace ui::external_app::blackjack
+
+#endif /* __UI_BLACKJACK_H__ */

firmware/application/external/calculator/ivt.hpp

@@ -440,7 +440,7 @@ static void _sumlr(void);
 #undef __O
 #undef __P
 
-#define PI 3.141592653589793
+#include "mathdef.hpp"
 
 static void _numinput(byte k);
 static double dpush(double d);

firmware/application/external/dinogame/main.cpp

@@ -4,9 +4,7 @@
  * |  Find me at https://betaskynet.com                       |
  * |  Argh matey!                                             |
  * ------------------------------------------------------------
- */
-
-/*
+ *
  * Chrome Dino Game for Portapack Mayhem
  * Based on the original DinoGame by various contributors
  */
@@ -32,38 +30,23 @@ __attribute__((section(".external_app.app_dinogame.application_information"), us
 
     "Dino Game",
     {
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0xF0,
-        0xF8,
-        0xFC,
-        0xFE,
-        0xFF,
-        0xFF,
-        0x7F,
-        0x7F,
-        0x3F,
-        0x3F,
-        0x3E,
-        0x3C,
-        0x38,
-        0x30,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
+        // Cactus icon 16x16
+        0x00, 0x00,  // ................
+        0x80, 0x01,  // .......##.......
+        0x80, 0x01,  // .......##.......
+        0x80, 0x01,  // .......##.......
+        0x98, 0x19,  // ...##..##..##...
+        0x98, 0x19,  // ...##..##..##...
+        0x98, 0x19,  // ...##..##..##...
+        0x98, 0x19,  // ...##..##..##...
+        0xF8, 0x1F,  // ...##########...
+        0xF0, 0x0F,  // ....########....
+        0x80, 0x01,  // .......##.......
+        0x80, 0x01,  // .......##.......
+        0x80, 0x01,  // .......##.......
+        0x80, 0x01,  // .......##.......
+        0x80, 0x01,  // .......##.......
+        0x00, 0x00,  // ................
     },
     ui::Color::green().v,
     app_location_t::GAMES,
@@ -72,4 +55,4 @@ __attribute__((section(".external_app.app_dinogame.application_information"), us
     {0, 0, 0, 0},
     0x00000000,
 };
-}
+}

firmware/application/external/doom/ui_doom.cpp

@@ -31,7 +31,7 @@ int HALF_HEIGHT = 0;
 #define JOGGING_SPEED 1.2
 #define MAX_ENTITY_DISTANCE 200
 #define ITEM_COLLIDER_DIST 6
-#define PI 3.14159265358979323846
+#include "mathdef.hpp"
 #define GUN_WIDTH 30
 #define GUN_HEIGHT 40
 #define GUN_TARGET_POS 24

firmware/application/external/epirb_rx/main.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2024 EPIRB Decoder Implementation
+ *
+ * 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_epirb_rx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::epirb_rx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<EPIRBAppView>();
+}
+}  // namespace ui::external_app::epirb_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_epirb_rx.application_information"), used)) application_information_t _application_information_epirb_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::epirb_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "EPIRB RX",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x7C,
+        0x3E,
+        0xFE,
+        0x7F,
+        0xFF,
+        0xFF,
+        0xF7,
+        0xEF,
+        0xE3,
+        0xC7,
+        0xE3,
+        0xC7,
+        0xE3,
+        0xC7,
+        0xE3,
+        0xC7,
+        0xF7,
+        0xEF,
+        0xFF,
+        0xFF,
+        0xFE,
+        0x7F,
+        0x7C,
+        0x3E,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::red().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_epirb_rx */ {'P', 'E', 'P', 'I'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/epirb_rx/ui_epirb_rx.cpp

@@ -0,0 +1,707 @@
+/*
+ * Copyright (C) 2024 EPIRB Decoder Implementation
+ *
+ * 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 "baseband_api.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "file_path.hpp"
+
+#include "ui_epirb_rx.hpp"
+
+using namespace portapack;
+
+#include "rtc_time.hpp"
+#include "string_format.hpp"
+#include "ui.hpp"
+
+#include "message.hpp"
+
+namespace ui::external_app::epirb_rx {
+
+EPIRBBeacon EPIRBDecoder::decode_packet(const baseband::Packet& packet) {
+    EPIRBBeacon beacon;
+
+    if (packet.size() < 112) {
+        return beacon;  // Invalid packet
+    }
+
+    // Convert packet bits to byte array for easier processing
+    std::array<uint8_t, 16> data{};
+    for (size_t i = 0; i < std::min(packet.size() / 8, data.size()); i++) {
+        uint8_t byte_val = 0;
+        for (int bit = 0; bit < 8 && (i * 8 + bit) < packet.size(); bit++) {
+            if (packet[i * 8 + bit]) {
+                byte_val |= (1 << (7 - bit));
+            }
+        }
+        data[i] = byte_val;
+    }
+
+    // Perform BCH error detection and correction
+    uint8_t error_count = 0;
+    beacon.packet_status = perform_bch_check(data, error_count);
+    beacon.error_count = error_count;
+
+    // Extract beacon ID (bits 26-85, 15 hex digits)
+    beacon.beacon_id = 0;
+    for (int i = 3; i < 11; i++) {
+        beacon.beacon_id = (beacon.beacon_id << 8) | data[i];
+    }
+
+    // Extract beacon type (bits 86-88)
+    uint8_t type_bits = (data[10] >> 5) & 0x07;
+    beacon.beacon_type = decode_beacon_type(type_bits);
+
+    // Extract emergency type (bits 91-94 for some beacon types)
+    uint8_t emergency_bits = (data[11] >> 4) & 0x0F;
+    beacon.emergency_type = decode_emergency_type(emergency_bits);
+
+    // Extract location if encoded (depends on beacon type and protocol)
+    beacon.location = decode_location(data);
+
+    // Extract country code (bits 1-10)
+    beacon.country_code = decode_country_code(data);
+
+    // Set timestamp
+    rtc::RTC datetime;
+    rtcGetTime(&RTCD1, &datetime);
+    beacon.timestamp = datetime;
+
+    return beacon;
+}
+
+EPIRBLocation EPIRBDecoder::decode_location(const std::array<uint8_t, 16>& data) {
+    // EPIRB location encoding varies by protocol version
+    // This is a simplified decoder for the most common format
+
+    // Check for location data presence (bit patterns vary)
+    if ((data[12] & 0x80) == 0) {
+        return EPIRBLocation();  // No location data
+    }
+
+    // Extract latitude (simplified - actual encoding is more complex)
+    int32_t lat_raw = ((data[12] & 0x7F) << 10) | (data[13] << 2) | ((data[14] >> 6) & 0x03);
+    if (lat_raw & 0x10000) lat_raw |= 0xFFFE0000;  // Sign extend
+    float latitude = lat_raw * (180.0f / 131072.0f);
+
+    // Extract longitude (simplified - actual encoding is more complex)
+    int32_t lon_raw = ((data[14] & 0x3F) << 12) | (data[15] << 4) | ((data[0] >> 4) & 0x0F);
+    if (lon_raw & 0x20000) lon_raw |= 0xFFFC0000;  // Sign extend
+    float longitude = lon_raw * (360.0f / 262144.0f);
+
+    // Validate coordinates
+    if (latitude < -90.0f || latitude > 90.0f || longitude < -180.0f || longitude > 180.0f) {
+        return EPIRBLocation();  // Invalid coordinates
+    }
+
+    return EPIRBLocation(latitude, longitude);
+}
+
+BeaconType EPIRBDecoder::decode_beacon_type(uint8_t type_bits) {
+    switch (type_bits) {
+        case 0:
+            return BeaconType::OrbitingLocationBeacon;
+        case 1:
+            return BeaconType::PersonalLocatorBeacon;
+        case 2:
+            return BeaconType::EmergencyLocatorTransmitter;
+        case 3:
+            return BeaconType::SerialELT;
+        case 4:
+            return BeaconType::NationalELT;
+        default:
+            return BeaconType::Other;
+    }
+}
+
+EmergencyType EPIRBDecoder::decode_emergency_type(uint8_t emergency_bits) {
+    switch (emergency_bits) {
+        case 0:
+            return EmergencyType::Fire;
+        case 1:
+            return EmergencyType::Flooding;
+        case 2:
+            return EmergencyType::Collision;
+        case 3:
+            return EmergencyType::Grounding;
+        case 4:
+            return EmergencyType::Sinking;
+        case 5:
+            return EmergencyType::Disabled;
+        case 6:
+            return EmergencyType::Abandoning;
+        case 7:
+            return EmergencyType::Piracy;
+        case 8:
+            return EmergencyType::Man_Overboard;
+        default:
+            return EmergencyType::Other;
+    }
+}
+
+uint32_t EPIRBDecoder::decode_country_code(const std::array<uint8_t, 16>& data) {
+    // Country code is in bits 1-10 (ITU country code)
+    return ((data[0] & 0x03) << 8) | data[1];
+}
+
+std::string EPIRBDecoder::decode_vessel_name(const std::array<uint8_t, 16>& /* data */) {
+    // Vessel name extraction depends on beacon type and protocol
+    // This is a placeholder - actual implementation would be more complex
+    return "";
+}
+
+PacketStatus EPIRBDecoder::perform_bch_check(std::array<uint8_t, 16>& data, uint8_t& error_count) {
+    // Make a copy to detect changes
+    std::array<uint8_t, 16> original_data = data;
+
+    // Calculate BCH syndrome
+    uint32_t syndrome = calculate_bch_syndrome(data);
+
+    if (syndrome == 0) {
+        // No errors detected
+        error_count = 0;
+        return PacketStatus::Valid;
+    }
+
+    // Try to correct single-bit error
+    if (correct_single_error(data, syndrome)) {
+        // Successfully corrected
+        error_count = count_bit_errors(original_data, data);
+        return PacketStatus::Corrected;
+    }
+
+    // Multiple errors or uncorrectable
+    error_count = 255;  // Indicate unknown error count
+    return PacketStatus::Error;
+}
+
+uint32_t EPIRBDecoder::calculate_bch_syndrome(const std::array<uint8_t, 16>& data) {
+    // BCH(127,92,5) polynomial for EPIRB: x^35 + x^2 + x + 1
+    // This is a simplified implementation - actual EPIRB uses BCH(63,21,6)
+    uint32_t syndrome = 0;
+    uint32_t polynomial = 0x80000007;  // x^31 + x^2 + x + 1 (simplified)
+
+    // Process each byte of the data
+    for (int i = 0; i < 14; i++) {  // Only data bits, not parity
+        uint32_t byte_val = data[i];
+        for (int bit = 7; bit >= 0; bit--) {
+            syndrome <<= 1;
+            if (byte_val & (1 << bit)) {
+                syndrome |= 1;
+            }
+
+            // XOR with polynomial if MSB is set
+            if (syndrome & 0x80000000) {
+                syndrome ^= polynomial;
+            }
+        }
+    }
+
+    // XOR with parity bits
+    syndrome ^= (data[14] << 8) | data[15];
+
+    return syndrome & 0xFFFF;  // 16-bit syndrome
+}
+
+bool EPIRBDecoder::correct_single_error(std::array<uint8_t, 16>& data, uint32_t syndrome) {
+    // Simplified single-error correction
+    // This is a basic implementation - real BCH correction is more complex
+
+    if (syndrome == 0) return true;  // No error
+
+    // Look up table for single-bit error patterns (simplified)
+    // In a real implementation, this would be a proper BCH syndrome table
+    for (int byte_idx = 0; byte_idx < 14; byte_idx++) {
+        for (int bit_idx = 0; bit_idx < 8; bit_idx++) {
+            // Create test error pattern
+            std::array<uint8_t, 16> test_data = data;
+            test_data[byte_idx] ^= (1 << bit_idx);
+
+            // Check if this correction produces zero syndrome
+            if (calculate_bch_syndrome(test_data) == 0) {
+                // Found the error location, apply correction
+                data[byte_idx] ^= (1 << bit_idx);
+                return true;
+            }
+        }
+    }
+
+    return false;  // Could not correct
+}
+
+uint8_t EPIRBDecoder::count_bit_errors(const std::array<uint8_t, 16>& original, const std::array<uint8_t, 16>& corrected) {
+    uint8_t count = 0;
+    for (size_t i = 0; i < 16; i++) {
+        uint8_t diff = original[i] ^ corrected[i];
+        // Count set bits in diff
+        while (diff) {
+            count += diff & 1;
+            diff >>= 1;
+        }
+    }
+    return count;
+}
+
+void EPIRBLogger::on_packet(const EPIRBBeacon& beacon) {
+    std::string entry = "EPIRB," +
+                        to_string_dec_uint(beacon.beacon_id, 15, '0') + "," +
+                        to_string_dec_uint(static_cast<uint8_t>(beacon.beacon_type)) + "," +
+                        to_string_dec_uint(static_cast<uint8_t>(beacon.emergency_type)) + ",";
+
+    if (beacon.location.valid) {
+        entry += to_string_decimal(beacon.location.latitude, 6) + "," +
+                 to_string_decimal(beacon.location.longitude, 6);
+    } else {
+        entry += ",";
+    }
+
+    entry += "," + to_string_dec_uint(beacon.country_code) + "," +
+             format_packet_status(beacon.packet_status) + "," +
+             to_string_dec_uint(beacon.error_count) + "\n";
+
+    log_file.write_entry(beacon.timestamp, entry);
+}
+
+std::string format_beacon_type(BeaconType type) {
+    switch (type) {
+        case BeaconType::OrbitingLocationBeacon:
+            return "OLB";
+        case BeaconType::PersonalLocatorBeacon:
+            return "PLB";
+        case BeaconType::EmergencyLocatorTransmitter:
+            return "ELT";
+        case BeaconType::SerialELT:
+            return "S-ELT";
+        case BeaconType::NationalELT:
+            return "N-ELT";
+        default:
+            return "Other";
+    }
+}
+
+std::string format_emergency_type(EmergencyType type) {
+    switch (type) {
+        case EmergencyType::Fire:
+            return "Fire";
+        case EmergencyType::Flooding:
+            return "Flooding";
+        case EmergencyType::Collision:
+            return "Collision";
+        case EmergencyType::Grounding:
+            return "Grounding";
+        case EmergencyType::Sinking:
+            return "Sinking";
+        case EmergencyType::Disabled:
+            return "Disabled";
+        case EmergencyType::Abandoning:
+            return "Abandoning";
+        case EmergencyType::Piracy:
+            return "Piracy";
+        case EmergencyType::Man_Overboard:
+            return "MOB";
+        default:
+            return "Other";
+    }
+}
+
+std::string format_packet_status(PacketStatus status) {
+    switch (status) {
+        case PacketStatus::Valid:
+            return "OK";
+        case PacketStatus::Corrected:
+            return "CORR";
+        case PacketStatus::Error:
+            return "ERR";
+        default:
+            return "UNK";
+    }
+}
+
+ui::Color get_packet_status_color(PacketStatus status) {
+    switch (status) {
+        case PacketStatus::Valid:
+            return ui::Color::green();
+        case PacketStatus::Corrected:
+            return ui::Color::yellow();
+        case PacketStatus::Error:
+            return ui::Color::red();
+        default:
+            return ui::Color::white();
+    }
+}
+
+EPIRBBeaconDetailView::EPIRBBeaconDetailView(ui::NavigationView& nav) {
+    add_children({&button_done,
+                  &button_see_map});
+
+    button_done.on_select = [this](Button&) {
+        if (on_close) on_close();
+    };
+
+    button_see_map.on_select = [this, &nav](Button&) {
+        if (beacon_.location.valid) {
+            nav.push<GeoMapView>(
+                to_string_hex(beacon_.beacon_id, 8),  // tag as string
+                0,                                    // altitude
+                GeoPos::alt_unit::METERS,
+                GeoPos::spd_unit::NONE,
+                beacon_.location.latitude,
+                beacon_.location.longitude,
+                0,  // angle
+                [this]() {
+                    if (on_close) on_close();
+                });
+        }
+    };
+}
+
+void EPIRBBeaconDetailView::set_beacon(const EPIRBBeacon& beacon) {
+    beacon_ = beacon;
+    set_dirty();
+}
+
+void EPIRBBeaconDetailView::focus() {
+    button_see_map.focus();
+}
+
+void EPIRBBeaconDetailView::paint(ui::Painter& painter) {
+    View::paint(painter);
+
+    const auto rect = screen_rect();
+    const auto s = style();
+
+    auto draw_cursor = rect.location();
+    draw_cursor += {8, 8};
+
+    draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                             "Beacon ID", to_string_hex(beacon_.beacon_id, 15))
+                      .location();
+
+    draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                             "Type", format_beacon_type(beacon_.beacon_type))
+                      .location();
+
+    draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                             "Emergency", format_emergency_type(beacon_.emergency_type))
+                      .location();
+
+    if (beacon_.location.valid) {
+        draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                                 "Latitude", to_string_decimal(beacon_.location.latitude, 6) + "°")
+                          .location();
+
+        draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                                 "Longitude", to_string_decimal(beacon_.location.longitude, 6) + "°")
+                          .location();
+    } else {
+        draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                                 "Location", "Unknown")
+                          .location();
+    }
+
+    draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                             "Country", to_string_dec_uint(beacon_.country_code))
+                      .location();
+
+    draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                             "Time", to_string_datetime(beacon_.timestamp, HMS))
+                      .location();
+
+    // Show packet status with appropriate color
+    std::string status_text = format_packet_status(beacon_.packet_status);
+    if (beacon_.error_count > 0 && beacon_.packet_status == PacketStatus::Corrected) {
+        status_text += " (" + to_string_dec_uint(beacon_.error_count) + " err)";
+    }
+    draw_cursor = draw_field(painter, {draw_cursor, {200, 16}}, s,
+                             "Status", status_text)
+                      .location();
+}
+
+ui::Rect EPIRBBeaconDetailView::draw_field(
+    ui::Painter& painter,
+    const ui::Rect& draw_rect,
+    const ui::Style& style,
+    const std::string& label,
+    const std::string& value) {
+    const auto label_width = 8 * 8;
+
+    painter.draw_string({draw_rect.location()}, style, label + ":");
+    painter.draw_string({draw_rect.location() + ui::Point{label_width, 0}}, style, value);
+
+    return {draw_rect.location() + ui::Point{0, draw_rect.height()}, draw_rect.size()};
+}
+
+EPIRBAppView::EPIRBAppView(ui::NavigationView& nav)
+    : nav_(nav) {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+
+    add_children({&label_frequency,
+                  &options_frequency,
+                  &field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &rssi,
+                  &field_volume,
+                  &channel,
+                  &label_status,
+                  &label_beacons_count,
+                  &label_latest,
+                  &text_latest_info,
+                  &label_packet_stats,
+                  &console,
+                  &button_map,
+                  &button_clear,
+                  &button_log});
+
+    button_map.on_select = [this](Button&) {
+        this->on_show_map();
+    };
+
+    button_clear.on_select = [this](Button&) {
+        this->on_clear_beacons();
+    };
+
+    button_log.on_select = [this](Button&) {
+        this->on_toggle_log();
+    };
+
+    options_frequency.on_change = [this](size_t, ui::OptionsField::value_t v) {
+        receiver_model.set_target_frequency(v);
+    };
+    options_frequency.set_by_value(receiver_model.target_frequency());
+
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        this->on_tick_second();
+    };
+
+    // Configure receiver for default EPIRB frequency (406.028 MHz)
+    receiver_model.set_target_frequency(406028000);
+    receiver_model.set_rf_amp(true);
+    receiver_model.set_lna(32);
+    receiver_model.set_vga(32);
+    receiver_model.set_sampling_rate(2457600);
+    receiver_model.enable();
+
+    logger = std::make_unique<EPIRBLogger>();
+    if (logger) {
+        logger->append(logs_dir / "epirb_rx.txt");
+    }
+}
+
+EPIRBAppView::~EPIRBAppView() {
+    rtc_time::signal_tick_second -= signal_token_tick_second;
+
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+void EPIRBAppView::set_parent_rect(const ui::Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+
+    const auto console_rect = ui::Rect{
+        new_parent_rect.left(),
+        new_parent_rect.top() + header_height,
+        new_parent_rect.width(),
+        new_parent_rect.height() - header_height - 32};
+    console.set_parent_rect(console_rect);
+}
+
+void EPIRBAppView::paint(ui::Painter& /* painter */) {
+    // Custom painting if needed
+}
+
+void EPIRBAppView::focus() {
+    options_frequency.focus();
+}
+
+void EPIRBAppView::on_packet(const baseband::Packet& packet) {
+    // Decode the EPIRB packet
+    auto beacon = EPIRBDecoder::decode_packet(packet);
+
+    if (beacon.beacon_id != 0) {  // Valid beacon decoded
+        on_beacon_decoded(beacon);
+    }
+}
+
+void EPIRBAppView::on_beacon_decoded(const EPIRBBeacon& beacon) {
+    beacons_received++;
+
+    // Track packet statistics
+    switch (beacon.packet_status) {
+        case PacketStatus::Valid:
+            packets_valid++;
+            break;
+        case PacketStatus::Corrected:
+            packets_corrected++;
+            break;
+        case PacketStatus::Error:
+            packets_error++;
+            break;
+    }
+
+    recent_beacons.push_back(beacon);
+
+    // Keep only last 50 beacons
+    if (recent_beacons.size() > 50) {
+        recent_beacons.erase(recent_beacons.begin());
+    }
+
+    // Update display
+    update_display();
+
+    // Log the beacon
+    if (logger) {
+        logger->on_packet(beacon);
+    }
+
+    // Display in console with full details and colored status
+    std::string beacon_info = format_beacon_summary(beacon);
+    if (beacon.emergency_type != EmergencyType::Other) {
+        beacon_info += " [" + format_emergency_type(beacon.emergency_type) + "]";
+    }
+
+    // Add colored status indicator
+    std::string status_color;
+    switch (beacon.packet_status) {
+        case PacketStatus::Valid:
+            status_color = STR_COLOR_GREEN;
+            break;
+        case PacketStatus::Corrected:
+            status_color = STR_COLOR_YELLOW;
+            break;
+        case PacketStatus::Error:
+            status_color = STR_COLOR_RED;
+            break;
+        default:
+            status_color = STR_COLOR_WHITE;
+            break;
+    }
+
+    beacon_info += " [" + status_color + format_packet_status(beacon.packet_status) + STR_COLOR_WHITE + "]";
+    if (beacon.error_count > 0 && beacon.packet_status == PacketStatus::Corrected) {
+        beacon_info += " (" + to_string_dec_uint(beacon.error_count) + "e)";
+    }
+
+    console.write(beacon_info + "\n");
+}
+
+void EPIRBAppView::on_show_map() {
+    if (!recent_beacons.empty()) {
+        // Find latest beacon with valid location
+        for (auto it = recent_beacons.rbegin(); it != recent_beacons.rend(); ++it) {
+            if (it->location.valid) {
+                // Create a GeoMapView with all beacon locations
+                auto map_view = nav_.push<ui::GeoMapView>(
+                    "EPIRB",  // tag
+                    0,        // altitude
+                    ui::GeoPos::alt_unit::METERS,
+                    ui::GeoPos::spd_unit::NONE,
+                    it->location.latitude,
+                    it->location.longitude,
+                    0  // angle
+                );
+
+                // Add all beacons with valid locations as markers
+                for (const auto& beacon : recent_beacons) {
+                    if (beacon.location.valid) {
+                        ui::GeoMarker marker;
+                        marker.lat = beacon.location.latitude;
+                        marker.lon = beacon.location.longitude;
+                        marker.angle = 0;
+                        marker.tag = to_string_hex(beacon.beacon_id, 8) + " " +
+                                     format_beacon_type(beacon.beacon_type);
+                        map_view->store_marker(marker);
+                    }
+                }
+                return;
+            }
+        }
+    }
+
+    // No valid location found
+    nav_.display_modal("No Location", "No beacons with valid\nlocation data found.");
+}
+
+void EPIRBAppView::on_clear_beacons() {
+    recent_beacons.clear();
+    beacons_received = 0;
+    packets_valid = 0;
+    packets_corrected = 0;
+    packets_error = 0;
+    console.clear(true);
+    update_display();
+}
+
+void EPIRBAppView::on_toggle_log() {
+    // Toggle logging functionality
+    if (logger) {
+        logger.reset();
+        button_log.set_text("Log");
+    } else {
+        logger = std::make_unique<EPIRBLogger>();
+        logger->append("epirb_rx.txt");
+        button_log.set_text("Stop");
+    }
+}
+
+void EPIRBAppView::on_tick_second() {
+    // Update status display every second
+    rtc::RTC datetime;
+    rtcGetTime(&RTCD1, &datetime);
+
+    label_status.set("Listening... " + to_string_datetime(datetime, HM));
+}
+
+void EPIRBAppView::update_display() {
+    label_beacons_count.set("Beacons: " + to_string_dec_uint(beacons_received));
+
+    // Update packet statistics display
+    std::string stats = std::string("Stats: ") +
+                        STR_COLOR_GREEN + to_string_dec_uint(packets_valid) + "OK " +
+                        STR_COLOR_YELLOW + to_string_dec_uint(packets_corrected) + "CORR " +
+                        STR_COLOR_RED + to_string_dec_uint(packets_error) + "ERR" + STR_COLOR_WHITE;
+    label_packet_stats.set(stats);
+
+    if (!recent_beacons.empty()) {
+        const auto& latest = recent_beacons.back();
+        text_latest_info.set(format_beacon_summary(latest));
+    }
+}
+
+std::string EPIRBAppView::format_beacon_summary(const EPIRBBeacon& beacon) {
+    std::string summary = to_string_hex(beacon.beacon_id, 8) + " " +
+                          format_beacon_type(beacon.beacon_type);
+
+    if (beacon.location.valid) {
+        summary += " " + format_location(beacon.location);
+    }
+
+    // Add status indicator for summary display
+    summary += " " + format_packet_status(beacon.packet_status);
+
+    return summary;
+}
+
+std::string EPIRBAppView::format_location(const EPIRBLocation& location) {
+    return to_string_decimal(location.latitude, 4) + "°," +
+           to_string_decimal(location.longitude, 4) + "°";
+}
+
+}  // namespace ui::external_app::epirb_rx

firmware/application/external/epirb_rx/ui_epirb_rx.hpp

@@ -0,0 +1,297 @@
+/*
+ * Copyright (C) 2024 EPIRB Decoder Implementation
+ *
+ * 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_EPIRB_RX_H__
+#define __UI_EPIRB_RX_H__
+
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_geomap.hpp"
+
+#include "event_m0.hpp"
+#include "signal.hpp"
+#include "message.hpp"
+#include "log_file.hpp"
+
+#include "baseband_packet.hpp"
+
+/* #include <cstdint>
+#include <cstddef>
+#include <string>
+#include <array> */
+
+namespace ui::external_app::epirb_rx {
+
+// EPIRB 406 MHz beacon types
+enum class BeaconType : uint8_t {
+    OrbitingLocationBeacon = 0,
+    PersonalLocatorBeacon = 1,
+    EmergencyLocatorTransmitter = 2,
+    SerialELT = 3,
+    NationalELT = 4,
+    Other = 15
+};
+
+// EPIRB distress and emergency types
+enum class EmergencyType : uint8_t {
+    Fire = 0,
+    Flooding = 1,
+    Collision = 2,
+    Grounding = 3,
+    Sinking = 4,
+    Disabled = 5,
+    Abandoning = 6,
+    Piracy = 7,
+    Man_Overboard = 8,
+    Other = 15
+};
+
+struct EPIRBLocation {
+    float latitude;   // degrees, -90 to +90
+    float longitude;  // degrees, -180 to +180
+    bool valid;
+
+    EPIRBLocation()
+        : latitude(0.0f), longitude(0.0f), valid(false) {}
+    EPIRBLocation(float lat, float lon)
+        : latitude(lat), longitude(lon), valid(true) {}
+};
+
+enum class PacketStatus : uint8_t {
+    Valid = 0,
+    Corrected = 1,
+    Error = 2
+};
+
+struct EPIRBBeacon {
+    uint32_t beacon_id;
+    BeaconType beacon_type;
+    EmergencyType emergency_type;
+    EPIRBLocation location;
+    uint32_t country_code;
+    std::string vessel_name;
+    rtc::RTC timestamp;
+    uint32_t sequence_number;
+    PacketStatus packet_status;
+    uint8_t error_count;
+
+    EPIRBBeacon()
+        : beacon_id(0), beacon_type(BeaconType::Other), emergency_type(EmergencyType::Other), location(), country_code(0), vessel_name(), timestamp(), sequence_number(0), packet_status(PacketStatus::Error), error_count(0) {}
+};
+
+class EPIRBDecoder {
+   public:
+    static EPIRBBeacon decode_packet(const baseband::Packet& packet);
+
+   private:
+    static EPIRBLocation decode_location(const std::array<uint8_t, 16>& data);
+    static BeaconType decode_beacon_type(uint8_t type_bits);
+    static EmergencyType decode_emergency_type(uint8_t emergency_bits);
+    static uint32_t decode_country_code(const std::array<uint8_t, 16>& data);
+    static std::string decode_vessel_name(const std::array<uint8_t, 16>& data);
+
+    // BCH error correction methods
+    static PacketStatus perform_bch_check(std::array<uint8_t, 16>& data, uint8_t& error_count);
+    static uint32_t calculate_bch_syndrome(const std::array<uint8_t, 16>& data);
+    static bool correct_single_error(std::array<uint8_t, 16>& data, uint32_t syndrome);
+    static uint8_t count_bit_errors(const std::array<uint8_t, 16>& original, const std::array<uint8_t, 16>& corrected);
+};
+
+class EPIRBLogger {
+   public:
+    Optional<File::Error> append(const std::filesystem::path& filename) {
+        return log_file.append(filename);
+    }
+
+    void on_packet(const EPIRBBeacon& beacon);
+
+   private:
+    LogFile log_file{};
+};
+
+// Forward declarations of formatting functions
+std::string format_beacon_type(BeaconType type);
+std::string format_emergency_type(EmergencyType type);
+std::string format_packet_status(PacketStatus status);
+ui::Color get_packet_status_color(PacketStatus status);
+
+class EPIRBBeaconDetailView : public ui::View {
+   public:
+    std::function<void(void)> on_close{};
+
+    EPIRBBeaconDetailView(ui::NavigationView& nav);
+    EPIRBBeaconDetailView(const EPIRBBeaconDetailView&) = delete;
+    EPIRBBeaconDetailView& operator=(const EPIRBBeaconDetailView&) = delete;
+
+    void set_beacon(const EPIRBBeacon& beacon);
+    const EPIRBBeacon& beacon() const { return beacon_; }
+
+    void focus() override;
+    void paint(ui::Painter&) override;
+
+    ui::GeoMapView* get_geomap_view() { return geomap_view; }
+
+   private:
+    EPIRBBeacon beacon_{};
+
+    ui::Button button_done{
+        {125, 224, 96, 24},
+        "Done"};
+    ui::Button button_see_map{
+        {19, 224, 96, 24},
+        "See on map"};
+
+    ui::GeoMapView* geomap_view{nullptr};
+
+    ui::Rect draw_field(
+        ui::Painter& painter,
+        const ui::Rect& draw_rect,
+        const ui::Style& style,
+        const std::string& label,
+        const std::string& value);
+};
+
+class EPIRBAppView : public ui::View {
+   public:
+    EPIRBAppView(ui::NavigationView& nav);
+    ~EPIRBAppView();
+
+    void set_parent_rect(const ui::Rect new_parent_rect) override;
+    void paint(ui::Painter&) override;
+    void focus() override;
+
+    std::string title() const override { return "EPIRB RX"; }
+
+   private:
+    app_settings::SettingsManager settings_{
+        "rx_epirb", app_settings::Mode::RX};
+
+    ui::NavigationView& nav_;
+
+    std::vector<EPIRBBeacon> recent_beacons{};
+    std::unique_ptr<EPIRBLogger> logger{};
+
+    EPIRBBeaconDetailView beacon_detail_view{nav_};
+
+    static constexpr auto header_height = 4 * 16;
+
+    ui::Text label_frequency{
+        {0 * 8, 0 * 16, 4 * 8, 1 * 16},
+        "Freq"};
+
+    ui::OptionsField options_frequency{
+        {5 * 8, 0 * 16},
+        7,
+        {
+            {"406.028", 406028000},
+            {"406.025", 406025000},
+            {"406.037", 406037000},
+            {"433.025", 433025000},
+            {"144.875", 144875000},
+        }};
+
+    ui::RFAmpField field_rf_amp{
+        {13 * 8, 0 * 16}};
+
+    ui::LNAGainField field_lna{
+        {15 * 8, 0 * 16}};
+
+    ui::VGAGainField field_vga{
+        {18 * 8, 0 * 16}};
+
+    ui::RSSI rssi{
+        {21 * 8, 0, 6 * 8, 4}};
+
+    ui::AudioVolumeField field_volume{
+        {screen_width - 2 * 8, 0 * 16}};
+
+    ui::Channel channel{
+        {21 * 8, 5, 6 * 8, 4}};
+
+    // Status display
+    ui::Text label_status{
+        {0 * 8, 1 * 16, 15 * 8, 1 * 16},
+        "Listening..."};
+
+    ui::Text label_beacons_count{
+        {16 * 8, 1 * 16, 14 * 8, 1 * 16},
+        "Beacons: 0"};
+
+    ui::Text label_packet_stats{
+        {0 * 8, 3 * 16, 29 * 8, 1 * 16},
+        ""};
+
+    // Latest beacon info display
+    ui::Text label_latest{
+        {0 * 8, 2 * 16, 8 * 8, 1 * 16},
+        "Latest:"};
+
+    ui::Text text_latest_info{
+        {8 * 8, 2 * 16, 22 * 8, 1 * 16},
+        ""};
+
+    // Beacon list
+    ui::Console console{
+        {0, 4 * 16, 240, 152}};
+
+    ui::Button button_map{
+        {0, 224, 60, 24},
+        "Map"};
+
+    ui::Button button_clear{
+        {64, 224, 60, 24},
+        "Clear"};
+
+    ui::Button button_log{
+        {128, 224, 60, 24},
+        "Log"};
+
+    SignalToken signal_token_tick_second{};
+    uint32_t beacons_received = 0;
+    uint32_t packets_valid = 0;
+    uint32_t packets_corrected = 0;
+    uint32_t packets_error = 0;
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::EPIRBPacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const EPIRBPacketMessage*>(p);
+            this->on_packet(message->packet);
+        }};
+
+    void on_packet(const baseband::Packet& packet);
+    void on_beacon_decoded(const EPIRBBeacon& beacon);
+    void on_show_map();
+    void on_clear_beacons();
+    void on_toggle_log();
+    void on_tick_second();
+
+    void update_display();
+    std::string format_beacon_summary(const EPIRBBeacon& beacon);
+    std::string format_location(const EPIRBLocation& location);
+};
+
+}  // namespace ui::external_app::epirb_rx
+
+#endif  // __UI_EPIRB_RX_H__

firmware/application/external/ert/ert_app.cpp

@@ -96,22 +96,7 @@ void ERTRecentEntry::update(const ert::Packet& packet) {
     packet_type = packet.type();
 }
 
-namespace ui {
-
-template <>
-void RecentEntriesTable<ERTRecentEntries>::draw(
-    const Entry& entry,
-    const Rect& target_rect,
-    Painter& painter,
-    const Style& style) {
-    std::string line = ert::format::id(entry.id) + " " + ert::format::commodity_type(entry.commodity_type) + " " + ert::format::consumption(entry.last_consumption) + " ";
-
-    line += (entry.packet_type == ert::Packet::Type::SCM) ? ert::format::tamper_flags_scm(entry.last_tamper_flags) : ert::format::tamper_flags(entry.last_tamper_flags);
-    line += (entry.received_count > 99) ? " ++" : to_string_dec_uint(entry.received_count, 3);
-
-    line.resize(target_rect.width() / 8, ' ');
-    painter.draw_string(target_rect.location(), style, line);
-}
+namespace ui::external_app::ert_app {
 
 ERTAppView::ERTAppView(NavigationView& nav)
     : nav_{nav} {
@@ -182,4 +167,21 @@ void ERTAppView::on_freqchg(int64_t freq) {
     field_frequency.set_value(freq);
 }
 
-} /* namespace ui */
+} /* namespace ui::external_app::ert_app */
+
+namespace ui {
+template <>
+void RecentEntriesTable<ui::external_app::ert_app::ERTRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line = ert::format::id(entry.id) + " " + ert::format::commodity_type(entry.commodity_type) + " " + ert::format::consumption(entry.last_consumption) + " ";
+
+    line += (entry.packet_type == ert::Packet::Type::SCM) ? ert::format::tamper_flags_scm(entry.last_tamper_flags) : ert::format::tamper_flags(entry.last_tamper_flags);
+    line += (entry.received_count > 99) ? " ++" : to_string_dec_uint(entry.received_count, 3);
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+}  // namespace ui

firmware/application/external/ert/ert_app.hpp

@@ -104,10 +104,9 @@ class ERTLogger {
     LogFile log_file{};
 };
 
+namespace ui::external_app::ert_app {
+
 using ERTRecentEntries = RecentEntries<ERTRecentEntry>;
-
-namespace ui {
-
 using ERTRecentEntriesView = RecentEntriesView<ERTRecentEntries>;
 
 class ERTAppView : public View {
@@ -188,6 +187,6 @@ class ERTAppView : public View {
     void on_show_list();
 };
 
-} /* namespace ui */
+} /* namespace ui::external_app::ert_app */
 
 #endif /*__ERT_APP_H__*/

firmware/application/external/ert/main.cpp

@@ -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 "ert_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::ert_app {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<ERTAppView>();
+}
+}  // namespace ui::external_app::ert_app
+
+extern "C" {
+
+__attribute__((section(".external_app.app_ert.application_information"), used)) application_information_t _application_information_ert = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::ert_app::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "ERT Meter",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x0F,
+        0x80,
+        0x7F,
+        0xC0,
+        0x0F,
+        0xFC,
+        0x0F,
+        0xC2,
+        0x0F,
+        0x82,
+        0x7F,
+        0x01,
+        0x0F,
+        0x01,
+        0x00,
+        0x21,
+        0x05,
+        0x53,
+        0x09,
+        0x56,
+        0x09,
+        0x50,
+        0x05,
+        0x50,
+        0x05,
+        0x20,
+        0xAD,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_none */ {'P', 'E', 'R', 'T'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/external.cmake

@@ -110,12 +110,13 @@ set(EXTCPPSRC
 	#wefax_rx
 	external/wefax_rx/main.cpp
 	external/wefax_rx/ui_wefax_rx.cpp
-	
+
+
 	#noaaapt_rx
 	external/noaaapt_rx/main.cpp
 	external/noaaapt_rx/ui_noaaapt_rx.cpp
-		
-	
+
+
 
 	#shoppingcart_lock
 	external/shoppingcart_lock/main.cpp
@@ -215,11 +216,39 @@ set(EXTCPPSRC
 
 	#gfxEQ
 	external/gfxeq/main.cpp
-	external/gfxeq/ui_gfxeq.cpp	
+	external/gfxeq/ui_gfxeq.cpp
 
 	#detector_rx
 	external/detector_rx/main.cpp
-	external/detector_rx/ui_detector_rx.cpp		
+	external/detector_rx/ui_detector_rx.cpp
+
+	#space_invaders
+	external/spaceinv/main.cpp
+	external/spaceinv/ui_spaceinv.cpp
+
+	#blackjack
+	external/blackjack/main.cpp
+	external/blackjack/ui_blackjack.cpp
+
+	#battleship
+	external/battleship/main.cpp
+	external/battleship/ui_battleship.cpp
+
+	#ert
+	external/ert/main.cpp
+	external/ert/ert_app.cpp
+
+	#epirb_rx
+	external/epirb_rx/main.cpp
+	external/epirb_rx/ui_epirb_rx.cpp
+
+	#soundboard
+	external/soundboard/main.cpp
+	external/soundboard/soundboard_app.cpp
+
+	#game2048
+	external/game2048/main.cpp
+	external/game2048/ui_game2048.cpp
 )
 
 set(EXTAPPLIST
@@ -248,7 +277,7 @@ set(EXTAPPLIST
 	morse_tx
 	sstvtx
 	random_password
-	#acars_rx
+	# acars_rx
 	ookbrute
 	ook_editor
 	wefax_rx
@@ -276,4 +305,11 @@ set(EXTAPPLIST
 	level
 	gfxeq
 	detector_rx
+	spaceinv
+	blackjack
+	battleship
+	ert
+	epirb_rx
+	soundboard
+	game2048
 )

firmware/application/external/external.ld

@@ -76,6 +76,15 @@ MEMORY
     ram_external_app_noaaapt_rx   (rwx) : org = 0xADE30000, len = 32k
     ram_external_app_detector_rx   (rwx) : org = 0xADE40000, len = 32k
     ram_external_app_dinogame   (rwx) : org = 0xADE50000, len = 32k
+    ram_external_app_spaceinv   (rwx) : org = 0xADE60000, len = 32k
+    ram_external_app_blackjack  (rwx) : org = 0xADE70000, len = 32k
+    ram_external_app_battleship   (rwx) : org = 0xADE80000, len = 32k
+    ram_external_app_ert        (rwx) : org = 0xADE90000, len = 32k
+    ram_external_app_epirb_rx   (rwx) : org = 0xADEA0000, len = 32k
+    ram_external_app_soundboard   (rwx) : org = 0xADEB0000, len = 32k
+    ram_external_app_game2048     (rwx) : org = 0xADEC0000, len = 32k
+
+
 }
 
 SECTIONS
@@ -337,7 +346,7 @@ SECTIONS
         KEEP(*(.external_app.app_stopwatch.application_information));
         *(*ui*external_app*stopwatch*);
     } > ram_external_app_stopwatch
-    
+
    .external_app_wefax_rx : ALIGN(4) SUBALIGN(4)
     {
         KEEP(*(.external_app.app_wefax_rx.application_information));
@@ -360,19 +369,19 @@ SECTIONS
     {
         KEEP(*(.external_app.app_doom.application_information));
         *(*ui*external_app*doom*);
-    } > ram_external_app_doom    
-    
+    } > ram_external_app_doom
+
     .external_app_debug_pmem : ALIGN(4) SUBALIGN(4)
     {
         KEEP(*(.external_app.app_debug_pmem.application_information));
         *(*ui*external_app*debug_pmem*);
-    } > ram_external_app_debug_pmem    
+    } > ram_external_app_debug_pmem
 
     .external_app_scanner : ALIGN(4) SUBALIGN(4)
     {
         KEEP(*(.external_app.app_scanner.application_information));
         *(*ui*external_app*scanner*);
-    } > ram_external_app_scanner    
+    } > ram_external_app_scanner
 
     .external_app_level : ALIGN(4) SUBALIGN(4)
     {
@@ -398,5 +407,47 @@ SECTIONS
         *(*ui*external_app*dinogame*);
     } > ram_external_app_dinogame
 
+    .external_app_spaceinv : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_spaceinv.application_information));
+        *(*ui*external_app*spaceinv*);
+    } > ram_external_app_spaceinv
+
+    .external_app_blackjack : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_blackjack.application_information));
+        *(*ui*external_app*blackjack*);
+    } > ram_external_app_blackjack
+
+    .external_app_battleship : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_battleship.application_information));
+        *(*ui*external_app*battleship*);
+    } > ram_external_app_battleship
+
+    .external_app_ert : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_ert.application_information));
+        *(*ui*external_app*ert*);
+    } > ram_external_app_ert
+
+    .external_app_epirb_rx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_epirb_rx.application_information));
+        *(*ui*external_app*epirb_rx*);
+    } > ram_external_app_epirb_rx
+
+    .external_app_soundboard : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_soundboard.application_information));
+        *(*ui*external_app*soundboard*);
+    } > ram_external_app_soundboard
+
+    .external_app_game2048 : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_game2048.application_information));
+        *(*ui*external_app*game2048*);
+    } > ram_external_app_game2048
+
 }
 

firmware/application/external/font_viewer/ui_font_viewer.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2023 Mark Thompson
- * copyleft Whiterose of the Dark Army
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/font_viewer/ui_font_viewer.hpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2023 Mark Thompson
- * copyleft Whiterose of the Dark Army
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/game2048/main.cpp

@@ -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_game2048.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::game2048 {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<Game2048View>();
+}
+}  // namespace ui::external_app::game2048
+
+extern "C" {
+
+__attribute__((section(".external_app.app_game2048.application_information"), used)) application_information_t _application_information_game2048 = {
+    (uint8_t*)0x00000000,
+    ui::external_app::game2048::initialize_app,
+    CURRENT_HEADER_VERSION,
+    VERSION_MD5,
+
+    "2048",
+    {
+        0x8C,
+        0x31,
+        0x5A,
+        0x6B,
+        0xDE,
+        0x7B,
+        0x8C,
+        0x31,
+        0x00,
+        0x00,
+        0x8C,
+        0x31,
+        0x5A,
+        0x7B,
+        0xDE,
+        0x7B,
+        0x8C,
+        0x31,
+        0x00,
+        0x00,
+        0x8C,
+        0x31,
+        0xDA,
+        0x7B,
+        0xDE,
+        0x7B,
+        0x8C,
+        0x31,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    ui::Color::green().v,
+    app_location_t::GAMES,
+    -1,
+
+    {0, 0, 0, 0},
+    0x00000000,
+};
+}  // namespace ui::external_app::game2048

firmware/application/external/game2048/ui_game2048.cpp

@@ -0,0 +1,422 @@
+/*
+ * copyleft 2025 zxkmm AKA zix aka sommermorgentraum
+ *
+ * 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_game2048.hpp"
+#include "string_format.hpp"
+
+namespace ui::external_app::game2048 {
+
+Game2048View::Game2048View(NavigationView& nav)
+    : nav_(nav), score(0), best_score(0), game_state(STATE_PLAYING) {
+    add_children({&dummy});
+    init_game();
+}
+
+void Game2048View::on_show() {
+    if (!initialized) {
+        std::srand(LPC_RTC->CTIME0);
+        reset_game();
+        initialized = true;
+    }
+}
+
+void Game2048View::init_game() {
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            grid[i][j] = 0;
+        }
+    }
+}
+
+void Game2048View::reset_game() {
+    need_repaint = true;
+    init_game();
+    score = 0;
+    game_state = STATE_PLAYING;
+    add_random_tile();
+    add_random_tile();
+}
+
+void Game2048View::add_random_tile() {
+    std::vector<std::pair<int, int>> empty_cells;
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            if (grid[i][j] == 0) {
+                empty_cells.push_back(std::make_pair(i, j));
+            }
+        }
+    }
+
+    if (!empty_cells.empty()) {
+        auto& random_cell = empty_cells[rand() % empty_cells.size()];
+        grid[random_cell.first][random_cell.second] = (rand() % 10 == 0) ? 4 : 2;
+    }
+}
+
+void Game2048View::compress_left(int row[]) {
+    int temp[GRID_SIZE];
+    int index = 0;
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        temp[i] = 0;
+    }
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        if (row[i] != 0) {
+            temp[index++] = row[i];
+        }
+    }
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        row[i] = temp[i];
+    }
+}
+
+void Game2048View::merge_left(int row[]) {
+    for (int i = 0; i < GRID_SIZE - 1; i++) {
+        if (row[i] != 0 && row[i] == row[i + 1]) {
+            row[i] *= 2;
+            score += row[i];
+            row[i + 1] = 0;
+        }
+    }
+}
+
+bool Game2048View::move_row_left(int row[]) {
+    int original[GRID_SIZE];
+    for (int i = 0; i < GRID_SIZE; i++) {
+        original[i] = row[i];
+    }
+
+    compress_left(row);
+    merge_left(row);
+    compress_left(row);
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        if (original[i] != row[i]) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void Game2048View::rotate_grid_clockwise() {
+    int temp[GRID_SIZE][GRID_SIZE];
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            temp[j][GRID_SIZE - 1 - i] = grid[i][j];
+        }
+    }
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            grid[i][j] = temp[i][j];
+        }
+    }
+}
+
+void Game2048View::rotate_grid_counter_clockwise() {
+    int temp[GRID_SIZE][GRID_SIZE];
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            temp[GRID_SIZE - 1 - j][i] = grid[i][j];
+        }
+    }
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            grid[i][j] = temp[i][j];
+        }
+    }
+}
+
+bool Game2048View::move_left() {
+    bool moved = false;
+    for (int i = 0; i < GRID_SIZE; i++) {
+        if (move_row_left(grid[i])) {
+            moved = true;
+        }
+    }
+    return moved;
+}
+
+bool Game2048View::move_right() {
+    rotate_grid_clockwise();
+    rotate_grid_clockwise();
+    bool moved = move_left();
+    rotate_grid_clockwise();
+    rotate_grid_clockwise();
+    return moved;
+}
+
+bool Game2048View::move_up() {
+    rotate_grid_counter_clockwise();
+    bool moved = move_left();
+    rotate_grid_clockwise();
+    return moved;
+}
+
+bool Game2048View::move_down() {
+    rotate_grid_clockwise();
+    bool moved = move_left();
+    rotate_grid_counter_clockwise();
+    return moved;
+}
+
+bool Game2048View::can_move() {
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            if (grid[i][j] == 0) return true;
+
+            if (j < GRID_SIZE - 1 && grid[i][j] == grid[i][j + 1]) return true;
+            if (i < GRID_SIZE - 1 && grid[i][j] == grid[i + 1][j]) return true;
+        }
+    }
+    return false;
+}
+
+bool Game2048View::is_game_won() {
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            if (grid[i][j] == 2048) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+Color Game2048View::get_tile_color(int value) {
+    switch (value) {
+        case 0:
+            return Color::light_grey();
+        case 2:
+            return Color::white();
+        case 4:
+            return Color::yellow();
+        case 8:
+            return Color::orange();
+        case 16:
+            return Color::red();
+        case 32:
+            return Color::magenta();
+        case 64:
+            return Color::purple();
+        case 128:
+            return Color::blue();
+        case 256:
+            return Color::cyan();
+        case 512:
+            return Color::green();
+        case 1024:
+            return Color::dark_green();
+        case 2048:
+            return Color::dark_red();
+        default:
+            return Color::black();
+    }
+}
+
+Color Game2048View::get_text_color(int value) {
+    if (value <= 4) {
+        return Color::black();
+    }
+    return Color::white();
+}
+
+void Game2048View::draw_tile(int x, int y, int value) {
+    int tile_x = BOARD_START_X + x * (TILE_SIZE + TILE_MARGIN);
+    int tile_y = BOARD_START_Y + y * (TILE_SIZE + TILE_MARGIN);
+
+    Color tile_color = get_tile_color(value);
+
+    painter.fill_rectangle({tile_x, tile_y, TILE_SIZE, TILE_SIZE}, tile_color);
+    painter.draw_rectangle({tile_x, tile_y, TILE_SIZE, TILE_SIZE}, Color::dark_grey());
+
+    if (value > 0) {
+        std::string value_str = to_string_dec_uint(value);
+        int text_width = value_str.length() * 8;
+        int text_height = 16;
+        int text_x = tile_x + (TILE_SIZE - text_width) / 2;
+        int text_y = tile_y + (TILE_SIZE - text_height) / 2;
+
+        painter.draw_string({text_x, text_y}, *Theme::getInstance()->bg_darkest, value_str);
+    }
+}
+
+void Game2048View::draw_score() {
+    painter.fill_rectangle({0, 0, screen_width, INFO_HEIGHT}, Color::black());
+
+    std::string score_str = "Score: " + to_string_dec_uint(score);
+    painter.draw_string({10, 5}, *Theme::getInstance()->bg_darkest, score_str);
+
+    if (best_score > 0) {
+        std::string best_str = "Best: " + to_string_dec_uint(best_score);
+        painter.draw_string({150, 5}, *Theme::getInstance()->bg_darkest, best_str);
+    }
+}
+
+void Game2048View::draw_game() {
+    // the paint timing is always bad at app enterences,
+    // in all apps it behave like this.
+    // this is a buffer timer to let it flash a time until app loaded.
+    if (!need_repaint && load_wait_time_counter++ < 40000) {
+        return;
+    }
+    if (need_repaint_bg_frame) painter.fill_rectangle({0, INFO_HEIGHT, screen_width, screen_height - INFO_HEIGHT}, Color::dark_grey());
+
+    for (int i = 0; i < GRID_SIZE; i++) {
+        for (int j = 0; j < GRID_SIZE; j++) {
+            draw_tile(j, i, grid[i][j]);
+        }
+    }
+
+    draw_score();
+
+    need_repaint = false;
+    need_repaint_bg_frame = false;
+}
+
+void Game2048View::show_game_over() {
+    if (show_you_won_you_lost_slow_down_cunter++ % 1000 != 0) return;
+    // slow down otherwies it repaint even faster than it finished paint full stuff
+    painter.fill_rectangle({40, 100, 160, 100}, Color::black());
+    painter.draw_rectangle({40, 100, 160, 100}, Color::white());
+    painter.draw_string({80, 115}, *Theme::getInstance()->bg_darkest, "GAME OVER");
+    painter.draw_string({70, 135}, *Theme::getInstance()->bg_darkest, "Press SELECT");
+    painter.draw_string({75, 155}, *Theme::getInstance()->bg_darkest, "to restart");
+    need_repaint = false;
+    need_repaint_bg_frame = true;
+}
+
+void Game2048View::show_you_won() {
+    if (show_you_won_you_lost_slow_down_cunter++ % 1000 != 0) return;
+    // slow down otherwies it repaint even faster than it finished paint full stuff
+    painter.fill_rectangle({40, 100, 160, 100}, Color::black());
+    painter.draw_rectangle({40, 100, 160, 100}, Color::white());
+    painter.draw_string({80, 115}, *Theme::getInstance()->bg_darkest, "YOU WON!");
+    painter.draw_string({70, 135}, *Theme::getInstance()->bg_darkest, "Press SELECT");
+    painter.draw_string({75, 155}, *Theme::getInstance()->bg_darkest, "to restart");
+    need_repaint = false;
+    need_repaint_bg_frame = true;
+}
+
+void Game2048View::paint(Painter&) {
+    draw_game();
+
+    if (game_state == STATE_GAME_OVER) {
+        need_repaint = true;
+        need_repaint_bg_frame = true;
+        show_game_over();
+    } else if (game_state == STATE_WON) {
+        need_repaint = true;
+        need_repaint_bg_frame = true;
+        show_you_won();
+    }
+}
+
+void Game2048View::frame_sync() {
+    draw_game();
+
+    if (game_state == STATE_GAME_OVER) {
+        show_game_over();
+    } else if (game_state == STATE_WON) {
+        show_you_won();
+    }
+}
+
+bool Game2048View::on_key(KeyEvent key) {
+    if (key == KeyEvent::Select) {
+        if (game_state == STATE_GAME_OVER || game_state == STATE_WON) {
+            reset_game();
+            return true;
+        }
+    }
+
+    if (game_state != STATE_PLAYING) {
+        return false;
+    }
+
+    bool moved = false;
+
+    switch (key) {
+        case KeyEvent::Left:
+            moved = move_left();
+            break;
+        case KeyEvent::Right:
+            moved = move_right();
+            break;
+        case KeyEvent::Up:
+            moved = move_up();
+            break;
+        case KeyEvent::Down:
+            moved = move_down();
+            break;
+        default:
+            return false;
+    }
+
+    if (moved) {
+        need_repaint = true;
+        add_random_tile();
+
+        if (score > best_score) {
+            best_score = score;
+        }
+
+        if (is_game_won() && game_state == STATE_PLAYING) {
+            game_state = STATE_WON;
+        } else if (!can_move()) {
+            game_state = STATE_GAME_OVER;
+        }
+    }
+
+    return true;
+}
+
+bool Game2048View::on_encoder(const EncoderEvent) {
+    if (game_state != STATE_PLAYING) {
+        return false;
+    }
+
+    bool moved = false;
+
+    if (moved) {
+        add_random_tile();
+
+        if (score > best_score) {
+            best_score = score;
+        }
+
+        if (is_game_won() && game_state == STATE_PLAYING) {
+            game_state = STATE_WON;
+        } else if (!can_move()) {
+            game_state = STATE_GAME_OVER;
+        }
+    }
+
+    return true;
+}
+
+}  // namespace ui::external_app::game2048

firmware/application/external/game2048/ui_game2048.hpp

@@ -0,0 +1,113 @@
+/*
+ * copyleft 2025 zxkmm AKA zix aka sommermorgentraum
+ *
+ * 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_GAME2048_H__
+#define __UI_GAME2048_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "event_m0.hpp"
+#include "message.hpp"
+#include "irq_controls.hpp"
+#include "lpc43xx_cpp.hpp"
+#include "ui_widget.hpp"
+
+namespace ui::external_app::game2048 {
+
+#define GRID_SIZE 4
+#define TILE_SIZE 50
+#define TILE_MARGIN 5
+#define BOARD_START_X 15
+#define BOARD_START_Y 35
+#define INFO_HEIGHT 30
+
+enum GameState {
+    STATE_PLAYING,
+    STATE_GAME_OVER,
+    STATE_WON
+};
+
+class Game2048View : public View {
+   public:
+    Game2048View(NavigationView& nav);
+    void on_show() override;
+
+    std::string title() const override { return "2048"; }
+
+    void focus() override { dummy.focus(); }
+    void paint(Painter& painter) override;
+    void frame_sync();
+    bool on_key(KeyEvent key) override;
+    bool on_encoder(const EncoderEvent event) override;
+
+   private:
+    NavigationView& nav_;
+    Painter painter{};
+
+    int grid[GRID_SIZE][GRID_SIZE];
+    int score;
+    int best_score;
+    GameState game_state;
+    bool initialized = false;
+    bool need_repaint = true;
+    bool need_repaint_bg_frame = true;  // drar bg frame is too flickering, so make it paint as less as possible
+    bool need_set_dirty = false;
+    uint32_t load_wait_time_counter = 0;                  // the paint timing is always bad at app enterences,
+                                                          // in all apps it behave like this.
+                                                          // this is a buffer timer to let it flash a time until app loaded.
+    uint32_t show_you_won_you_lost_slow_down_cunter = 0;  // slow down otherwies it repaint even faster than it finished paint fulll stuff
+
+    void init_game();
+    void reset_game();
+    void add_random_tile();
+    bool move_left();
+    bool move_right();
+    bool move_up();
+    bool move_down();
+    bool can_move();
+    bool is_game_won();
+    void draw_game();
+    void draw_tile(int x, int y, int value);
+    void draw_score();
+    void show_game_over();
+    void show_you_won();
+    Color get_tile_color(int value);
+    Color get_text_color(int value);
+    void compress_left(int row[]);
+    void merge_left(int row[]);
+    bool move_row_left(int row[]);
+    void rotate_grid_clockwise();
+    void rotate_grid_counter_clockwise();
+
+    Button dummy{
+        {screen_width, 0, 0, 0},
+        ""};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->frame_sync();
+        }};
+};
+
+}  // namespace ui::external_app::game2048
+
+#endif /* __UI_GAME2048_H__ */

firmware/application/external/hopper/ui_hopper.cpp

@@ -2,7 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2020 euquiq
- * copyleft mr.r0b0t from the F society
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/hopper/ui_hopper.hpp

@@ -2,7 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2020 euquiq
- * copyleft mr.r0b0t from the F society
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/jammer/ui_jammer.cpp

@@ -112,6 +112,7 @@ void RangeView::paint(Painter&) {
 }
 
 RangeView::RangeView(NavigationView& nav) {
+    (void)nav;
     hidden(true);
 
     add_children({&labels,
@@ -122,50 +123,6 @@ RangeView::RangeView(NavigationView& nav) {
                   &button_center,
                   &button_width});
 
-    check_enabled.on_select = [this](Checkbox&, bool v) {
-        frequency_range.enabled = v;
-    };
-
-    button_start.on_select = [this, &nav](Button& button) {
-        auto new_view = nav.push<FrequencyKeypadView>(frequency_range.min);
-        new_view->on_changed = [this, &button](rf::Frequency f) {
-            update_start(f);
-        };
-    };
-
-    button_stop.on_select = [this, &nav](Button& button) {
-        auto new_view = nav.push<FrequencyKeypadView>(frequency_range.max);
-        new_view->on_changed = [this, &button](rf::Frequency f) {
-            update_stop(f);
-        };
-    };
-
-    button_center.on_select = [this, &nav](Button& button) {
-        auto new_view = nav.push<FrequencyKeypadView>(center);
-        new_view->on_changed = [this, &button](rf::Frequency f) {
-            update_center(f);
-        };
-    };
-
-    button_width.on_select = [this, &nav](Button& button) {
-        auto new_view = nav.push<FrequencyKeypadView>(width);
-        new_view->on_changed = [this, &button](rf::Frequency f) {
-            update_width(f);
-        };
-    };
-
-    button_load_range.on_select = [this, &nav](Button&) {
-        auto load_view = nav.push<FrequencyLoadView>();
-        load_view->on_frequency_loaded = [this](rf::Frequency value) {
-            update_center(value);
-            update_width(100000);
-        };
-        load_view->on_range_loaded = [this](rf::Frequency start, rf::Frequency stop) {
-            update_start(start);
-            update_stop(stop);
-        };
-    };
-
     check_enabled.set_value(false);
 }
 
@@ -274,7 +231,7 @@ bool JammerView::update_config() {
         return true;
     } else {
         if (out_of_ranges)
-            nav_.display_modal("Error", "Jamming bandwidth too large.\nMust be less than 24MHz.");
+            nav_.display_modal("Error", "Jamming bandwidth too large.\nMust be 80MHz or less.");
         else
             nav_.display_modal("Error", "No range enabled.");
         return false;
@@ -400,7 +357,8 @@ JammerView::JammerView(NavigationView& nav)
     };
 
     for (auto range_view : range_views) {
-        range_view->check_enabled.on_select = [this](Checkbox&, bool) {
+        range_view->check_enabled.on_select = [this, range_view](Checkbox&, bool v) {
+            range_view->frequency_range.enabled = v;
             if (jamming) update_config();
         };
         range_view->button_start.on_select = [this, range_view](Button&) {

firmware/application/external/metronome/ui_metronome.cpp

@@ -1,5 +1,5 @@
 /*
- * copyleft 2024 sommermorgentraum
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/metronome/ui_metronome.hpp

@@ -1,5 +1,5 @@
 /*
- * copyleft 2024 sommermorgentraum
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/ook_editor/ui_ook_editor.cpp

@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2024 Samir Sánchez Garnica @sasaga92
- * copyleft Elliot Alderson from F society
- * copyleft Darlene Alderson from F society
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
+
  *
  * This file is part of PortaPack.
  *

firmware/application/external/ook_editor/ui_ook_editor.hpp

@@ -1,7 +1,6 @@
 /*
  * Copyright (C) 2024 Samir Sánchez Garnica @sasaga92
- * copyleft Elliot Alderson from F society
- * copyleft Darlene Alderson from F society
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/ookbrute/ui_ookbrute.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2024 HTotoo
- * copyleft Whiterose of the Dark Army
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/ookbrute/ui_ookbrute.hpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2024 HTotoo
- * copyleft Whiterose of the Dark Army
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/playlist_editor/ui_playlist_editor.cpp

@@ -1,6 +1,5 @@
 /*
- * copyleft Elliot Alderson from F society
- * copyleft Darlene Alderson from F society
+ * copyleft 2025 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/playlist_editor/ui_playlist_editor.hpp

@@ -1,6 +1,5 @@
 /*
- * copyleft Elliot Alderson from F society
- * copyleft Darlene Alderson from F society
+ * copyleft 2025 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/shoppingcart_lock/main.cpp

@@ -10,7 +10,7 @@
 
 namespace ui::external_app::shoppingcart_lock {
 void initialize_app(NavigationView& nav) {
-    baseband::run_image(portapack::spi_flash::image_tag_audio_tx);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
     nav.push<ShoppingCartLock>();
 }
 }  // namespace ui::external_app::shoppingcart_lock

firmware/application/external/soundboard/main.cpp

@@ -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 "soundboard_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::soundboard {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<SoundBoardView>();
+}
+}  // namespace ui::external_app::soundboard
+
+extern "C" {
+
+__attribute__((section(".external_app.app_soundboard.application_information"), used)) application_information_t _application_information_soundboard = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::soundboard::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Soundbrd",
+    /*.bitmap_data = */ {
+        0xF0,
+        0x0F,
+        0x1C,
+        0x18,
+        0x17,
+        0x38,
+        0x15,
+        0x78,
+        0x15,
+        0xF8,
+        0x15,
+        0x82,
+        0x15,
+        0x8B,
+        0xD5,
+        0x83,
+        0xD5,
+        0xBB,
+        0xD5,
+        0x83,
+        0x15,
+        0x8B,
+        0x15,
+        0x92,
+        0x15,
+        0xA0,
+        0x17,
+        0x80,
+        0x1C,
+        0x80,
+        0xF0,
+        0xFF,
+    },
+    /*.icon_color = */ ui::Color::orange().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_soundboard */ {'P', 'A', 'T', 'X'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/soundboard/soundboard_app.cpp

@@ -33,7 +33,7 @@
 using namespace tonekey;
 using namespace portapack;
 
-namespace ui {
+namespace ui::external_app::soundboard {
 
 #define FILE_PER_PAGE 50
 
@@ -251,7 +251,7 @@ void SoundBoardView::refresh_list() {
 SoundBoardView::SoundBoardView(
     NavigationView& nav)
     : nav_(nav) {
-    baseband::run_image(portapack::spi_flash::image_tag_audio_tx);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
 
     add_children({&labels,
                   &menu_view,
@@ -323,4 +323,4 @@ SoundBoardView::~SoundBoardView() {
     baseband::shutdown();
 }
 
-}  // namespace ui
+}  // namespace ui::external_app::soundboard

firmware/application/external/soundboard/soundboard_app.hpp

@@ -33,7 +33,7 @@
 #include "app_settings.hpp"
 #include "radio_state.hpp"
 
-namespace ui {
+namespace ui::external_app::soundboard {
 
 class SoundBoardView : public View {
    public:
@@ -178,6 +178,6 @@ class SoundBoardView : public View {
         }};
 };
 
-} /* namespace ui */
+} /* namespace ui::external_app::soundboard */
 
 #endif /*__UI_SOUNDBOARD_H__*/

firmware/application/external/spaceinv/main.cpp

@@ -0,0 +1,55 @@
+/*
+ * ------------------------------------------------------------
+ * |  Made by RocketGod                                       |
+ * |  Find me at https://betaskynet.com                       |
+ * |  Argh matey!                                             |
+ * ------------------------------------------------------------
+ */
+
+#include "ui.hpp"
+#include "ui_spaceinv.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::spaceinv {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<SpaceInvadersView>();
+}
+}  // namespace ui::external_app::spaceinv
+
+extern "C" {
+
+__attribute__((section(".external_app.app_spaceinv.application_information"), used)) application_information_t _application_information_spaceinv = {
+    (uint8_t*)0x00000000,
+    ui::external_app::spaceinv::initialize_app,
+    CURRENT_HEADER_VERSION,
+    VERSION_MD5,
+
+    "Space Invaders",
+    {
+        // Space Invader alien icon 16x16
+        0x00, 0x18,  // .......##.......
+        0x00, 0x3C,  // ......####......
+        0x00, 0x7E,  // .....######.....
+        0x00, 0xDB,  // ....##.##.##....
+        0x00, 0xFF,  // ....########....
+        0x00, 0xFF,  // ....########....
+        0x00, 0x24,  // ......#..#......
+        0x00, 0x66,  // .....##..##.....
+        0x00, 0x42,  // .....#....#.....
+        0x00, 0x00,  // ................
+        0x00, 0x24,  // ......#..#......
+        0x00, 0x18,  // .......##.......
+        0x00, 0x24,  // ......#..#......
+        0x00, 0x42,  // .....#....#.....
+        0x00, 0x81,  // ....#......#....
+        0x00, 0x00,  // ................
+    },
+    ui::Color::magenta().v,
+    app_location_t::GAMES,
+    -1,
+
+    {0, 0, 0, 0},
+    0x00000000,
+};
+}  // namespace ui::external_app::spaceinv

firmware/application/external/spaceinv/ui_spaceinv.cpp

@@ -0,0 +1,879 @@
+/*
+ * ------------------------------------------------------------
+ * |  Made by RocketGod                                       |
+ * |  Find me at https://betaskynet.com                       |
+ * |  Argh matey!                                             |
+ * ------------------------------------------------------------
+ */
+
+#include "ui_spaceinv.hpp"
+
+namespace ui::external_app::spaceinv {
+
+// Game constants
+#define PLAYER_WIDTH 26
+#define PLAYER_HEIGHT 16
+#define PLAYER_Y 280
+#define BULLET_WIDTH 3
+#define BULLET_HEIGHT 10
+#define BULLET_SPEED 8
+#define MAX_BULLETS 3
+#define INVADER_WIDTH 20
+#define INVADER_HEIGHT 16
+#define INVADER_ROWS 5  // Classic 5 rows
+#define INVADER_COLS 6  // Reduced for more movement space on narrow PP screen
+#define INVADER_GAP_X 10
+#define INVADER_GAP_Y 8  // Gap between invaders
+#define MAX_ENEMY_BULLETS 3
+#define ENEMY_BULLET_SPEED 3
+
+// Game state
+static int game_state = 0;  // 0=menu, 1=playing, 2=game over, 3=wave_complete
+static bool initialized = false;
+static int player_x = 120;
+static uint32_t score = 0;
+static int lives = 3;
+static uint32_t wave = 1;
+static uint32_t speed_bonus = 0;
+static uint32_t wave_complete_timer = 0;
+
+// Cannon Bullets
+static int bullet_x[MAX_BULLETS] = {0, 0, 0};
+static int bullet_y[MAX_BULLETS] = {0, 0, 0};
+static bool bullet_active[MAX_BULLETS] = {false, false, false};
+
+// Enemy bullets
+static int enemy_bullet_x[MAX_ENEMY_BULLETS] = {0, 0, 0};
+static int enemy_bullet_y[MAX_ENEMY_BULLETS] = {0, 0, 0};
+static bool enemy_bullet_active[MAX_ENEMY_BULLETS] = {false, false, false};
+static uint32_t enemy_fire_counter = 0;
+
+// Invaders
+static bool invaders[INVADER_ROWS][INVADER_COLS];
+static int invaders_x = 40;
+static int invaders_y = 60;
+static int invader_direction = 1;
+static uint32_t invader_move_counter = 0;
+static uint32_t invader_move_delay = 30;
+static bool invader_animation_frame = false;
+
+// Menu state
+static bool menu_initialized = false;
+static bool game_over_initialized = false;
+static bool blink_state = true;
+static uint32_t blink_counter = 0;
+static int16_t prompt_x = 0;
+
+// Timer
+static Ticker game_timer;
+static Callback game_update_callback = nullptr;
+static uint32_t game_update_timeout = 0;
+static uint32_t game_update_counter = 0;
+
+// Painter
+static Painter painter;
+
+// For high score access
+static SpaceInvadersView* current_instance = nullptr;
+
+void check_game_timer() {
+    if (game_update_callback) {
+        if (++game_update_counter >= game_update_timeout) {
+            game_update_counter = 0;
+            game_update_callback();
+        }
+    }
+}
+
+void Ticker::attach(Callback func, double delay_sec) {
+    game_update_callback = func;
+    game_update_timeout = delay_sec * 60;
+}
+
+void Ticker::detach() {
+    game_update_callback = nullptr;
+}
+
+static void init_invaders() {
+    // Initialize invader array
+    for (int row = 0; row < INVADER_ROWS; row++) {
+        for (int col = 0; col < INVADER_COLS; col++) {
+            invaders[row][col] = true;
+        }
+    }
+    invaders_x = 40;
+    invaders_y = 60;
+    invader_direction = 1;
+    invader_move_counter = 0;
+
+    // Clear any active enemy bullets
+    for (int i = 0; i < MAX_ENEMY_BULLETS; i++) {
+        enemy_bullet_active[i] = false;
+    }
+
+    // Clear any active player bullets
+    for (int i = 0; i < MAX_BULLETS; i++) {
+        bullet_active[i] = false;
+    }
+}
+
+static void save_high_score() {
+    if (current_instance && score > current_instance->highScore) {
+        current_instance->highScore = score;
+        // Settings are automatically saved when the view is destroyed
+    }
+}
+
+static void init_menu() {
+    painter.fill_rectangle({0, 0, 240, 320}, Color::black());
+
+    auto style_green = *ui::Theme::getInstance()->fg_green;
+    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
+    auto style_cyan = *ui::Theme::getInstance()->fg_cyan;
+
+    int16_t screen_width = 240;
+    int16_t title_x = (screen_width - 15 * 8) / 2;
+    int16_t divider_width = 24 * 8;
+    int16_t divider_x = (screen_width - divider_width) / 2;
+    int16_t instruction_width = 22 * 8;
+    int16_t instruction_x = (screen_width - instruction_width) / 2;
+    int16_t prompt_width = 12 * 8;
+    prompt_x = (screen_width - prompt_width) / 2;
+
+    painter.fill_rectangle({0, 30, screen_width, 30}, Color::black());
+    painter.draw_string({title_x, 42}, style_green, "SPACE INVADERS");
+
+    painter.draw_string({divider_x, 70}, style_yellow, "========================");
+
+    painter.fill_rectangle({instruction_x - 5, 100, instruction_width + 10, 80}, Color::black());
+    painter.draw_rectangle({instruction_x - 5, 100, instruction_width + 10, 80}, Color::white());
+
+    painter.draw_string({instruction_x, 110}, style_cyan, " ROTARY: MOVE SHIP");
+    painter.draw_string({instruction_x, 130}, style_cyan, " SELECT: FIRE");
+    painter.draw_string({instruction_x, 150}, style_cyan, " DEFEND EARTH!");
+
+    // Draw point values
+    auto style_purple = *ui::Theme::getInstance()->fg_magenta;
+    painter.draw_string({50, 190}, style_purple, "TOP ROW = 30 PTS");
+    painter.draw_string({50, 205}, style_yellow, "MID ROW = 20 PTS");
+    painter.draw_string({50, 220}, style_green, "BOT ROW = 10 PTS");
+
+    // Draw high score
+    if (current_instance) {
+        auto style_white = *ui::Theme::getInstance()->fg_light;
+        std::string high_score_text = "HIGH SCORE: " + std::to_string(current_instance->highScore);
+        int16_t high_score_x = (screen_width - high_score_text.length() * 8) / 2;
+        painter.draw_string({high_score_x, 240}, style_white, high_score_text);
+    }
+
+    menu_initialized = true;
+}
+
+static void init_game_over() {
+    painter.fill_rectangle({0, 0, 240, 320}, Color::black());
+
+    auto style_red = *ui::Theme::getInstance()->fg_red;
+    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
+    auto style_cyan = *ui::Theme::getInstance()->fg_cyan;
+    auto style_white = *ui::Theme::getInstance()->fg_light;
+
+    int16_t screen_width = 240;
+
+    // Game Over title
+    int16_t title_x = (screen_width - 9 * 8) / 2;
+    painter.draw_string({title_x, 42}, style_red, "GAME OVER");
+
+    // Divider
+    int16_t divider_width = 24 * 8;
+    int16_t divider_x = (screen_width - divider_width) / 2;
+    painter.draw_string({divider_x, 70}, style_yellow, "========================");
+
+    // Score box
+    int16_t box_width = 22 * 8;
+    int16_t box_x = (screen_width - box_width) / 2;
+    painter.fill_rectangle({box_x - 5, 100, box_width + 10, 80}, Color::black());
+    painter.draw_rectangle({box_x - 5, 100, box_width + 10, 80}, Color::white());
+
+    // Display scores
+    std::string score_text = "SCORE: " + std::to_string(score);
+    int16_t score_x = (screen_width - score_text.length() * 8) / 2;
+    painter.draw_string({score_x, 120}, style_cyan, score_text);
+
+    std::string wave_text = "WAVE: " + std::to_string(wave);
+    int16_t wave_x = (screen_width - wave_text.length() * 8) / 2;
+    painter.draw_string({wave_x, 140}, style_cyan, wave_text);
+
+    // High score section
+    if (current_instance) {
+        if (score > current_instance->highScore) {
+            // New high score!
+            std::string new_high = "NEW HIGH SCORE!";
+            int16_t new_high_x = (screen_width - new_high.length() * 8) / 2;
+            painter.draw_string({new_high_x, 200}, style_yellow, new_high);
+
+            std::string high_score_text = std::to_string(score);
+            int16_t high_score_x = (screen_width - high_score_text.length() * 8) / 2;
+            painter.draw_string({high_score_x, 220}, style_yellow, high_score_text);
+        } else {
+            // Show existing high score
+            std::string high_label = "HIGH SCORE:";
+            int16_t label_x = (screen_width - high_label.length() * 8) / 2;
+            painter.draw_string({label_x, 200}, style_white, high_label);
+
+            std::string high_score_text = std::to_string(current_instance->highScore);
+            int16_t high_score_x = (screen_width - high_score_text.length() * 8) / 2;
+            painter.draw_string({high_score_x, 220}, style_white, high_score_text);
+        }
+    }
+
+    game_over_initialized = true;
+}
+
+static void draw_player() {
+    // Clear the entire player area
+    painter.fill_rectangle({0, PLAYER_Y - 4, 240, PLAYER_HEIGHT + 8}, Color::black());
+
+    // Draw the classic Space Invaders cannon
+    Color green = Color::green();
+
+    // Top part - the cannon barrel
+    painter.draw_hline({player_x + 12, PLAYER_Y}, 2, green);
+    painter.draw_hline({player_x + 12, PLAYER_Y + 1}, 2, green);
+
+    // Upper body
+    painter.draw_hline({player_x + 11, PLAYER_Y + 2}, 4, green);
+    painter.draw_hline({player_x + 11, PLAYER_Y + 3}, 4, green);
+    painter.draw_hline({player_x + 10, PLAYER_Y + 4}, 6, green);
+    painter.draw_hline({player_x + 10, PLAYER_Y + 5}, 6, green);
+
+    // Main body
+    painter.draw_hline({player_x + 2, PLAYER_Y + 6}, 22, green);
+    painter.draw_hline({player_x + 2, PLAYER_Y + 7}, 22, green);
+    painter.draw_hline({player_x + 1, PLAYER_Y + 8}, 24, green);
+    painter.draw_hline({player_x + 1, PLAYER_Y + 9}, 24, green);
+    painter.draw_hline({player_x, PLAYER_Y + 10}, 26, green);
+    painter.draw_hline({player_x, PLAYER_Y + 11}, 26, green);
+    painter.draw_hline({player_x, PLAYER_Y + 12}, 26, green);
+    painter.draw_hline({player_x, PLAYER_Y + 13}, 26, green);
+    painter.draw_hline({player_x, PLAYER_Y + 14}, 26, green);
+    painter.draw_hline({player_x, PLAYER_Y + 15}, 26, green);
+}
+
+static void draw_invader(int row, int col) {
+    int x = invaders_x + col * (INVADER_WIDTH + INVADER_GAP_X);
+    int y = invaders_y + row * (INVADER_HEIGHT + INVADER_GAP_Y);
+
+    // Clear the area first
+    painter.fill_rectangle({x, y, INVADER_WIDTH, INVADER_HEIGHT}, Color::black());
+
+    // Different colors and shapes for different rows
+    Color color;
+    if (row == 0) {
+        color = Color::red();  // Top row - 30 points
+    } else if (row == 1 || row == 2) {
+        color = Color::yellow();  // Middle rows - 20 points
+    } else {
+        color = Color::green();  // Bottom rows - 10 points
+    }
+
+    // Draw different invader types based on row
+    if (row == 0) {
+        // Top row - squid-like invader (30 points)
+        if (invader_animation_frame) {
+            // Frame 1 - arms down
+            painter.draw_hline({x + 8, y + 2}, 4, color);
+            painter.draw_hline({x + 6, y + 3}, 8, color);
+            painter.draw_hline({x + 4, y + 4}, 12, color);
+            painter.draw_hline({x + 2, y + 5}, 16, color);
+            painter.draw_hline({x + 2, y + 6}, 16, color);
+            painter.draw_hline({x, y + 7}, 20, color);
+            painter.draw_hline({x, y + 8}, 20, color);
+            painter.draw_hline({x + 2, y + 9}, 2, color);
+            painter.draw_hline({x + 6, y + 9}, 8, color);
+            painter.draw_hline({x + 16, y + 9}, 2, color);
+            painter.draw_hline({x + 4, y + 10}, 2, color);
+            painter.draw_hline({x + 14, y + 10}, 2, color);
+        } else {
+            // Frame 2 - arms up
+            painter.draw_hline({x + 8, y + 2}, 4, color);
+            painter.draw_hline({x + 6, y + 3}, 8, color);
+            painter.draw_hline({x + 4, y + 4}, 12, color);
+            painter.draw_hline({x + 2, y + 5}, 16, color);
+            painter.draw_hline({x + 2, y + 6}, 16, color);
+            painter.draw_hline({x, y + 7}, 20, color);
+            painter.draw_hline({x, y + 8}, 20, color);
+            painter.draw_hline({x + 4, y + 9}, 2, color);
+            painter.draw_hline({x + 8, y + 9}, 4, color);
+            painter.draw_hline({x + 14, y + 9}, 2, color);
+            painter.draw_hline({x + 2, y + 10}, 2, color);
+            painter.draw_hline({x + 16, y + 10}, 2, color);
+        }
+    } else if (row == 1 || row == 2) {
+        // Middle rows - crab-like invader (20 points)
+        if (invader_animation_frame) {
+            // Frame 1 - arms in
+            painter.draw_hline({x + 4, y + 2}, 2, color);
+            painter.draw_hline({x + 14, y + 2}, 2, color);
+            painter.draw_hline({x + 2, y + 3}, 2, color);
+            painter.draw_hline({x + 6, y + 3}, 8, color);
+            painter.draw_hline({x + 16, y + 3}, 2, color);
+            painter.draw_hline({x + 2, y + 4}, 16, color);
+            painter.draw_hline({x, y + 5}, 6, color);
+            painter.draw_hline({x + 8, y + 5}, 4, color);
+            painter.draw_hline({x + 14, y + 5}, 6, color);
+            painter.draw_hline({x, y + 6}, 20, color);
+            painter.draw_hline({x + 2, y + 7}, 16, color);
+            painter.draw_hline({x + 4, y + 8}, 2, color);
+            painter.draw_hline({x + 14, y + 8}, 2, color);
+            painter.draw_hline({x + 2, y + 9}, 4, color);
+            painter.draw_hline({x + 14, y + 9}, 4, color);
+        } else {
+            // Frame 2 - arms out
+            painter.draw_hline({x + 4, y + 2}, 2, color);
+            painter.draw_hline({x + 14, y + 2}, 2, color);
+            painter.draw_hline({x + 2, y + 3}, 2, color);
+            painter.draw_hline({x + 6, y + 3}, 8, color);
+            painter.draw_hline({x + 16, y + 3}, 2, color);
+            painter.draw_hline({x + 2, y + 4}, 16, color);
+            painter.draw_hline({x, y + 5}, 6, color);
+            painter.draw_hline({x + 8, y + 5}, 4, color);
+            painter.draw_hline({x + 14, y + 5}, 6, color);
+            painter.draw_hline({x, y + 6}, 20, color);
+            painter.draw_hline({x + 2, y + 7}, 16, color);
+            painter.draw_hline({x + 4, y + 8}, 2, color);
+            painter.draw_hline({x + 14, y + 8}, 2, color);
+            painter.draw_hline({x, y + 9}, 2, color);
+            painter.draw_hline({x + 6, y + 9}, 2, color);
+            painter.draw_hline({x + 12, y + 9}, 2, color);
+            painter.draw_hline({x + 18, y + 9}, 2, color);
+        }
+    } else {
+        // Bottom rows - octopus-like invader (10 points)
+        if (invader_animation_frame) {
+            // Frame 1
+            painter.draw_hline({x + 6, y + 2}, 8, color);
+            painter.draw_hline({x + 4, y + 3}, 12, color);
+            painter.draw_hline({x + 2, y + 4}, 16, color);
+            painter.draw_hline({x, y + 5}, 20, color);
+            painter.draw_hline({x, y + 6}, 20, color);
+            painter.draw_hline({x + 4, y + 7}, 4, color);
+            painter.draw_hline({x + 12, y + 7}, 4, color);
+            painter.draw_hline({x + 2, y + 8}, 4, color);
+            painter.draw_hline({x + 8, y + 8}, 4, color);
+            painter.draw_hline({x + 14, y + 8}, 4, color);
+            painter.draw_hline({x + 4, y + 9}, 2, color);
+            painter.draw_hline({x + 14, y + 9}, 2, color);
+        } else {
+            // Frame 2
+            painter.draw_hline({x + 6, y + 2}, 8, color);
+            painter.draw_hline({x + 4, y + 3}, 12, color);
+            painter.draw_hline({x + 2, y + 4}, 16, color);
+            painter.draw_hline({x, y + 5}, 20, color);
+            painter.draw_hline({x, y + 6}, 20, color);
+            painter.draw_hline({x + 4, y + 7}, 4, color);
+            painter.draw_hline({x + 12, y + 7}, 4, color);
+            painter.draw_hline({x + 2, y + 8}, 4, color);
+            painter.draw_hline({x + 8, y + 8}, 4, color);
+            painter.draw_hline({x + 14, y + 8}, 4, color);
+            painter.draw_hline({x + 2, y + 9}, 2, color);
+            painter.draw_hline({x + 16, y + 9}, 2, color);
+        }
+    }
+}
+
+static void draw_all_invaders() {
+    for (int row = 0; row < INVADER_ROWS; row++) {
+        for (int col = 0; col < INVADER_COLS; col++) {
+            if (invaders[row][col]) {
+                draw_invader(row, col);
+            }
+        }
+    }
+}
+
+static void clear_all_invaders() {
+    for (int row = 0; row < INVADER_ROWS; row++) {
+        for (int col = 0; col < INVADER_COLS; col++) {
+            if (invaders[row][col]) {
+                int x = invaders_x + col * (INVADER_WIDTH + INVADER_GAP_X);
+                int y = invaders_y + row * (INVADER_HEIGHT + INVADER_GAP_Y);
+                painter.fill_rectangle({x, y, INVADER_WIDTH, INVADER_HEIGHT}, Color::black());
+            }
+        }
+    }
+}
+
+static void clear_all_enemy_bullets() {
+    // Clear any visible enemy bullets
+    for (int i = 0; i < MAX_ENEMY_BULLETS; i++) {
+        if (enemy_bullet_active[i]) {
+            painter.fill_rectangle({enemy_bullet_x[i], enemy_bullet_y[i], BULLET_WIDTH, BULLET_HEIGHT}, Color::black());
+            enemy_bullet_active[i] = false;
+        }
+    }
+}
+
+static void fire_enemy_bullet() {
+    // Find a random invader to fire from
+    int active_count = 0;
+    for (int row = 0; row < INVADER_ROWS; row++) {
+        for (int col = 0; col < INVADER_COLS; col++) {
+            if (invaders[row][col]) active_count++;
+        }
+    }
+
+    if (active_count == 0) return;
+
+    int shooter = rand() % active_count;
+    int count = 0;
+
+    for (int row = 0; row < INVADER_ROWS; row++) {
+        for (int col = 0; col < INVADER_COLS; col++) {
+            if (invaders[row][col]) {
+                if (count == shooter) {
+                    // Fire from this invader
+                    for (int i = 0; i < MAX_ENEMY_BULLETS; i++) {
+                        if (!enemy_bullet_active[i]) {
+                            int x = invaders_x + col * (INVADER_WIDTH + INVADER_GAP_X);
+                            int y = invaders_y + row * (INVADER_HEIGHT + INVADER_GAP_Y);
+                            enemy_bullet_x[i] = x + INVADER_WIDTH / 2;
+                            enemy_bullet_y[i] = y + INVADER_HEIGHT;
+                            enemy_bullet_active[i] = true;
+                            return;
+                        }
+                    }
+                }
+                count++;
+            }
+        }
+    }
+}
+
+static void update_enemy_bullets() {
+    for (int i = 0; i < MAX_ENEMY_BULLETS; i++) {
+        if (enemy_bullet_active[i]) {
+            // Clear old position - but protect the border line
+            if (enemy_bullet_y[i] != 49) {  // Don't clear if we're exactly on the border line
+                painter.fill_rectangle({enemy_bullet_x[i], enemy_bullet_y[i], BULLET_WIDTH, BULLET_HEIGHT}, Color::black());
+            }
+
+            enemy_bullet_y[i] += ENEMY_BULLET_SPEED;
+
+            if (enemy_bullet_y[i] > 320) {
+                enemy_bullet_active[i] = false;
+            } else {
+                // Draw at new position
+                painter.fill_rectangle({enemy_bullet_x[i], enemy_bullet_y[i], BULLET_WIDTH, BULLET_HEIGHT}, Color::red());
+
+                // Check collision with player
+                if (enemy_bullet_x[i] >= player_x &&
+                    enemy_bullet_x[i] <= player_x + PLAYER_WIDTH &&
+                    enemy_bullet_y[i] >= PLAYER_Y &&
+                    enemy_bullet_y[i] <= PLAYER_Y + PLAYER_HEIGHT) {
+                    // Player hit!
+                    enemy_bullet_active[i] = false;
+                    lives--;
+
+                    // Update lives display
+                    auto style = *ui::Theme::getInstance()->fg_green;
+                    painter.fill_rectangle({5, 30, 100, 20}, Color::black());
+                    painter.draw_string({5, 30}, style, "Lives: " + std::to_string(lives));
+
+                    if (lives <= 0) {
+                        game_state = 2;  // Game over
+                        save_high_score();
+                    }
+                }
+            }
+        }
+    }
+}
+
+static void update_invaders() {
+    uint32_t adjusted_delay = (speed_bonus >= invader_move_delay) ? 1 : invader_move_delay - speed_bonus;
+
+    if (++invader_move_counter >= adjusted_delay) {
+        invader_move_counter = 0;
+
+        // Clear old positions
+        clear_all_invaders();
+
+        // Check bounds - find the actual leftmost and rightmost invaders
+        int leftmost = INVADER_COLS;
+        int rightmost = -1;
+
+        for (int col = 0; col < INVADER_COLS; col++) {
+            for (int row = 0; row < INVADER_ROWS; row++) {
+                if (invaders[row][col]) {
+                    if (col < leftmost) leftmost = col;
+                    if (col > rightmost) rightmost = col;
+                }
+            }
+        }
+
+        bool hit_edge = false;
+        if (invader_direction > 0) {
+            // Moving right - check rightmost invader
+            int right_edge = invaders_x + rightmost * (INVADER_WIDTH + INVADER_GAP_X) + INVADER_WIDTH;
+            if (right_edge >= 240) {
+                hit_edge = true;
+            }
+        } else {
+            // Moving left - check leftmost invader
+            int left_edge = invaders_x + leftmost * (INVADER_WIDTH + INVADER_GAP_X);
+            if (left_edge <= 0) {
+                hit_edge = true;
+            }
+        }
+
+        // Move invaders
+        if (hit_edge) {
+            invaders_y += 15;  // Move down
+            invader_direction = -invader_direction;
+        } else {
+            invaders_x += invader_direction * 8;  // Horizontal movement
+        }
+
+        // Toggle animation frame
+        invader_animation_frame = !invader_animation_frame;
+
+        // Draw new positions
+        draw_all_invaders();
+    }
+
+    // Enemy firing logic - only in hard mode or always with lower frequency
+    if (!current_instance || !current_instance->easy_mode) {
+        if (++enemy_fire_counter >= 120) {  // Fire every 2 seconds at 60fps
+            enemy_fire_counter = 0;
+            fire_enemy_bullet();
+        }
+    }
+}
+
+static void fire_bullet() {
+    for (int i = 0; i < MAX_BULLETS; i++) {
+        if (!bullet_active[i]) {
+            bullet_active[i] = true;
+            bullet_x[i] = player_x + PLAYER_WIDTH / 2 - BULLET_WIDTH / 2;
+            bullet_y[i] = PLAYER_Y - BULLET_HEIGHT;
+            break;
+        }
+    }
+}
+
+static void update_bullets() {
+    for (int i = 0; i < MAX_BULLETS; i++) {
+        if (bullet_active[i]) {
+            painter.fill_rectangle({bullet_x[i], bullet_y[i], BULLET_WIDTH, BULLET_HEIGHT}, Color::black());
+
+            bullet_y[i] -= BULLET_SPEED;
+
+            if (bullet_y[i] < 50) {
+                bullet_active[i] = false;
+            } else {
+                painter.fill_rectangle({bullet_x[i], bullet_y[i], BULLET_WIDTH, BULLET_HEIGHT}, Color::white());
+            }
+        }
+    }
+}
+
+static void check_collisions() {
+    for (int i = 0; i < MAX_BULLETS; i++) {
+        if (!bullet_active[i]) continue;
+
+        for (int row = 0; row < INVADER_ROWS; row++) {
+            for (int col = 0; col < INVADER_COLS; col++) {
+                if (!invaders[row][col]) continue;
+
+                int inv_x = invaders_x + col * (INVADER_WIDTH + INVADER_GAP_X);
+                int inv_y = invaders_y + row * (INVADER_HEIGHT + INVADER_GAP_Y);
+
+                // Simple collision check
+                if (bullet_x[i] < inv_x + INVADER_WIDTH &&
+                    bullet_x[i] + BULLET_WIDTH > inv_x &&
+                    bullet_y[i] < inv_y + INVADER_HEIGHT &&
+                    bullet_y[i] + BULLET_HEIGHT > inv_y) {
+                    // Hit!
+                    bullet_active[i] = false;
+                    painter.fill_rectangle({bullet_x[i], bullet_y[i], BULLET_WIDTH, BULLET_HEIGHT}, Color::black());
+
+                    invaders[row][col] = false;
+                    painter.fill_rectangle({inv_x, inv_y, INVADER_WIDTH, INVADER_HEIGHT}, Color::black());
+
+                    // Score based on row: top=30, middle=20, bottom=10
+                    if (row == 0) {
+                        score += 30;
+                    } else if (row == 1 || row == 2) {
+                        score += 20;
+                    } else {
+                        score += 10;
+                    }
+
+                    return;
+                }
+            }
+        }
+    }
+}
+
+static void check_wave_complete() {
+    // Check if all invaders are destroyed
+    bool all_destroyed = true;
+    for (int row = 0; row < INVADER_ROWS; row++) {
+        for (int col = 0; col < INVADER_COLS; col++) {
+            if (invaders[row][col]) {
+                all_destroyed = false;
+                break;
+            }
+        }
+        if (!all_destroyed) break;
+    }
+
+    if (all_destroyed) {
+        // Next wave!
+        wave++;
+        speed_bonus = (wave - 1) * 3;            // Each wave is slightly faster
+        if (speed_bonus > 15) speed_bonus = 15;  // Cap the speed increase
+
+        // Clear any enemy bullets before transitioning
+        clear_all_enemy_bullets();
+
+        // Set state to wave complete and start timer
+        game_state = 3;
+        wave_complete_timer = 60;  // 1 second at 60fps
+
+        // Clear screen and show wave message - but preserve the border line
+        painter.fill_rectangle({0, 51, 240, 269}, Color::black());  // Start at 51 to preserve line at 49
+
+        // Redraw the border line to ensure it's intact - stupid bullet clearing wants to damage it
+        painter.draw_hline({0, 49}, 240, Color::white());
+
+        auto style = *ui::Theme::getInstance()->fg_green;
+        std::string wave_text = "WAVE " + std::to_string(wave);
+        int wave_x = (240 - wave_text.length() * 8) / 2;
+        painter.draw_string({wave_x, 150}, style, wave_text);
+
+        return;
+    }
+
+    // Check if invaders reached player
+    for (int row = 0; row < INVADER_ROWS; row++) {
+        for (int col = 0; col < INVADER_COLS; col++) {
+            if (invaders[row][col]) {
+                int y = invaders_y + row * (INVADER_HEIGHT + INVADER_GAP_Y);
+                if (y + INVADER_HEIGHT >= PLAYER_Y) {  // Actual collision with player
+                    game_state = 2;                    // Game over
+                    save_high_score();
+                    return;
+                }
+            }
+        }
+    }
+}
+
+void game_timer_check() {
+    if (game_state == 0) {
+        // Menu state
+        if (!menu_initialized) {
+            init_menu();
+        }
+
+        if (++blink_counter >= 30) {
+            blink_counter = 0;
+            blink_state = !blink_state;
+
+            auto style = *ui::Theme::getInstance()->fg_red;
+            if (blink_state) {
+                painter.draw_string({prompt_x, 260}, style, "PRESS SELECT");
+            } else {
+                painter.fill_rectangle({prompt_x, 260, 16 * 8, 20}, Color::black());
+            }
+        }
+    } else if (game_state == 1) {
+        // Playing state
+        update_bullets();
+        update_enemy_bullets();
+        update_invaders();
+        check_collisions();
+        check_wave_complete();
+
+        // Update score display
+        static uint32_t last_score = 999999;
+        if (score != last_score) {
+            last_score = score;
+            auto style = *ui::Theme::getInstance()->fg_green;
+            painter.fill_rectangle({5, 10, 100, 20}, Color::black());
+            painter.draw_string({5, 10}, style, "Score: " + std::to_string(score));
+
+            // Redraw border line after score update (in case it was damaged) - stupid bullet clearing wants to damage it
+            painter.draw_hline({0, 49}, 240, Color::white());
+        }
+
+        // Periodically redraw the border line to fix any damage because it's a pain in the ass
+        static uint32_t border_redraw_counter = 0;
+        if (++border_redraw_counter >= 60) {  // Once per second - might make less if causing flickering
+            border_redraw_counter = 0;
+            painter.draw_hline({0, 49}, 240, Color::white());
+        }
+    } else if (game_state == 2) {
+        // Game over state
+        if (!game_over_initialized) {
+            init_game_over();
+        }
+
+        if (++blink_counter >= 30) {
+            blink_counter = 0;
+            blink_state = !blink_state;
+
+            auto style = *ui::Theme::getInstance()->fg_red;
+            if (blink_state) {
+                painter.draw_string({prompt_x, 260}, style, "PRESS SELECT");
+            } else {
+                painter.fill_rectangle({prompt_x, 260, 16 * 8, 20}, Color::black());
+            }
+        }
+    } else if (game_state == 3) {
+        // Wave complete state - wait for timer
+        if (--wave_complete_timer <= 0) {
+            // Timer expired, start next wave
+            game_state = 1;
+
+            // Clear and redraw game area - preserve border line
+            painter.fill_rectangle({0, 51, 240, 269}, Color::black());  // Start at 51 to preserve line
+
+            // Restore UI
+            auto style = *ui::Theme::getInstance()->fg_green;
+            painter.draw_string({5, 10}, style, "Score: " + std::to_string(score));
+            painter.draw_string({5, 30}, style, "Lives: " + std::to_string(lives));
+
+            // Redraw the border line in case it was damaged again
+            painter.draw_hline({0, 49}, 240, Color::white());
+
+            // Initialize new wave of invaders
+            init_invaders();
+            draw_all_invaders();
+            draw_player();
+        }
+    }
+}
+
+SpaceInvadersView::SpaceInvadersView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&dummy, &button_difficulty});
+    current_instance = this;
+    game_timer.attach(&game_timer_check, 1.0 / 60.0);
+
+    // Update button text based on loaded setting
+    button_difficulty.set_text(easy_mode ? "Mode: EASY" : "Mode: HARD");
+
+    button_difficulty.on_select = [this](Button&) {
+        easy_mode = !easy_mode;
+        button_difficulty.set_text(easy_mode ? "Mode: EASY" : "Mode: HARD");
+        // Settings will be saved when the view is destroyed
+    };
+}
+
+SpaceInvadersView::~SpaceInvadersView() {
+    // Settings are automatically saved when destroyed
+    current_instance = nullptr;
+}
+
+void SpaceInvadersView::on_show() {
+}
+
+void SpaceInvadersView::paint(Painter& painter) {
+    (void)painter;
+
+    if (!initialized) {
+        initialized = true;
+        game_state = 0;
+        menu_initialized = false;
+        game_over_initialized = false;
+        blink_state = true;
+        blink_counter = 0;
+        player_x = 107;
+        score = 0;
+        lives = 3;
+        wave = 1;
+        speed_bonus = 0;
+
+        // Initialize arrays
+        for (int i = 0; i < MAX_BULLETS; i++) {
+            bullet_active[i] = false;
+            bullet_x[i] = 0;
+            bullet_y[i] = 0;
+        }
+
+        for (int i = 0; i < MAX_ENEMY_BULLETS; i++) {
+            enemy_bullet_active[i] = false;
+            enemy_bullet_x[i] = 0;
+            enemy_bullet_y[i] = 0;
+        }
+
+        init_invaders();
+    }
+}
+
+void SpaceInvadersView::frame_sync() {
+    check_game_timer();
+    set_dirty();
+}
+
+bool SpaceInvadersView::on_encoder(const EncoderEvent delta) {
+    if (game_state == 1) {
+        if (delta > 0) {
+            player_x += 5;
+            if (player_x > 214) player_x = 214;
+            draw_player();
+        } else if (delta < 0) {
+            player_x -= 5;
+            if (player_x < 0) player_x = 0;
+            draw_player();
+        }
+
+        set_dirty();
+    }
+    return true;
+}
+
+bool SpaceInvadersView::on_key(const KeyEvent key) {
+    if (key == KeyEvent::Select) {
+        if (game_state == 0) {
+            // Start game
+            game_state = 1;
+            button_difficulty.hidden(true);
+            score = 0;
+            lives = 3;
+            wave = 1;
+            speed_bonus = 0;
+            invader_move_delay = 30;
+            enemy_fire_counter = 0;
+            init_invaders();
+
+            painter.fill_rectangle({0, 0, 240, 320}, Color::black());
+            painter.draw_hline({0, 49}, 240, Color::white());
+
+            auto style = *ui::Theme::getInstance()->fg_green;
+            painter.draw_string({5, 10}, style, "Score: 0");
+            painter.draw_string({5, 30}, style, "Lives: 3");
+
+            draw_all_invaders();
+            draw_player();
+
+            set_dirty();
+        } else if (game_state == 1) {
+            fire_bullet();
+        } else if (game_state == 2) {
+            // Return to menu
+            game_state = 0;
+            menu_initialized = false;
+            game_over_initialized = false;
+            button_difficulty.hidden(false);
+            set_dirty();
+        }
+    }
+
+    return true;
+}
+
+}  // namespace ui::external_app::spaceinv

firmware/application/external/spaceinv/ui_spaceinv.hpp

@@ -0,0 +1,79 @@
+/*
+ * ------------------------------------------------------------
+ * |  Made by RocketGod                                       |
+ * |  Find me at https://betaskynet.com                       |
+ * |  Argh matey!                                             |
+ * ------------------------------------------------------------
+ */
+
+#ifndef __UI_SPACEINV_H__
+#define __UI_SPACEINV_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "event_m0.hpp"
+#include "message.hpp"
+#include "irq_controls.hpp"
+#include "random.hpp"
+#include "lpc43xx_cpp.hpp"
+#include "ui_widget.hpp"
+#include "app_settings.hpp"
+
+namespace ui::external_app::spaceinv {
+
+using Callback = void (*)(void);
+
+class Ticker {
+   public:
+    Ticker() = default;
+    void attach(Callback func, double delay_sec);
+    void detach();
+};
+
+void check_game_timer();
+void game_timer_check();
+
+class SpaceInvadersView : public View {
+   public:
+    SpaceInvadersView(NavigationView& nav);
+    ~SpaceInvadersView();  // Destructor will trigger settings save
+    void on_show() override;
+
+    std::string title() const override { return "Space Invaders"; }
+
+    void focus() override { dummy.focus(); }
+    void paint(Painter& painter) override;
+    void frame_sync();
+    bool on_encoder(const EncoderEvent event) override;
+    bool on_key(KeyEvent key) override;
+
+    uint32_t highScore = 0;
+    bool easy_mode = false;
+
+   private:
+    NavigationView& nav_;
+
+    Button button_difficulty{
+        {70, 285, 100, 20},
+        "Mode: HARD"};
+
+    app_settings::SettingsManager settings_{
+        "spaceinv",
+        app_settings::Mode::NO_RF,
+        {{"highscore"sv, &highScore},
+         {"easy_mode"sv, &easy_mode}}};
+
+    Button dummy{
+        {240, 0, 0, 0},
+        ""};
+
+    MessageHandlerRegistration message_handler_frame_sync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const) {
+            this->frame_sync();
+        }};
+};
+
+}  // namespace ui::external_app::spaceinv
+
+#endif /* __UI_SPACEINV_H__ */

firmware/application/external/stopwatch/ui_stopwatch.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright 2025 Mark Thompson
- * copyleft Mr. Robot of F.Society
+ * copyleft 2025 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/stopwatch/ui_stopwatch.hpp

@@ -1,6 +1,6 @@
 /*
  * Copyright 2025 Mark Thompson
- * copyleft Mr. Robot of F.Society
+ * copyleft 2025 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/tuner/ui_tuner.cpp

@@ -1,5 +1,5 @@
 /*
- * copyleft 2024 sommermorgentraum
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/tuner/ui_tuner.hpp

@@ -1,5 +1,5 @@
 /*
- * copyleft 2024 sommermorgentraum
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/external/wardrivemap/ui_wardrivemap.cpp

@@ -158,9 +158,10 @@ WardriveMapView::WardriveMapView(NavigationView& nav)
     }
 
     // never move this before the first load() bc that will mess load up
-    geomap.on_move = [this](float lon, float lat) {
+    geomap.on_move = [this](float lon, float lat, bool absolute) {
         (void)lon;
         (void)lat;
+        (void)absolute;
         load_markers();
     };
     btn_back.on_select = [this, &nav](Button&) {

firmware/application/external/wav_view/ui_view_wav.cpp

@@ -262,7 +262,7 @@ void ViewWavView::on_playback_progress(const uint32_t progress) {
 ViewWavView::ViewWavView(
     NavigationView& nav)
     : nav_(nav) {
-    baseband::run_image(portapack::spi_flash::image_tag_audio_tx);
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
     wav_reader = std::make_unique<WAVFileReader>();
 
     add_children({&labels,

firmware/application/file.cpp

@@ -113,7 +113,7 @@ File::Result<bool> File::eof() {
 File::Result<File::Offset> File::seek(Offset new_position) {
     /* NOTE: Returns *old* position, not new position */
     const auto old_position = tell();
-    const auto result = f_lseek(&f, new_position);
+    const auto result = (old_position == new_position) ? FR_OK : f_lseek(&f, new_position);
     if (result != FR_OK) {
         return {static_cast<Error>(result)};
     }

firmware/application/hw/touch_adc.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
- * copyleft (ɔ) 2023 zxkmm under GPL license
+ * copyleft 2023 zxkmm AKA zix aka sommermorgentraum
  * Copyright (C) 2023 u-foka
  *
  * This file is part of PortaPack.

firmware/application/hw/touch_adc.hpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
- * copyleft (ɔ) 2023 zxkmm under GPL license
+ * copyleft 2023 zxkmm AKA zix aka sommermorgentraum
  * Copyright (C) 2023 u-foka
  *
  * This file is part of PortaPack.

firmware/application/log_file.cpp

@@ -28,10 +28,10 @@ Optional<File::Error> LogFile::write_entry(const std::string& entry) {
 
 Optional<File::Error> LogFile::write_entry(const rtc::RTC& datetime, const std::string& entry) {
     std::string timestamp = to_string_timestamp(datetime);
-    return write_line(timestamp + " " + entry);
+    return write_raw(timestamp + " " + entry);
 }
 
-Optional<File::Error> LogFile::write_line(const std::string& message) {
+Optional<File::Error> LogFile::write_raw(const std::string& message) {
     auto error = file.write_line(message);
     if (!error) {
         file.sync();

firmware/application/log_file.hpp

@@ -39,11 +39,10 @@ class LogFile {
 
     Optional<File::Error> write_entry(const std::string& entry);
     Optional<File::Error> write_entry(const rtc::RTC& datetime, const std::string& entry);
+    Optional<File::Error> write_raw(const std::string& message);
 
    private:
     File file{};
-
-    Optional<File::Error> write_line(const std::string& message);
 };
 
 #endif /*__LOG_FILE_H__*/

firmware/application/recent_entries.cpp

@@ -24,7 +24,7 @@
 namespace ui {
 
 RecentEntriesColumns::RecentEntriesColumns(
-    const std::initializer_list<RecentEntriesColumn> columns)
+    std::initializer_list<RecentEntriesColumn> columns)
     : _columns{columns} {
 }
 

firmware/application/recent_entries.hpp

@@ -133,14 +133,27 @@ class RecentEntriesColumns {
    public:
     using ContainerType = std::vector<RecentEntriesColumn>;
 
-    RecentEntriesColumns(
-        const std::initializer_list<RecentEntriesColumn> columns);
+    RecentEntriesColumns(std::initializer_list<RecentEntriesColumn> columns);
 
-    ContainerType::const_iterator begin() const { return std::begin(_columns); }
-    ContainerType::const_iterator end() const { return std::end(_columns); }
+    ContainerType::iterator begin() { return _columns.begin(); }
+    ContainerType::iterator end() { return _columns.end(); }
+    ContainerType::const_iterator begin() const { return _columns.begin(); }
+    ContainerType::const_iterator end() const { return _columns.end(); }
+
+    void set(size_t index, const std::string& name, size_t width) {
+        if (index < _columns.size()) {
+            _columns[index] = {name, width};
+        }
+    }
+
+    const RecentEntriesColumn& at(size_t index) const {
+        return _columns.at(index);
+    }
+
+    size_t size() const { return _columns.size(); }
 
    private:
-    const ContainerType _columns;
+    ContainerType _columns;
 };
 
 class RecentEntriesHeader : public Widget {

firmware/application/theme.cpp

@@ -4,6 +4,12 @@ namespace ui {
 
 ThemeTemplate* Theme::current = nullptr;
 
+void Theme::destroy() {
+    if (current != nullptr)
+        delete current;
+    current = nullptr;
+}
+
 ThemeTemplate* Theme::getInstance() {
     if (current == nullptr) SetTheme(DefaultGrey);
     return Theme::current;

firmware/application/theme.hpp

@@ -113,7 +113,7 @@ class Theme {
 
     static void SetTheme(ThemeId theme);
     static ThemeTemplate* current;
-
+    static void destroy();  // used from standalone app, to prevent memleak
    private:
 };
 

firmware/application/ui/ui_btngrid.cpp

@@ -4,7 +4,7 @@
  * Copyright (C) 2019 Elia Yehuda (z4ziggy)
  * Copyright (C) 2023 Mark Thompson
  * Copyright (C) 2024 u-foka
- * Copyleft (ↄ) 2024 zxkmm with the GPL license
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/ui/ui_geomap.cpp

@@ -22,21 +22,17 @@
  */
 
 #include "ui_geomap.hpp"
-
 #include "portapack.hpp"
-
 #include <cstring>
 #include <stdio.h>
-
+#include <string_view>
 using namespace portapack;
-
 #include "string_format.hpp"
 #include "complex.hpp"
 #include "ui_font_fixed_5x8.hpp"
 #include "file_path.hpp"
 
 namespace ui {
-
 GeoPos::GeoPos(
     const Point pos,
     const alt_unit altitude_unit,
@@ -110,6 +106,7 @@ GeoPos::GeoPos(
     text_alt_unit.set(altitude_unit_ ? "m" : "ft");
     if (speed_unit_ == KMPH) text_speed_unit.set("kmph");
     if (speed_unit_ == MPH) text_speed_unit.set("mph");
+    if (speed_unit_ == KNOTS) text_speed_unit.set("knots");
     if (speed_unit_ == HIDDEN) {
         text_speed_unit.hidden(true);
         label_spd_position.hidden(true);
@@ -187,6 +184,7 @@ int32_t GeoPos::speed() {
 GeoMap::GeoMap(
     Rect parent_rect)
     : Widget{parent_rect}, markerListLen(0) {
+    has_osm = use_osm = find_osm_file_tile();
 }
 
 bool GeoMap::on_encoder(const EncoderEvent delta) {
@@ -200,6 +198,8 @@ bool GeoMap::on_encoder(const EncoderEvent delta) {
                 map_zoom += (map_zoom >= MAP_ZOOM_RESOLUTION_LIMIT) ? map_zoom : 1;
             }
         }
+        map_osm_zoom++;
+        if (has_osm) set_osm_max_zoom();
     } else if (delta < 0) {
         if (map_zoom > -MAX_MAP_ZOOM_OUT) {
             if (map_zoom == 1) {
@@ -211,12 +211,18 @@ bool GeoMap::on_encoder(const EncoderEvent delta) {
                     map_zoom--;
             }
         }
+        if (map_osm_zoom > 0) map_osm_zoom--;
     } else {
         return false;
     }
 
     map_visible = map_opened && (map_zoom <= MAP_ZOOM_RESOLUTION_LIMIT);
-    zoom_pixel_offset = (map_visible && (map_zoom > 1)) ? (float)map_zoom / 2 : 0.0f;
+    if (use_osm) {
+        map_visible = true;
+        zoom_pixel_offset = 0;
+    } else {
+        zoom_pixel_offset = (map_visible && (map_zoom > 1)) ? (float)map_zoom / 2 : 0.0f;
+    }
 
     // Trigger map redraw
     redraw_map = true;
@@ -224,7 +230,7 @@ bool GeoMap::on_encoder(const EncoderEvent delta) {
     return true;
 }
 
-void GeoMap::map_read_line(ui::Color* buffer, uint16_t pixels) {
+void GeoMap::map_read_line_bin(ui::Color* buffer, uint16_t pixels) {
     if (map_zoom == 1) {
         map_file.read(buffer, pixels << 1);
     } else if (map_zoom > 1) {
@@ -250,7 +256,7 @@ void GeoMap::map_read_line(ui::Color* buffer, uint16_t pixels) {
         for (int i = 0; i < geomap_rect_width; i++) {
             buffer[i] = zoom_out_buffer[i * (-map_zoom)];
         }
-        delete zoom_out_buffer;
+        delete[] zoom_out_buffer;
     }
 }
 
@@ -263,39 +269,86 @@ void GeoMap::draw_markers(Painter& painter) {
 void GeoMap::draw_marker_item(Painter& painter, GeoMarker& item, const Color color, const Color fontColor, const Color backColor) {
     const auto r = screen_rect();
     const ui::Point itemPoint = item_rect_pixel(item);
-
     if ((itemPoint.x() >= 0) && (itemPoint.x() < r.width()) &&
         (itemPoint.y() > 10) && (itemPoint.y() < r.height()))  // Dont draw within symbol size of top
     {
-        draw_marker(painter, {itemPoint.x(), itemPoint.y() + r.top()}, item.angle, item.tag, color, fontColor, backColor);
+        draw_marker(painter, {itemPoint.x() + r.left(), itemPoint.y() + r.top()}, item.angle, item.tag, color, fontColor, backColor);
     }
 }
 
 // Calculate screen position of item, adjusted for zoom factor.
 ui::Point GeoMap::item_rect_pixel(GeoMarker& item) {
-    const auto r = screen_rect();
-    const auto geomap_rect_half_width = r.width() / 2;
-    const auto geomap_rect_half_height = r.height() / 2;
-
-    GeoPoint mapPoint = lat_lon_to_map_pixel(item.lat, item.lon);
-    float x = mapPoint.x - x_pos;
-    float y = mapPoint.y - y_pos;
-
-    if (map_zoom > 1) {
-        x = x * map_zoom + zoom_pixel_offset;
-        y = y * map_zoom + zoom_pixel_offset;
-    } else if (map_zoom < 0) {
-        x = x / (-map_zoom);
-        y = y / (-map_zoom);
+    if (!use_osm) {
+        const auto r = screen_rect();
+        const auto geomap_rect_half_width = r.width() / 2;
+        const auto geomap_rect_half_height = r.height() / 2;
+        GeoPoint mapPoint = lat_lon_to_map_pixel(item.lat, item.lon);
+        float x = mapPoint.x - x_pos;
+        float y = mapPoint.y - y_pos;
+        if (map_zoom > 1) {
+            x = x * map_zoom + zoom_pixel_offset;
+            y = y * map_zoom + zoom_pixel_offset;
+        } else if (map_zoom < 0) {
+            x = x / (-map_zoom);
+            y = y / (-map_zoom);
+        }
+        x += geomap_rect_half_width;
+        y += geomap_rect_half_height;
+        return {(int16_t)x, (int16_t)y};
     }
-
-    x += geomap_rect_half_width;
-    y += geomap_rect_half_height;
-
+    // osm calculation
+    double y = lat_to_pixel_y_tile(item.lat, map_osm_zoom) - viewport_top_left_py;
+    double x = lon_to_pixel_x_tile(item.lon, map_osm_zoom) - viewport_top_left_px;
     return {(int16_t)x, (int16_t)y};
 }
 
-// Converts latitude/longitude to pixel coordinates in map file.
+/**
+ * @brief Converts longitude to a map tile's X-coordinate.
+ * @param lon The longitude in degrees.
+ * @param zoom The zoom level.
+ * @return The X-coordinate of the tile.
+ */
+int GeoMap::lon2tile(double lon, int zoom) {
+    return (int)floor((lon + 180.0) / 360.0 * pow(2.0, zoom));
+}
+
+/**
+ * @brief Converts latitude to a map tile's Y-coordinate.
+ * @param lat The latitude in degrees.
+ * @param zoom The zoom level.
+ * @return The Y-coordinate of the tile.
+ */
+int GeoMap::lat2tile(double lat, int zoom) {
+    // Convert latitude from degrees to radians for trigonometric functions
+    double lat_rad = lat * M_PI / 180.0;
+    // Perform the Mercator projection calculation
+    return (int)floor((1.0 - log(tan(lat_rad) + 1.0 / cos(lat_rad)) / M_PI) / 2.0 * pow(2.0, zoom));
+}
+
+void GeoMap::set_osm_max_zoom() {
+    if (map_osm_zoom > 20) map_osm_zoom = 20;
+    for (uint8_t i = map_osm_zoom; i > 0; i--) {
+        int tile_x = lon2tile(lon_, i);
+        int tile_y = lat2tile(lat_, i);
+        std::string filename = "/OSM/" + to_string_dec_int(i) + "/" + to_string_dec_int(tile_x) + "/" + to_string_dec_int(tile_y) + ".bmp";
+        std::filesystem::path file_path(filename);
+        if (file_exists(file_path)) {
+            map_osm_zoom = i;
+            return;
+        }
+    }
+    map_osm_zoom = 0;  // should not happen
+}
+
+// checks if the tile file presents or not. to determine if we got osm or not
+uint8_t GeoMap::find_osm_file_tile() {
+    std::string filename = "/OSM/" + to_string_dec_int(0) + "/" + to_string_dec_int(0) + "/" + to_string_dec_int(0) + ".bmp";
+    std::filesystem::path file_path(filename);
+    if (file_exists(file_path)) return 1;
+    return 0;  // not found
+}
+
+// Converts latitude/longitude to pixel coordinates in binary map file.
 // (Note that when map_zoom==1, one pixel in map file corresponds to 1 pixel on screen)
 GeoPoint GeoMap::lat_lon_to_map_pixel(float lat, float lon) {
     // Using WGS 84/Pseudo-Mercator projection
@@ -309,9 +362,7 @@ GeoPoint GeoMap::lat_lon_to_map_pixel(float lat, float lon) {
 }
 
 // Draw grid in place of map (when zoom-in level is too high).
-void GeoMap::draw_map_grid() {
-    const auto r = screen_rect();
-
+void GeoMap::draw_map_grid(ui::Rect r) {
     // Grid spacing is just based on zoom at the moment, and centered on screen.
     // TODO: Maybe align with latitude/longitude seconds instead?
     int grid_spacing = map_zoom * 2;
@@ -331,60 +382,184 @@ void GeoMap::draw_map_grid() {
     }
 }
 
+double GeoMap::tile_pixel_x_to_lon(int x, int zoom) {
+    double map_width = pow(2.0, zoom) * TILE_SIZE;
+    return (x / map_width * 360.0) - 180.0;
+}
+
+double GeoMap::tile_pixel_y_to_lat(int y, int zoom) {
+    double map_height = pow(2.0, zoom) * TILE_SIZE;
+    double n = M_PI * (1.0 - 2.0 * y / map_height);
+    return atan(sinh(n)) * 180.0 / M_PI;
+}
+
+double GeoMap::lon_to_pixel_x_tile(double lon, int zoom) {
+    return ((lon + 180.0) / 360.0) * pow(2.0, zoom) * TILE_SIZE;
+}
+
+double GeoMap::lat_to_pixel_y_tile(double lat, int zoom) {
+    double lat_rad = lat * M_PI / 180.0;
+    double sin_lat = sin(lat_rad);
+    return ((1.0 - log((1.0 + sin_lat) / (1.0 - sin_lat)) / (2.0 * M_PI)) / 2.0) * pow(2.0, zoom) * TILE_SIZE;
+}
+
+bool GeoMap::draw_osm_file(int zoom, int tile_x, int tile_y, int relative_x, int relative_y) {
+    const auto r = screen_rect();
+    // Early exit if the tile is completely outside the viewport
+    if (relative_x >= r.width() || relative_y >= r.height() ||
+        relative_x + TILE_SIZE <= 0 || relative_y + TILE_SIZE <= 0) {
+        return true;
+    }
+
+    BMPFile bmp{};
+    bmp.open("/OSM/" + to_string_dec_int(zoom) + "/" + to_string_dec_int(tile_x) + "/" + to_string_dec_int(tile_y) + ".bmp", true);
+    // 1. Define the source and destination areas, starting with the full tile.
+    int src_x = 0;
+    int src_y = 0;
+    int dest_x = relative_x;
+    int dest_y = relative_y;
+    int clip_w = TILE_SIZE;
+    int clip_h = TILE_SIZE;
+    // 2. Clip left edge
+    if (dest_x < 0) {
+        src_x = -dest_x;
+        clip_w += dest_x;
+        dest_x = 0;
+    }
+    // 3. Clip top edge
+    if (dest_y < 0) {
+        src_y = -dest_y;
+        clip_h += dest_y;
+        dest_y = 0;
+    }
+    // 4. Clip right edge
+    if (dest_x + clip_w > r.width()) {
+        clip_w = r.width() - dest_x;
+    }
+    // 5. Clip bottom edge
+    if (dest_y + clip_h > r.height()) {
+        clip_h = r.height() - dest_y;
+    }
+    // 6. If clipping resulted in no visible area, we're done.
+    if (clip_w <= 0 || clip_h <= 0) {
+        return true;
+    }
+
+    if (!bmp.is_loaded()) {
+        // Draw an error rectangle using the calculated clipped dimensions
+        ui::Rect error_rect{{dest_x + r.left(), dest_y + r.top()}, {clip_w, clip_h}};
+        display.fill_rectangle(error_rect, Theme::getInstance()->bg_darkest->background);
+        return false;
+    }
+    std::vector<ui::Color> line(clip_w);
+    for (int y = 0; y < clip_h; ++y) {
+        int source_row = src_y + y;
+        int dest_row = dest_y + y;
+        bmp.seek(src_x, source_row);
+        for (int x = 0; x < clip_w; ++x) {
+            bmp.read_next_px(line[x], true);
+        }
+        display.draw_pixels({dest_x + r.left(), dest_row + r.top(), clip_w, 1}, line);
+    }
+    return true;
+}
+
 void GeoMap::paint(Painter& painter) {
     const auto r = screen_rect();
     std::array<ui::Color, geomap_rect_width> map_line_buffer;
     int16_t zoom_seek_x, zoom_seek_y;
 
-    // Ony redraw map if it moved by at least 1 pixel or the markers list was updated
-    if (map_zoom <= 1) {
-        // Zooming out, or no zoom
-        const int min_diff = abs(map_zoom);
-        if ((int)abs(x_pos - prev_x_pos) >= min_diff)
-            redraw_map = true;
-        else if ((int)abs(y_pos - prev_y_pos) >= min_diff)
-            redraw_map = true;
+    if (!use_osm) {
+        // Ony redraw map if it moved by at least 1 pixel or the markers list was updated
+        if (map_zoom <= 1) {
+            // Zooming out, or no zoom
+            const int min_diff = abs(map_zoom);
+            if ((int)abs(x_pos - prev_x_pos) >= min_diff)
+                redraw_map = true;
+            else if ((int)abs(y_pos - prev_y_pos) >= min_diff)
+                redraw_map = true;
+        } else {
+            // Zooming in; magnify position differences (utilizing zoom_pixel_offset)
+            if ((int)(abs(x_pos - prev_x_pos) * map_zoom) >= 1)
+                redraw_map = true;
+            else if ((int)(abs(y_pos - prev_y_pos) * map_zoom) >= 1)
+                redraw_map = true;
+        }
     } else {
-        // Zooming in; magnify position differences (utilizing zoom_pixel_offset)
-        if ((int)(abs(x_pos - prev_x_pos) * map_zoom) >= 1)
-            redraw_map = true;
-        else if ((int)(abs(y_pos - prev_y_pos) * map_zoom) >= 1)
-            redraw_map = true;
+        // using osm; needs to be stricter with the redraws, it'll be checked on move
     }
 
     if (redraw_map) {
-        prev_x_pos = x_pos;  // Note x_pos/y_pos pixel position in map file now correspond to screen rect CENTER pixel
-        prev_y_pos = y_pos;
         redraw_map = false;
-
-        // Adjust starting corner position of map per zoom setting;
-        // When zooming in the map should technically by shifted left & up by another map_zoom/2 pixels but
-        // the map_read_line() function doesn't handle that yet so we're adjusting markers instead (see zoom_pixel_offset).
-        if (map_zoom > 1) {
-            zoom_seek_x = x_pos - (float)r.width() / (2 * map_zoom);
-            zoom_seek_y = y_pos - (float)r.height() / (2 * map_zoom);
-        } else {
-            zoom_seek_x = x_pos - (r.width() * abs(map_zoom)) / 2;
-            zoom_seek_y = y_pos - (r.height() * abs(map_zoom)) / 2;
-        }
-
         if (map_visible) {
-            // Read from map file and display to zoomed scale
-            int duplicate_lines = (map_zoom < 0) ? 1 : map_zoom;
-            for (uint16_t line = 0; line < (r.height() / duplicate_lines); line++) {
-                uint16_t seek_line = zoom_seek_y + ((map_zoom >= 0) ? line : line * (-map_zoom));
-                map_file.seek(4 + ((zoom_seek_x + (map_width * seek_line)) << 1));
-                map_read_line(map_line_buffer.data(), r.width());
+            if (!use_osm) {
+                prev_x_pos = x_pos;  // Note x_pos/y_pos pixel position in map file now correspond to screen rect CENTER pixel
+                prev_y_pos = y_pos;
+                // Adjust starting corner position of map per zoom setting;
+                // When zooming in the map should technically by shifted left & up by another map_zoom/2 pixels but
+                // the map_read_line_bin() function doesn't handle that yet so we're adjusting markers instead (see zoom_pixel_offset).
+                if (map_zoom > 1) {
+                    zoom_seek_x = x_pos - (float)r.width() / (2 * map_zoom);
+                    zoom_seek_y = y_pos - (float)r.height() / (2 * map_zoom);
+                } else {
+                    zoom_seek_x = x_pos - (r.width() * abs(map_zoom)) / 2;
+                    zoom_seek_y = y_pos - (r.height() * abs(map_zoom)) / 2;
+                }
+                // Read from map file and display to zoomed scale
+                int duplicate_lines = (map_zoom < 0) ? 1 : map_zoom;
+                for (uint16_t line = 0; line < (r.height() / duplicate_lines); line++) {
+                    uint16_t seek_line = zoom_seek_y + ((map_zoom >= 0) ? line : line * (-map_zoom));
+                    map_file.seek(4 + ((zoom_seek_x + (map_width * seek_line)) << 1));
+                    map_read_line_bin(map_line_buffer.data(), r.width());
+                    for (uint16_t j = 0; j < duplicate_lines; j++) {
+                        display.draw_pixels({0, r.top() + (line * duplicate_lines) + j, r.width(), 1}, map_line_buffer);
+                    }
+                }
 
-                for (uint16_t j = 0; j < duplicate_lines; j++) {
-                    display.draw_pixels({0, r.top() + (line * duplicate_lines) + j, r.width(), 1}, map_line_buffer);
+            } else {
+                // display osm tiles
+                //  Convert center GPS to a global pixel coordinate
+                double global_center_px = lon_to_pixel_x_tile(lon_, map_osm_zoom);
+                double global_center_py = lat_to_pixel_y_tile(lat_, map_osm_zoom);
+
+                // Find the top-left corner of the screen (viewport) in global pixel coordinates
+                viewport_top_left_px = global_center_px - (r.width() / 2.0);
+                viewport_top_left_py = global_center_py - (r.height() / 2.0);
+
+                // Find the tile ID that contains the top-left corner of the viewport
+                int start_tile_x = floor(viewport_top_left_px / TILE_SIZE);
+                int start_tile_y = floor(viewport_top_left_py / TILE_SIZE);
+
+                // Calculate the crucial render offset.
+                // This determines how much the first tile is shifted to align the map correctly.
+                // This value will almost always be negative or zero.
+                double render_offset_x = -(viewport_top_left_px - (start_tile_x * TILE_SIZE));
+                double render_offset_y = -(viewport_top_left_py - (start_tile_y * TILE_SIZE));
+
+                // Determine how many tiles we need to draw to fill the screen
+                int tiles_needed_x = (r.width() / TILE_SIZE) + 2;
+                int tiles_needed_y = (r.height() / TILE_SIZE) + 2;
+
+                for (int y = 0; y < tiles_needed_y; ++y) {
+                    for (int x = 0; x < tiles_needed_x; ++x) {
+                        int current_tile_x = start_tile_x + x;
+                        int current_tile_y = start_tile_y + y;
+
+                        // Calculate the final on-screen drawing position for this tile.
+                        // For the first tile (x=0, y=0), this will be the negative offset.
+                        int draw_pos_x = round(render_offset_x + x * TILE_SIZE);
+                        int draw_pos_y = round(render_offset_y + y * TILE_SIZE);
+                        if (!draw_osm_file(map_osm_zoom, current_tile_x, current_tile_y, draw_pos_x, draw_pos_y)) {
+                            // already blanked it.
+                        }
+                    }
                 }
             }
+
         } else {
             // No map data or excessive zoom; just draw a grid
-            draw_map_grid();
+            draw_map_grid(r);
         }
-
         // Draw crosshairs in center in manual panning mode
         if (manual_panning_) {
             display.fill_rectangle({r.center() - Point(16, 1) + Point(zoom_pixel_offset, zoom_pixel_offset), {32, 2}}, Color::red());
@@ -393,8 +568,9 @@ void GeoMap::paint(Painter& painter) {
 
         // Draw the other markers
         draw_markers(painter);
-        draw_scale(painter);
+        if (!use_osm) draw_scale(painter);
         draw_mypos(painter);
+        if (has_osm) draw_switcher(painter);
         set_clean();
     }
 
@@ -404,6 +580,12 @@ void GeoMap::paint(Painter& painter) {
     }
 }
 
+void GeoMap::draw_switcher(Painter& painter) {
+    painter.fill_rectangle({screen_rect().left(), screen_rect().top(), 3 * 20, 20}, Theme::getInstance()->bg_darker->background);
+    std::string_view txt = (use_osm) ? "B I N" : "O S M";
+    painter.draw_string({screen_rect().left() + 5, screen_rect().top() + 2}, *Theme::getInstance()->fg_light, txt);
+}
+
 bool GeoMap::on_keyboard(KeyboardEvent key) {
     if (key == '+' || key == ' ') return on_encoder(1);
     if (key == '-') return on_encoder(-1);
@@ -412,11 +594,26 @@ bool GeoMap::on_keyboard(KeyboardEvent key) {
 }
 
 bool GeoMap::on_touch(const TouchEvent event) {
+    if (has_osm && event.type == TouchEvent::Type::Start && event.point.x() < screen_rect().left() + 3 * 20 && event.point.y() < screen_rect().top() + 20) {
+        use_osm = !use_osm;
+        move(lon_, lat_);  // to re calculate the center for each map type
+        if (use_osm) set_osm_max_zoom();
+        redraw_map = true;
+        set_dirty();
+        return false;  // false, because with true this hits 2 times
+    }
+
     if ((event.type == TouchEvent::Type::Start) && (mode_ == PROMPT)) {
+        Point p;
         set_highlighted(true);
         if (on_move) {
-            Point p = event.point - screen_rect().center();
-            on_move(p.x() / 2.0 * lon_ratio, p.y() / 2.0 * lat_ratio);
+            if (!use_osm) {
+                p = event.point - screen_rect().center();
+                on_move(p.x() / 2.0 * lon_ratio, p.y() / 2.0 * lat_ratio, false);
+            } else {
+                p = event.point - screen_rect().location();
+                on_move(tile_pixel_x_to_lon(p.x() + viewport_top_left_px, map_osm_zoom), tile_pixel_y_to_lat(p.y() + viewport_top_left_py, map_osm_zoom), true);
+            }
             return true;
         }
     }
@@ -425,25 +622,30 @@ bool GeoMap::on_touch(const TouchEvent event) {
 
 void GeoMap::move(const float lon, const float lat) {
     const auto r = screen_rect();
-
+    bool is_changed = (lon_ != lon || lat_ != lat);
     lon_ = lon;
     lat_ = lat;
+    if (!use_osm) {
+        // Calculate x_pos/y_pos in map file corresponding to CENTER pixel of screen rect
+        // (Note there is a 1:1 correspondence between map file pixels and screen pixels when map_zoom=1)
+        GeoPoint mapPoint = lat_lon_to_map_pixel(lat_, lon_);
+        x_pos = mapPoint.x;
+        y_pos = mapPoint.y;
+        // Cap position
+        if (x_pos > (map_width - r.width() / 2))
+            x_pos = map_width - r.width() / 2;
+        if (y_pos > (map_height + r.height() / 2))
+            y_pos = map_height - r.height() / 2;
 
-    // Calculate x_pos/y_pos in map file corresponding to CENTER pixel of screen rect
-    // (Note there is a 1:1 correspondence between map file pixels and screen pixels when map_zoom=1)
-    GeoPoint mapPoint = lat_lon_to_map_pixel(lat_, lon_);
-    x_pos = mapPoint.x;
-    y_pos = mapPoint.y;
-
-    // Cap position
-    if (x_pos > (map_width - r.width() / 2))
-        x_pos = map_width - r.width() / 2;
-    if (y_pos > (map_height + r.height() / 2))
-        y_pos = map_height - r.height() / 2;
-
-    // Scale calculation
-    float km_per_deg_lon = cos(lat * pi / 180) * 111.321;  // 111.321 km/deg longitude at equator, and 0 km at poles
-    pixels_per_km = (r.width() / 2) / km_per_deg_lon;
+        // Scale calculation
+        float km_per_deg_lon = cos(lat * pi / 180) * 111.321;  // 111.321 km/deg longitude at equator, and 0 km at poles
+        pixels_per_km = (r.width() / 2) / km_per_deg_lon;
+    } else {
+        if (is_changed) {
+            set_osm_max_zoom();
+            redraw_map = true;
+        }
+    }
 }
 
 bool GeoMap::init() {
@@ -458,7 +660,7 @@ bool GeoMap::init() {
         map_height = 32768;
     }
 
-    map_visible = map_opened;
+    map_visible = map_opened || has_osm;
     map_center_x = map_width >> 1;
     map_center_y = map_height >> 1;
 
@@ -468,7 +670,6 @@ bool GeoMap::init() {
     map_bottom = sin(-85.05 * pi / 180);  // Map bitmap only goes from about -85 to 85 lat
     map_world_lon = map_width / (2 * pi);
     map_offset = (map_world_lon / 2 * log((1 + map_bottom) / (1 - map_bottom)));
-
     return map_opened;
 }
 
@@ -572,15 +773,22 @@ void GeoMap::clear_markers() {
 MapMarkerStored GeoMap::store_marker(GeoMarker& marker) {
     const auto r = screen_rect();
     MapMarkerStored ret;
-
     // Check if it could be on screen
     // (Shows more distant planes when zoomed out)
-    GeoPoint mapPoint = lat_lon_to_map_pixel(marker.lat, marker.lon);
-    int x_dist = abs((int)mapPoint.x - (int)x_pos);
-    int y_dist = abs((int)mapPoint.y - (int)y_pos);
-    int zoom_out = (map_zoom < 0) ? -map_zoom : 1;
+    bool can_see_on_map = true;
+    if (!use_osm) {
+        GeoPoint mapPoint = lat_lon_to_map_pixel(marker.lat, marker.lon);
+        int x_dist = abs((int)mapPoint.x - (int)x_pos);
+        int y_dist = abs((int)mapPoint.y - (int)y_pos);
+        int zoom_out = (map_zoom < 0) ? -map_zoom : 1;
+        if ((x_dist >= (zoom_out * r.width() / 2)) || (y_dist >= (zoom_out * r.height() / 2))) {
+            can_see_on_map = false;
+        }
+    } else {
+        // osm is so zoomable, we try to store all possible. maybe need to refine it a bit more later
+    }
 
-    if ((x_dist >= (zoom_out * r.width() / 2)) || (y_dist >= (zoom_out * r.height() / 2))) {
+    if (!can_see_on_map) {
         ret = MARKER_NOT_STORED;
     } else if (markerListLen < NumMarkerListElements) {
         markerList[markerListLen] = marker;
@@ -594,24 +802,29 @@ MapMarkerStored GeoMap::store_marker(GeoMarker& marker) {
 }
 
 void GeoMap::update_my_position(float lat, float lon, int32_t altitude) {
+    bool is_changed = (my_pos.lat != lat) || (my_pos.lon != lon);
     my_pos.lat = lat;
     my_pos.lon = lon;
     my_altitude = altitude;
-    redraw_map = true;
+    redraw_map = is_changed;
     set_dirty();
 }
 
 void GeoMap::update_my_orientation(uint16_t angle, bool refresh) {
+    bool is_changed = (my_pos.angle != angle);
     my_pos.angle = angle;
-    if (refresh) {
+    if (refresh && is_changed) {
         redraw_map = true;
         set_dirty();
     }
 }
 
+MapType GeoMap::get_map_type() {
+    return use_osm ? MAP_TYPE_OSM : MAP_TYPE_BIN;
+}
+
 void GeoMapView::focus() {
     geopos.focus();
-
     if (!geomap.map_file_opened())
         nav_.display_modal("No map", "No world_map.bin file in\n/" + adsb_dir.string() + "/ directory", ABORT);
 }
@@ -628,7 +841,7 @@ void GeoMapView::update_position(float lat, float lon, uint16_t angle, int32_t a
         geomap.set_dirty();
         return;
     }
-
+    bool is_changed = lat_ != lat || lon_ != lon || altitude_ != altitude || speed_ != speed || angle_ != angle;
     lat_ = lat;
     lon_ = lon;
     altitude_ = altitude;
@@ -643,7 +856,7 @@ void GeoMapView::update_position(float lat, float lon, uint16_t angle, int32_t a
     geopos.set_report_change(true);
 
     geomap.set_angle(angle);
-    geomap.move(lon_, lat_);
+    if (is_changed) geomap.move(lon_, lat_);
     geomap.set_dirty();
 }
 
@@ -659,19 +872,25 @@ void GeoMapView::setup() {
     geopos.set_lon(lon_);
 
     geopos.on_change = [this](int32_t altitude, float lat, float lon, int32_t speed) {
+        bool is_changed = (altitude_ != altitude) || (lat_ != lat) || (lon_ != lon) || (speed_ != speed);
         altitude_ = altitude;
         lat_ = lat;
         lon_ = lon;
         speed_ = speed;
         geopos.hide_altandspeed();
         geomap.set_manual_panning(true);
-        geomap.move(lon_, lat_);
+        if (is_changed) geomap.move(lon_, lat_);
         geomap.set_dirty();
     };
 
-    geomap.on_move = [this](float move_x, float move_y) {
-        lon_ += move_x;
-        lat_ += move_y;
+    geomap.on_move = [this](float move_x, float move_y, bool absolute) {
+        if (absolute) {
+            lon_ = move_x;
+            lat_ = move_y;
+        } else {
+            lon_ += move_x;
+            lat_ += move_y;
+        }
 
         // Stupid hack to avoid an event loop
         geopos.set_report_change(false);
@@ -768,4 +987,8 @@ MapMarkerStored GeoMapView::store_marker(GeoMarker& marker) {
     return geomap.store_marker(marker);
 }
 
+MapType GeoMapView::get_map_type() {
+    return geomap.get_map_type();
+}
+
 } /* namespace ui */

firmware/application/ui/ui_geomap.hpp

@@ -27,6 +27,8 @@
 #include "ui.hpp"
 #include "file.hpp"
 #include "ui_navigation.hpp"
+#include "bmpfile.hpp"
+#include "mathdef.hpp"
 
 #include "portapack.hpp"
 
@@ -43,6 +45,8 @@ namespace ui {
 #define GEOMAP_RECT_WIDTH 240
 #define GEOMAP_RECT_HEIGHT (320 - 16 - GEOMAP_BANNER_HEIGHT)
 
+#define TILE_SIZE 256
+
 enum GeoMapMode {
     DISPLAY,
     PROMPT
@@ -81,6 +85,7 @@ class GeoPos : public View {
         NONE = 0,
         MPH,
         KMPH,
+        KNOTS,
         HIDDEN = 255
     };
 
@@ -134,7 +139,7 @@ class GeoPos : public View {
         {12 * 8, 0 * 16, 2 * 8, 16},
         ""};
     Text text_speed_unit{
-        {25 * 8, 0 * 16, 4 * 8, 16},
+        {25 * 8, 0 * 16, 5 * 8, 16},
         ""};
 
     NumberField field_lat_degrees{
@@ -192,9 +197,14 @@ enum MapMarkerStored {
     MARKER_LIST_FULL
 };
 
+enum MapType {
+    MAP_TYPE_OSM,
+    MAP_TYPE_BIN
+};
+
 class GeoMap : public Widget {
    public:
-    std::function<void(float, float)> on_move{};
+    std::function<void(float, float, bool)> on_move{};
 
     GeoMap(Rect parent_rect);
 
@@ -215,6 +225,7 @@ class GeoMap : public Widget {
     void set_tag(std::string new_tag) {
         tag_ = new_tag;
     }
+    MapType get_map_type();
 
     void set_angle(uint16_t new_angle) {
         angle_ = new_angle;
@@ -245,8 +256,22 @@ class GeoMap : public Widget {
     void draw_markers(Painter& painter);
     void draw_mypos(Painter& painter);
     void draw_bearing(const Point origin, const uint16_t angle, uint32_t size, const Color color);
-    void draw_map_grid();
-    void map_read_line(ui::Color* buffer, uint16_t pixels);
+    void draw_map_grid(ui::Rect r);
+    void draw_switcher(Painter& painter);
+    void map_read_line_bin(ui::Color* buffer, uint16_t pixels);
+    // open street map related
+    uint8_t find_osm_file_tile();
+    void set_osm_max_zoom();
+    bool draw_osm_file(int zoom, int tile_x, int tile_y, int relative_x, int relative_y);
+    int lon2tile(double lon, int zoom);
+    int lat2tile(double lat, int zoom);
+    double lon_to_pixel_x_tile(double lon, int zoom);
+    double lat_to_pixel_y_tile(double lat, int zoom);
+    double tile_pixel_x_to_lon(int x, int zoom);
+    double tile_pixel_y_to_lat(int y, int zoom);
+    uint8_t map_osm_zoom{3};
+    double viewport_top_left_px = 0;
+    double viewport_top_left_py = 0;
 
     bool manual_panning_{false};
     bool hide_center_marker_{false};
@@ -257,11 +282,11 @@ class GeoMap : public Widget {
     uint16_t map_width{}, map_height{};
     int32_t map_center_x{}, map_center_y{};
     int16_t map_zoom{1};
+
     float lon_ratio{}, lat_ratio{};
     double map_bottom{};
     double map_world_lon{};
     double map_offset{};
-
     float x_pos{}, y_pos{};
     float prev_x_pos{32767.0f}, prev_y_pos{32767.0f};
     float lat_{};
@@ -277,7 +302,9 @@ class GeoMap : public Widget {
 
     int markerListLen{0};
     GeoMarker markerList[NumMarkerListElements];
-    bool redraw_map{false};
+    bool redraw_map{true};
+    bool use_osm{false};
+    bool has_osm{false};
 };
 
 class GeoMapView : public View {
@@ -312,6 +339,8 @@ class GeoMapView : public View {
     void update_my_position(float lat, float lon, int32_t altitude);
     void update_my_orientation(uint16_t angle, bool refresh = false);
 
+    MapType get_map_type();
+
     std::string title() const override { return "Map view"; };
 
     void clear_markers();

firmware/application/ui/ui_receiver.cpp

@@ -275,29 +275,63 @@ FrequencyKeypadView::FrequencyKeypadView(
         };
         button.on_select = button_fn;
         button.set_parent_rect({(n % 3) * button_w,
-                                (n / 3) * button_h + 24,
+                                (n / 3) * button_h + 25,
                                 button_w, button_h});
         button.set_text(label);
         n++;
     }
 
-    add_children({&button_save,
+    add_children({&button_save_ghz,
+                  &button_save_khz,
+                  &button_save_mhz,
                   &button_load,
-                  &button_close});
+                  &button_clear,
+                  &button_done_ghz,
+                  &button_done_mhz,
+                  &button_done_khz});
 
-    button_save.on_select = [this, &nav](Button&) {
-        nav.push<FrequencySaveView>(this->value());
+    button_save_mhz.on_select = [this, &nav](Button&) {
+        nav.push<FrequencySaveView>(this->value(FrequencyUnit::MHZ));  // pass as mhz and handle unit convert logic there, cuz idk if pass others would loss something
     };
+    button_save_ghz.on_select = [this, &nav](Button&) {
+        nav.push<FrequencySaveView>(this->value(FrequencyUnit::GHZ));
+    };
+    button_save_khz.on_select = [this, &nav](Button&) {
+        nav.push<FrequencySaveView>(this->value(FrequencyUnit::KHZ));
+    };
+
     button_load.on_select = [this, &nav](Button&) {
         auto load_view = nav.push<FrequencyLoadView>();
         load_view->on_frequency_loaded = [this](rf::Frequency value) {
             set_value(value);
         };
     };
+    button_clear.on_select = [this](Button&) {
+        mhz.clear();
+        submhz.clear();
+        clear_field_if_digits_entered = true;
+        if (state == State::DigitSubMHz) {
+            state = State::DigitMHz;
+        }
+        draw_input_hint();
+        update_text();
+    };
 
-    button_close.on_select = [this, &nav](Button&) {
+    button_done_ghz.on_select = [this, &nav](Button&) {
         if (on_changed)
-            on_changed(this->value());
+            on_changed(this->value(FrequencyUnit::GHZ));
+        nav.pop();
+    };
+
+    button_done_mhz.on_select = [this, &nav](Button&) {
+        if (on_changed)
+            on_changed(this->value(FrequencyUnit::MHZ));
+        nav.pop();
+    };
+
+    button_done_khz.on_select = [this, &nav](Button&) {
+        if (on_changed)
+            on_changed(this->value(FrequencyUnit::KHZ));
         nav.pop();
     };
 
@@ -305,11 +339,20 @@ FrequencyKeypadView::FrequencyKeypadView(
 }
 
 void FrequencyKeypadView::focus() {
-    button_close.focus();
+    button_done_mhz.focus();
 }
 
-rf::Frequency FrequencyKeypadView::value() const {
-    return mhz.as_int() * 1000000ULL + submhz.as_int() * submhz_base;
+rf::Frequency FrequencyKeypadView::value(FrequencyUnit frequency_uni) const {
+    switch (frequency_uni) {
+        case FrequencyUnit::GHZ:
+            return mhz.as_int() * 1000000000ULL + submhz.as_int() * submhz_base * 1000;
+        case FrequencyUnit::MHZ:
+            return mhz.as_int() * 1000000ULL + submhz.as_int() * submhz_base;
+        case FrequencyUnit::KHZ:
+            return mhz.as_int() * 1000ULL + submhz.as_int() * submhz_base / 1000;
+        default:
+            return mhz.as_int() * 1000000ULL + submhz.as_int() * submhz_base;
+    }
 }
 
 void FrequencyKeypadView::set_value(const rf::Frequency new_value) {
@@ -381,6 +424,25 @@ void FrequencyKeypadView::field_toggle() {
         state = State::DigitMHz;
         clear_field_if_digits_entered = true;
     }
+    draw_input_hint();
+}
+
+void FrequencyKeypadView::draw_input_hint() {
+    set_dirty();
+}
+
+void FrequencyKeypadView::paint(Painter& painter) {
+    View::paint(painter);
+
+    const bool s = state == State::DigitMHz;
+    painter.draw_hline(
+        {0, 36},
+        8 * 4,
+        s ? Color::white() : Color::black());
+    painter.draw_hline(
+        {5 * 8, 36},
+        8 * 4,
+        s ? Color::black() : Color::white());
 }
 
 void FrequencyKeypadView::update_text() {

firmware/application/ui/ui_receiver.hpp

@@ -44,6 +44,12 @@ extern options_db_t freqman_steps;
 
 namespace ui {
 
+enum FrequencyUnit {
+    GHZ = 0,
+    MHZ,
+    KHZ,
+};
+
 class FrequencyField : public Widget {
    public:
     std::function<void(rf::Frequency)> on_change{};
@@ -207,8 +213,9 @@ class FrequencyKeypadView : public View {
         const rf::Frequency value);
 
     void focus() override;
+    void paint(Painter& painter) override;
 
-    rf::Frequency value() const;
+    rf::Frequency value(FrequencyUnit frequency_uni) const;
     void set_value(const rf::Frequency new_value);
     bool on_encoder(const EncoderEvent delta) override;
     bool on_keyboard(const KeyboardEvent key) override;
@@ -220,7 +227,6 @@ class FrequencyKeypadView : public View {
 
     static constexpr int mhz_digits = 4;
     static constexpr int submhz_digits = 4;
-
     static constexpr int mhz_mod = pow(10, mhz_digits);
     static constexpr int submhz_base = pow(10, 6 - submhz_digits);
     static constexpr int text_digits = mhz_digits + 1 + submhz_digits;
@@ -230,15 +236,30 @@ class FrequencyKeypadView : public View {
 
     std::array<Button, 12> buttons{};
 
-    Button button_save{
-        {0, button_h * 5, 60, button_h},
-        "Save"};
+    Button button_save_ghz{
+        {0, 14 * 16, 80 / 2 - 1, 2 * 16},
+        "GHz"};
+    Button button_save_khz{
+        {0 + 40 - 1, 14 * 16, 80 / 2, 2 * 16},
+        "kHz"};
+    Button button_save_mhz{
+        {0, 16 * 16, 80 - 1, 3 * 16},
+        "Save MHz"};
     Button button_load{
-        {60, button_h * 5, 60, button_h},
+        {80 + 1, 14 * 16, 80 - 2, 40},
         "Load"};
-    Button button_close{
-        {128, button_h * 5, 112, button_h},
-        "Done"};
+    Button button_clear{
+        {80 + 1, 264, 80 - 2, 40},
+        "Clear"};
+    Button button_done_ghz{
+        {160 + 1, 14 * 16, 80 / 2 - 1, 2 * 16},
+        "GHz"};
+    Button button_done_khz{
+        {160 + 40, 14 * 16, 80 / 2 - 1, 2 * 16},
+        "kHz"};
+    Button button_done_mhz{
+        {160 + 1, 16 * 16, 80 - 2, 3 * 16},
+        "Done MHz"};
 
     /* TODO: Template arg required in enum?! */
     FieldString<mhz_digits> mhz{FieldString<4>::Justify::Right};
@@ -254,6 +275,8 @@ class FrequencyKeypadView : public View {
 
     void on_button(Button& button);
 
+    void draw_input_hint();
+
     void digit_add(const char c);
     void digit_delete();
 

firmware/application/ui/ui_spectrum.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
- * Copyleft Mr. Robot 2025
+ * copyleft 2025 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/ui/ui_spectrum.hpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
- * Copyleft Mr. Robot 2025
+ * copyleft 2025 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *

firmware/application/ui_external_items_menu_loader.cpp

@@ -347,7 +347,7 @@ namespace ui {
         return false;
 
     // TODO: move this to m4 memory space
-    auto app_image = reinterpret_cast<uint8_t*>(portapack::memory::map::m4_code.end() - app.size());
+    auto app_image = reinterpret_cast<uint8_t*>(portapack::memory::map::local_sram_0.base());
 
     // read file in 512 byte chunks
     for (size_t file_read_index = 0; file_read_index < app.size(); file_read_index += std::filesystem::max_file_block_size) {

firmware/application/ui_navigation.cpp

@@ -2,7 +2,7 @@
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
  * Copyright (C) 2024 u-foka
- * Copyleft (ɔ) 2024 zxkmm under GPL license
+ * copyleft 2024 zxkmm AKA zix aka sommermorgentraum
  *
  * This file is part of PortaPack.
  *
@@ -70,9 +70,7 @@
 #include "ble_rx_app.hpp"
 #include "ble_tx_app.hpp"
 #include "capture_app.hpp"
-#include "ert_app.hpp"
 #include "pocsag_app.hpp"
-#include "soundboard_app.hpp"
 
 #include "core_control.hpp"
 #include "file.hpp"
@@ -131,7 +129,6 @@ const NavigationView::AppList NavigationView::appList = {
     {"aprsrx", "APRS", RX, Color::green(), &bitmap_icon_aprs, new ViewFactory<APRSRXView>()},
     {"audio", "Audio", RX, Color::green(), &bitmap_icon_speaker, new ViewFactory<AnalogAudioView>()},
     {"blerx", "BLE Rx", RX, Color::green(), &bitmap_icon_btle, new ViewFactory<BLERxView>()},
-    {"ert", "ERT Meter", RX, Color::green(), &bitmap_icon_ert, new ViewFactory<ERTAppView>()},
     {"pocsag", "POCSAG", RX, Color::green(), &bitmap_icon_pocsag, new ViewFactory<POCSAGAppView>()},
     {"radiosonde", "Radiosnde", RX, Color::green(), &bitmap_icon_sonde, new ViewFactory<SondeView>()},
     {"search", "Search", RX, Color::yellow(), &bitmap_icon_search, new ViewFactory<SearchView>()},
@@ -144,7 +141,6 @@ const NavigationView::AppList NavigationView::appList = {
     {"ooktx", "OOK", TX, ui::Color::yellow(), &bitmap_icon_remote, new ViewFactory<EncodersView>()},
     {"pocsagtx", "POCSAG TX", TX, ui::Color::green(), &bitmap_icon_pocsag, new ViewFactory<POCSAGTXView>()},
     {"rdstx", "RDS", TX, ui::Color::green(), &bitmap_icon_rds, new ViewFactory<RDSView>()},
-    {"soundbrd", "Soundbrd", TX, ui::Color::green(), &bitmap_icon_soundboard, new ViewFactory<SoundBoardView>()},
     {"touchtune", "TouchTune", TX, ui::Color::green(), &bitmap_icon_touchtunes, new ViewFactory<TouchTunesView>()},
     {"signalgen", "SignalGen", TX, Color::green(), &bitmap_icon_cwgen, new ViewFactory<SigGenView>()},
     /* TRX ********************************************************************/
@@ -764,7 +760,7 @@ void add_apps(NavigationView& nav, BtnGridView& grid, app_location_t loc) {
     for (auto& app : NavigationView::appList) {
         if (app.menuLocation == loc) {
             grid.add_item({app.displayName, app.iconColor, app.icon,
-                           [&nav, &app]() { 
+                           [&nav, &app]() {
                             i2cdev::I2CDevManager::set_autoscan_interval(0); //if i navigate away from any menu, turn off autoscan
                             nav.push_view(std::unique_ptr<View>(app.viewFactory->produce(nav))); }},
                           true);
@@ -791,8 +787,8 @@ void add_external_items(NavigationView& nav, app_location_t location, BtnGridVie
                          error_tile_pos);
     } else {
         std::sort(externalItems.begin(), externalItems.end(), [](const auto &a, const auto &b)
-        { 
-            return a.desired_position < b.desired_position; 
+        {
+            return a.desired_position < b.desired_position;
         });
 
         for (auto const& gridItem : externalItems) {
@@ -801,7 +797,7 @@ void add_external_items(NavigationView& nav, app_location_t location, BtnGridVie
             } else {
                 grid.insert_item(gridItem, gridItem.desired_position, true);
             }
-            
+
         }
 
         grid.update_items();