fix build (#3129)

Co-authored-by: gullradriel <gullradriel@users.noreply.github.com>

SECURITY.md

@@ -1 +1,17 @@
-Please check [Intended-Use-and-Legality](https://github.com/portapack-mayhem/mayhem-firmware/wiki/)
+# Security Policy
+
+## Scope and Threat Model
+This repository hosts the codebase for an embedded system designed for security research. Because the system operates primarily offline, traditional network-based vulnerabilities are generally not applicable. However, we still welcome and review security reports concerning the code within this repository. 
+
+## Reporting a Vulnerability
+If you discover a vulnerability within this tool itself, please submit a report. Please be aware that the maintainers do not promise assistance with obtaining CVE IDs or managing formal security advisories.
+
+## Out of Scope
+* **Vulnerabilities found *using* this tool:** Please do not submit reports here for vulnerabilities you have discovered in other systems or targets using this tool. This channel is strictly for reporting vulnerabilities found *in* the tool itself. 
+* **Other Repositories:** For security issues concerning related tools, such as MayhemHub, please submit your reports directly to their respective repositories.
+
+## Research Attribution
+If you utilize this tool to successfully discover vulnerabilities in external systems, we would greatly appreciate it if you credit or mention our project in your published research or write-ups.
+
+## Legal and Security Disclaimer  
+For comprehensive guidelines regarding the legal and secure usage of this tool, as well as our full liability disclaimer, please refer to: [Intended-Use-and-Legality](https://github.com/portapack-mayhem/mayhem-firmware/wiki/). Users are expected to comply with all applicable laws and regulations when using this software and/or hardware.

firmware/application/apps/analog_audio_app.cpp

@@ -419,10 +419,10 @@ void AnalogAudioView::on_baseband_bandwidth_changed(uint32_t bandwidth_hz) {
 }
 
 void AnalogAudioView::on_modulation_changed(ReceiverModel::Mode modulation) {
-    baseband::spectrum_streaming_stop();
+    waterfall.stop();
     update_modulation(modulation);
     on_show_options_modulation();
-    baseband::spectrum_streaming_start();
+    waterfall.start();
 }
 
 void AnalogAudioView::remove_options_widget() {

firmware/application/apps/ui_battinfo.cpp

@@ -27,6 +27,8 @@
 #include "portapack.hpp"
 #include "battery.hpp"
 #include <cstring>
+#include "ui_settings.hpp"
+#include "portapack_persistent_memory.hpp"
 
 using namespace portapack;
 
@@ -138,10 +140,8 @@ void BattinfoView::update_result() {
     }
     if ((valid_mask & battery::BatteryManagement::BATT_VALID_PERCENT) == battery::BatteryManagement::BATT_VALID_PERCENT) {
         text_method.set("IC");
-        button_mode.set_text("Volt");
     } else {
         text_method.set("Voltage");
-        button_mode.set_text("IC");
     }
     if (uichg) set_dirty();
     // to update status bar too, send message in behalf of batt manager
@@ -158,8 +158,9 @@ BattinfoView::BattinfoView(NavigationView& nav)
                   &text_current,
                   &text_charge,
                   &text_method,
-                  &button_mode,
+                  &button_settings,
                   &button_exit,
+                  &text_capacity,
                   // &text_cycles,
                   // &text_warn,
                   &text_ttef});
@@ -167,17 +168,11 @@ BattinfoView::BattinfoView(NavigationView& nav)
     button_exit.on_select = [this, &nav](Button&) {
         nav.pop();
     };
-    button_mode.on_select = [this, &nav](Button&) {
-        if (button_mode.text() == "IC") {
-            battery::BatteryManagement::set_calc_override(false);
-            persistent_memory::set_ui_override_batt_calc(false);
-            button_mode.set_text("Volt");
-        } else {
-            battery::BatteryManagement::set_calc_override(true);
-            persistent_memory::set_ui_override_batt_calc(true);
-            button_mode.set_text("IC");
-        }
+    button_settings.on_select = [this, &nav](Button&) {
+        nav.replace<SetBatteryView>();
     };
+    text_capacity.set(to_string_dec_uint(persistent_memory::battery_cap_mah()) + " mAh");
+    if (!persistent_memory::battery_cap_valid()) text_capacity.set_style(Theme::getInstance()->fg_red);
     update_result();
     if (thread == nullptr) thread = chThdCreateFromHeap(NULL, 1024, NORMALPRIO + 10, BattinfoView::static_fn, this);
 }

firmware/application/apps/ui_battinfo.hpp

@@ -54,48 +54,53 @@ class BattinfoView : public View {
     int32_t current = 0;
 
     Labels labels{
-        {{2 * 8, 1 * 16}, "Percent:", Theme::getInstance()->fg_light->foreground},
-        {{2 * 8, 2 * 16}, "Voltage:", Theme::getInstance()->fg_light->foreground},
-        {{2 * 8, 3 * 16}, "Method:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(1)}, "Percent:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(2)}, "Voltage:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(3)}, "Method:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(4)}, "Capacity:", Theme::getInstance()->fg_light->foreground},
     };
 
     Labels labels_opt{
-        {{2 * 8, 4 * 16}, "Current:", Theme::getInstance()->fg_light->foreground},
-        {{2 * 8, 5 * 16}, "Charge:", Theme::getInstance()->fg_light->foreground},
-        {{2 * 8, 6 * 16}, "TTF/E:", Theme::getInstance()->fg_light->foreground},
-        // {{2 * 8, 7 * 16}, "Cycles:", Theme::getInstance()->fg_light->foreground},
-        {{2 * 8, 10 * 16}, "Change method:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(5)}, "Current:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(6)}, "Charge:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(7)}, "TTF/E:", Theme::getInstance()->fg_light->foreground},
+        // {{UI_POS_X(2), UI_POS_Y(8)}, "Cycles:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(2), UI_POS_Y(10)}, "Change settings:", Theme::getInstance()->fg_light->foreground},
     };
 
     Text text_percent{
-        {13 * 8, 1 * 16, 10 * 16, 16},
+        {UI_POS_X(13), UI_POS_Y(1), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
         "-"};
     Text text_voltage{
-        {13 * 8, 2 * 16, 10 * 16, 16},
+        {UI_POS_X(13), UI_POS_Y(2), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
         "-"};
     Text text_method{
-        {13 * 8, 3 * 16, 10 * 16, 16},
+        {UI_POS_X(13), UI_POS_Y(3), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
+        "-"};
+    Text text_capacity{
+        {UI_POS_X(13), UI_POS_Y(4), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
         "-"};
     Text text_current{
-        {13 * 8, 4 * 16, 10 * 16, 16},
+        {UI_POS_X(13), UI_POS_Y(5), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
         "-"};
     Text text_charge{
-        {13 * 8, 5 * 16, 10 * 16, 16},
+        {UI_POS_X(13), UI_POS_Y(6), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
         "-"};
     Text text_ttef{
-        {13 * 8, 6 * 16, 10 * 16, 16},
+        {UI_POS_X(13), UI_POS_Y(7), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
         "-"};
+
     /* Text text_cycles{
-        {13 * 8, 7 * 16, 10 * 16, 16},
+        {UI_POS_X(13), UI_POS_Y(8), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
         "-"};
 
     Text text_warn{
-        {1 * 8, 8 * 16, screen_width, 2 * 16},
+        {UI_POS_X(1), UI_POS_Y(9), screen_width, UI_POS_HEIGHT(2)},
         ""}; */
 
-    Button button_mode{
-        {2 * 8, 11 * 16 + 5, 5 * 16, 32},
-        "Volt"};
+    Button button_settings{
+        {UI_POS_X(2), UI_POS_Y(11) + 5, UI_POS_WIDTH(10), UI_POS_HEIGHT(2)},
+        "Settings"};
 
     Button button_exit{
         {UI_POS_X_CENTER(12), UI_POS_Y_BOTTOM(4), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},

firmware/application/apps/ui_settings.cpp

@@ -1160,6 +1160,8 @@ SetBatteryView::SetBatteryView(NavigationView& nav) {
     add_children({&labels,
                   &button_save,
                   &button_cancel,
+                  &field_battcap,
+                  &button_help_cap,
                   &checkbox_overridebatt,
                   &checkbox_battery_charge_hint});
 
@@ -1169,21 +1171,44 @@ SetBatteryView::SetBatteryView(NavigationView& nav) {
         pmem::set_ui_override_batt_calc(checkbox_overridebatt.value());
         pmem::set_ui_battery_charge_hint(checkbox_battery_charge_hint.value());
         battery::BatteryManagement::set_calc_override(checkbox_overridebatt.value());
+        if (((uint32_t)field_battcap.value() != pmem::battery_cap_mah()) || (!pmem::battery_cap_valid())) {
+            pmem::set_battery_cap_mah(field_battcap.value());
+            i2cdev::I2cDev_MAX17055* dev = (i2cdev::I2cDev_MAX17055*)i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDEVMDL_MAX17055);
+            if (dev && !dev->reInit()) {
+                nav.display_modal("Error", "Battery gauge re-init failed");
+                return;
+            }
+        }
         send_system_refresh();
         nav.pop();
     };
 
     button_reset.on_select = [&nav, this](Button&) {
         auto dev = (i2cdev::I2cDev_MAX17055*)i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDEVMDL_MAX17055);
-        if (dev->reset_learned())
+        if (dev && dev->reset_learned())
             nav.display_modal("Reset", "Battery parameters reset");
         else
             nav.display_modal("Error", "Error parameter reset");
     };
 
+    button_help_cap.on_select = [&nav, this](Button&) {
+        nav.display_modal("Battery Capacity",
+                          "Only change default, if you\n"
+                          "   changed the battery!\n"
+                          "Defaults:\n"
+                          "H4 + Hackrf One: 2500\n"
+                          "H4 + Hackrf Pro: 2000\n"
+                          "H4Pro + Hackrf Pro: custom\n"
+                          "PortaRf: 3000\n"
+
+        );
+    };
+
     checkbox_overridebatt.set_value(pmem::ui_override_batt_calc());
     checkbox_battery_charge_hint.set_value(pmem::ui_battery_charge_hint());
 
+    field_battcap.set_value(pmem::battery_cap_mah());
+
     button_cancel.on_select = [&nav, this](Button&) {
         nav.pop();
     };

firmware/application/apps/ui_settings.hpp

@@ -1045,21 +1045,36 @@ class SetBatteryView : public View {
    private:
     int32_t selected = 0;
     Labels labels{
-        {{1 * 8, 1 * 16}, "Override batt calculation", Theme::getInstance()->fg_light->foreground},
-        {{1 * 8, 2 * 16}, "method to voltage based", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_CENTER(26), UI_POS_Y(0)}, "Override batt calculation", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_CENTER(24), UI_POS_Y(1)}, "method to voltage based", Theme::getInstance()->fg_light->foreground},
         /**/
-        {{1 * 8, 6 * 16}, "Display a hint to remind you", Theme::getInstance()->fg_light->foreground},
-        {{1 * 8, 7 * 16}, "when you charge", Theme::getInstance()->fg_light->foreground}};
+        {{UI_POS_X_CENTER(29), UI_POS_Y(4)}, "Display a hint to remind you", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_CENTER(16), UI_POS_Y(5)}, "when you charge", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_CENTER(17), UI_POS_Y(8)}, "Battery capacity", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(7), UI_POS_Y(9)}, "mAh", Theme::getInstance()->fg_light->foreground}};
 
-    Labels labels2{{{1 * 8, 11 * 16}, "Reset IC's learned params.", Theme::getInstance()->fg_light->foreground}};
+    Labels labels2{{{UI_POS_X(1), UI_POS_Y(11)}, "Reset IC's learned params.", Theme::getInstance()->fg_light->foreground}};
+
+    NumberField field_battcap{
+        {UI_POS_X(1), UI_POS_Y(9)},
+        5,
+        {BATT_18650_MIN_MAH, BATT_18650_MAX_MAH},
+        100,
+        ' ',
+    };
+
+    Button button_help_cap{
+        {UI_POS_X(12), UI_POS_Y(9), UI_POS_WIDTH(5), UI_POS_HEIGHT(1)},
+        "Help",
+    };
 
     Checkbox checkbox_overridebatt{
-        {2 * 8, 4 * 16},
+        {UI_POS_X(2), UI_POS_Y(2)},
         23,
         "Override"};
 
     Checkbox checkbox_battery_charge_hint{
-        {2 * 8, 9 * 16},
+        {UI_POS_X(2), UI_POS_Y(6)},
         23,
         "Charge hint"};
 

firmware/application/baseband_api.cpp

@@ -393,6 +393,11 @@ void set_moreserx_config(uint8_t mode) {
     send_message(&message);
 }
 
+void set_tonedetect_config(uint8_t squelch, uint32_t ctcss_freq_x10) {
+    const ToneDetectConfigureMessage message{squelch, ctcss_freq_x10};
+    send_message(&message);
+}
+
 void set_morsetx_config(uint8_t mode, uint32_t tone, float fm_delta) {
     const MorseTXConfigureMessage message{mode, tone, fm_delta};
     send_message(&message);

firmware/application/baseband_api.hpp

@@ -108,6 +108,7 @@ void set_siggen_config(const uint32_t bw, const uint32_t shape, const uint32_t d
 void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bool update, int32_t bw);
 void set_subghzd_config(uint8_t modulation, uint32_t sampling_rate);
 void set_moreserx_config(uint8_t mode);
+void set_tonedetect_config(uint8_t squelch, uint32_t ctcss_freq_x10 = 0);
 void set_morsetx_config(uint8_t mode, uint32_t tone, float fm_delta);
 void set_morsetx_key(bool key_down);
 void set_wefax_config(uint8_t lpm, uint8_t ioc);

firmware/application/external/detector_rx/ui_detector_rx.cpp

@@ -26,6 +26,7 @@
 #include "ui_freqman.hpp"
 #include "baseband_api.hpp"
 #include "file.hpp"
+#include "file_path.hpp"
 #include "oversample.hpp"
 #include "ui_font_fixed_8x16.hpp"
 
@@ -35,36 +36,112 @@ using portapack::memory::map::backup_ram;
 
 namespace ui::external_app::detector_rx {
 
-// Function to map the value from one range to another
 int32_t DetectorRxView::map(int32_t value, int32_t fromLow, int32_t fromHigh, int32_t toLow, int32_t toHigh) {
     return toLow + (value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow);
 }
 
 void DetectorRxView::focus() {
-    field_lna.focus();
+    button_index.focus();
 }
 
 DetectorRxView::~DetectorRxView() {
-    // reset performance counters request to default
     shared_memory.request_m4_performance_counter = 0;
     receiver_model.disable();
     audio::output::stop();
     baseband::shutdown();
 }
 
-void DetectorRxView::on_timer() {
-    freq_index++;
-    if (freq_mode == 0 && freq_index >= tetra_uplink_monitoring_frequencies_hz.size()) freq_index = 0;  // TETRA UP
-    if (freq_mode == 1 && freq_index >= lora_monitoring_frequencies_hz.size()) freq_index = 0;          // Lora
-    if (freq_mode == 2 && freq_index >= remotes_monitoring_frequencies_hz.size()) freq_index = 0;       // Remotes
+std::string DetectorRxView::format_freq_mhz(int64_t freq_hz) {
+    int64_t mhz = freq_hz / 1000000;
+    int64_t khz_frac = (freq_hz % 1000000) / 1000;
+    return "< " + to_string_dec_uint(mhz) + "." + to_string_dec_uint(khz_frac, 3, '0') + " MHz >";
+}
 
-    if (freq_mode == 2)
-        freq_ = remotes_monitoring_frequencies_hz[freq_index];
-    else if (freq_mode == 1)
-        freq_ = lora_monitoring_frequencies_hz[freq_index];
-    else
-        freq_ = tetra_uplink_monitoring_frequencies_hz[freq_index];
-    receiver_model.set_target_frequency(freq_);
+void DetectorRxView::load_freqman() {
+    freqman_load_options options{};
+    options.load_freqs = true;
+    options.load_ranges = true;
+    options.load_hamradios = false;
+    options.load_repeaters = false;
+
+    if (!load_freqman_file(freq_file_stem, frequency_list, options) || frequency_list.empty()) {
+        button_file.set_text("No file!");
+        button_index.set_text("");
+        text_entry_desc.set("");
+        button_freq.set_text("");
+        frequency_list.clear();
+        return;
+    }
+
+    current_index = 0;
+    init_current_entry();
+    button_file.set_text(freq_file_stem);
+}
+
+void DetectorRxView::init_current_entry() {
+    if (frequency_list.empty()) return;
+
+    auto& entry = *frequency_list[current_index];
+    if (entry.type == freqman_type::Range) {
+        minfreq = entry.frequency_a;
+        maxfreq = entry.frequency_b;
+        current_freq = minfreq;
+        current_step = is_valid(entry.step) ? freqman_entry_get_step_value(entry.step) : DETECTOR_BW;
+    } else {
+        current_freq = entry.frequency_a;
+        minfreq = current_freq;
+        maxfreq = current_freq;
+        current_step = DETECTOR_BW;
+    }
+
+    update_entry_display();
+    update_freq_display();
+    receiver_model.set_target_frequency(current_freq);
+}
+
+void DetectorRxView::update_entry_display() {
+    if (frequency_list.empty()) return;
+
+    auto& entry = *frequency_list[current_index];
+    button_index.set_text(
+        to_string_dec_uint(current_index + 1) + "/" +
+        to_string_dec_uint(frequency_list.size()));
+    text_entry_desc.set(entry.description);
+}
+
+void DetectorRxView::update_freq_display() {
+    if (auto_scan && (minfreq != maxfreq)) {
+        if (last_update_was_auto_range_type != 1) {
+            button_freq.set_text("RANGE SCAN...");
+            last_update_was_auto_range_type = 1;
+        }
+    } else {
+        button_freq.set_text(format_freq_mhz(current_freq));
+        last_update_was_auto_range_type = 0;
+    }
+}
+
+void DetectorRxView::on_timer() {
+    if (frequency_list.empty() || !auto_scan) return;
+
+    auto& entry = *frequency_list[current_index];
+    if (entry.type == freqman_type::Range) {
+        current_freq += current_step;
+        if (current_freq > maxfreq) {
+            if (auto_advance) {
+                current_index = (current_index + 1) % frequency_list.size();
+                init_current_entry();
+                return;
+            }
+            current_freq = minfreq;
+        }
+        receiver_model.set_target_frequency(current_freq);
+        update_freq_display();
+    } else if (auto_advance) {
+        // Single frequency: advance to next entry
+        current_index = (current_index + 1) % frequency_list.size();
+        init_current_entry();
+    }
 }
 
 DetectorRxView::DetectorRxView(NavigationView& nav)
@@ -75,21 +152,22 @@ DetectorRxView::DetectorRxView(NavigationView& nav)
         &field_vga,
         &field_rf_amp,
         &field_volume,
-        &text_frequency,
-        &freq_stats_rssi,
-        &freq_stats_db,
+        &button_file,
+        &button_index,
+        &text_entry_desc,
         &text_beep_squelch,
         &field_beep_squelch,
+        &freq_stats_db,
+        &freq_stats_rssi,
+        &button_freq,
+        &button_auto_scan,
+        &button_auto_advance,
         &rssi,
         &rssi_graph,
-        &field_mode,
     });
 
-    // activate vertical bar mode
     rssi.set_vertical_rssi(true);
 
-    freq_ = receiver_model.target_frequency();
-
     field_beep_squelch.set_value(beep_squelch);
     field_beep_squelch.on_change = [this](int32_t v) {
         beep_squelch = v;
@@ -97,29 +175,85 @@ DetectorRxView::DetectorRxView(NavigationView& nav)
 
     rssi_graph.set_nb_columns(256);
 
+    // FILE button opens file picker
+    button_file.on_select = [this](Button&) {
+        auto open_view = nav_.push<FileLoadView>(".TXT");
+        open_view->push_dir(freqman_dir);
+        open_view->on_changed = [this](std::filesystem::path new_file_path) {
+            if (new_file_path.native().find((u"/" / freqman_dir).native()) != 0) {
+                button_file.set_text("Invalid file");
+                return;
+            }
+            freq_file_stem = new_file_path.stem().string();
+            load_freqman();
+        };
+    };
+
+    // Index encoder: rotate to change entry, click does nothing
+    button_index.on_change = [this]() {
+        if (frequency_list.empty()) return;
+        int32_t delta = button_index.get_encoder_delta();
+        button_index.set_encoder_delta(0);
+        if (delta == 0) return;
+
+        // Use signed arithmetic for index wraparound to avoid unsigned promotion issues.
+        const int32_t list_size = static_cast<int32_t>(frequency_list.size());
+        int32_t idx = static_cast<int32_t>(current_index);
+        if (delta > 0) {
+            idx = (idx + 1) % list_size;
+        } else {
+            idx = (idx - 1 + list_size) % list_size;
+        }
+        current_index = static_cast<size_t>(idx);
+        init_current_entry();
+    };
+
+    // Frequency encoder: rotate to step within range
+    button_freq.on_change = [this]() {
+        if (frequency_list.empty()) return;
+        auto& entry = *frequency_list[current_index];
+        if (entry.type != freqman_type::Range) {
+            button_freq.set_encoder_delta(0);
+            return;
+        }
+
+        int32_t delta = button_freq.get_encoder_delta();
+        button_freq.set_encoder_delta(0);
+        if (delta == 0) return;
+
+        if (delta > 0) {
+            current_freq += current_step;
+            if (current_freq > maxfreq) current_freq = minfreq;
+        } else {
+            current_freq -= current_step;
+            if (current_freq < minfreq) current_freq = maxfreq;
+        }
+        receiver_model.set_target_frequency(current_freq);
+        update_freq_display();
+    };
+
+    // Auto-scan toggle
+    button_auto_scan.on_select = [this](Button&) {
+        auto_scan = !auto_scan;
+        button_auto_scan.set_text(auto_scan ? "AUTOSCAN" : "NO SCAN");
+        update_freq_display();
+    };
+    button_auto_scan.set_text(auto_scan ? "AUTOSCAN" : "NO SCAN");
+
+    // Auto-advance toggle
+    button_auto_advance.on_select = [this](Button&) {
+        auto_advance = !auto_advance;
+        button_auto_advance.set_text(auto_advance ? "AUTOADV" : "NO ADV");
+    };
+    button_auto_advance.set_text(auto_advance ? "AUTOADV" : "NO ADV");
+
     change_mode();
     rssi.set_peak(true, 3000);
 
-    // FILL STEP OPTIONS
     freq_stats_rssi.set_style(Theme::getInstance()->bg_darkest);
     freq_stats_db.set_style(Theme::getInstance()->bg_darkest);
 
-    field_mode.on_change = [this](size_t, int32_t value) {
-        freq_mode = value;
-        freq_index = 0;
-        switch (value) {
-            case 1:  // Lora
-                text_frequency.set("   433, 868, 915 Mhz");
-                break;
-            case 2:  // Remotes
-                text_frequency.set("        433, 315 Mhz");
-                break;
-            default:
-            case 0:  // TETRA UP
-                text_frequency.set("         380-390 Mhz");
-                break;
-        }
-    };
+    load_freqman();
 }
 
 void DetectorRxView::on_statistics_update(const ChannelStatistics& statistics) {
@@ -130,25 +264,23 @@ void DetectorRxView::on_statistics_update(const ChannelStatistics& statistics) {
 
     rssi_graph.add_values(rssi.get_min(), rssi.get_avg(), rssi.get_max(), statistics.max_db);
 
-    // refresh db
     if (last_max_db != statistics.max_db) {
         last_max_db = statistics.max_db;
         freq_stats_db.set("Power: " + to_string_dec_int(statistics.max_db) + " db");
         rssi.set_db(statistics.max_db);
     }
-    // refresh rssi
+
     if (last_min_rssi != rssi_graph.get_graph_min() || last_avg_rssi != rssi_graph.get_graph_avg() || last_max_rssi != rssi_graph.get_graph_max()) {
         last_min_rssi = rssi_graph.get_graph_min();
         last_avg_rssi = rssi_graph.get_graph_avg();
         last_max_rssi = rssi_graph.get_graph_max();
-        freq_stats_rssi.set("RSSI: " + to_string_dec_uint(last_min_rssi) + "/" + to_string_dec_uint(last_avg_rssi) + "/" + to_string_dec_uint(last_max_rssi));
+        freq_stats_rssi.set("RSSI:" + to_string_dec_uint(last_min_rssi) + "/" + to_string_dec_uint(last_avg_rssi) + "/" + to_string_dec_uint(last_max_rssi));
     }
 
     if (statistics.max_db > beep_squelch) {
         baseband::request_audio_beep(map(statistics.max_db, -100, 20, 400, 2600), 24000, 150);
     }
-
-} /* on_statistic_updates */
+}
 
 size_t DetectorRxView::change_mode() {
     audio::output::stop();
@@ -160,14 +292,13 @@ size_t DetectorRxView::change_mode() {
     receiver_model.set_modulation(ReceiverModel::Mode::Capture);
 
     baseband::set_sample_rate(DETECTOR_BW, get_oversample_rate(DETECTOR_BW));
-    // The radio needs to know the effective sampling rate.
     auto actual_sampling_rate = get_actual_sample_rate(DETECTOR_BW);
     receiver_model.set_sampling_rate(actual_sampling_rate);
     receiver_model.set_baseband_bandwidth(filter_bandwidth_for_sampling_rate(actual_sampling_rate));
 
     audio::set_rate(audio_sampling_rate);
     audio::output::start();
-    receiver_model.set_headphone_volume(receiver_model.headphone_volume());  // WM8731 hack.
+    receiver_model.set_headphone_volume(receiver_model.headphone_volume());
 
     receiver_model.enable();
 

firmware/application/external/detector_rx/ui_detector_rx.hpp

@@ -29,6 +29,7 @@
 #include "audio.hpp"
 #include "baseband_api.hpp"
 #include "file.hpp"
+#include "freqman.hpp"
 #include "freqman_db.hpp"
 #include "portapack_persistent_memory.hpp"
 #include "radio_state.hpp"
@@ -60,20 +61,35 @@ class DetectorRxView : public View {
     int32_t map(int32_t value, int32_t fromLow, int32_t fromHigh, int32_t toLow, int32_t toHigh);
     size_t change_mode();
     void on_statistics_update(const ChannelStatistics& statistics);
-    void set_display_freq(int64_t freq);
     void on_timer();
+    void load_freqman();
+    void init_current_entry();
+    void update_entry_display();
+    void update_freq_display();
+    std::string format_freq_mhz(int64_t freq_hz);
+
+    freqman_db frequency_list{};
+    size_t current_index{0};
+    int64_t current_freq{0};
+    int64_t minfreq{0};
+    int64_t maxfreq{0};
+    int32_t current_step{DETECTOR_BW};
+    std::string freq_file_stem{"DETECTOR"};
+    bool auto_scan{true};
+    bool auto_advance{false};
+    uint8_t last_update_was_auto_range_type = -1;
 
-    uint8_t freq_index = 0;
-    rf::Frequency freq_ = {433920000};
     int32_t beep_squelch = 0;
     audio::Rate audio_sampling_rate = audio::Rate::Hz_48000;
-    uint8_t freq_mode = 0;
 
     app_settings::SettingsManager settings_{
         "rx_detector",
         app_settings::Mode::RX,
         {
             {"beep_squelch"sv, &beep_squelch},
+            {"freq_file"sv, &freq_file_stem},
+            {"auto_scan"sv, &auto_scan},
+            {"auto_advance"sv, &auto_advance},
         }};
 
     Labels labels{
@@ -93,41 +109,55 @@ class DetectorRxView : public View {
     AudioVolumeField field_volume{
         {UI_POS_X_RIGHT(2), UI_POS_Y(0)}};
 
-    OptionsField field_mode{
-        {UI_POS_X(0), UI_POS_Y(1)},
-        9,
-        {
-            {"TETRA UP", 0},
-            {"Lora", 1},
-            {"Remotes", 2},
-        }};
+    // Row 1: filename + auto advance
+    Button button_file{
+        {UI_POS_X(0), UI_POS_Y(1), UI_POS_WIDTH(20), UI_POS_DEFAULT_HEIGHT},
+        ""};
 
-    Text text_frequency{
-        {UI_POS_X_RIGHT(20), UI_POS_Y(1), UI_POS_WIDTH(20), UI_POS_DEFAULT_HEIGHT},
+    Button button_auto_advance{
+        {UI_POS_X_RIGHT(9), UI_POS_Y(1), UI_POS_WIDTH(9), UI_POS_DEFAULT_HEIGHT},
+        "NO ADV"};
+
+    // Row 2: index encoder + description + auto scan
+    ButtonWithEncoder button_index{
+        {UI_POS_X(0), UI_POS_Y(2), UI_POS_WIDTH(4), UI_POS_DEFAULT_HEIGHT},
+        ""};
+
+    Text text_entry_desc{
+        {UI_POS_X(4), UI_POS_Y(2), UI_POS_WIDTH(17), UI_POS_DEFAULT_HEIGHT},
+        ""};
+
+    Button button_auto_scan{
+        {UI_POS_X_RIGHT(9), UI_POS_Y(2), UI_POS_WIDTH(9), UI_POS_DEFAULT_HEIGHT},
+        "AUTO SCAN"};
+
+    // Row 3: frequency encoder + bip level
+    ButtonWithEncoder button_freq{
+        {UI_POS_X(0), UI_POS_Y(3), UI_POS_WIDTH(20), UI_POS_DEFAULT_HEIGHT},
         ""};
 
     Text text_beep_squelch{
-        {UI_POS_X_RIGHT(9), UI_POS_Y(2), UI_POS_WIDTH(4), UI_POS_DEFAULT_HEIGHT},
+        {UI_POS_X_RIGHT(9), UI_POS_Y(3), UI_POS_WIDTH(4), UI_POS_DEFAULT_HEIGHT},
         "Bip>"};
 
     NumberField field_beep_squelch{
-        {UI_POS_X_RIGHT(5), UI_POS_Y(2)},
+        {UI_POS_X_RIGHT(5), UI_POS_Y(3)},
         4,
         {-100, 20},
         1,
         ' ',
     };
 
-    // RSSI: XX/XX/XXX
-    Text freq_stats_rssi{
-        {UI_POS_X(0), UI_POS_Y(2), UI_POS_WIDTH(15), UI_POS_DEFAULT_HEIGHT},
-    };
-
-    // Power: -XXX db
+    // Row 4: Power + RSSI on same line
     Text freq_stats_db{
-        {UI_POS_X(0), UI_POS_Y(3), UI_POS_WIDTH(15), UI_POS_DEFAULT_HEIGHT},
+        {UI_POS_X(0), UI_POS_Y(4), UI_POS_WIDTH(15), UI_POS_DEFAULT_HEIGHT},
     };
 
+    Text freq_stats_rssi{
+        {UI_POS_X(15), UI_POS_Y(4), UI_POS_WIDTH(15), UI_POS_DEFAULT_HEIGHT},
+    };
+
+    // Row 5+: RSSI graph + vertical bar
     RSSIGraph rssi_graph{
         {UI_POS_X(0), UI_POS_Y(5), UI_POS_WIDTH_REMAINING(5), UI_POS_HEIGHT_REMAINING(6)},
     };
@@ -147,55 +177,6 @@ class DetectorRxView : public View {
         [this](const Message* const) {
             this->on_timer();
         }};
-
-    const std::vector<uint32_t> remotes_monitoring_frequencies_hz = {
-        // Around 315 MHz (common for older remotes, key fobs in some regions)
-        // Window centered on 315 MHz, covers 314.625 - 315.375 MHz
-        315000000,
-
-        // Around 433.92 MHz (very common for remotes, sensors, key fobs globally)
-        // Window centered on 433.92 MHz, covers 433.545 - 434.295 MHz
-        433920000,
-    };
-    const std::vector<uint32_t> lora_monitoring_frequencies_hz = {
-        // EU433 Band (Europe, typically 433.05 MHz to 434.79 MHz)
-        // Scanning the approximate range 433.0 MHz to 434.8 MHz with 750kHz steps
-        433375000,  // Covers 433.000 - 433.750 MHz
-        434125000,  // Covers 433.750 - 434.500 MHz (includes 433.92 MHz)
-        434875000,  // Covers 434.500 - 435.250 MHz (covers up to 434.79 MHz)
-
-        // EU868 Band (Europe, typically 863 MHz to 870 MHz, specific channels around 868 MHz)
-        // Targeting common LoRaWAN channel groups (approx 867.0 - 868.6 MHz) with 750kHz steps
-        867375000,  // Covers 867.000 - 867.750 MHz
-        868125000,  // Covers 867.750 - 868.500 MHz
-        868875000,  // Covers 868.500 - 869.250 MHz (covers up to 868.6 MHz)
-
-        // US915 Band (North America, typically 902 MHz to 928 MHz, specific channels around 915 MHz)
-        // Providing a few sample windows around the 915 MHz area with 750kHz steps.
-        // This band is wide; a full scan would require many more frequencies.
-        914250000,  // Covers 913.875 - 914.625 MHz
-        915000000,  // Covers 914.625 - 915.375 MHz (Centered on 915 MHz)
-        915750000,  // Covers 915.375 - 916.125 MHz
-    };
-    const std::vector<uint32_t> tetra_uplink_monitoring_frequencies_hz = {
-        // Band starts at 380,000,000 Hz, ends at 390,000,000 Hz.
-        // First center: 380,000,000 + 375,000 = 380,375,000 Hz
-        // Last center:  380,375,000 + 13 * 750,000 = 390,125,000 Hz (14 frequencies total for this band)
-        380375000,  // Covers 380.000 - 380.750 MHz
-        381125000,  // Covers 380.750 - 381.500 MHz
-        381875000,  // Covers 381.500 - 382.250 MHz
-        382625000,  // Covers 382.250 - 383.000 MHz
-        383375000,  // Covers 383.000 - 383.750 MHz
-        384125000,  // Covers 383.750 - 384.500 MHz
-        384875000,  // Covers 384.500 - 385.250 MHz
-        385625000,  // Covers 385.250 - 386.000 MHz
-        386375000,  // Covers 386.000 - 386.750 MHz
-        387125000,  // Covers 386.750 - 387.500 MHz
-        387875000,  // Covers 387.500 - 388.250 MHz
-        388625000,  // Covers 388.250 - 389.000 MHz
-        389375000,  // Covers 389.000 - 389.750 MHz
-        390125000,  // Covers 389.750 - 390.500 MHz
-    };
 };
 
 }  // namespace ui::external_app::detector_rx

firmware/application/external/epirb_tx/ui_epirb_tx.cpp

@@ -98,6 +98,39 @@ void EPIRBTXAppView::on_timer() {
     }
 }
 
+void EPIRBTXAppView::update_bpsk_frequency() {
+    bool was_transmitting = false;
+    if (transmitting && (am_enabled || transmitting_bpsk)) {
+        // We need to stop transmission before changing frequency
+        transmitter_model.disable();
+        was_transmitting = true;
+    }
+    transmitter_model.set_target_frequency(bpsk_frequency);
+    // Update displayed frequency
+    tx_view.on_show();
+    if (was_transmitting) {
+        // Start over
+        start_tx();
+    }
+}
+
+void EPIRBTXAppView::update_am_transmission() {
+    if (am_enabled && transmitting && !transmitting_bpsk) {
+        // Start am transmission
+        // Restore am frequency
+        epirb_tx_message.mode_bpsk = false;
+        transmitter_model.set_target_frequency(am_frequency);
+        // Send config to baseband
+        baseband::set_epirb_tx_config(epirb_tx_message);
+        // Start transmitting
+        transmitter_model.enable();
+    } else if (transmitting && !transmitting_bpsk) {
+        // Stop am transmission
+        transmitter_model.disable();
+        tx_view.set_transmitting(false);
+    }
+}
+
 void EPIRBTXAppView::update_frame(bool updateConfig) {
     if (mode_file) {
         // In file mode, currently selected beacon has changed => load the new one
@@ -136,17 +169,17 @@ void EPIRBTXAppView::update_frame(bool updateConfig) {
 }
 
 void EPIRBTXAppView::update_config() {
-    if (epirb_tx_message.mode_bpsk) {
-        // Already in BPSK mode => backup bpsk frequency
-        bpsk_frequency = transmitter_model.target_frequency();
-    } else {
+    if (!epirb_tx_message.mode_bpsk) {
         // Previously in AM mode => restore bpsk frequency
         transmitter_model.set_target_frequency(bpsk_frequency);
+        // Update displayed frequency
+        tx_view.on_show();
     }
     // Set mode to bpsk
     epirb_tx_message.mode_bpsk = true;
+    transmitting_bpsk = true;
     // Set pre/post count
-    epirb_tx_message.pre_count = (150 * TONES_SAMPLERATE) / 1000;   // 150 ms
+    epirb_tx_message.pre_count = (160 * TONES_SAMPLERATE) / 1000;   // 160 ms carrier (COSPAS spec.)
     epirb_tx_message.post_count = (100 * TONES_SAMPLERATE) / 1000;  // 100 ms
     // Send config to baseband
     baseband::set_epirb_tx_config(epirb_tx_message);
@@ -178,15 +211,12 @@ void EPIRBTXAppView::stop_tx() {
 void EPIRBTXAppView::on_tx_progress(const uint32_t progress, const bool done) {
     (void)progress;
     if (done) {
+        transmitting_bpsk = false;
         if (am_enabled) {
             // BPSK frame sent, switch back to 121.5 AM signal
             epirb_tx_message.mode_bpsk = false;
-            // Backup bpsk frequency for next run
-            bpsk_frequency = transmitter_model.target_frequency();
-            // Restore am frequency
-            transmitter_model.set_target_frequency(am_frequency);
-            // Send config to baseband
-            baseband::set_epirb_tx_config(epirb_tx_message);
+            // Start am transmission
+            update_am_transmission();
         } else {
             // End of BPSK frame
             transmitter_model.disable();
@@ -262,6 +292,8 @@ EPIRBTXAppView::EPIRBTXAppView(
                   &checkbox_am,
                   &field_am_frequency,
                   &checkbox_send_on_change,
+                  &options_am_channel,
+                  &options_bpsk_channel,
                   &tx_view});
 
     text_beacon.set_style(Theme::getInstance()->fg_light);
@@ -279,6 +311,11 @@ EPIRBTXAppView::EPIRBTXAppView(
     options_mode.set_by_value(!mode_file);
     transmitter_model.set_target_frequency(bpsk_frequency);
     field_am_frequency.set_value(am_frequency);
+    options_am_channel.set_by_value(am_channel);
+    options_am_channel.set_style((am_channel == (uint8_t)AmChannel::REAL) ? Theme::getInstance()->fg_red : Theme::getInstance()->bg_darkest);
+    manual_am_frequency = am_frequency;
+    options_bpsk_channel.set_by_value(bpsk_channel);
+    manual_bpsk_frequency = bpsk_frequency;
     field_delay.set_value(delay);
     options_beacon_type.set_by_value(beacon_type);
     options_beacon_protocol.set_by_value(beacon_protocol);
@@ -292,23 +329,23 @@ EPIRBTXAppView::EPIRBTXAppView(
     update_mode();
     update_location();
 
-    options_mode.on_change = [this](size_t index, OptionsField::value_t) {
-        mode_file = (index == 0);
+    options_mode.on_change = [this](size_t, OptionsField::value_t value) {
+        mode_file = (((BeaconMode)value) == BeaconMode::FILE);
         update_mode();
         update_frame();
         set_dirty();
     };
 
-    options_beacon_type.on_change = [this](size_t index, OptionsField::value_t) {
-        beacon_params.type = (BeaconType)index;
-        beacon_type = index;
+    options_beacon_type.on_change = [this](size_t, OptionsField::value_t value) {
+        beacon_params.type = (BeaconType)value;
+        beacon_type = value;
         update_frame();
         set_dirty();
     };
 
-    options_beacon_protocol.on_change = [this](size_t index, OptionsField::value_t) {
-        beacon_params.protocol = (BeaconProtocol)index;
-        beacon_protocol = index;
+    options_beacon_protocol.on_change = [this](size_t, OptionsField::value_t value) {
+        beacon_params.protocol = (BeaconProtocol)value;
+        beacon_protocol = value;
         update_frame();
         set_dirty();
     };
@@ -320,6 +357,71 @@ EPIRBTXAppView::EPIRBTXAppView(
         set_dirty();
     };
 
+    options_am_channel.on_change = [this](size_t, OptionsField::value_t v) {
+        bool is_real = false;
+        switch ((AmChannel)v) {
+            case AmChannel::REAL:
+                is_real = true;
+                am_frequency = AM_REAL_FREQUENCY;
+                break;
+            case AmChannel::MANUAL:
+                am_frequency = manual_am_frequency;
+                break;
+            default:
+                v = (uint8_t)AmChannel::TEST;
+                // fallthrough
+            case AmChannel::TEST:
+                am_frequency = AM_TEST_FREQUENCY;
+                break;
+        }
+        // Actual frequency change will be done by field_am_frequency.on_change()
+        field_am_frequency.set_value(am_frequency);
+        am_channel = v;
+        options_am_channel.set_style(is_real ? Theme::getInstance()->fg_red : Theme::getInstance()->bg_darkest);
+        set_dirty();
+    };
+
+    options_bpsk_channel.on_change = [this](size_t, OptionsField::value_t v) {
+        switch ((BpskChannel)v) {
+            case BpskChannel::MANUAL:
+                bpsk_frequency = manual_bpsk_frequency;
+                break;
+            case BpskChannel::B:
+                bpsk_frequency = BPSK_FREQUENCY_B;
+                break;
+            case BpskChannel::C:
+                bpsk_frequency = BPSK_FREQUENCY_C;
+                break;
+            case BpskChannel::F:
+                bpsk_frequency = BPSK_FREQUENCY_F;
+                break;
+            case BpskChannel::G:
+                bpsk_frequency = BPSK_FREQUENCY_G;
+                break;
+            case BpskChannel::J:
+                bpsk_frequency = BPSK_FREQUENCY_J;
+                break;
+            case BpskChannel::K:
+                bpsk_frequency = BPSK_FREQUENCY_K;
+                break;
+            case BpskChannel::N:
+                bpsk_frequency = BPSK_FREQUENCY_N;
+                break;
+            case BpskChannel::O:
+                bpsk_frequency = BPSK_FREQUENCY_O;
+                break;
+            default:
+                v = (uint8_t)BpskChannel::HAM;
+                // fallthrough
+            case BpskChannel::HAM:
+                bpsk_frequency = BPSK_FREQUENCY_HAM;
+                break;
+        }
+        bpsk_channel = v;
+        update_bpsk_frequency();
+        set_dirty();
+    };
+
     checkbox_beacon_internal.on_select = [this](Checkbox&, bool v) {
         beacon_internal = v;
         beacon_params.is_internal = v;
@@ -358,7 +460,7 @@ EPIRBTXAppView::EPIRBTXAppView(
 
     field_am_frequency.on_change = [this](rf::Frequency freq) {
         am_frequency = freq;
-        if (transmitting && !epirb_tx_message.mode_bpsk && am_enabled)
+        if (transmitting && !transmitting_bpsk && am_enabled)
             // Update transmitter frequency
             transmitter_model.set_target_frequency(am_frequency);
     };
@@ -397,6 +499,8 @@ EPIRBTXAppView::EPIRBTXAppView(
     checkbox_am.on_select = [this](Checkbox&, bool v) {
         beacon_params.has_121_5 = v;
         am_enabled = v;
+        update_am_transmission();
+        // We update the additional location device data in the frame based on this
         if (!mode_file) update_frame(false);
     };
 
@@ -404,7 +508,21 @@ EPIRBTXAppView::EPIRBTXAppView(
     field_am_frequency.on_edit = [this, &nav]() {
         auto new_view = nav.push<FrequencyKeypadView>(field_am_frequency.value());
         new_view->on_changed = [this](rf::Frequency f) {
-            field_am_frequency.set_value(f);
+            switch (f) {
+                case AM_REAL_FREQUENCY:
+                    am_channel = (uint8_t)AmChannel::REAL;
+                    break;
+                case AM_TEST_FREQUENCY:
+                    am_channel = (uint8_t)AmChannel::TEST;
+                    break;
+                default:
+                    manual_am_frequency = f;
+                    am_channel = (uint8_t)AmChannel::MANUAL;
+                    break;
+            }
+            // Actual frequency change will be done by options_am_channel.on_change()
+            options_am_channel.set_by_value(am_channel);
+            set_dirty();
         };
     };
 
@@ -415,8 +533,43 @@ EPIRBTXAppView::EPIRBTXAppView(
     tx_view.on_edit_frequency = [this, &nav]() {
         auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.target_frequency());
         new_view->on_changed = [this](rf::Frequency f) {
-            transmitter_model.set_target_frequency(f);
             bpsk_frequency = f;
+            switch (f) {
+                case BPSK_FREQUENCY_HAM:
+                    bpsk_channel = (uint8_t)BpskChannel::HAM;
+                    break;
+                case BPSK_FREQUENCY_B:
+                    bpsk_channel = (uint8_t)BpskChannel::B;
+                    break;
+                case BPSK_FREQUENCY_C:
+                    bpsk_channel = (uint8_t)BpskChannel::C;
+                    break;
+                case BPSK_FREQUENCY_F:
+                    bpsk_channel = (uint8_t)BpskChannel::F;
+                    break;
+                case BPSK_FREQUENCY_G:
+                    bpsk_channel = (uint8_t)BpskChannel::G;
+                    break;
+                case BPSK_FREQUENCY_J:
+                    bpsk_channel = (uint8_t)BpskChannel::J;
+                    break;
+                case BPSK_FREQUENCY_K:
+                    bpsk_channel = (uint8_t)BpskChannel::K;
+                    break;
+                case BPSK_FREQUENCY_N:
+                    bpsk_channel = (uint8_t)BpskChannel::N;
+                    break;
+                case BPSK_FREQUENCY_O:
+                    bpsk_channel = (uint8_t)BpskChannel::O;
+                    break;
+                default:
+                    bpsk_channel = (uint8_t)BpskChannel::MANUAL;
+                    manual_bpsk_frequency = bpsk_frequency;
+                    break;
+            }
+            // Actual frequency change will be done by options_bpsk_channel.on_change()
+            options_bpsk_channel.set_by_value(bpsk_channel);
+            set_dirty();
         };
     };
 

firmware/application/external/epirb_tx/ui_epirb_tx.hpp

@@ -37,8 +37,26 @@
 #define BEACON_HEXA_HALF_SIZE 18
 #define BEACON_SIZE 18
 
+#define AM_TEST_FREQUENCY 121375000
+#define AM_REAL_FREQUENCY 121500000
+
+#define BPSK_FREQUENCY_HAM 433025000
+#define BPSK_FREQUENCY_B 406025000
+#define BPSK_FREQUENCY_C 406028000
+#define BPSK_FREQUENCY_F 406037000
+#define BPSK_FREQUENCY_G 406040000
+#define BPSK_FREQUENCY_J 406049000
+#define BPSK_FREQUENCY_K 406052000
+#define BPSK_FREQUENCY_N 406061000
+#define BPSK_FREQUENCY_O 406064000
+
 namespace ui::external_app::epirb_tx {
 
+enum class BeaconMode {
+    FILE = 0,
+    MODE_MANUAL = 1
+};
+
 enum class BeaconType {
     EPIRB = 0,
     ELT = 1,
@@ -51,6 +69,25 @@ enum class BeaconProtocol {
     NATIONAL = 2
 };
 
+enum class AmChannel {
+    TEST = 0,
+    REAL = 1,
+    MANUAL = 2
+};
+
+enum class BpskChannel {
+    HAM = 0,
+    B = 1,
+    C = 2,
+    F = 3,
+    G = 4,
+    J = 5,
+    K = 6,
+    N = 7,
+    O = 8,
+    MANUAL = 10
+};
+
 struct Location {
     std::string locator;
     bool south;
@@ -95,6 +132,8 @@ class EPIRBTXAppView : public View {
     std::string frame_to_hex_string(bool start);
     void generate_frame(BeaconParams params);
     void update_frame(bool updateConfig = true);
+    void update_bpsk_frequency();
+    void update_am_transmission();
     void update_mode();
     void update_location(bool updateLocatorField = true);
 
@@ -114,25 +153,33 @@ class EPIRBTXAppView : public View {
     // Frequency of the transmitter before starting the app (used to restore frequency when leaving)
     rf::Frequency original_frequency{0};
     // Frequency of the AM emergency signal
-    rf::Frequency am_frequency{121500000};
+    rf::Frequency am_frequency{AM_TEST_FREQUENCY};
     // Frequency of the 406 MHz BPSK signal
-    rf::Frequency bpsk_frequency{406025000};
+    rf::Frequency bpsk_frequency{BPSK_FREQUENCY_HAM};
+    // Selected am channel
+    uint8_t am_channel{(uint8_t)AmChannel::TEST};
+    // Selected bpsk channel
+    uint8_t bpsk_channel{(uint8_t)BpskChannel::HAM};
+    // Manual AM frequency value
+    rf::Frequency manual_am_frequency{AM_TEST_FREQUENCY};
+    // Manual BPSK frequency value
+    rf::Frequency manual_bpsk_frequency{BPSK_FREQUENCY_HAM};
 
     // True when using a beacon from the BEACONS.TXT file
-    bool mode_file{true};
+    bool mode_file{false};
     // True when looping on sending beacons is enabled
     bool loop_enabled{true};
     // True if AM emergency signal transmission is enabled
     bool am_enabled{true};
     // True if we want to send a new frame each time the user changes the current beacon
-    bool send_on_change{false};
+    bool send_on_change{true};
     // The current locator string
     std::string locator{"JN03RO"};
     // The delay between each frame when on loop mode
     uint32_t delay{50};
-    uint8_t beacon_type{0};
+    uint8_t beacon_type{(uint8_t)BeaconType::EPIRB};
     // Currently selected beacon protocol
-    uint8_t beacon_protocol{0};
+    uint8_t beacon_protocol{(uint8_t)BeaconProtocol::USER};
     // Currently selected beacon country
     uint32_t beacon_country{227};
     // Current beacon's internal state (true for internal location system)
@@ -150,6 +197,8 @@ class EPIRBTXAppView : public View {
             {"sbeacon"sv, &selected_beacon},
             {"amfreq"sv, &am_frequency},
             {"bpskfreq"sv, &bpsk_frequency},
+            {"amchan"sv, &am_channel},
+            {"bpskchan"sv, &bpsk_channel},
             {"loop"sv, &loop_enabled},
             {"delay"sv, &delay},
             {"file"sv, &mode_file},
@@ -166,6 +215,8 @@ class EPIRBTXAppView : public View {
     uint32_t last_frame_time{0};
     // True when transmission is enabled
     bool transmitting{false};
+    // True when transmitting a BPSK frame
+    bool transmitting_bpsk{false};
     // True when currently looping on sending beacons
     bool loop{false};
 
@@ -179,7 +230,9 @@ class EPIRBTXAppView : public View {
         {{UI_POS_X(0), UI_POS_Y(0)}, "Source:", Theme::getInstance()->fg_light->foreground},
         {{UI_POS_X(0), UI_POS_Y(6)}, "Frame:", Theme::getInstance()->fg_light->foreground},
         {{UI_POS_X(0), UI_POS_Y(10)}, "Next frame in   s.", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), UI_POS_Y(12)}, "AM frequency          MHz", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(12)}, "AM frequency:         MHz", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(14)}, "AM   chan.:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(15)}, "BPSK chan.:", Theme::getInstance()->fg_light->foreground},
         {{UI_POS_X(17), UI_POS_Y(9)}, "s.", Theme::getInstance()->fg_light->foreground}};
 
     // For file mode
@@ -231,15 +284,15 @@ class EPIRBTXAppView : public View {
     OptionsField options_beacon_type{
         {UI_POS_X(9), UI_POS_Y(1)},
         7,
-        {{"EPIRB", 0},
-         {"ELT", 1},
-         {"PLB", 2}}};
+        {{"EPIRB", (uint8_t)BeaconType::EPIRB},
+         {"ELT", (uint8_t)BeaconType::ELT},
+         {"PLB", (uint8_t)BeaconType::PLB}}};
     OptionsField options_beacon_protocol{
         {UI_POS_X(9 + 7), UI_POS_Y(1)},
         30,
-        {{"User", 0},
-         {"Standard", 1},
-         {"National", 2}}};
+        {{"User", (uint8_t)BeaconProtocol::USER},
+         {"Standard", (uint8_t)BeaconProtocol::STANDARD},
+         {"National", (uint8_t)BeaconProtocol::NATIONAL}}};
     OptionsField options_beacon_country{
         {UI_POS_X(9), UI_POS_Y(2)},
         7,
@@ -261,8 +314,8 @@ class EPIRBTXAppView : public View {
     OptionsField options_mode{
         {UI_POS_X(7), UI_POS_Y(0)},
         30,
-        {{"File (BEACONS.TXT)", 0},
-         {"Manual (Editor)", 1}}};
+        {{"File (BEACONS.TXT)", (uint8_t)BeaconMode::FILE},
+         {"Manual (Editor)", (uint8_t)BeaconMode::MODE_MANUAL}}};
 
     // Frame content
     Text text_frame{
@@ -305,6 +358,25 @@ class EPIRBTXAppView : public View {
         "START"};
     const Style& style_tx_start = *Theme::getInstance()->fg_green;
     const Style& style_tx_stop = *Theme::getInstance()->fg_red;
+    OptionsField options_am_channel{
+        {UI_POS_X(11), UI_POS_Y(14)},
+        20,
+        {{"121.375 MHz (Test)", 0},
+         {"121.500 MHz /!\\Real", 1},
+         {"Manual", 2}}};
+    OptionsField options_bpsk_channel{
+        {UI_POS_X(11), UI_POS_Y(15)},
+        20,
+        {{"433.025 MHz (Ham)", (uint8_t)BpskChannel::HAM},
+         {"406.025 MHz (B)", (uint8_t)BpskChannel::B},
+         {"406.028 MHz (C)", (uint8_t)BpskChannel::C},
+         {"406.037 MHz (F)", (uint8_t)BpskChannel::F},
+         {"406.040 MHz (G)", (uint8_t)BpskChannel::G},
+         {"406.049 MHz (J)", (uint8_t)BpskChannel::J},
+         {"406.052 MHz (K)", (uint8_t)BpskChannel::K},
+         {"406.061 MHz (N)", (uint8_t)BpskChannel::N},
+         {"406.064 MHz (O)", (uint8_t)BpskChannel::O},
+         {"Manual", (uint8_t)BpskChannel::MANUAL}}};
 
     // Transmitter view
     TransmitterView tx_view{

firmware/application/external/external.cmake

@@ -340,6 +340,14 @@ set(EXTCPPSRC
 	#p25_tx
 	external/p25_tx/main.cpp
 	external/p25_tx/ui_p25_tx.cpp
+
+	#two_tone_pager
+	external/two_tone_pager/main.cpp
+	external/two_tone_pager/ui_two_tone_pager.cpp
+
+	#two_tone_rx
+	external/two_tone_rx/main.cpp
+	external/two_tone_rx/ui_two_tone_rx.cpp
 )
 
 set(EXTAPPLIST
@@ -425,6 +433,8 @@ set(EXTAPPLIST
 	time_sink
 	kiss_tnc
 	p25_tx
+	two_tone_pager
+	two_tone_rx
 )
 
 # sdusb has type conflicts with PRALINE (HackRF Pro) - add only for non-PRALINE builds

firmware/application/external/external.ld

@@ -106,6 +106,8 @@ MEMORY
     ram_external_app_epirb_tx              (rwx) : org = 0xAE010000, len = 32k
     ram_external_app_fpv_detect            (rwx) : org = 0xAE020000, len = 32k
     ram_external_app_p25_tx                (rwx) : org = 0xAE030000, len = 32k
+    ram_external_app_two_tone_pager        (rwx) : org = 0xAE040000, len = 32k
+    ram_external_app_two_tone_rx           (rwx) : org = 0xAE050000, len = 32k
 }
 
 SECTIONS
@@ -607,4 +609,16 @@ SECTIONS
         KEEP(*(.external_app.app_p25_tx.application_information));
         *(*ui*external_app*p25_tx*);
     } > ram_external_app_p25_tx
+
+    .external_app_two_tone_pager : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_two_tone_pager.application_information));
+        *(*ui*external_app*two_tone_pager*);
+    } > ram_external_app_two_tone_pager
+
+    .external_app_two_tone_rx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_two_tone_rx.application_information));
+        *(*ui*external_app*two_tone_rx*);
+    } > ram_external_app_two_tone_rx
 }

firmware/application/external/fpv_detect/ui_fpv_detect.cpp

@@ -3,13 +3,11 @@
 /*
  * FPV RX — how frequency search and lock work
  *
- * 1. Power metric: We use channelized power (baseband IQ magnitude² in the
- *    capture bandwidth), not raw RF RSSI. Stats come from ChannelStatsCollector
- *    over filtered IQ, so we see power in the tuned channel, not wideband.
+ * 1. Power metric: We use channelized power that portapack RSSI algo included.
  *
  * 2. Scanning: We step through FPV bands/channels (A/B/E/F/R, 8 ch each). When
  *    power on the current channel exceeds the detect threshold, we enter
- *    "Candidate" and run verification — we do not lock on a single peak.
+ *    "Candidate" and run verification - with some edge detecting algo.
  *
  * 3. Verification (making sure the drone is on that freq):
  *    - Multiple samples: verify_hits / verify_misses over several updates.
@@ -177,7 +175,7 @@ void FpvDetectView::reset_detector(bool retune_current) {
     }
 }
 
-bool FpvDetectView::is_possible_analog_carrier(const ChannelStatistics& statistics) const {
+bool FpvDetectView::is_possible_freq_spike(const ChannelStatistics& statistics) const {
     return statistics.max_db >= detect_threshold_db();
 }
 
@@ -392,17 +390,17 @@ void FpvDetectView::update_state_badge() {
             text_state.set("SCANNING");
             break;
         case DetectState::Candidate:
-            text_state.set("VERIFY FPV");
+            text_state.set("CHECKING");
             break;
         case DetectState::Locked:
-            text_state.set("DRONE FOUND");
+            text_state.set("FREQ FOUND");
             break;
     }
 }
 
 void FpvDetectView::update_confidence_text() {
     char buf[16];
-    std::snprintf(buf, sizeof(buf), "Conf %u%%", static_cast<unsigned>(candidate_confidence_));
+    std::snprintf(buf, sizeof(buf), "Posi %u%%", static_cast<unsigned>(candidate_confidence_));
     text_confidence.set(buf);
 }
 
@@ -412,21 +410,21 @@ void FpvDetectView::update_status_text() {
     switch (detect_state_) {
         case DetectState::Scanning:
             if (band_mode < FPV_NUM_BANDS) {
-                std::snprintf(buf, sizeof(buf), "Scanning band %c for analog FPV", band_labels[band_mode]);
+                std::snprintf(buf, sizeof(buf), "Scanning band %c", band_labels[band_mode]);
             } else {
-                std::snprintf(buf, sizeof(buf), "Scanning all FPV bands");
+                std::snprintf(buf, sizeof(buf), "Scanning all from list");
             }
             break;
 
         case DetectState::Candidate:
-            std::snprintf(buf, sizeof(buf), "VERIFYING %c%d  %ld MHz",
+            std::snprintf(buf, sizeof(buf), "CHKING %c%d  %ld MHz",
                           band_labels[candidate_band_],
                           static_cast<int>(candidate_ch_ + 1),
                           static_cast<long>(fpv_frequencies[candidate_band_][candidate_ch_] / 1000000LL));
             break;
 
         case DetectState::Locked:
-            std::snprintf(buf, sizeof(buf), "!!! DRONE FOUND !!! %c%d  %ld",
+            std::snprintf(buf, sizeof(buf), "FREQ FOUND %c%d  %ld",
                           band_labels[candidate_band_],
                           static_cast<int>(candidate_ch_ + 1),
                           static_cast<long>(fpv_frequencies[candidate_band_][candidate_ch_] / 1000000LL));
@@ -453,7 +451,7 @@ void FpvDetectView::update_detail_text() {
             break;
 
         case DetectState::Locked:
-            std::snprintf(buf, sizeof(buf), "LOCKED %c%d  conf %u%%  hold %u",
+            std::snprintf(buf, sizeof(buf), "LOCKED %c%d  posi %u%%  hold %u",
                           band_labels[candidate_band_],
                           static_cast<int>(candidate_ch_ + 1),
                           static_cast<unsigned>(candidate_confidence_),
@@ -605,7 +603,7 @@ void FpvDetectView::on_statistics_update(const ChannelStatistics& statistics) {
 
     switch (detect_state_) {
         case DetectState::Scanning:
-            if (is_possible_analog_carrier(statistics)) {
+            if (is_possible_freq_spike(statistics)) {
                 enter_candidate(statistics);
             }
             break;

firmware/application/external/fpv_detect/ui_fpv_detect.hpp

@@ -72,7 +72,7 @@ class FpvDetectView : public View {
     void step_scan();
     void reset_detector(bool retune_current);
 
-    bool is_possible_analog_carrier(const ChannelStatistics& statistics) const;
+    bool is_possible_freq_spike(const ChannelStatistics& statistics) const;
     void enter_candidate(const ChannelStatistics& statistics);
     void evaluate_candidate_sample(const ChannelStatistics& statistics);
     void enter_lock();
@@ -162,7 +162,7 @@ class FpvDetectView : public View {
     Text text_freq{{UI_POS_X_RIGHT(20), UI_POS_Y(1), UI_POS_WIDTH(20), UI_POS_DEFAULT_HEIGHT}, ""};
 
     Text text_state{{UI_POS_X(0), UI_POS_Y(2), UI_POS_WIDTH(12), UI_POS_DEFAULT_HEIGHT}, "SCANNING"};
-    Text text_confidence{{UI_POS_X(12), UI_POS_Y(2), UI_POS_WIDTH(8), UI_POS_DEFAULT_HEIGHT}, "Conf 0%"};
+    Text text_confidence{{UI_POS_X(12), UI_POS_Y(2), UI_POS_WIDTH(8), UI_POS_DEFAULT_HEIGHT}, "Posi 0%"};
     Text text_detect_label{{UI_POS_X_RIGHT(10), UI_POS_Y(2), UI_POS_WIDTH(5), UI_POS_DEFAULT_HEIGHT}, "Thr>"};
 
     NumberField field_detect_threshold{
@@ -176,8 +176,8 @@ class FpvDetectView : public View {
     Text freq_stats_rssi{{UI_POS_X(0), UI_POS_Y(3), UI_POS_WIDTH(15), UI_POS_DEFAULT_HEIGHT}, "RSSI 0/0/0"};
     Text freq_stats_db{{UI_POS_X_RIGHT(14), UI_POS_Y(3), UI_POS_WIDTH(14), UI_POS_DEFAULT_HEIGHT}, "PWR -120 dB"};
 
-    Text text_status{{UI_POS_X(0), UI_POS_Y(4), UI_POS_WIDTH(30), UI_POS_DEFAULT_HEIGHT}, "SCANNING FOR ANALOG FPV"};
-    Text text_detail{{UI_POS_X(0), UI_POS_Y(5), UI_POS_WIDTH(30), UI_POS_DEFAULT_HEIGHT}, "Waiting for FPV-like carrier"};
+    Text text_status{{UI_POS_X(0), UI_POS_Y(4), UI_POS_WIDTH(30), UI_POS_DEFAULT_HEIGHT}, "SCANNING FOR FREQS"};
+    Text text_detail{{UI_POS_X(0), UI_POS_Y(5), UI_POS_WIDTH(30), UI_POS_DEFAULT_HEIGHT}, "Waiting for FPV FREQ"};
 
     RSSIGraph rssi_graph{{UI_POS_X(0), UI_POS_Y(6), UI_POS_WIDTH_REMAINING(5), UI_POS_HEIGHT_REMAINING(7)}};
     RSSI rssi{{UI_POS_X_RIGHT(5), UI_POS_Y(6), UI_POS_WIDTH(5), UI_POS_HEIGHT_REMAINING(7)}};

firmware/application/external/morseradiotx/ui_morse_radiotx.cpp

@@ -27,6 +27,9 @@ MorseRadiotxView::MorseRadiotxView(ui::NavigationView& nav)
                   &chk_trans,
                   &bandwidth,
                   &chk_callsgn,
+                  &chk_loop,
+                  &wait_time,
+                  &progressbar,
                   &txt_last,
                   &console_text,
                   &btn_clear,
@@ -69,6 +72,7 @@ MorseRadiotxView::MorseRadiotxView(ui::NavigationView& nav)
     options_mode.set_selected_index(current_mode, true);
     tone_.set_value(tone, true);
     wpm_.set_value(wpm, true);
+    wait_time.set_value(1, true);
     bandwidth.set_value(band, true);
 
     btn_ptt.on_select = [this](Button&) {
@@ -156,6 +160,14 @@ MorseRadiotxView::MorseRadiotxView(ui::NavigationView& nav)
             transmitter_model.set_target_frequency(f);
         };
     };
+
+    chk_trans.on_select = [this](Checkbox&, bool v) {
+        if (v) chk_loop.set_value(false);
+    };
+
+    chk_loop.on_select = [this](Checkbox&, bool v) {
+        if (v) chk_trans.set_value(false);
+    };
 }
 
 MorseRadiotxView::~MorseRadiotxView() {
@@ -197,19 +209,15 @@ MorseRadiotxView::MorseTimings MorseRadiotxView::calculate_morse_timings(uint32_
 
 void MorseRadiotxView::transmit_morse_message() {
     std::string full_message = "";
-    // cal sign
-    if (chk_callsgn.value() && !call_sign.empty()) {
-        full_message = call_sign;
-        if (!chk_trans.value() && !msg_buffer.empty()) {
-            full_message += " " + msg_buffer;
-        }
-    } else {
-        if (!chk_trans.value()) full_message = msg_buffer;
-    }
 
-    if (full_message.empty() && !chk_trans.value()) {
+    if (chk_trans.value()) {
         ptt_button_visibility(false);
         return;
+    } else {
+        full_message = msg_buffer;
+        if (chk_callsgn.value() && !call_sign.empty()) {  // call sign
+            full_message += " " + call_sign;
+        }
     }
 
     // enable transmit
@@ -219,46 +227,63 @@ void MorseRadiotxView::transmit_morse_message() {
         ui_toggle();
     }
 
-    for (size_t i = 0; i < full_message.length(); i++) {
-        if (chThdShouldTerminate()) break;
+    uint8_t loop_seconds = static_cast<uint8_t>(wait_time.value());
+    progressbar.set_max(loop_seconds * 2);
 
-        char c = full_message[i];
+    do {
+        for (size_t i = 0; i < full_message.length(); i++) {
+            if (chThdShouldTerminate()) break;
 
-        std::string s_char(1, c);
-        // space
-        if (c == ' ') {
-            console_text.write(" ");
-            chThdSleepMilliseconds(current_timings.word_gap);
-            continue;
-        }
+            char c = full_message[i];
 
-        const char* pattern = morse_decoder_.get_morse_pattern(c);
+            std::string s_char(1, c);
+            // space
+            if (c == ' ') {
+                console_text.write(" ");
+                chThdSleepMilliseconds(current_timings.word_gap);
+                continue;
+            }
 
-        if (pattern != nullptr) {
-            txt_last.set(pattern);
+            const char* pattern = morse_decoder_.get_morse_pattern(c);
 
-            // write blue char to console
-            console_text.write(STR_COLOR_BLUE + s_char);
+            if (pattern != nullptr) {
+                txt_last.set(pattern);
 
-            // Morze (dih/dah) send
-            for (int j = 0; pattern[j] != '\0'; j++) {
-                baseband::set_morsetx_key(true);
-                if (pattern[j] == '.') {
-                    chThdSleepMilliseconds(current_timings.dot_ms);
-                } else if (pattern[j] == '-') {
-                    chThdSleepMilliseconds(current_timings.dash_ms);
+                // write blue char to console
+                console_text.write(STR_COLOR_BLUE + s_char);
+
+                // Morze (dih/dah) send
+                for (int j = 0; pattern[j] != '\0'; j++) {
+                    baseband::set_morsetx_key(true);
+                    if (pattern[j] == '.') {
+                        chThdSleepMilliseconds(current_timings.dot_ms);
+                    } else if (pattern[j] == '-') {
+                        chThdSleepMilliseconds(current_timings.dash_ms);
+                    }
+                    if (chThdShouldTerminate()) break;
+                    // pause between signs
+                    baseband::set_morsetx_key(false);
+                    chThdSleepMilliseconds(current_timings.symbol_gap);
                 }
                 if (chThdShouldTerminate()) break;
-                // pause between signs
-                baseband::set_morsetx_key(false);
-                chThdSleepMilliseconds(current_timings.symbol_gap);
-            }
-            if (chThdShouldTerminate()) break;
-            if (current_timings.char_gap > current_timings.symbol_gap) {
-                chThdSleepMilliseconds(current_timings.char_gap - current_timings.symbol_gap);
+                if (current_timings.char_gap > current_timings.symbol_gap) {
+                    chThdSleepMilliseconds(current_timings.char_gap - current_timings.symbol_gap);
+                }
             }
         }
-    }
+        if (chThdShouldTerminate()) break;
+        if (chk_loop.value()) {
+            console_text.write(" ");
+            for (uint8_t s = 0; s < (loop_seconds * 2); s++) {
+                if (chThdShouldTerminate()) break;
+                progressbar.set_value(s + 1);
+                if (!chk_loop.value()) break;
+                chThdSleepMilliseconds(500);
+            }
+            progressbar.set_value(0);
+        }
+        if (!chk_loop.value()) break;
+    } while (chk_loop.value() && !chThdShouldTerminate());
 
     if (chk_trans.value()) ptt_button_visibility(false);
     baseband::set_morsetx_key(false);
@@ -356,13 +381,17 @@ void MorseRadiotxView::ui_toggle() {
         wpm_.set_style(Theme::getInstance()->fg_dark);
         wpm_.set_focusable(false);
         btn_message.set_style(Theme::getInstance()->fg_dark);
+        btn_message.set_focusable(false);
         btn_calls.set_style(Theme::getInstance()->fg_dark);
+        btn_calls.set_focusable(false);
         chk_trans.set_style(Theme::getInstance()->fg_dark);
         chk_trans.set_focusable(false);
-        bandwidth.set_style(Theme::getInstance()->fg_dark);
-        bandwidth.set_focusable(false);
         chk_callsgn.set_style(Theme::getInstance()->fg_dark);
         chk_callsgn.set_focusable(false);
+        wait_time.set_style(Theme::getInstance()->fg_dark);
+        wait_time.set_focusable(false);
+        bandwidth.set_style(Theme::getInstance()->fg_dark);
+        bandwidth.set_focusable(false);
 
     } else {
         options_mode.set_style(Theme::getInstance()->bg_darker);
@@ -370,11 +399,15 @@ void MorseRadiotxView::ui_toggle() {
         wpm_.set_style(Theme::getInstance()->bg_darker);
         wpm_.set_focusable(true);
         btn_message.set_style(Theme::getInstance()->bg_darker);
+        btn_message.set_focusable(true);
         btn_calls.set_style(Theme::getInstance()->bg_darker);
+        btn_calls.set_focusable(true);
         chk_trans.set_style(Theme::getInstance()->bg_darker);
         chk_trans.set_focusable(true);
         chk_callsgn.set_style(Theme::getInstance()->bg_darker);
         chk_callsgn.set_focusable(true);
+        wait_time.set_style(Theme::getInstance()->bg_darker);
+        wait_time.set_focusable(true);
         ptt_button_visibility(true);
         tone_.set_style(Theme::getInstance()->bg_darker);
         tone_.set_focusable(true);

firmware/application/external/morseradiotx/ui_morse_radiotx.hpp

@@ -118,15 +118,20 @@ class MorseRadiotxView : public ui::View {
         {{"AM", 0}, {"FM", 1}, {"DSB", 2}, {"USB", 3}, {"LSB", 4}}};
     NumberField tone_{{UI_POS_X(14), UI_POS_Y(0)}, 4, {400, 1400}, 10, ' ', true};
     NumberField wpm_{{UI_POS_X(25), UI_POS_Y(0)}, 2, {10, 45}, 1, ' ', true};
-    FloatField bandwidth{{UI_POS_X(20), UI_POS_Y(3)}, 4, {1.0, 16.0}, 0.1, ' ', true, 1};
+    NumberField wait_time{{UI_POS_X(10), UI_POS_Y(4)}, 3, {1, 99}, 1, ' ', true};  // wait between tx-es in loop mode (sec)
+    FloatField bandwidth{{UI_POS_X(6), UI_POS_Y(5)}, 4, {1.0, 16.0}, 0.1, ' ', true, 1};
+
+    ProgressBar progressbar{
+        {UI_POS_X(0), UI_POS_Y(6), screen_width, 16}};
 
     ui::Text txt_msg{{UI_POS_X(0), UI_POS_Y(1), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)}, "[" + msg_buffer + "] "};
     ui::Button btn_message{{UI_POS_X(0), UI_POS_Y(2), UI_POS_WIDTH(11), UI_POS_HEIGHT(1)}, "Message"};
-    ui::Button btn_calls{{UI_POS_X(0), UI_POS_Y(4), UI_POS_WIDTH(11), UI_POS_HEIGHT(1)}, (call_sign.empty()) ? "call sign?" : call_sign};
+    ui::Button btn_calls{{UI_POS_X(0), UI_POS_Y(3), UI_POS_WIDTH(11), UI_POS_HEIGHT(1)}, (call_sign.empty()) ? "call sign?" : call_sign};
     Checkbox chk_trans{{UI_POS_X(14), UI_POS_Y(2)}, 13, "Manual trans.", true};
-    Checkbox chk_callsgn{{UI_POS_X(14), UI_POS_Y(4)}, 13, "Call sign", true};
-    ui::Text txt_last{{UI_POS_X(10), UI_POS_Y(5), UI_POS_WIDTH_REMAINING(10), UI_POS_HEIGHT(1)}, ""};
-    ui::Console console_text{{UI_POS_X(0), UI_POS_Y(7), UI_POS_MAXWIDTH, UI_POS_HEIGHT_REMAINING(14)}};
+    Checkbox chk_callsgn{{UI_POS_X(14), UI_POS_Y(3)}, 9, "Call sign", true};
+    Checkbox chk_loop{{UI_POS_X(14), UI_POS_Y(4)}, 4, "loop", true};
+    ui::Text txt_last{{UI_POS_X(10), UI_POS_Y(7), UI_POS_WIDTH_REMAINING(10), UI_POS_HEIGHT(1)}, ""};
+    ui::Console console_text{{UI_POS_X(0), UI_POS_Y(9), UI_POS_MAXWIDTH, UI_POS_HEIGHT_REMAINING(14)}};
     ui::Button btn_clear{{UI_POS_X(0), UI_POS_Y_BOTTOM(5), UI_POS_WIDTH(5), UI_POS_HEIGHT(1)}, "CLR"};
     ui::Button btn_ptt{{UI_POS_X_CENTER(12), UI_POS_Y_BOTTOM(7), UI_POS_WIDTH(12), UI_POS_HEIGHT(3)}, "PTT"};
 
@@ -135,10 +140,11 @@ class MorseRadiotxView : public ui::View {
         {{UI_POS_X(9), UI_POS_Y(0)}, "Tone:", Theme::getInstance()->fg_light->foreground},
         {{UI_POS_X(18), UI_POS_Y(0)}, "Hz", Theme::getInstance()->fg_light->foreground},
         {{UI_POS_X(21), UI_POS_Y(0)}, "WPM:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(14), UI_POS_Y(3)}, "BandW:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(24), UI_POS_Y(3)}, "kHz", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), UI_POS_Y(5)}, "Last seq:", Theme::getInstance()->fg_light->foreground},
-        {{UI_POS_X(0), UI_POS_Y(6)}, "Sent Message:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(5)}, "BandW:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(10), UI_POS_Y(5)}, "kHz", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(4)}, "Wait time: ", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(7)}, "Last seq:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(8)}, "Sent Message:", Theme::getInstance()->fg_light->foreground},
         {{UI_POS_X_RIGHT(7), UI_POS_Y_BOTTOM(5)}, "Vol.:", Theme::getInstance()->fg_light->foreground},
     };
 

firmware/application/external/two_tone_pager/main.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2024 PortaPack Mayhem
+ *
+ * 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_two_tone_pager.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::two_tone_pager {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<TwoTonePagerView>();
+}
+}  // namespace ui::external_app::two_tone_pager
+
+extern "C" {
+
+__attribute__((section(".external_app.app_two_tone_pager.application_information"), used)) application_information_t _application_information_two_tone_pager = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::two_tone_pager::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "2-Tone TX",
+    /*.bitmap_data = */ {
+        // 16×16 pager icon — two-tone radio / pager device
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xFC,
+        0x3F,
+        0xFE,
+        0x7F,
+        0x02,
+        0x40,
+        0xBA,
+        0x45,
+        0x02,
+        0x40,
+        0xFE,
+        0x7F,
+        0xFE,
+        0x7F,
+        0x92,
+        0x7C,
+        0x92,
+        0x7C,
+        0xFC,
+        0x3F,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::orange().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+
+    // Uses the proc_tones baseband processor (same as Morse TX)
+    /*.m4_app_tag = portapack::spi_flash::image_tag_tones */ {'P', 'T', 'O', 'N'},
+    /*.m4_app_offset = */ 0x00000000,  // filled at compile time
+};
+
+}  // extern "C"

firmware/application/external/two_tone_pager/ui_two_tone_pager.cpp

@@ -0,0 +1,616 @@
+/*
+ * Copyright (C) 2024 PortaPack Mayhem
+ *
+ * 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_two_tone_pager.hpp"
+
+#include "portapack.hpp"
+#include "baseband_api.hpp"
+#include "portapack_shared_memory.hpp"
+#include "string_format.hpp"
+#include "theme.hpp"
+
+#include <algorithm>
+#include <cstring>
+
+using namespace portapack;
+
+namespace ui::external_app::two_tone_pager {
+
+// ---------------------------------------------------------------------------
+// Tone tables — store only freq×10 values; names are generated at runtime
+// to keep static data small and avoid const-char-pointer patching issues.
+// ---------------------------------------------------------------------------
+
+static const uint32_t MOTO_FREQS[45] = {
+    2885,
+    3047,
+    3217,
+    3396,
+    3586,
+    3786,
+    3998,
+    4221,
+    4457,
+    4705,
+    4968,
+    5246,
+    5539,
+    5848,
+    6174,
+    6519,
+    6883,
+    7268,
+    7674,
+    8102,
+    8555,
+    9032,
+    9537,
+    10073,
+    10642,
+    11225,
+    11247,
+    11534,
+    11852,
+    11885,
+    12178,
+    12514,
+    12555,
+    12858,
+    13258,
+    13576,
+    13950,
+    13996,
+    14768,
+    15579,
+    16430,
+    17325,
+    18262,
+    19245,
+    20275,
+};
+
+// Index 0 = None (0), indices 1-50 = standard CTCSS tones
+static const uint32_t CTCSS_FREQS[51] = {
+    0,
+    670,
+    719,
+    744,
+    770,
+    797,
+    825,
+    854,
+    885,
+    915,
+    948,
+    974,
+    1000,
+    1035,
+    1072,
+    1109,
+    1148,
+    1188,
+    1230,
+    1273,
+    1318,
+    1365,
+    1413,
+    1462,
+    1500,
+    1514,
+    1567,
+    1598,
+    1622,
+    1655,
+    1679,
+    1713,
+    1738,
+    1773,
+    1799,
+    1835,
+    1862,
+    1899,
+    1928,
+    1966,
+    1995,
+    2035,
+    2065,
+    2107,
+    2181,
+    2257,
+    2291,
+    2336,
+    2418,
+    2503,
+    2541,
+};
+
+// Generate a display name from a freq×10 value ("288.5Hz", "None" for 0)
+static std::string freq_name(uint32_t freq_x10) {
+    if (freq_x10 == 0) return "None";
+    return to_string_dec_uint(freq_x10 / 10) + "." +
+           to_string_dec_uint(freq_x10 % 10) + "Hz";
+}
+
+// Common timing profiles used in the field
+struct TimingPreset {
+    uint32_t dur_a;  // ms
+    uint32_t dur_b;  // ms
+    uint32_t gap;    // ms
+};
+
+static const TimingPreset TIMING_PRESETS[4] = {
+    {1000, 3000, 0},  // Moto Std
+    {700, 1000, 0},   // Short Alert
+    {2000, 1000, 0},  // Fire Std
+    {3000, 3000, 0},  // Long Alert
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+// Parse one unsigned decimal integer from *p, advancing p past the digits and
+// an optional trailing comma.
+static uint32_t parse_uint_field(const char*& p) {
+    uint32_t v = 0;
+    while (*p >= '0' && *p <= '9')
+        v = v * 10 + (*p++ - '0');
+    if (*p == ',')
+        ++p;
+    return v;
+}
+
+// Phase-delta for the 32-bit sine-table accumulator used by proc_tones.
+// delta = freq_hz * 2^32 / sample_rate
+// Using freq_x10 to avoid floating-point: delta = (freq_x10 * 2^32) / (sample_rate * 10)
+uint32_t TwoTonePagerView::tone_delta(uint32_t freq_x10) const {
+    if (freq_x10 == 0) return 0;
+    return static_cast<uint32_t>(
+        (static_cast<uint64_t>(freq_x10) << 32) /
+        (static_cast<uint64_t>(SAMPLE_RATE) * 10ULL));
+}
+
+uint32_t TwoTonePagerView::ms_to_samples(uint32_t ms) const {
+    return static_cast<uint32_t>(
+        (static_cast<uint64_t>(ms) * SAMPLE_RATE) / 1000ULL);
+}
+
+// ---------------------------------------------------------------------------
+// Preset encode / decode
+// ---------------------------------------------------------------------------
+
+std::string TwoTonePagerView::encode_preset() const {
+    return to_string_dec_uint(ctcss_idx) + "," +
+           to_string_dec_uint(tone_a_idx) + "," +
+           to_string_dec_uint(tone_b_idx) + "," +
+           to_string_dec_uint(dur_a) + "," +
+           to_string_dec_uint(dur_b) + "," +
+           to_string_dec_uint(gap_ms) + "," +
+           to_string_dec_uint(custom_freq_a_hz) + "," +
+           to_string_dec_uint(custom_freq_b_hz);
+}
+
+void TwoTonePagerView::decode_preset(const std::string& s) {
+    const char* p = s.c_str();
+    uint32_t ci = parse_uint_field(p);
+    uint32_t ai = parse_uint_field(p);
+    uint32_t bi = parse_uint_field(p);
+    uint32_t da = parse_uint_field(p);
+    uint32_t db = parse_uint_field(p);
+    uint32_t gp = parse_uint_field(p);
+
+    uint32_t cfa = (*p != '\0') ? parse_uint_field(p) : 405;
+    uint32_t cfb = (*p != '\0') ? parse_uint_field(p) : 814;
+
+    ctcss_idx = std::min(ci, static_cast<uint32_t>(CTCSS_COUNT - 1));
+    tone_a_idx = std::min(ai, CUSTOM_TONE_IDX);
+    tone_b_idx = std::min(bi, CUSTOM_TONE_IDX);
+    dur_a = std::max(uint32_t{100}, std::min(da, uint32_t{9900}));
+    dur_b = std::max(uint32_t{100}, std::min(db, uint32_t{9900}));
+    gap_ms = std::min(gp, uint32_t{9900});
+    custom_freq_a_hz = std::max(uint32_t{100}, std::min(cfa, uint32_t{9999}));
+    custom_freq_b_hz = std::max(uint32_t{100}, std::min(cfb, uint32_t{9999}));
+}
+
+std::string& TwoTonePagerView::slot_ref(uint32_t slot) {
+    switch (slot) {
+        case 2:
+            return preset_2;
+        case 3:
+            return preset_3;
+        case 4:
+            return preset_4;
+        case 5:
+            return preset_5;
+        default:
+            return preset_1;
+    }
+}
+
+std::string& TwoTonePagerView::slot_name_ref(uint32_t slot) {
+    switch (slot) {
+        case 2:
+            return preset_name_2;
+        case 3:
+            return preset_name_3;
+        case 4:
+            return preset_name_4;
+        case 5:
+            return preset_name_5;
+        default:
+            return preset_name_1;
+    }
+}
+
+void TwoTonePagerView::update_slot_name_display() {
+    const auto& name = slot_name_ref(preset_slot);
+    std::string display = name.empty() ? "(none)" : name;
+    if (display.size() > 8) display = display.substr(0, 8);
+    text_slot_name.set(display);
+}
+
+void TwoTonePagerView::save_preset(uint32_t slot) {
+    slot_ref(slot) = encode_preset();
+    text_status.set("Saved to slot " + to_string_dec_uint(slot));
+}
+
+void TwoTonePagerView::load_preset(uint32_t slot) {
+    decode_preset(slot_ref(slot));
+
+    // Update all UI fields without firing their on_change callbacks
+    options_ctcss.set_selected_index(ctcss_idx, false);
+    options_tone_a.set_selected_index(tone_a_idx, false);
+    options_tone_b.set_selected_index(tone_b_idx, false);
+    field_dur_a.set_value(static_cast<int32_t>(dur_a), false);
+    field_dur_b.set_value(static_cast<int32_t>(dur_b), false);
+    field_gap.set_value(static_cast<int32_t>(gap_ms), false);
+    symfield_custom_a.set_value(custom_freq_a_hz);
+    symfield_custom_b.set_value(custom_freq_b_hz);
+    options_timing.set_selected_index(detect_timing_preset(), false);
+
+    update_tx_time();
+    update_slot_name_display();
+    text_status.set("Loaded slot " + to_string_dec_uint(slot));
+}
+
+// ---------------------------------------------------------------------------
+// Timing presets
+// ---------------------------------------------------------------------------
+
+size_t TwoTonePagerView::detect_timing_preset() const {
+    for (size_t i = 0; i < 4; i++) {
+        if (TIMING_PRESETS[i].dur_a == dur_a &&
+            TIMING_PRESETS[i].dur_b == dur_b &&
+            TIMING_PRESETS[i].gap == gap_ms)
+            return i;
+    }
+    return 4;  // "Custom"
+}
+
+void TwoTonePagerView::apply_timing_preset(size_t idx) {
+    if (idx >= 4) return;  // "Custom" — do not override current values
+    dur_a = TIMING_PRESETS[idx].dur_a;
+    dur_b = TIMING_PRESETS[idx].dur_b;
+    gap_ms = TIMING_PRESETS[idx].gap;
+    field_dur_a.set_value(static_cast<int32_t>(dur_a), false);
+    field_dur_b.set_value(static_cast<int32_t>(dur_b), false);
+    field_gap.set_value(static_cast<int32_t>(gap_ms), false);
+    update_tx_time();
+}
+
+// ---------------------------------------------------------------------------
+// UI helpers
+// ---------------------------------------------------------------------------
+
+void TwoTonePagerView::update_tx_time() {
+    uint32_t total_ms = dur_a + gap_ms + dur_b;
+    std::string name_a = (tone_a_idx == CUSTOM_TONE_IDX)
+                             ? to_string_dec_uint(custom_freq_a_hz) + "Hz"
+                             : freq_name(MOTO_FREQS[tone_a_idx]);
+    std::string name_b = (tone_b_idx == CUSTOM_TONE_IDX)
+                             ? to_string_dec_uint(custom_freq_b_hz) + "Hz"
+                             : freq_name(MOTO_FREQS[tone_b_idx]);
+    text_time.set("TX time: " +
+                  to_string_dec_uint(total_ms / 1000) + "." +
+                  to_string_dec_uint((total_ms / 100) % 10) + "s" +
+                  "  A:" + name_a + " B:" + name_b);
+}
+
+// ---------------------------------------------------------------------------
+// Transmission
+// ---------------------------------------------------------------------------
+
+bool TwoTonePagerView::start_tx() {
+    auto& td = shared_memory.bb_data.tones_data;
+
+    const uint32_t freq_a_x10 = (tone_a_idx == CUSTOM_TONE_IDX)
+                                    ? custom_freq_a_hz * 10
+                                    : MOTO_FREQS[tone_a_idx];
+    const uint32_t freq_b_x10 = (tone_b_idx == CUSTOM_TONE_IDX)
+                                    ? custom_freq_b_hz * 10
+                                    : MOTO_FREQS[tone_b_idx];
+    const uint32_t delta_a = tone_delta(freq_a_x10);
+    const uint32_t delta_b = tone_delta(freq_b_x10);
+    const uint32_t delta_c = tone_delta(CTCSS_FREQS[ctcss_idx]);
+    const uint32_t samp_a = ms_to_samples(dur_a);
+    const uint32_t samp_b = ms_to_samples(dur_b);
+    const uint32_t samp_g = ms_to_samples(gap_ms);
+    const bool with_ctcss = (ctcss_idx > 0);
+
+    // Clear tone defs we'll use
+    memset(&td, 0, sizeof(td));
+
+    uint8_t tone_count;
+
+    if (!with_ctcss) {
+        // Single-tone sequential mode
+        // tone_defs[0] = Tone A,  tone_defs[1] = Tone B
+        td.tone_defs[0].delta = delta_a;
+        td.tone_defs[0].duration = samp_a;
+        td.tone_defs[1].delta = delta_b;
+        td.tone_defs[1].duration = samp_b;
+
+        if (gap_ms > 0) {
+            td.silence = samp_g;
+            td.message[0] = 0;    // Tone A
+            td.message[1] = 255;  // Silence (any index ≥ 32 triggers silence)
+            td.message[2] = 1;    // Tone B
+            tone_count = 3;
+        } else {
+            td.message[0] = 0;  // Tone A
+            td.message[1] = 1;  // Tone B
+            tone_count = 2;
+        }
+    } else {
+        // Dual-tone mode: CTCSS mixed simultaneously with pager tones.
+        //
+        // proc_tones dual-tone indexing for digit n:
+        //   main delta = tone_deltas[n * 2]   = tone_defs[n*2].delta
+        //   sub  delta = tone_deltas[n*2 + 1] = tone_defs[n*2+1].delta
+        //   duration   = tone_durations[n]    = tone_defs[n].duration
+        //
+        // digit 0 → Tone A (main) + CTCSS (sub),  duration from tone_defs[0]
+        // digit 1 → Tone B (main) + CTCSS (sub),  duration from tone_defs[1]
+        td.tone_defs[0].delta = delta_a;  // digit 0 main
+        td.tone_defs[0].duration = samp_a;
+        td.tone_defs[1].delta = delta_c;  // digit 0 sub (CTCSS); also digit 1 duration source
+        td.tone_defs[1].duration = samp_b;
+        td.tone_defs[2].delta = delta_b;  // digit 1 main (Tone B)
+        td.tone_defs[2].duration = 0;     // duration for digit 1 comes from tone_defs[1]
+        td.tone_defs[3].delta = delta_c;  // digit 1 sub (CTCSS)
+        td.tone_defs[3].duration = 0;
+
+        if (gap_ms > 0) {
+            td.silence = samp_g;
+            td.message[0] = 0;
+            td.message[1] = 255;
+            td.message[2] = 1;
+            tone_count = 3;
+        } else {
+            td.message[0] = 0;
+            td.message[1] = 1;
+            tone_count = 2;
+        }
+    }
+
+    progressbar.set_max(tone_count);
+    progressbar.set_value(0);
+
+    transmitter_model.set_baseband_bandwidth(1'750'000);
+    transmitter_model.enable();
+
+    baseband::set_tones_config(
+        transmitter_model.channel_bandwidth(),
+        0,  // no pre-silence
+        tone_count,
+        with_ctcss,  // dual_tone flag
+        false);      // no audio monitor output
+
+    return true;
+}
+
+void TwoTonePagerView::stop_tx() {
+    transmitter_model.disable();
+    baseband::kill_tone();
+    tx_view.set_transmitting(false);
+    text_status.set("Stopped.");
+}
+
+void TwoTonePagerView::on_tx_progress(uint32_t progress, bool done) {
+    if (done) {
+        transmitter_model.disable();
+        progressbar.set_value(0);
+        tx_view.set_transmitting(false);
+        text_status.set("Done.");
+    } else {
+        progressbar.set_value(progress);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// View lifecycle
+// ---------------------------------------------------------------------------
+
+void TwoTonePagerView::focus() {
+    options_tone_a.focus();
+}
+
+TwoTonePagerView::~TwoTonePagerView() {
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+TwoTonePagerView::TwoTonePagerView(NavigationView& nav)
+    : nav_(nav) {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+
+    // Clamp restored settings to valid ranges before touching UI
+    ctcss_idx = std::min(ctcss_idx, static_cast<uint32_t>(CTCSS_COUNT - 1));
+    tone_a_idx = std::min(tone_a_idx, CUSTOM_TONE_IDX);
+    tone_b_idx = std::min(tone_b_idx, CUSTOM_TONE_IDX);
+    dur_a = std::max(uint32_t{100}, std::min(dur_a, uint32_t{9900}));
+    dur_b = std::max(uint32_t{100}, std::min(dur_b, uint32_t{9900}));
+    gap_ms = std::min(gap_ms, uint32_t{9900});
+    preset_slot = std::max(uint32_t{1}, std::min(preset_slot, uint32_t{5}));
+    custom_freq_a_hz = std::max(uint32_t{100}, std::min(custom_freq_a_hz, uint32_t{9999}));
+    custom_freq_b_hz = std::max(uint32_t{100}, std::min(custom_freq_b_hz, uint32_t{9999}));
+
+    // Build CTCSS options list
+    {
+        std::vector<std::pair<std::string, int32_t>> opts;
+        opts.reserve(CTCSS_COUNT);
+        for (size_t i = 0; i < CTCSS_COUNT; i++)
+            opts.push_back({freq_name(CTCSS_FREQS[i]), static_cast<int32_t>(i)});
+        options_ctcss.set_options(std::move(opts));
+    }
+
+    // Build Motorola tone options (same pool for both A and B); "Custom" appended
+    {
+        std::vector<std::pair<std::string, int32_t>> opts;
+        opts.reserve(MOTO_TONE_COUNT + 1);
+        for (size_t i = 0; i < MOTO_TONE_COUNT; i++)
+            opts.push_back({freq_name(MOTO_FREQS[i]), static_cast<int32_t>(i)});
+        opts.push_back({"Custom", static_cast<int32_t>(CUSTOM_TONE_IDX)});
+        options_tone_a.set_options(opts);
+        options_tone_b.set_options(std::move(opts));
+    }
+
+    add_children({&labels,
+                  &options_ctcss,
+                  &options_tone_a,
+                  &options_tone_b,
+                  &symfield_custom_a,
+                  &symfield_custom_b,
+                  &field_dur_a,
+                  &field_dur_b,
+                  &field_gap,
+                  &options_timing,
+                  &field_slot,
+                  &button_save,
+                  &button_load,
+                  &text_slot_name,
+                  &text_time,
+                  &text_status,
+                  &progressbar,
+                  &tx_view});
+
+    // Restore saved indices into the options / number fields (no callbacks)
+    options_ctcss.set_selected_index(ctcss_idx, false);
+    options_tone_a.set_selected_index(tone_a_idx, false);
+    options_tone_b.set_selected_index(tone_b_idx, false);
+    symfield_custom_a.set_value(custom_freq_a_hz);
+    symfield_custom_b.set_value(custom_freq_b_hz);
+    field_dur_a.set_value(static_cast<int32_t>(dur_a), false);
+    field_dur_b.set_value(static_cast<int32_t>(dur_b), false);
+    field_gap.set_value(static_cast<int32_t>(gap_ms), false);
+    options_timing.set_selected_index(detect_timing_preset(), false);
+    field_slot.set_value(static_cast<int32_t>(preset_slot), false);
+
+    update_tx_time();
+    update_slot_name_display();
+
+    // --- Callbacks ---
+
+    options_ctcss.on_change = [this](size_t i, int32_t) {
+        ctcss_idx = static_cast<uint32_t>(i);
+    };
+
+    options_tone_a.on_change = [this](size_t i, int32_t) {
+        tone_a_idx = static_cast<uint32_t>(i);
+        update_tx_time();
+    };
+
+    options_tone_b.on_change = [this](size_t i, int32_t) {
+        tone_b_idx = static_cast<uint32_t>(i);
+        update_tx_time();
+    };
+
+    symfield_custom_a.on_change = [this](SymField&) {
+        uint32_t v = static_cast<uint32_t>(symfield_custom_a.to_integer());
+        custom_freq_a_hz = std::max(uint32_t{100}, std::min(v, uint32_t{9999}));
+        update_tx_time();
+    };
+
+    symfield_custom_b.on_change = [this](SymField&) {
+        uint32_t v = static_cast<uint32_t>(symfield_custom_b.to_integer());
+        custom_freq_b_hz = std::max(uint32_t{100}, std::min(v, uint32_t{9999}));
+        update_tx_time();
+    };
+
+    field_dur_a.on_change = [this](int32_t v) {
+        dur_a = static_cast<uint32_t>(v);
+        options_timing.set_selected_index(detect_timing_preset(), false);
+        update_tx_time();
+    };
+
+    field_dur_b.on_change = [this](int32_t v) {
+        dur_b = static_cast<uint32_t>(v);
+        options_timing.set_selected_index(detect_timing_preset(), false);
+        update_tx_time();
+    };
+
+    field_gap.on_change = [this](int32_t v) {
+        gap_ms = static_cast<uint32_t>(v);
+        options_timing.set_selected_index(detect_timing_preset(), false);
+        update_tx_time();
+    };
+
+    options_timing.on_change = [this](size_t i, int32_t) {
+        apply_timing_preset(i);
+    };
+
+    field_slot.on_change = [this](int32_t v) {
+        preset_slot = static_cast<uint32_t>(v);
+        update_slot_name_display();
+    };
+
+    button_save.on_select = [this](Button&) {
+        text_prompt(nav_, slot_name_ref(preset_slot), 12, ENTER_KEYBOARD_MODE_ALPHA,
+                    [this](std::string&) {
+                        save_preset(preset_slot);
+                        update_slot_name_display();
+                    });
+    };
+
+    button_load.on_select = [this](Button&) {
+        load_preset(preset_slot);
+    };
+
+    tx_view.on_edit_frequency = [this, &nav]() {
+        auto new_view = nav.push<FrequencyKeypadView>(transmitter_model.target_frequency());
+        new_view->on_changed = [this](rf::Frequency f) {
+            transmitter_model.set_target_frequency(f);
+        };
+    };
+
+    tx_view.on_start = [this]() {
+        if (start_tx()) {
+            tx_view.set_transmitting(true);
+            text_status.set("Transmitting...");
+        }
+    };
+
+    tx_view.on_stop = [this]() {
+        stop_tx();
+    };
+}
+
+}  // namespace ui::external_app::two_tone_pager

firmware/application/external/two_tone_pager/ui_two_tone_pager.hpp

@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2024 PortaPack Mayhem
+ *
+ * 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_TWO_TONE_PAGER_H__
+#define __UI_TWO_TONE_PAGER_H__
+
+#include "ui.hpp"
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_transmitter.hpp"
+#include "ui_textentry.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "portapack.hpp"
+#include "message.hpp"
+#include "string_format.hpp"
+
+namespace ui::external_app::two_tone_pager {
+
+class TwoTonePagerView : public View {
+   public:
+    TwoTonePagerView(NavigationView& nav);
+    ~TwoTonePagerView();
+
+    TwoTonePagerView(const TwoTonePagerView&) = delete;
+    TwoTonePagerView(TwoTonePagerView&&) = delete;
+    TwoTonePagerView& operator=(const TwoTonePagerView&) = delete;
+    TwoTonePagerView& operator=(TwoTonePagerView&&) = delete;
+
+    void focus() override;
+    std::string title() const override { return "2-Tone TX"; };
+
+   private:
+    NavigationView& nav_;
+
+    static constexpr uint32_t SAMPLE_RATE = 1536000;
+    static constexpr size_t MOTO_TONE_COUNT = 45;
+    static constexpr size_t CTCSS_COUNT = 51;
+    static constexpr uint32_t CUSTOM_TONE_IDX = MOTO_TONE_COUNT;  // sentinel: one past the table, use custom Hz field
+
+    TxRadioState radio_state_{
+        154280000ULL,  // 154.280 MHz — common VHF paging frequency
+        1750000,
+        SAMPLE_RATE};
+
+    // Persisted settings
+    uint32_t ctcss_idx{0};
+    uint32_t tone_a_idx{8};   // 405.3 Hz
+    uint32_t tone_b_idx{24};  // 813.9 Hz
+    uint32_t dur_a{1000};
+    uint32_t dur_b{3000};
+    uint32_t gap_ms{0};
+    uint32_t preset_slot{1};
+    uint32_t custom_freq_a_hz{405};  // used when tone_a_idx == CUSTOM_TONE_IDX
+    uint32_t custom_freq_b_hz{814};
+
+    // Five preset slots — encoded tone/timing data and a user-chosen display name
+    std::string preset_1{"0,8,24,1000,3000,0"};
+    std::string preset_2{"0,8,24,1000,3000,0"};
+    std::string preset_3{"0,8,24,1000,3000,0"};
+    std::string preset_4{"0,8,24,1000,3000,0"};
+    std::string preset_5{"0,8,24,1000,3000,0"};
+    std::string preset_name_1{""};
+    std::string preset_name_2{""};
+    std::string preset_name_3{""};
+    std::string preset_name_4{""};
+    std::string preset_name_5{""};
+
+    app_settings::SettingsManager settings_{
+        "tx_twotone",
+        app_settings::Mode::TX,
+        {
+            {"ctcss"sv, &ctcss_idx},
+            {"tone_a"sv, &tone_a_idx},
+            {"tone_b"sv, &tone_b_idx},
+            {"dur_a"sv, &dur_a},
+            {"dur_b"sv, &dur_b},
+            {"gap"sv, &gap_ms},
+            {"slot"sv, &preset_slot},
+            {"custom_a"sv, &custom_freq_a_hz},
+            {"custom_b"sv, &custom_freq_b_hz},
+            {"preset1"sv, &preset_1},
+            {"preset2"sv, &preset_2},
+            {"preset3"sv, &preset_3},
+            {"preset4"sv, &preset_4},
+            {"preset5"sv, &preset_5},
+            {"pname1"sv, &preset_name_1},
+            {"pname2"sv, &preset_name_2},
+            {"pname3"sv, &preset_name_3},
+            {"pname4"sv, &preset_name_4},
+            {"pname5"sv, &preset_name_5},
+        }};
+
+    bool start_tx();
+    void stop_tx();
+    void on_tx_progress(uint32_t progress, bool done);
+    void apply_timing_preset(size_t idx);
+    void save_preset(uint32_t slot);
+    void load_preset(uint32_t slot);
+    std::string encode_preset() const;
+    void decode_preset(const std::string& s);
+    std::string& slot_ref(uint32_t slot);
+    std::string& slot_name_ref(uint32_t slot);
+    uint32_t tone_delta(uint32_t freq_x10) const;
+    uint32_t ms_to_samples(uint32_t ms) const;
+    size_t detect_timing_preset() const;
+    void update_tx_time();
+    void update_slot_name_display();
+
+    // --- Widgets ---
+
+    Labels labels{
+        {{0 * 8, 1 * 16}, "CTCSS:", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 2 * 16}, "A:", Theme::getInstance()->fg_light->foreground},
+        {{13 * 8, 2 * 16}, "B:", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 3 * 16}, "ADur:", Theme::getInstance()->fg_light->foreground},
+        {{9 * 8, 3 * 16}, "ms", Theme::getInstance()->fg_light->foreground},
+        {{12 * 8, 3 * 16}, "BDur:", Theme::getInstance()->fg_light->foreground},
+        {{21 * 8, 3 * 16}, "ms", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 4 * 16}, "Gap: ", Theme::getInstance()->fg_light->foreground},
+        {{9 * 8, 4 * 16}, "ms", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 5 * 16}, "Timing:", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 6 * 16}, "Slot: ", Theme::getInstance()->fg_light->foreground},
+        {{0 * 8, 9 * 16}, "AHz:", Theme::getInstance()->fg_light->foreground},
+        {{8 * 8, 9 * 16}, "Hz", Theme::getInstance()->fg_light->foreground},
+        {{13 * 8, 9 * 16}, "BHz:", Theme::getInstance()->fg_light->foreground},
+        {{21 * 8, 9 * 16}, "Hz", Theme::getInstance()->fg_light->foreground},
+    };
+
+    OptionsField options_ctcss{
+        {7 * 8, 1 * 16},
+        9,
+        {}};
+
+    OptionsField options_tone_a{
+        {3 * 8, 2 * 16},
+        9,
+        {}};
+
+    OptionsField options_tone_b{
+        {16 * 8, 2 * 16},
+        9,
+        {}};
+
+    NumberField field_dur_a{
+        {5 * 8, 3 * 16},
+        4,
+        {100, 9900},
+        100,
+        ' '};
+
+    NumberField field_dur_b{
+        {17 * 8, 3 * 16},
+        4,
+        {100, 9900},
+        100,
+        ' '};
+
+    // Digit-by-digit entry for custom tone frequency (integer Hz, 4 slots, 0100–9999)
+    SymField symfield_custom_a{
+        {4 * 8, 9 * 16},
+        4,
+        SymField::Type::Dec};
+
+    SymField symfield_custom_b{
+        {17 * 8, 9 * 16},
+        4,
+        SymField::Type::Dec};
+
+    NumberField field_gap{
+        {5 * 8, 4 * 16},
+        4,
+        {0, 9900},
+        50,
+        ' '};
+
+    OptionsField options_timing{
+        {8 * 8, 5 * 16},
+        12,
+        {{"Moto Std", 0},
+         {"Short Alert", 1},
+         {"Fire Std", 2},
+         {"Long Alert", 3},
+         {"Custom", 4}}};
+
+    NumberField field_slot{
+        {7 * 8, 6 * 16},
+        1,
+        {1, 5},
+        1,
+        ' '};
+
+    Button button_save{
+        {9 * 8, 6 * 16, 6 * 8, 20},
+        "Save"};
+
+    Button button_load{
+        {16 * 8, 6 * 16, 6 * 8, 20},
+        "Load"};
+
+    // Shows the name of the currently selected preset slot (up to 8 visible chars)
+    Text text_slot_name{
+        {22 * 8, 6 * 16, 8 * 8, 16},
+        ""};
+
+    Text text_time{
+        {0, 7 * 16, 30 * 8, 16},
+        ""};
+
+    Text text_status{
+        {0, 8 * 16, 30 * 8, 16},
+        ""};
+
+    ProgressBar progressbar{
+        {2 * 8, 14 * 16, UI_POS_WIDTH_REMAINING(4), 16}};
+
+    TransmitterView tx_view{
+        (int16_t)UI_POS_Y_BOTTOM(4),
+        10000,
+        9};
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto msg = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(msg.progress, msg.done);
+        }};
+};
+
+}  // namespace ui::external_app::two_tone_pager
+
+#endif /* __UI_TWO_TONE_PAGER_H__ */

firmware/application/external/two_tone_rx/main.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2024 PortaPack Mayhem
+ *
+ * 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_two_tone_rx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::two_tone_rx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<TwoToneRxView>();
+}
+}  // namespace ui::external_app::two_tone_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_two_tone_rx.application_information"), used)) application_information_t _application_information_two_tone_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::two_tone_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "2-Tone RX",
+    /*.bitmap_data = */ {
+        // 16×16 icon — pager device with receive arrow
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xFC,
+        0x3F,
+        0xFE,
+        0x7F,
+        0x02,
+        0x40,
+        0xBA,
+        0x5D,
+        0x02,
+        0x40,
+        0xFE,
+        0x7F,
+        0xFE,
+        0x7F,
+        0x12,
+        0x48,
+        0x12,
+        0x48,
+        0xFC,
+        0x3F,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    // Uses the proc_tonedetect baseband processor
+    /*.m4_app_tag = portapack::spi_flash::image_tag_tonedetect */ {'P', 'T', 'N', 'E'},
+    /*.m4_app_offset = */ 0x00000000,  // filled at compile time
+};
+
+}  // extern "C"

firmware/application/external/two_tone_rx/ui_two_tone_rx.cpp

@@ -0,0 +1,599 @@
+/*
+ * Copyright (C) 2024 PortaPack Mayhem
+ *
+ * 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_two_tone_rx.hpp"
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "portapack.hpp"
+#include "string_format.hpp"
+
+using namespace portapack;
+
+namespace ui::external_app::two_tone_rx {
+
+static constexpr uint32_t DETECT_WINDOW_MS = 40;
+static constexpr Coord screen_width_px = 240;
+static constexpr Coord screen_height_px = 320;
+static constexpr Coord tone_log_top = 4 * 16;
+static constexpr Coord waterfall_top = 13 * 16;
+static constexpr Coord waterfall_height = 6 * 16;
+static constexpr Rect tone_log_rect{0, tone_log_top, 30 * 8, waterfall_top - tone_log_top};
+
+// ---------------------------------------------------------------------------
+// Tone tables
+// ---------------------------------------------------------------------------
+
+static const uint32_t MOTO_FREQS[45] = {
+    2885,
+    3047,
+    3217,
+    3396,
+    3586,
+    3786,
+    3998,
+    4221,
+    4457,
+    4705,
+    4968,
+    5246,
+    5539,
+    5848,
+    6174,
+    6519,
+    6883,
+    7268,
+    7674,
+    8102,
+    8555,
+    9032,
+    9537,
+    10073,
+    10642,
+    11225,
+    11247,
+    11534,
+    11852,
+    11885,
+    12178,
+    12514,
+    12555,
+    12858,
+    13258,
+    13576,
+    13950,
+    13996,
+    14768,
+    15579,
+    16430,
+    17325,
+    18262,
+    19245,
+    20275,
+};
+
+// Index 0 = None (0), indices 1–50 = standard CTCSS tones (freq × 10)
+static const uint32_t CTCSS_FREQS[51] = {
+    0,
+    670,
+    719,
+    744,
+    770,
+    797,
+    825,
+    854,
+    885,
+    915,
+    948,
+    974,
+    1000,
+    1035,
+    1072,
+    1109,
+    1148,
+    1188,
+    1230,
+    1273,
+    1318,
+    1365,
+    1413,
+    1462,
+    1500,
+    1514,
+    1567,
+    1598,
+    1622,
+    1655,
+    1679,
+    1713,
+    1738,
+    1773,
+    1799,
+    1835,
+    1862,
+    1899,
+    1928,
+    1966,
+    1995,
+    2035,
+    2065,
+    2107,
+    2181,
+    2257,
+    2291,
+    2336,
+    2418,
+    2503,
+    2541,
+};
+
+static std::string ctcss_name(uint32_t freq_x10) {
+    if (freq_x10 == 0) return "None";
+    return to_string_dec_uint(freq_x10 / 10) + "." +
+           to_string_dec_uint(freq_x10 % 10) + "Hz";
+}
+
+// ---------------------------------------------------------------------------
+// MOTO table helpers
+// ---------------------------------------------------------------------------
+
+static constexpr uint32_t MOTO_NONE = 255;
+static constexpr uint32_t MOTO_TRANSITION_SNAP_HZ = 30;   // stricter live transition tolerance
+static constexpr uint32_t MOTO_FINAL_MATCH_HZ = 60;       // looser phase-end/logging tolerance
+static constexpr uint32_t MOTO_TRANSITION_DELTA_HZ = 25;  // raw shift needed to confirm close-in A→B handoff
+
+static uint32_t abs_diff_u32(uint32_t a, uint32_t b) {
+    return (a > b) ? (a - b) : (b - a);
+}
+
+// Return the nearest MOTO table index within match_hz, or MOTO_NONE.
+static uint32_t moto_index(uint32_t freq_hz, uint32_t match_hz = MOTO_TRANSITION_SNAP_HZ) {
+    if (freq_hz == 0) return MOTO_NONE;
+    uint32_t best_idx = MOTO_NONE;
+    uint32_t best_diff = match_hz + 1;
+    for (size_t i = 0; i < 45; i++) {
+        const uint32_t hz = MOTO_FREQS[i] / 10;
+        const uint32_t diff = (freq_hz > hz) ? (freq_hz - hz) : (hz - freq_hz);
+        if (diff < best_diff) {
+            best_diff = diff;
+            best_idx = i;
+        }
+    }
+    return best_idx;
+}
+
+// Format a detected tone for display, snapping to nearest MOTO table entry.
+static std::string format_tone(uint32_t freq_hz, uint32_t duration_ms) {
+    const uint32_t idx = moto_index(freq_hz, MOTO_FINAL_MATCH_HZ);
+    std::string freq_str;
+    if (idx != MOTO_NONE) {
+        const uint32_t matched_x10 = MOTO_FREQS[idx];
+        freq_str = to_string_dec_uint(matched_x10 / 10) + "." +
+                   to_string_dec_uint(matched_x10 % 10) + "Hz";
+    } else {
+        freq_str = to_string_dec_uint(freq_hz) + "Hz";
+    }
+    return freq_str + " " + to_string_dec_uint(duration_ms) + "ms";
+}
+
+// ---------------------------------------------------------------------------
+// Waterfall rect
+// ---------------------------------------------------------------------------
+static constexpr ui::Rect waterfall_rect{0, waterfall_top, screen_width_px, waterfall_height};
+
+// ---------------------------------------------------------------------------
+// TwoToneRxView
+// ---------------------------------------------------------------------------
+
+void TwoToneRxView::focus() {
+    button_startstop.focus();
+}
+
+void TwoToneRxView::on_hide() {
+    if (running_) stop_rx();
+}
+
+TwoToneRxView::TwoToneRxView(NavigationView& nav)
+    : nav_{nav} {
+    prior_antenna_bias_ = get_antenna_bias();
+    debug_file_.append(u"DEBUG/TWOTONERX.TXT");
+    debug_file_.write_entry("==== two_tone_rx session start ====");
+
+    add_children({
+        &field_frequency,
+        &field_rf_amp,
+        &field_lna,
+        &field_vga,
+        &rssi,
+        &field_volume,
+        &labels,
+        &options_ctcss,
+        &field_squelch,
+        &button_startstop,
+        &button_clear,
+        &text_status,
+        &check_bias_t,
+        &tone_log_view,
+    });
+
+    // Populate CTCSS options
+    using opt_t = std::pair<std::string, int32_t>;
+    options_ctcss.set_options([&]() {
+        std::vector<opt_t> opts;
+        opts.reserve(51);
+        for (size_t i = 0; i < 51; i++)
+            opts.push_back({ctcss_name(CTCSS_FREQS[i]), (int32_t)i});
+        return opts;
+    }());
+    options_ctcss.set_by_value((int32_t)ctcss_idx);
+    options_ctcss.on_change = [this](size_t, int32_t v) {
+        ctcss_idx = (uint32_t)v;
+        if (running_) baseband::set_tonedetect_config((uint8_t)squelch_val, CTCSS_FREQS[ctcss_idx]);
+    };
+
+    field_squelch.set_value((int32_t)squelch_val);
+    field_squelch.on_change = [this](int32_t v) {
+        squelch_val = (uint32_t)v;
+        if (running_) baseband::set_tonedetect_config((uint8_t)squelch_val, CTCSS_FREQS[ctcss_idx]);
+    };
+
+    button_startstop.on_select = [this](Button&) {
+        if (running_)
+            stop_rx();
+        else
+            start_rx();
+    };
+
+    button_clear.on_select = [this](Button&) {
+        tone_log_entries_.clear();
+        tone_log_view.set_dirty();
+        text_status.set("");
+        reset_detect_state();
+    };
+
+    check_bias_t.set_value(bias_t_enabled);
+    check_bias_t.on_select = [this](Checkbox&, bool v) {
+        bias_t_enabled = v;
+        apply_bias_t(running_);
+    };
+
+    field_frequency.set_step(12500);
+    tone_log_view.set_parent_rect(tone_log_rect);
+}
+
+TwoToneRxView::~TwoToneRxView() {
+    if (running_) stop_rx();
+}
+
+void TwoToneRxView::reset_detect_state() {
+    detect_state_ = DetectState::IDLE;
+    phase_window_count_ = 0;
+    phase_freq_accum_ = 0;
+    phase_valid_windows_ = 0;
+    phase_last_freq_ = 0;
+    phase_last_is_first_ = true;
+    t1_avg_freq_ = 0;
+    t1_window_count_ = 0;
+    t1_transition_candidate_windows_ = 0;
+    t2_zero_window_count_ = 0;
+    debug_trace_active_ = false;
+    debug_trace_id_ = 0;
+}
+
+void TwoToneRxView::start_rx() {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+
+    audio::set_rate(audio::Rate::Hz_24000);
+    audio::output::start();
+
+    receiver_model.set_hidden_offset(0);
+    receiver_model.set_sampling_rate(3072000);
+    receiver_model.set_baseband_bandwidth(1750000);
+    receiver_model.enable();
+    apply_bias_t(true);
+
+    baseband::set_tonedetect_config((uint8_t)squelch_val, CTCSS_FREQS[ctcss_idx]);
+
+    add_child(&waterfall);
+    waterfall.set_parent_rect(waterfall_rect);
+
+    running_ = true;
+    button_startstop.set_text("Stop");
+    text_status.set("");
+}
+
+void TwoToneRxView::stop_rx() {
+    remove_child(&waterfall);
+
+    apply_bias_t(false);
+    receiver_model.disable();
+    baseband::shutdown();
+    audio::output::stop();
+
+    running_ = false;
+    button_startstop.set_text("Start");
+    text_status.set("");
+    reset_detect_state();
+}
+
+void TwoToneRxView::apply_bias_t(bool active) {
+    if (active && bias_t_enabled) {
+        set_antenna_bias(true);
+        receiver_model.set_antenna_bias();
+        applied_bias_t_ = true;
+        return;
+    }
+
+    if (!applied_bias_t_) return;
+
+    set_antenna_bias(prior_antenna_bias_);
+    receiver_model.set_antenna_bias();
+    applied_bias_t_ = false;
+}
+
+void TwoToneRxView::debug_log(const std::string& line) {
+    const std::string trace_prefix = debug_trace_active_
+                                         ? ("#" + to_string_dec_uint(debug_trace_id_) + " ")
+                                         : "";
+    const std::string entry = "[D] " + trace_prefix + line;
+    debug_file_.write_entry(entry);
+}
+
+void TwoToneRxView::debug_trace_begin(const std::string& line) {
+    if (!debug_trace_active_) {
+        debug_trace_id_ = ++debug_trace_counter_;
+        debug_trace_active_ = true;
+    }
+    debug_log(line);
+}
+
+void TwoToneRxView::finalize_detected_pair(uint32_t t2_avg, uint32_t t2_dur, const char* reason) {
+    const uint32_t t1_dur = t1_window_count_ * DETECT_WINDOW_MS;
+    const std::string suffix = std::string(" via ") + reason;
+
+    if (t1_avg_freq_ > 0 && t2_avg > 0 &&
+        t1_dur >= 500 && t2_dur >= 500 &&
+        moto_index(t1_avg_freq_, MOTO_FINAL_MATCH_HZ) != MOTO_NONE &&
+        moto_index(t2_avg, MOTO_FINAL_MATCH_HZ) != MOTO_NONE) {
+        debug_trace_begin("END ok T1=" + format_tone(t1_avg_freq_, t1_dur) +
+                          " T2=" + format_tone(t2_avg, t2_dur) + suffix);
+        log_tone_pair(t1_avg_freq_, t1_dur, t2_avg, t2_dur);
+    } else {
+        debug_trace_begin("END drop T1=" + format_tone(t1_avg_freq_, t1_dur) +
+                          " T2=" + format_tone(t2_avg, t2_dur) + suffix);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// on_tone_data — window-based two-tone detection state machine
+//
+// Every 40 ms the baseband sends tone_end=false with a raw frequency estimate
+// for that window (freq_hz=0 if no stable QCII candidate).
+// When the CTCSS gate closes it sends tone_end=true (freq_hz=0).
+//
+// First and last windows of each phase are discarded:
+//   - "First" is tracked with phase_last_is_first_.
+//   - "Last" is phase_last_freq_, never added to the accumulator while
+//     pending; discarded when the phase ends.
+//
+// T1→T2 transition: consecutive windows that snap to different MOTO table
+// entries. The transition window becomes T2's first window.
+//
+// Final matching is done from the phase-average raw estimates collected here,
+// not from the per-window nearest-table snap used for transition detection.
+// ---------------------------------------------------------------------------
+void TwoToneRxView::on_tone_data(const ToneDetectDataMessage* msg) {
+    if (!running_) return;
+
+    if (msg->tone_end) {
+        // Gate closed — finalize whatever phase we're in
+        if (detect_state_ == DetectState::T2_COLLECTING) {
+            // phase_last_freq_ is the last T2 window → discard it
+            uint32_t t2_avg = (phase_valid_windows_ > 0)
+                                  ? (phase_freq_accum_ / phase_valid_windows_)
+                                  : phase_last_freq_;
+            uint32_t t2_dur = phase_window_count_ * DETECT_WINDOW_MS;
+            finalize_detected_pair(t2_avg, t2_dur, "tone_end");
+        } else if (debug_trace_active_) {
+            debug_log("END before T2");
+        }
+        reset_detect_state();
+        text_status.set("");
+        return;
+    }
+
+    // tone_end=false: this is a 40 ms measurement window
+    const uint32_t freq = msg->freq_hz;
+    if (freq == 0) {
+        if (detect_state_ == DetectState::T2_COLLECTING) {
+            const uint32_t t2_avg = (phase_valid_windows_ > 0)
+                                        ? (phase_freq_accum_ / phase_valid_windows_)
+                                        : phase_last_freq_;
+            const uint32_t t2_dur = phase_window_count_ * DETECT_WINDOW_MS;
+
+            if (t2_avg > 0 && t2_dur >= 2000) {
+                finalize_detected_pair(t2_avg, t2_dur, "t2_break");
+                reset_detect_state();
+                text_status.set("");
+                return;
+            }
+        }
+
+        // A single weak/noisy dropout is tolerated during T2 so standard 3 s
+        // B tones are not lost to one marginal 40 ms estimate window.
+        if (detect_state_ == DetectState::T2_COLLECTING && t2_zero_window_count_ == 0) {
+            t2_zero_window_count_++;
+            if (debug_trace_active_) {
+                debug_log("T2 zero dropout");
+            }
+            text_status.set("T1:" + format_tone(t1_avg_freq_, t1_window_count_ * DETECT_WINDOW_MS) +
+                            " T2 ?");
+            return;
+        }
+
+        // Otherwise, treat the missing estimate as a break in the sequence.
+        if (debug_trace_active_) {
+            debug_log("RESET zero");
+        }
+        reset_detect_state();
+        text_status.set("");
+        return;
+    }
+
+    t2_zero_window_count_ = 0;
+
+    switch (detect_state_) {
+        case DetectState::IDLE:
+            detect_state_ = DetectState::T1_COLLECTING;
+            phase_window_count_ = 1;
+            phase_freq_accum_ = 0;
+            phase_valid_windows_ = 0;
+            phase_last_freq_ = freq;
+            phase_last_is_first_ = true;
+            text_status.set("T1 ...");
+            break;
+
+        case DetectState::T1_COLLECTING: {
+            // Check for T1→T2 MOTO index transition.
+            // Skip if phase_last_freq_ is the first (noisy) window — it's
+            // marked for discard and must not trigger a false transition.
+            if (freq > 0 && phase_last_freq_ > 0 && !phase_last_is_first_) {
+                const uint32_t t1_ref_freq = (phase_valid_windows_ > 0)
+                                                 ? (phase_freq_accum_ / phase_valid_windows_)
+                                                 : phase_last_freq_;
+                const uint32_t idx_ref = moto_index(t1_ref_freq, MOTO_FINAL_MATCH_HZ);
+                const uint32_t idx_last = moto_index(phase_last_freq_);
+                const uint32_t idx_cur = moto_index(freq);
+                const uint32_t idx_cur_final = moto_index(freq, MOTO_FINAL_MATCH_HZ);
+
+                bool transition_detected = false;
+                if (idx_last != MOTO_NONE && idx_cur != MOTO_NONE && idx_last != idx_cur) {
+                    if (!debug_trace_active_) {
+                        debug_trace_begin("T1 start " + format_tone(t1_ref_freq, phase_window_count_ * DETECT_WINDOW_MS));
+                    }
+                    debug_log("T1->T2 snap " + format_tone(phase_last_freq_, DETECT_WINDOW_MS) +
+                              " -> " + format_tone(freq, DETECT_WINDOW_MS));
+                    transition_detected = true;
+                } else if (idx_ref != MOTO_NONE &&
+                           idx_cur_final != MOTO_NONE &&
+                           idx_cur_final != idx_ref &&
+                           abs_diff_u32(freq, t1_ref_freq) >= MOTO_TRANSITION_DELTA_HZ) {
+                    t1_transition_candidate_windows_++;
+                    if (debug_trace_active_) {
+                        debug_log("T1 cand " + to_string_dec_uint(t1_transition_candidate_windows_) +
+                                  " ref=" + to_string_dec_uint(t1_ref_freq) +
+                                  " cur=" + to_string_dec_uint(freq));
+                    }
+                    transition_detected = (t1_transition_candidate_windows_ >= 2);
+                } else {
+                    if (debug_trace_active_ && t1_transition_candidate_windows_ > 0) {
+                        debug_log("T1 cand reset");
+                    }
+                    t1_transition_candidate_windows_ = 0;
+                }
+
+                if (transition_detected) {
+                    // Transition detected.
+                    // phase_last_freq_ is the last T1 window → discard.
+                    t1_avg_freq_ = (phase_valid_windows_ > 0)
+                                       ? (phase_freq_accum_ / phase_valid_windows_)
+                                       : phase_last_freq_;
+                    t1_window_count_ = phase_window_count_;
+
+                    // Start T2 with current window as first (also discarded)
+                    detect_state_ = DetectState::T2_COLLECTING;
+                    phase_window_count_ = 1;
+                    phase_freq_accum_ = 0;
+                    phase_valid_windows_ = 0;
+                    phase_last_freq_ = freq;
+                    phase_last_is_first_ = true;
+                    t1_transition_candidate_windows_ = 0;
+                    t2_zero_window_count_ = 0;
+
+                    if (!debug_trace_active_) {
+                        debug_trace_begin("T1 start " + format_tone(t1_avg_freq_, t1_window_count_ * DETECT_WINDOW_MS));
+                    }
+                    debug_log("T2 start " + format_tone(freq, DETECT_WINDOW_MS));
+                    text_status.set("T1:" + format_tone(t1_avg_freq_, t1_window_count_ * DETECT_WINDOW_MS) + " T2...");
+                    break;
+                }
+            }
+
+            // No transition: promote pending window into accumulator (unless first)
+            if (!phase_last_is_first_ && phase_last_freq_ > 0) {
+                phase_freq_accum_ += phase_last_freq_;
+                phase_valid_windows_++;
+            }
+            phase_last_freq_ = freq;
+            phase_last_is_first_ = false;
+            phase_window_count_++;
+
+            if (!debug_trace_active_ &&
+                phase_window_count_ >= 3 &&
+                moto_index(phase_last_freq_, MOTO_FINAL_MATCH_HZ) != MOTO_NONE) {
+                const uint32_t t1_ref_freq = (phase_valid_windows_ > 0)
+                                                 ? (phase_freq_accum_ / phase_valid_windows_)
+                                                 : phase_last_freq_;
+                debug_trace_begin("T1 start " + format_tone(t1_ref_freq, phase_window_count_ * DETECT_WINDOW_MS));
+            }
+
+            text_status.set("T1 " + to_string_dec_uint(phase_window_count_ * DETECT_WINDOW_MS) + "ms...");
+            break;
+        }
+
+        case DetectState::T2_COLLECTING:
+            // Promote pending window into accumulator (unless first)
+            if (!phase_last_is_first_ && phase_last_freq_ > 0) {
+                phase_freq_accum_ += phase_last_freq_;
+                phase_valid_windows_++;
+            }
+            phase_last_freq_ = freq;
+            phase_last_is_first_ = false;
+            phase_window_count_++;
+
+            text_status.set("T1:" + format_tone(t1_avg_freq_, t1_window_count_ * DETECT_WINDOW_MS) +
+                            " T2 " + to_string_dec_uint(phase_window_count_ * DETECT_WINDOW_MS) + "ms");
+            break;
+    }
+}
+
+void TwoToneRxView::log_tone_pair(uint32_t f1, uint32_t d1_ms, uint32_t f2, uint32_t d2_ms) {
+    // Keep the oldest entry at the top so newer pairs appear below it.
+    tone_log_entries_.push_back({++next_log_serial_, format_tone(f1, d1_ms) + " " + format_tone(f2, d2_ms)});
+    tone_log_view.set_dirty();
+}
+
+}  // namespace ui::external_app::two_tone_rx
+
+namespace ui {
+
+template <>
+void RecentEntriesTable<ui::external_app::two_tone_rx::TwoToneLogEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style,
+    ui::RecentEntriesColumns&) {
+    std::string line = entry.line;
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+}  // namespace ui

firmware/application/external/two_tone_rx/ui_two_tone_rx.hpp

@@ -0,0 +1,214 @@
+/*
+ * Copyright (C) 2024 PortaPack Mayhem
+ *
+ * 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_TWO_TONE_RX_H__
+#define __UI_TWO_TONE_RX_H__
+
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_spectrum.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "message.hpp"
+#include "string_format.hpp"
+#include "log_file.hpp"
+#include "recent_entries.hpp"
+
+namespace ui::external_app::two_tone_rx {
+
+struct TwoToneLogEntry {
+    using Key = uint32_t;
+
+    static constexpr Key invalid_key = 0;
+
+    Key serial{};
+    std::string line{};
+
+    Key key() const { return serial; }
+};
+
+using TwoToneLogEntries = RecentEntries<TwoToneLogEntry>;
+
+class TwoToneRxView : public View {
+   public:
+    TwoToneRxView(NavigationView& nav);
+    ~TwoToneRxView();
+
+    TwoToneRxView(const TwoToneRxView&) = delete;
+    TwoToneRxView(TwoToneRxView&&) = delete;
+    TwoToneRxView& operator=(const TwoToneRxView&) = delete;
+    TwoToneRxView& operator=(TwoToneRxView&&) = delete;
+
+    void focus() override;
+    void on_hide() override;
+    std::string title() const override { return "2-Tone RX"; };
+
+   private:
+    NavigationView& nav_;
+
+    RxRadioState radio_state_{};
+
+    bool running_{false};
+
+    TwoToneLogEntries tone_log_entries_{};
+    uint32_t next_log_serial_{0};
+
+    uint32_t squelch_val{50};
+    uint32_t ctcss_idx{0};
+    bool bias_t_enabled{false};
+    bool prior_antenna_bias_{false};
+    bool applied_bias_t_{false};
+    LogFile debug_file_{};
+
+    app_settings::SettingsManager settings_{
+        "rx_twotone",
+        app_settings::Mode::RX,
+        {
+            {"tone_sq"sv, &squelch_val},
+            {"ctcss"sv, &ctcss_idx},
+            {"bias_t"sv, &bias_t_enabled},
+        }};
+
+    void start_rx();
+    void stop_rx();
+    void apply_bias_t(bool active);
+    void debug_log(const std::string& line);
+    void debug_trace_begin(const std::string& line);
+    void on_tone_data(const ToneDetectDataMessage* msg);
+    void log_tone_pair(uint32_t f1, uint32_t d1_ms, uint32_t f2, uint32_t d2_ms);
+    void finalize_detected_pair(uint32_t t2_avg, uint32_t t2_dur, const char* reason);
+    void reset_detect_state();
+
+    // ── Two-tone detection state machine ─────────────────────────────────────
+    //
+    // Each 40 ms measurement window from the baseband arrives as tone_end=false.
+    // tone_end=true signals that the CTCSS gate closed (end of transmission).
+    //
+    // Collection rule: discard first and last window of each phase.
+    //   - "First" is always discarded (may contain carrier ramp-up).
+    //   - "Last" is never added to the accumulator while pending; it is
+    //     discarded when the next window confirms it is not the last, OR when
+    //     the phase ends (tone_end=true or T1→T2 transition).
+    //
+    // Transition detection: two consecutive windows that snap to different MOTO
+    // table entries trigger T1→T2. The transition window becomes T2's first
+    // window (also discarded as T2's first).
+
+    enum class DetectState : uint8_t { IDLE,
+                                       T1_COLLECTING,
+                                       T2_COLLECTING };
+    DetectState detect_state_{DetectState::IDLE};
+
+    // Per-phase window collection
+    uint32_t phase_window_count_{0};   // total windows seen in this phase (including first)
+    uint32_t phase_freq_accum_{0};     // sum of non-first, non-last window frequencies
+    uint32_t phase_valid_windows_{0};  // count of windows in phase_freq_accum_
+    uint32_t phase_last_freq_{0};      // pending window (not yet added; discarded if last)
+    bool phase_last_is_first_{true};   // true when phase_last_freq_ is window 1 (discard)
+
+    // T1 result (stored at T1→T2 transition for use when pair is logged)
+    uint32_t t1_avg_freq_{0};
+    uint32_t t1_window_count_{0};
+    uint8_t t1_transition_candidate_windows_{0};
+    uint8_t t2_zero_window_count_{0};
+    bool debug_trace_active_{false};
+    uint32_t debug_trace_id_{0};
+    uint32_t debug_trace_counter_{0};
+
+    // ── Row 0: frequency + RF controls ───────────────────────────────────────
+
+    RxFrequencyField field_frequency{
+        {UI_POS_X(0), UI_POS_Y(0)},
+        nav_};
+    RFAmpField field_rf_amp{
+        {UI_POS_X(13), UI_POS_Y(0)}};
+    LNAGainField field_lna{
+        {UI_POS_X(15), UI_POS_Y(0)}};
+    VGAGainField field_vga{
+        {UI_POS_X(18), UI_POS_Y(0)}};
+    RSSI rssi{
+        {UI_POS_X(21), UI_POS_Y(0), UI_POS_WIDTH_REMAINING(24), 4}};
+    AudioVolumeField field_volume{
+        {UI_POS_X_RIGHT(2), UI_POS_Y(0)}};
+
+    // ── Row 1: CTCSS / Squelch / Start+Stop / Clear ──────────────────────────
+
+    Labels labels{
+        {{0 * 8, 1 * 16}, "CTCSS:", Theme::getInstance()->fg_light->foreground},
+        {{15 * 8, 1 * 16}, "Sq:", Theme::getInstance()->fg_light->foreground},
+    };
+
+    OptionsField options_ctcss{
+        {7 * 8, 1 * 16},
+        8,
+        {}};
+
+    NumberField field_squelch{
+        {19 * 8, 1 * 16},
+        2,
+        {0, 99},
+        1,
+        ' '};
+
+    Button button_startstop{
+        {21 * 8, 1 * 16, 5 * 8, 18},
+        "Start"};
+
+    Button button_clear{
+        {26 * 8, 1 * 16, 4 * 8, 18},
+        "Clr"};
+
+    // ── Row 2: live status (active tone in progress) + Bias-T toggle ─────────
+
+    Text text_status{
+        {0, 2 * 16 + 4, 20 * 8, 16},
+        ""};
+
+    Checkbox check_bias_t{
+        {20 * 8, 2 * 16 + 2},
+        9,
+        "Bias-T",
+        true};
+
+    ui::RecentEntriesColumns tone_log_columns{{
+        {"Tones", 0},
+    }};
+    ui::RecentEntriesTable<TwoToneLogEntries> tone_log_view{tone_log_entries_, tone_log_columns};
+
+    // ── Waterfall (rest of screen) ────────────────────────────────────────────
+
+    spectrum::WaterfallView waterfall{};
+
+    // ── Message handler ───────────────────────────────────────────────────────
+
+    MessageHandlerRegistration message_handler_tone{
+        Message::ID::ToneDetectData,
+        [this](const Message* const p) {
+            const auto* msg = reinterpret_cast<const ToneDetectDataMessage*>(p);
+            this->on_tone_data(msg);
+        }};
+};
+
+}  // namespace ui::external_app::two_tone_rx
+
+#endif /* __UI_TWO_TONE_RX_H__ */

firmware/application/freqman_db.cpp

@@ -134,6 +134,7 @@ options_t freqman_steps = {
     {"100kHz (FM2)", 100000},
     {"250kHz  (N2)", 250000},
     {"500kHz (WFM)", 500000},
+    {"750kHz      ", 750000},
     {"1MHz        ", 1000000},
 };
 
@@ -156,6 +157,7 @@ options_t freqman_steps_short = {
     {"100kHz", 100000},
     {"250kHz", 250000},
     {"500kHz", 500000},
+    {"750kHz", 750000},
     {"1MHz", 1000000},
 };
 

firmware/application/freqman_db.hpp

@@ -102,6 +102,7 @@ enum class freqman_type : uint8_t {
     _100kHz,
     _250kHz,
     _500kHz,
+    _750kHz,
     _1MHz,
     Unknown,
  * };
@@ -130,6 +131,7 @@ enum class freqman_type : uint8_t {
     freqman_step_info{ freqman_step::_100kHz,  "100kHz",  "100kHz (FM2)", 100'000 },
     freqman_step_info{ freqman_step::_250kHz,  "250kHz",  "250kHz  (N2)", 250'000 },
     freqman_step_info{ freqman_step::_500kHz,  "500kHz",  "500kHz (WFM)", 500'000 },
+    freqman_step_info{ freqman_step::_750kHz,  "750kHz",  "750kHz      ", 750'000 },
     freqman_step_info{ freqman_step::_1MHz,    "1MHz",    "1MHz        ", 1'000'000 },
     freqman_step_info{ freqman_step::Unknown,  "Unknown", "Unknown     ", 0 },
  * };

firmware/application/hackrf_core_mini.c

@@ -1,4 +1,5 @@
 #include "gpio_lpc.h"
+#include "gpio.h"
 
 typedef enum {
     LED1 = 0,
@@ -8,7 +9,7 @@ typedef enum {
 } led_t;
 
 /* GPIO Output PinMux */
-static struct gpio_t gpio_led[] = {
+static struct gpio gpio_led[] = {
     GPIO(2, 1),
     GPIO(2, 2),
     GPIO(2, 8),

firmware/application/hw/max2831.cpp

@@ -182,20 +182,24 @@ void MAX2831::set_mode(const Mode mode) {
         case Mode::Shutdown:
             gpio_max2831_rx_enable.write(0); /* RXTX=0 */
             gpio_max283x_enable.write(0);    /* ENABLE=0 */
+            set_rssi_mux(0);
             break;
         case Mode::Standby:
             gpio_max2831_rx_enable.write(1); /* RXTX=1 */
             gpio_max283x_enable.write(0);    /* ENABLE=0 */
+            set_rssi_mux(0);
             break;
         case Mode::Transmit:
         case Mode::Tx_Calibration:
             gpio_max2831_rx_enable.write(1); /* RXTX=1 for TX */
             gpio_max283x_enable.write(1);    /* ENABLE=1 */
+            set_rssi_mux(2);                 // transmit power
             break;
         case Mode::Receive:
         case Mode::Rx_Calibration:
             gpio_max2831_rx_enable.write(0); /* RXTX=0 for RX */
             gpio_max283x_enable.write(1);    /* ENABLE=1 */
+            set_rssi_mux(1);                 // RSSI
             break;
     }
 
@@ -475,5 +479,38 @@ void MAX2831::write(const address_t reg_num, const reg_t value) {
     }
 }
 
+void MAX2831::set_rssi_mux(const uint8_t mode) {
+    /* RSSI MUX allows switching the RSSI output between different internal signals.
+     * 0 = disable mux
+     * 1 = RSSI
+     * 2 = TX_POWER
+     * 3 = TEMP
+     */
+    uint16_t mux_val = 0;
+
+    // Select the appropriate constant based on the input mode.
+    if (mode == 0) {
+        mux_val = 0;
+    } else {
+        // Select the appropriate constant based on the input mode.
+        switch (mode) {
+            case 3:
+                mux_val = REG8_RSSI_MUX_TEMP;
+                break;
+            case 2:
+                mux_val = REG8_RSSI_MUX_TX_POWER;
+                break;
+            case 1:
+            default:
+                mux_val = REG8_RSSI_MUX_RSSI;
+                break;
+        }
+        mux_val |= REG8_RSSI_EN;
+    }
+
+    set_reg_field(8, REG8_RSSI_MUX_MASK | REG8_RSSI_EN, mux_val);
+    flush_reg(8);
+}
+
 }  // namespace max2831
 #endif

firmware/application/hw/max2831.hpp

@@ -151,6 +151,7 @@ constexpr uint16_t REG8_RSSI_MUX_MASK = 0x0300; /* D9:D8 */
 constexpr uint16_t REG8_RSSI_MUX_RSSI = (0 << REG8_RSSI_MUX_SHIFT);
 constexpr uint16_t REG8_RSSI_MUX_TEMP = (1 << REG8_RSSI_MUX_SHIFT);
 constexpr uint16_t REG8_RSSI_MUX_TX_POWER = (2 << REG8_RSSI_MUX_SHIFT);
+constexpr uint16_t REG8_RSSI_EN = (1 << 10);
 
 constexpr uint16_t REG8_RXVGA_GAIN_SPI_EN_SHIFT = 12;
 constexpr uint16_t REG8_RXVGA_GAIN_SPI_EN = (1 << REG8_RXVGA_GAIN_SPI_EN_SHIFT);
@@ -213,6 +214,8 @@ class MAX2831 : public MAX283x {
     reg_t read(const address_t reg_num) override;
     void write(const address_t reg_num, const reg_t value) override;
 
+    void set_rssi_mux(const uint8_t mode);
+
    private:
     spi::arbiter::Target& _target;
     Mode _mode{Mode::Standby};

firmware/application/portapack.cpp

@@ -636,7 +636,7 @@ init_status_t init() {
     // This function returns LD_SUCCESS (0) if the FPGA confirms the bitstream
     // Call fpga_bridge_init and continue boot regardless of result
     // (Watchdog was resetting device when we halted with while(1))
-    int load_result = fpga_bridge_init();
+    int load_result = fpga_bridge_init(&shared_memory.bb_data.data[0]);
     (void)load_result;  // Ignore result for now, just let boot continue
 
     /* RELEASE FPGA RESET */

firmware/application/ui/ui_rssi.cpp

@@ -46,17 +46,17 @@ RSSI::RSSI(
 void RSSI::paint(Painter& painter) {
     const auto r = screen_rect();
 
-    /* RSSI scaling based on transceiver output voltage range.
-     * MAX2837 (HackRF One): 0.4V to 2.2V
-     * MAX2831 (HackRF Pro): 0.5V to 2.0V (similar enough to use same scaling)
-     */
     constexpr int rssi_sample_range = 256;
-    // constexpr float rssi_voltage_min = 0.4;
+    constexpr float rssi_voltage_min = 0.4;
+#ifdef PRALINE
+    constexpr float rssi_voltage_max = 2.4;
+#else
     constexpr float rssi_voltage_max = 2.2;
-    // constexpr int raw_min = rssi_sample_range * rssi_voltage_min / adc_voltage_max;
-    constexpr int raw_min = 0;
+#endif
+
     constexpr float adc_voltage_max = 3.3;
-    constexpr int raw_max = rssi_sample_range * rssi_voltage_max / adc_voltage_max;
+    constexpr int raw_min = (rssi_sample_range * rssi_voltage_min) / adc_voltage_max;
+    constexpr int raw_max = (int)(((rssi_sample_range * rssi_voltage_max) / adc_voltage_max) + 0.5f);
     constexpr int raw_delta = raw_max - raw_min;
 
     if (!vertical_rssi_enabled) {
@@ -117,7 +117,6 @@ void RSSI::paint(Painter& painter) {
         const Rect r_db{r.left() + x_db, r.top(), 1, r.height()};
 
         if (db_) painter.fill_rectangle(r_db, Color::green());
-
     } else {
         // vertical bottom to top level meters
         const range_t<int> y_avg_range{0, r.height() - 1};
@@ -226,7 +225,6 @@ void RSSI::on_statistics_update(const RSSIStatistics& statistics) {
     min_ = statistics.min;
     avg_ = statistics.accumulator / statistics.count;
     max_ = statistics.max;
-
     if (peak_enabled) {
         peak_duration_ = peak_duration_ + 100;
         if (max_ > peak_) {
@@ -434,25 +432,38 @@ void RSSIGraph::paint(Painter& painter) {
 void RSSIGraph::add_values(int16_t rssi_min, int16_t rssi_avg, int16_t rssi_max, int16_t db) {
     const auto r = screen_rect();
 
+    /* RSSI scaling based on transceiver output voltage range.
+     * MAX2837 (HackRF One): 0.4V to 2.2V
+     * MAX2831 (HackRF Pro): 0.4V to 2.4V
+     */
+
     constexpr int rssi_sample_range = 256;
-    // constexpr float rssi_voltage_min = 0.4;
+    constexpr float rssi_voltage_min = 0.4;
+#ifdef PRALINE
+    constexpr float rssi_voltage_max = 2.4;
+#else
     constexpr float rssi_voltage_max = 2.2;
-    // constexpr int raw_min = rssi_sample_range * rssi_voltage_min / adc_voltage_max;
-    constexpr int raw_min = 0;
+#endif
+
     constexpr float adc_voltage_max = 3.3;
-    constexpr int raw_max = rssi_sample_range * rssi_voltage_max / adc_voltage_max;
+    constexpr int raw_min = (rssi_sample_range * rssi_voltage_min) / adc_voltage_max;
+    constexpr int raw_max = (int)(((rssi_sample_range * rssi_voltage_max) / adc_voltage_max) + 0.5f);
     constexpr int raw_delta = raw_max - raw_min;
 
     // vertical bottom to top level meters
+    // y_avg
     const range_t<int> y_avg_range{0, r.height() - 1};
     const int16_t y_avg = y_avg_range.clip((rssi_avg - raw_min) * r.height() / raw_delta);
+    // y_min
     const range_t<int> y_min_range{0, y_avg};
     const int16_t y_min = y_min_range.clip((rssi_min - raw_min) * r.height() / raw_delta);
-    const range_t<int> y_max_range{y_avg + 1, r.height() - 1};
+    // y_max
+    const range_t<int> y_max_range{y_avg, r.height() - 1};
     const int16_t y_max = y_max_range.clip((rssi_max - raw_min) * r.height() / raw_delta);
+    // range
     const range_t<int> db_range{-80, 10};
     int16_t db_ = db_range.clip(db);
-    db_ = db_ - 10;
+    db_ -= 10;
     db_ = db_ * r.height() / 90;
     db_ = r.height() + db_;
 
@@ -529,12 +540,6 @@ bool RSSI::on_touch(const TouchEvent event) {
 }
 
 void RSSI::set_db(int16_t db) {
-#ifdef PRALINE
-    /* Add a +30dB global boost to align 40MHz/1.2V VCM data
-    with the UI's existing display scale. */
-    db_ = db + 30;
-#else
     db_ = db;
-#endif
 }
 } /* namespace ui */

firmware/application/ui/ui_rssi.hpp

@@ -64,18 +64,11 @@ class RSSI : public Widget {
     void set_db(int16_t db);
 
    private:
-#ifdef PRALINE
-    // Changed from int8_t to uint8_t:
     uint8_t min_ = 0;
     uint8_t avg_ = 0;
     uint8_t max_ = 0;
     uint8_t peak_ = 0;
-#else
-    int8_t min_ = 0;
-    int8_t avg_ = 0;
-    int8_t max_ = 0;
-    int8_t peak_ = 0;
-#endif
+
     size_t peak_duration_ = 0;
     int16_t db_ = 0;
     bool instant_exec_{false};

firmware/application/ui/ui_spectrum.cpp

@@ -361,6 +361,8 @@ void WaterfallView::stop() {
         baseband::spectrum_streaming_stop();
         running_ = false;
     }
+    this->channel_fifo = nullptr;
+    this->audio_spectrum_data = nullptr;
 }
 
 void WaterfallView::show_audio_spectrum_view(const bool show) {

firmware/application/ui/ui_spectrum.hpp

@@ -173,12 +173,16 @@ class WaterfallView : public View {
     MessageHandlerRegistration message_handler_channel_spectrum_config{
         Message::ID::ChannelSpectrumConfig,
         [this](const Message* const p) {
+            if (!running_)
+                return;
             const auto message = *reinterpret_cast<const ChannelSpectrumConfigMessage*>(p);
             this->channel_fifo = message.fifo;
         }};
     MessageHandlerRegistration message_handler_audio_spectrum{
         Message::ID::AudioSpectrum,
         [this](const Message* const p) {
+            if (!running_)
+                return;
             const auto message = *reinterpret_cast<const AudioSpectrumMessage*>(p);
             this->audio_spectrum_data = message.data;
             this->audio_spectrum_update = true;
@@ -186,6 +190,8 @@ class WaterfallView : public View {
     MessageHandlerRegistration message_handler_frame_sync{
         Message::ID::DisplayFrameSync,
         [this](const Message* const) {
+            if (!running_)
+                return;
             if (this->channel_fifo) {
                 ChannelSpectrum channel_spectrum;
                 while (channel_fifo->out(channel_spectrum)) {

firmware/baseband/CMakeLists.txt

@@ -683,6 +683,14 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PSCD subcar)
 
+### Tone Detect RX
+
+set(MODE_CPPSRC
+    proc_tonedetect.cpp
+)
+DeclareTargets(PTNE tonedetect)
+
+
 ### Morse RX Decoder
 
 set(MODE_CPPSRC
@@ -746,6 +754,8 @@ set(MODE_CPPSRC
 	${HACKRF_PATH}/firmware/common/usb_request.c
 	${HACKRF_PATH}/firmware/common/usb_standard_request.c
 	${HACKRF_PATH}/firmware/common/platform_detect.c
+	${HACKRF_PATH}/firmware/common/platform_gpio.c
+	${HACKRF_PATH}/firmware/common/platform_scu.c
 	${HACKRF_PATH}/firmware/common/gpio_lpc.c
 	${HACKRF_PATH}/firmware/common/firmware_info.c
 	${HACKRF_PATH}/firmware/common/si5351c.c

firmware/baseband/baseband_thread.cpp

@@ -102,31 +102,6 @@ void BasebandThread::run() {
             buffer_c8_t buffer{
                 buffer_tmp.p, buffer_tmp.count, sampling_rate_};
 
-#ifdef PRALINE
-            /*
-             * Software RSSI: Copy 8 I/Q samples spread across buffer.
-             *
-             * Just pack and copy - no computation here.
-             * rssi_thread does __SMUAD power and rssi calculation.
-             * 8 samples avoids zero-crossing artifacts.
-             */
-            if (direction_ == baseband::Direction::Receive && buffer_tmp.count >= 32) {
-                const size_t step = buffer_tmp.count / 8;
-
-                for (size_t i = 0; i < 8; i++) {
-                    const size_t idx = i * step + (step / 2);
-                    const auto sample = buffer_tmp.p[idx];
-
-                    // Pack into 32 bits: Q in high 16 bits, I in low 16 bits, the safe approach:
-                    // 1. Cast to uint16_t to capture the raw 16-bit pattern (e.g., -1 becomes 0xFFFF)
-                    // 2. OR them together. The uint16_t will be promoted to uint32_t cleanly.
-                    // This is accomplished with the specific hardware instruction designed
-                    // for this __PKHBT (Pack Halfword Bottom Top).
-                    shared_memory.software_rssi_iq[i] = __PKHBT(sample.real(), sample.imag(), 16);
-                }
-            }
-#endif
-
             if (shared_memory.request_m4_performance_counter == 0x02) {
                 uint8_t max = shared_memory.m4_performance_counter;
                 for (size_t i = 0; i < buffer_tmp.count; i++) {

firmware/baseband/proc_epirb_tx.cpp

@@ -46,15 +46,15 @@ void EPIRBTXProcessor::execute(const buffer_c8_t& buffer) {
         if (mode_bpsk) {
             // BPSK Manchester beacon signal
             if (bpsk_pre_count < config_pre_count) {
-                // Pre-count state: send a negative phase carrier during pre-count
+                // Pre-count state: send carrier only during pre-count
                 bpsk_pre_count++;
-                re = i_neg;
-                im = q_neg;
+                re = i_carrier;
+                im = q_carrier;
             } else if (bpsk_post_count > 0) {
-                // Post-count: send a negative phase carrier during post-count
+                // Post-count: send carrier only during post-count
                 bpsk_post_count++;
-                re = i_neg;
-                im = q_neg;
+                re = i_carrier;
+                im = q_carrier;
                 if (bpsk_post_count >= config_post_count) {
                     // End transmission here
                     byte_index = 0;

firmware/baseband/proc_epirb_tx.hpp

@@ -60,14 +60,17 @@ class EPIRBTXProcessor : public BasebandProcessor {
     // Size of the frame to send in BPSK mode
     uint8_t frame_data_len = 0;
 
-    // BPSK parameters: Target phase +/-63° as per COSPAS/SARSAT specifications
-    static constexpr float phase_rad = 63.0f * M_PI / 180.0f;
+    // BPSK parameters: Target phase +/-1.1 RAD as per COSPAS/SARSAT specifications
+    static constexpr float phase_rad = 1.1f;
 
     // I/Q values for BPSK (positive phase and negative phase)
     int8_t i_pos = (int8_t)(cos(phase_rad) * 127);
     int8_t q_pos = (int8_t)(sin(phase_rad) * 127);
     int8_t i_neg = i_pos;
     int8_t q_neg = -q_pos;
+    // I/Q values for carrier only
+    static constexpr int8_t i_carrier = 127;
+    static constexpr int8_t q_carrier = 0;
 
     // COSPAS/SARSAT signal is manchester (2 states per bit) encoded 400 bit/sec
     static const uint32_t samples_per_halfbit = TONES_SAMPLERATE / 400 / 2;

firmware/baseband/proc_tonedetect.cpp

@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2024 PortaPack Mayhem
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "proc_tonedetect.hpp"
+#include "audio_dma.hpp"
+#include "portapack_shared_memory.hpp"
+#include "event_m4.hpp"
+#include <cmath>
+
+static constexpr float SAMPLE_RATE = 24000.0f;
+static constexpr uint32_t WINDOW_SAMPLES = 960;  // 40 ms at 24 kHz (30 execute() calls)
+static constexpr uint32_t WINDOW_MS = (1000 * WINDOW_SAMPLES) / (uint32_t)SAMPLE_RATE;
+static constexpr uint32_t AUDIO_BLOCK_SAMPLES = 32;  // demod_fm emits 32 audio samples per execute()
+static constexpr uint32_t SQUELCH_HOLD_BLOCKS =
+    (100 * (uint32_t)SAMPLE_RATE) / (1000 * AUDIO_BLOCK_SAMPLES);  // 100 ms hold at execute() block rate
+static constexpr float PI_F = 3.14159265f;
+
+// Motorola/EIA QCII paging frequencies (×10 to avoid float in table)
+static constexpr uint32_t MOTO_FREQS_X10[45] = {
+    2885,
+    3047,
+    3217,
+    3396,
+    3586,
+    3786,
+    3998,
+    4221,
+    4457,
+    4705,
+    4968,
+    5246,
+    5539,
+    5848,
+    6174,
+    6519,
+    6883,
+    7268,
+    7674,
+    8102,
+    8555,
+    9032,
+    9537,
+    10073,
+    10642,
+    11225,
+    11247,
+    11534,
+    11852,
+    11885,
+    12178,
+    12514,
+    12555,
+    12858,
+    13258,
+    13576,
+    13950,
+    13996,
+    14768,
+    15579,
+    16430,
+    17325,
+    18262,
+    19245,
+    20275,
+};
+
+// Minimum coherent Goertzel energy for MOTO tone detection.
+// For amplitude A over WINDOW_SAMPLES: energy ≈ (A × N/2)² = (A × 240)².
+// Threshold 1000 → requires A > ~13% of FM demod full scale (~650 Hz deviation).
+// Set high enough that FM broadband noise (σ ≈ 0.3, expected per-bin energy ≈ 43)
+// never triggers a false detection even when the carrier gate is briefly open.
+static constexpr float MOTO_ENERGY_THRESHOLD = 1000.0f;
+
+// Fixed carrier-detect threshold for the detection gate (independent of user squelch).
+// FMSquelch returns true when HF noise is BELOW this value (= FM carrier present).
+// 0.20 opens reliably on any clean FM carrier without false-opening on noise.
+static constexpr float CARRIER_DETECT_THRESHOLD = 0.20f;
+
+// Goertzel energy threshold for CTCSS detection.
+// Pure CTCSS at 5% amplitude over 960 samples → energy ≈ (0.05 × 480)² = 576.
+static constexpr float CTCSS_ENERGY_THRESHOLD = 30.0f;
+
+void ToneDetectProcessor::configure(uint8_t squelch, uint32_t ctcss_f_x10) {
+    configured = false;
+    user_squelch_level = squelch;
+    ctcss_freq_x10 = ctcss_f_x10;
+
+    decim_0.configure(taps_11k0_decim_0.taps);
+    decim_1.configure(taps_11k0_decim_1.taps);
+    channel_filter.configure(taps_11k0_channel.taps, 2);
+    demod_fm.configure(24000, 5000);
+    audio_output.configure(false);
+    fm_squelch.set_threshold((float)user_squelch_level / 100.0f);
+    channel_spectrum.set_decimation_factor(1);
+
+    // Precompute Goertzel coefficient for CTCSS (if active).
+    // k = nearest DFT bin for the CTCSS frequency over WINDOW_SAMPLES.
+    if (ctcss_freq_x10 > 0) {
+        const float freq = (float)ctcss_freq_x10 / 10.0f;
+        const float k = roundf((float)WINDOW_SAMPLES * freq / SAMPLE_RATE);
+        const float omega = 2.0f * PI_F * k / (float)WINDOW_SAMPLES;
+        goertzel_coeff = 2.0f * cosf(omega);
+    } else {
+        goertzel_coeff = 0.0f;
+    }
+
+    // Precompute Goertzel coefficients for all 45 MOTO frequencies.
+    // Each filter is tuned to the EXACT MOTO frequency (not the nearest DFT bin center)
+    // so that every entry has a unique coefficient and maximum energy only at its
+    // specific frequency.  This eliminates bin-sharing ambiguity and gives the best
+    // discrimination between close entries such as 1357.6 Hz and 1395.0 Hz.
+    for (size_t i = 0; i < 45; i++) {
+        const float freq = (float)MOTO_FREQS_X10[i] / 10.0f;
+        const float omega = 2.0f * PI_F * freq / SAMPLE_RATE;
+        moto_coeff[i] = 2.0f * cosf(omega);
+        moto_s1[i] = 0.0f;
+        moto_s2[i] = 0.0f;
+    }
+
+    // Fixed carrier-detect squelch — threshold never changes with user settings.
+    carrier_sq.set_threshold(CARRIER_DETECT_THRESHOLD);
+
+    // Reset all per-window state
+    goertzel_s1 = 0.0f;
+    goertzel_s2 = 0.0f;
+    window_sample_count = 0;
+    was_ctcss_detected = false;
+    tone_duration_windows = 0;
+    squelch_is_open = false;
+    squelch_hold = 0;
+    carrier_is_open = false;
+    carrier_hold = 0;
+
+    configured = true;
+}
+
+void ToneDetectProcessor::execute(const buffer_c8_t& buffer) {
+    if (!configured) return;
+
+    const auto decim_0_out = decim_0.execute(buffer, dst_buffer);
+    const auto decim_1_out = decim_1.execute(decim_0_out, dst_buffer);
+
+    // Feed IQ data into spectrum collector for the RF waterfall.
+    channel_spectrum.feed(decim_1_out, -5500, 5500, 3400);
+
+    const auto channel_out = channel_filter.execute(decim_1_out, dst_buffer);
+    auto audio_buf = demod_fm.execute(channel_out, audio_buffer);
+
+    // --- Audio muting squelch (user-adjustable level) ---
+    // FMSquelch returns true when HF noise is LOW (carrier present).
+    const bool fm_open = fm_squelch.execute(audio_buf);
+    if (fm_open) {
+        squelch_hold = SQUELCH_HOLD_BLOCKS;
+        squelch_is_open = true;
+    } else if (squelch_hold > 0) {
+        squelch_hold--;
+    } else {
+        squelch_is_open = false;
+    }
+
+    // --- Fixed carrier-detect gate (independent of user squelch level) ---
+    // carrier_sq always uses CARRIER_DETECT_THRESHOLD (0.20) regardless of squelch_val.
+    // This ensures the detection gate closes when the carrier disappears even when the
+    // user sets squelch=0 (always-open audio), preventing the state machine from
+    // accumulating noise windows or getting stuck between transmissions.
+    const bool carrier_raw = carrier_sq.execute(audio_buf);
+    if (carrier_raw) {
+        carrier_hold = SQUELCH_HOLD_BLOCKS;
+        carrier_is_open = true;
+    } else if (carrier_hold > 0) {
+        carrier_hold--;
+    } else {
+        carrier_is_open = false;
+    }
+
+    for (size_t i = 0; i < audio_buf.count; i++) {
+        const float s = audio_buf.p[i];
+
+        // Mute audio output when FM squelch is closed (does not affect Goertzel).
+        if (!squelch_is_open) audio_buf.p[i] = 0.0f;
+
+        // CTCSS Goertzel step (CTCSS mode only).
+        // Uses original unmuted sample so CTCSS energy is unaffected by audio muting.
+        if (ctcss_freq_x10 > 0) {
+            const float s0 = s + goertzel_coeff * goertzel_s1 - goertzel_s2;
+            goertzel_s2 = goertzel_s1;
+            goertzel_s1 = s0;
+        }
+
+        // MOTO frequency bank — Goertzel step for all 45 MOTO bins.
+        // Runs unconditionally so the full window always contributes to energy.
+        // Benefit over zero-crossing: coherent detection, no warm-up period,
+        // accurate on the very first window after the gate opens.
+        for (size_t j = 0; j < 45; j++) {
+            const float s0 = s + moto_coeff[j] * moto_s1[j] - moto_s2[j];
+            moto_s2[j] = moto_s1[j];
+            moto_s1[j] = s0;
+        }
+
+        // Window boundary: every WINDOW_SAMPLES samples = one 40 ms estimate window
+        if (++window_sample_count >= WINDOW_SAMPLES) {
+            window_sample_count = 0;
+
+            // --- Detection gate ---
+            // Carrier presence (carrier_is_open) is always required — without it,
+            // the FM demod outputs broadband noise that floods every Goertzel bin and
+            // triggers false detections regardless of the CTCSS threshold.
+            // CTCSS mode adds a second requirement: coherent CTCSS energy must also
+            // be present.  This is the standard two-condition squelch used in real radios.
+            bool gate_open;
+            if (ctcss_freq_x10 > 0) {
+                const float power = goertzel_s1 * goertzel_s1 + goertzel_s2 * goertzel_s2 - goertzel_coeff * goertzel_s1 * goertzel_s2;
+                gate_open = carrier_is_open && (power > CTCSS_ENERGY_THRESHOLD);
+                goertzel_s1 = 0.0f;
+                goertzel_s2 = 0.0f;
+            } else {
+                gate_open = carrier_is_open;
+            }
+
+            // --- MOTO frequency identification via Goertzel energy ---
+            // Find the MOTO table entry with the highest coherent energy this window.
+            // Reset all states regardless of gate so each window starts fresh.
+            float energies[45]{};
+            uint32_t best_idx = 45;  // 45 = sentinel (no match)
+            float best_energy = MOTO_ENERGY_THRESHOLD;
+            for (size_t j = 0; j < 45; j++) {
+                const float pwr = moto_s1[j] * moto_s1[j] + moto_s2[j] * moto_s2[j] - moto_coeff[j] * moto_s1[j] * moto_s2[j];
+                energies[j] = pwr;
+                moto_s1[j] = 0.0f;
+                moto_s2[j] = 0.0f;
+                if (pwr > best_energy) {
+                    best_energy = pwr;
+                    best_idx = j;
+                }
+            }
+            // Report a raw estimate from the local energy centroid around the best
+            // entry, and let the UI do the final table snap from the phase average.
+            uint32_t win_freq_hz = 0;
+            if (best_idx < 45) {
+                const size_t start = (best_idx > 0) ? (best_idx - 1) : best_idx;
+                const size_t end = (best_idx + 1 < 45) ? (best_idx + 1) : best_idx;
+                float weight_sum = 0.0f;
+                float weighted_freq_x10 = 0.0f;
+                for (size_t j = start; j <= end; j++) {
+                    const float weight = energies[j] - MOTO_ENERGY_THRESHOLD;
+                    if (weight > 0.0f) {
+                        weight_sum += weight;
+                        weighted_freq_x10 += weight * (float)MOTO_FREQS_X10[j];
+                    }
+                }
+                if (weight_sum > 0.0f) {
+                    win_freq_hz = (uint32_t)((weighted_freq_x10 / weight_sum) / 10.0f + 0.5f);
+                } else {
+                    win_freq_hz = MOTO_FREQS_X10[best_idx] / 10;
+                }
+            }
+
+            if (gate_open) {
+                if (!was_ctcss_detected) {
+                    tone_duration_windows = 0;
+                }
+                tone_duration_windows++;
+                was_ctcss_detected = true;
+
+                data_message.freq_hz = win_freq_hz;
+                data_message.duration_ms = tone_duration_windows * WINDOW_MS;
+                data_message.tone_end = false;
+                shared_memory.application_queue.push(data_message);
+
+            } else {
+                if (was_ctcss_detected) {
+                    // Gate just closed — signal tone end to application
+                    data_message.freq_hz = 0;
+                    data_message.duration_ms = tone_duration_windows * WINDOW_MS;
+                    data_message.tone_end = true;
+                    shared_memory.application_queue.push(data_message);
+                    tone_duration_windows = 0;
+                }
+                was_ctcss_detected = false;
+            }
+        }
+    }
+
+    audio_output.write(audio_buf);
+}
+
+void ToneDetectProcessor::on_message(const Message* const p) {
+    switch (p->id) {
+        case Message::ID::ToneDetectConfig: {
+            const auto& msg = *reinterpret_cast<const ToneDetectConfigureMessage*>(p);
+            configure(msg.squelch_level, msg.ctcss_freq_x10);
+            break;
+        }
+        case Message::ID::NBFMConfigure: {
+            const auto& msg = *reinterpret_cast<const NBFMConfigureMessage*>(p);
+            user_squelch_level = msg.squelch_level;
+            fm_squelch.set_threshold((float)user_squelch_level / 100.0f);
+            break;
+        }
+        case Message::ID::UpdateSpectrum:
+        case Message::ID::SpectrumStreamingConfig:
+            channel_spectrum.on_message(p);
+            break;
+        default:
+            break;
+    }
+}
+
+int main() {
+    audio::dma::init_audio_out();
+    EventDispatcher event_dispatcher{std::make_unique<ToneDetectProcessor>()};
+    event_dispatcher.run();
+    return 0;
+}

firmware/baseband/proc_tonedetect.hpp

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2024 PortaPack Mayhem
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __PROC_TONEDETECT_H__
+#define __PROC_TONEDETECT_H__
+
+#include "baseband_processor.hpp"
+#include "baseband_thread.hpp"
+#include "message.hpp"
+#include "dsp_decimate.hpp"
+#include "dsp_demodulate.hpp"
+#include "audio_output.hpp"
+#include "dsp_fir_taps.hpp"
+#include "rssi_thread.hpp"
+#include "spectrum_collector.hpp"
+#include "dsp_squelch.hpp"
+
+class ToneDetectProcessor : public BasebandProcessor {
+   public:
+    ToneDetectProcessor() {}
+
+    void execute(const buffer_c8_t& buffer) override;
+    void on_message(const Message* const p) override;
+
+   private:
+    void configure(uint8_t squelch, uint32_t ctcss_freq_x10);
+
+    BasebandThread baseband_thread{3072000, this, baseband::Direction::Receive};
+    RSSIThread rssi_thread{};
+
+    std::array<complex16_t, 512> dst{};
+    const buffer_c16_t dst_buffer{dst.data(), dst.size()};
+    std::array<float, 32> audio{};
+    const buffer_f32_t audio_buffer{audio.data(), audio.size()};
+
+    dsp::decimate::FIRC8xR16x24FS4Decim8 decim_0{};
+    dsp::decimate::FIRC16xR16x32Decim8 decim_1{};
+    dsp::decimate::FIRAndDecimateComplex channel_filter{};
+    dsp::demodulate::FM demod_fm{};
+    AudioOutput audio_output{};
+
+    bool configured{false};
+    uint8_t user_squelch_level{0};
+    FMSquelch fm_squelch{};  // user-adjustable: drives audio muting only
+    FMSquelch carrier_sq{};  // fixed threshold: drives detection gate
+
+    // Audio muting squelch state (user-adjustable level, has hold for smooth audio)
+    bool squelch_is_open{false};
+    uint32_t squelch_hold{0};
+
+    // Carrier-detect gate state (fixed 0.20 threshold, separate from audio squelch)
+    bool carrier_is_open{false};
+    uint32_t carrier_hold{0};
+
+    // CTCSS gate via Goertzel algorithm (per 40 ms window)
+    uint32_t ctcss_freq_x10{0};  // 0 = None → fall back to FMSquelch gate
+    float goertzel_coeff{0.0f};  // 2 * cos(2π * k / WINDOW_SAMPLES)
+    float goertzel_s1{0.0f};
+    float goertzel_s2{0.0f};
+
+    // 40 ms measurement window
+    uint32_t window_sample_count{0};
+    bool was_ctcss_detected{false};
+    uint32_t tone_duration_windows{0};
+
+    // MOTO frequency bank — one Goertzel filter per MOTO table entry.
+    // States reset each window; coefficients set once in configure().
+    float moto_coeff[45]{};
+    float moto_s1[45]{};
+    float moto_s2[45]{};
+
+    ToneDetectDataMessage data_message{};
+    SpectrumCollector channel_spectrum{};
+};
+
+#endif /* __PROC_TONEDETECT_H__ */

firmware/baseband/rssi_thread.cpp

@@ -28,110 +28,6 @@
 #include "message.hpp"
 #include "portapack_shared_memory.hpp"
 
-#ifdef PRALINE
-/*
- * =============================================================================
- * PRALINE Software RSSI
- * =============================================================================
- *
- * Architecture:
- * - baseband_thread: Copies 8 packed I/Q samples (no computation)
- * - rssi_thread: __SMUAD power calc, avg power, LUT, trackers
- *
- * All DSP happens here to keep baseband_thread minimal.
- */
-
-/*
- * Power-to-RSSI Lookup Table (32 entries)
- *
- * Maps I²+Q² power to RSSI (0-255) using logarithmic scaling.
- * For 8-bit I/Q: max |I|=|Q|=127, so max I²+Q² = 32258
- *
- * For example, the formula: rssi = 32 * log2((index * 8) + 1), clamped to 255
- * where using  >> 8 scaling provide 4x more sensitive than >> 10:
- *
- * The trade-off: more sensitivity means the meter saturates (hits max) at lower signal levels.
- * We'll want the bar to be mid-range at typical signal levels, not pegged at max.
- * - Index 0: power 0-255 (I/Q magnitude ~11)
- * - Index 31: power 7936+ (I/Q magnitude ~63+)
- */
-static constexpr uint8_t power_to_rssi_lut[32] = {
-    0, 101, 130, 148, 161, 171, 179, 186,
-    192, 197, 202, 206, 210, 213, 217, 220,
-    222, 225, 227, 230, 232, 234, 236, 238,
-    240, 241, 243, 244, 246, 247, 249, 255};
-
-/*
- * Convert power to RSSI using 32-entry LUT.
- * If more sensitivity thank >> 10 is needed:
- *     use power >= 8192 & >> 8, yields 4x more sensitivity than >> 10.
- *     use power >= 4096 & >> 7, yields 8x more sensitivity than >> 10
- *     use power >= 2048 & >> 6, yields 16x more sensitivity than >> 10
- *     use power >= 1024 & >> 5, yields 32x more sensitivity than >> 10
- */
-static inline uint8_t power_to_rssi(uint32_t power) {
-    // uint8_t index = (power >= 32768) ? 31 : static_cast<uint8_t>(power >> 10);
-    uint8_t index = (power >= 2048) ? 31 : static_cast<uint8_t>(power >> 6);
-    return power_to_rssi_lut[index];
-}
-
-/*
- * IIR Smoothing Filter (Exponential Moving Average)
- * Formula: smooth = (current + 7*smooth) / 8  (α = 1/8)
- */
-class IIRFilter {
-   public:
-    uint8_t update(uint8_t current) {
-        uint16_t current_q8 = static_cast<uint16_t>(current) << 8;
-        smooth_q8_ = (current_q8 + 7 * smooth_q8_) >> 3;
-        return static_cast<uint8_t>(smooth_q8_ >> 8);
-    }
-
-   private:
-    uint16_t smooth_q8_ = 0;
-};
-
-/*
- * Running min tracker with decay.
- * Instantly captures new minimums, slowly decays upward.
- */
-class MinTracker {
-   public:
-    uint8_t update(uint8_t current) {
-        if (current < min_) {
-            min_ = current;
-        } else {
-            // Slow decay upward (α = 1/16)
-            min_ = min_ + ((current - min_) >> 4);
-        }
-        return min_;
-    }
-
-   private:
-    uint8_t min_ = 255;
-};
-
-/*
- * Running max tracker with decay.
- * Instantly captures new maximums, slowly decays downward.
- */
-class MaxTracker {
-   public:
-    uint8_t update(uint8_t current) {
-        if (current > max_) {
-            max_ = current;
-        } else {
-            // Slow decay downward (α = 1/16)
-            max_ = max_ - ((max_ - current) >> 4);
-        }
-        return max_;
-    }
-
-   private:
-    uint8_t max_ = 0;
-};
-#endif  // PRALINE
-
 WORKING_AREA(rssi_thread_wa, 128);
 
 Thread* RSSIThread::thread = nullptr;
@@ -158,85 +54,6 @@ void RSSIThread::start() {
 }
 
 void RSSIThread::run() {
-#ifdef PRALINE
-
-    /*
-     * PRALINE (HackRF Pro): Software RSSI from I/Q samples
-     *
-     * Hardware ADC-based RSSI doesn't work on HackRF Pro.
-     *
-     * baseband_thread copies 8 packed I/Q samples.
-     * We use __SMUAD to compute power, then apply LUT and
-     * maintain running stats.
-     */
-
-    IIRFilter avg_filter;
-    MinTracker min_tracker;
-    MaxTracker max_tracker;
-
-    RSSIStatistics stats{};
-    uint32_t accumulator = 0;
-    uint32_t sample_count = 0;
-
-    constexpr uint32_t samples_per_report = 50;  // ~10Hz reporting at 2ms poll
-
-    while (!chThdShouldTerminate()) {
-        chThdSleepMilliseconds(2);  // Poll at ~500Hz
-
-        /*
-         * SIMD-accelerated I/Q power calculation for Cortex-M4.
-         *
-         * Uses __SMUAD (Signed Multiply Accumulate Dual) instruction to compute
-         * sum of products of packed halfwords: (a0*a0) + (a1*a1)
-         *
-         * Processes complex samples per iteration, computing I²+Q² with SIMD.
-         * SIMD-accelerated I/Q power calculation for Cortex-M4.
-         * ~4x faster than scalar loop.
-         * Sum power from all 8 samples (more stable than peak).
-         *
-         * __SMUAD(val, val) computes:
-         *   (low16 * low16) + (high16 * high16) = I² + Q²
-         */
-
-        uint32_t total_power = 0;
-
-        for (size_t i = 0; i < 8; i++) {
-            const uint32_t packed = shared_memory.software_rssi_iq[i];
-            total_power += __SMUAD(packed, packed);
-        }
-
-        // Average the 8 samples for min, and avg power
-        const uint32_t avg_power = total_power >> 3;
-
-        // Convert to RSSI scale (0-255) via LUT
-        const uint8_t avg_rssi = power_to_rssi(avg_power);
-
-        // Update running trackers
-        const uint8_t smooth_min = min_tracker.update(avg_rssi);
-        const uint8_t smooth_avg = avg_filter.update(avg_rssi);
-        const uint8_t smooth_max = max_tracker.update(avg_rssi);
-
-        // Accumulate for periodic report
-        accumulator += smooth_avg;
-        sample_count++;
-
-        // Report periodically
-        if (sample_count >= samples_per_report) {
-            stats.min = smooth_min;
-            stats.max = smooth_max;
-            stats.accumulator = accumulator;
-            stats.count = sample_count;
-
-            const RSSIStatisticsMessage message{stats};
-            shared_memory.application_queue.push(message);
-
-            // Reset accumulator for next period
-            accumulator = 0;
-            sample_count = 0;
-        }
-    }
-#else
-    /* HackRF One: Use hardware ADC-based RSSI */
     rf::rssi::init();
     rf::rssi::dma::allocate(4, 400);
 
@@ -260,5 +77,4 @@ void RSSIThread::run() {
 
     rf::rssi::stop();
     rf::rssi::dma::free();
-#endif
 }

firmware/baseband/sd_over_usb/hackrf_core.c

@@ -35,6 +35,9 @@
 #include "i2c_lpc.h"
 #include "cpld_jtag.h"
 #include "platform_detect.h"
+#include "platform_gpio.h"
+#include "platform_scu.h"
+#include "fixed_point.h"
 #include "clkin.h"
 #include <libopencm3/lpc43xx/cgu.h>
 #include <libopencm3/lpc43xx/ccu.h>
@@ -48,7 +51,7 @@
 #include "gpio_lpc.h"
 
 /* GPIO Output PinMux */
-static struct gpio_t gpio_led[] = {
+static struct gpio gpio_led[] = {
     GPIO(2, 1),
     GPIO(2, 2),
     GPIO(2, 8),
@@ -58,90 +61,89 @@ static struct gpio_t gpio_led[] = {
 };
 
 // clang-format off
-static struct gpio_t gpio_1v8_enable        = GPIO(3,  6);
+static struct gpio gpio_1v8_enable        = GPIO(3,  6);
 
 /* MAX283x GPIO (XCVR_CTL) PinMux */
-static struct gpio_t gpio_max283x_select    = GPIO(0, 15);
+static struct gpio gpio_max283x_select    = GPIO(0, 15);
 
 /* MAX5864 SPI chip select (AD_CS) GPIO PinMux */
-static struct gpio_t gpio_max5864_select    = GPIO(2,  7);
+static struct gpio gpio_max5864_select    = GPIO(2,  7);
 
 /* RFFC5071 GPIO serial interface PinMux */
 // #ifdef RAD1O
-// static struct gpio_t gpio_rffc5072_select   = GPIO(2, 13);
-// static struct gpio_t gpio_rffc5072_clock    = GPIO(5,  6);
-// static struct gpio_t gpio_rffc5072_data     = GPIO(3,  3);
-// static struct gpio_t gpio_rffc5072_reset    = GPIO(2, 14);
+// static struct gpio gpio_rffc5072_select   = GPIO(2, 13);
+// static struct gpio gpio_rffc5072_clock    = GPIO(5,  6);
+// static struct gpio gpio_rffc5072_data     = GPIO(3,  3);
+// static struct gpio gpio_rffc5072_reset    = GPIO(2, 14);
 // #endif
 
 /* RF supply (VAA) control */
 #ifdef HACKRF_ONE
-static struct gpio_t gpio_vaa_disable       = GPIO(2, 9);
+static struct gpio gpio_vaa_disable       = GPIO(2, 9);
 #endif
 #ifdef RAD1O
-static struct gpio_t gpio_vaa_enable        = GPIO(2, 9);
+static struct gpio gpio_vaa_enable        = GPIO(2, 9);
 #endif
 
-static struct gpio_t gpio_w25q80bv_hold     = GPIO(1, 14);
-static struct gpio_t gpio_w25q80bv_wp       = GPIO(1, 15);
-static struct gpio_t gpio_w25q80bv_select   = GPIO(5, 11);
+static struct gpio gpio_w25q80bv_hold     = GPIO(1, 14);
+static struct gpio gpio_w25q80bv_wp       = GPIO(1, 15);
 
 /* RF switch control */
 #ifdef HACKRF_ONE
-static struct gpio_t gpio_hp                = GPIO(2,  0);
-static struct gpio_t gpio_lp                = GPIO(2, 10);
-static struct gpio_t gpio_tx_mix_bp         = GPIO(2, 11);
-static struct gpio_t gpio_no_mix_bypass     = GPIO(1,  0);
-static struct gpio_t gpio_rx_mix_bp         = GPIO(2, 12);
-static struct gpio_t gpio_tx_amp            = GPIO(2, 15);
-static struct gpio_t gpio_tx                = GPIO(5, 15);
-static struct gpio_t gpio_mix_bypass        = GPIO(5, 16);
-static struct gpio_t gpio_rx                = GPIO(5,  5);
-static struct gpio_t gpio_no_tx_amp_pwr     = GPIO(3,  5);
-static struct gpio_t gpio_amp_bypass        = GPIO(0, 14);
-static struct gpio_t gpio_rx_amp            = GPIO(1, 11);
-static struct gpio_t gpio_no_rx_amp_pwr     = GPIO(1, 12);
+static struct gpio gpio_hp                = GPIO(2,  0);
+static struct gpio gpio_lp                = GPIO(2, 10);
+static struct gpio gpio_tx_mix_bp         = GPIO(2, 11);
+static struct gpio gpio_no_mix_bypass     = GPIO(1,  0);
+static struct gpio gpio_rx_mix_bp         = GPIO(2, 12);
+static struct gpio gpio_tx_amp            = GPIO(2, 15);
+static struct gpio gpio_tx                = GPIO(5, 15);
+static struct gpio gpio_mix_bypass        = GPIO(5, 16);
+static struct gpio gpio_rx                = GPIO(5,  5);
+static struct gpio gpio_no_tx_amp_pwr     = GPIO(3,  5);
+static struct gpio gpio_amp_bypass        = GPIO(0, 14);
+static struct gpio gpio_rx_amp            = GPIO(1, 11);
+static struct gpio gpio_no_rx_amp_pwr     = GPIO(1, 12);
 #endif
 #ifdef RAD1O
-static struct gpio_t gpio_tx_rx_n           = GPIO(1,  11);
-static struct gpio_t gpio_tx_rx             = GPIO(0,  14);
-static struct gpio_t gpio_by_mix            = GPIO(1,  12);
-static struct gpio_t gpio_by_mix_n          = GPIO(2,  10);
-static struct gpio_t gpio_by_amp            = GPIO(1,  0);
-static struct gpio_t gpio_by_amp_n          = GPIO(5,  5);
-static struct gpio_t gpio_mixer_en          = GPIO(5,  16);
-static struct gpio_t gpio_low_high_filt     = GPIO(2,  11);
-static struct gpio_t gpio_low_high_filt_n   = GPIO(2,  12);
-static struct gpio_t gpio_tx_amp            = GPIO(2,  15);
-static struct gpio_t gpio_rx_lna            = GPIO(5,  15);
+static struct gpio gpio_tx_rx_n           = GPIO(1,  11);
+static struct gpio gpio_tx_rx             = GPIO(0,  14);
+static struct gpio gpio_by_mix            = GPIO(1,  12);
+static struct gpio gpio_by_mix_n          = GPIO(2,  10);
+static struct gpio gpio_by_amp            = GPIO(1,  0);
+static struct gpio gpio_by_amp_n          = GPIO(5,  5);
+static struct gpio gpio_mixer_en          = GPIO(5,  16);
+static struct gpio gpio_low_high_filt     = GPIO(2,  11);
+static struct gpio gpio_low_high_filt_n   = GPIO(2,  12);
+static struct gpio gpio_tx_amp            = GPIO(2,  15);
+static struct gpio gpio_rx_lna            = GPIO(5,  15);
 #endif
 
 /* CPLD JTAG interface GPIO pins */
-static struct gpio_t gpio_cpld_tdo          = GPIO(5, 18);
-static struct gpio_t gpio_cpld_tck          = GPIO(3,  0);
+static struct gpio gpio_cpld_tdo          = GPIO(5, 18);
+static struct gpio gpio_cpld_tck          = GPIO(3,  0);
 #if (defined HACKRF_ONE || defined RAD1O)
-static struct gpio_t gpio_cpld_tms          = GPIO(3,  4);
-static struct gpio_t gpio_cpld_tdi          = GPIO(3,  1);
+static struct gpio gpio_cpld_tms          = GPIO(3,  4);
+static struct gpio gpio_cpld_tdi          = GPIO(3,  1);
 #else
-static struct gpio_t gpio_cpld_tms          = GPIO(3,  1);
-static struct gpio_t gpio_cpld_tdi          = GPIO(3,  4);
+static struct gpio gpio_cpld_tms          = GPIO(3,  1);
+static struct gpio gpio_cpld_tdi          = GPIO(3,  4);
 #endif
 
 #ifdef HACKRF_ONE
-static struct gpio_t gpio_cpld_pp_tms       = GPIO(1,  1);
-static struct gpio_t gpio_cpld_pp_tdo       = GPIO(1,  8);
+static struct gpio gpio_cpld_pp_tms       = GPIO(1,  1);
+static struct gpio gpio_cpld_pp_tdo       = GPIO(1,  8);
 #endif
 
 /* other CPLD interface GPIO pins */
-static struct gpio_t gpio_hw_sync_enable    = GPIO(5, 12);
-static struct gpio_t gpio_q_invert          = GPIO(0, 13);
+static struct gpio gpio_hw_sync_enable    = GPIO(5, 12);
+static struct gpio gpio_q_invert          = GPIO(0, 13);
 
 /* HackRF One r9 */
 #ifdef HACKRF_ONE
-static struct gpio_t gpio_h1r9_rx             = GPIO(0, 7);
-static struct gpio_t gpio_h1r9_1v8_enable     = GPIO(2, 9);
-static struct gpio_t gpio_h1r9_vaa_disable    = GPIO(3, 6);
-static struct gpio_t gpio_h1r9_hw_sync_enable = GPIO(5, 5);
+static struct gpio gpio_h1r9_rx             = GPIO(0, 7);
+static struct gpio gpio_h1r9_1v8_enable     = GPIO(2, 9);
+static struct gpio gpio_h1r9_vaa_disable    = GPIO(3, 6);
+static struct gpio gpio_h1r9_hw_sync_enable = GPIO(5, 5);
 #endif
 // clang-format on
 
@@ -216,11 +218,10 @@ max5864_driver_t max5864 = {
     .target_init = max5864_target_init,
 };
 
-const ssp_config_t ssp_config_w25q80bv = {
+ssp_config_t ssp_config_w25q80bv = {
     .data_bits = SSP_DATA_8BITS,
     .serial_clock_rate = 2,
     .clock_prescale_rate = 2,
-    .gpio_select = &gpio_w25q80bv_select,
 };
 
 spi_bus_t spi_bus_ssp0 = {
@@ -431,96 +432,105 @@ bool sample_rate_frac_set(uint32_t rate_num, uint32_t rate_denom) {
     return true;
 }
 
-bool sample_rate_set(const uint32_t sample_rate_hz) {
-    uint32_t p1 = 4608;
-    uint32_t p2 = 0;
-    uint32_t p3 = 0;
+/*
+ * Configure clock generator to produce sample clock in units of 1/(2**24) Hz.
+ * Can be called with program=false for a dry run that returns the resultant
+ * frequency without actually configuring the clock generator.
+ */
+fp_40_24_t sample_rate_set(const fp_40_24_t sample_rate, const bool program) {
+    const fp_40_24_t vco = 800 * FP_ONE_MHZ;
+    uint64_t p1, p2, p3;
+    uint64_t n, d, q;
+    fp_40_24_t remainder, resultant_rate;
 
-    switch (sample_rate_hz) {
-        case 8000000:
-            p1 = SI_INTDIV(50);  // 800MHz / 50 = 16 MHz (SGPIO), 8 MHz (codec)
-            break;
+    fp_40_24_t rate = sample_rate * 2;
 
-        case 9216000:
-            // 43.40277777777778: a = 43; b = 29; c = 72
-            p1 = 5043;
-            p2 = 40;
-            p3 = 72;
-            break;
+    p1 = ((128 * vco) / rate) - 512;
+    if (vco % rate) {
+        n = (128 * vco) - (rate * (p1 + 512));
+        d = rate / FP_ONE_HZ;
+        n += (d / 2);
+        p2 = n / d;
+        p3 = 1 << 24;
 
-        case 10000000:
-            p1 = SI_INTDIV(40);  // 800MHz / 40 = 20 MHz (SGPIO), 10 MHz (codec)
-            break;
+        unsigned int shift = p2 ? __builtin_ctzll(p2) : 24;
+        p2 >>= shift;
+        p3 >>= shift;
 
-        case 12288000:
-            // 32.552083333333336: a = 32; b = 159; c = 288
-            p1 = 3654;
-            p2 = 192;
-            p3 = 288;
-            break;
+        const uint64_t p3_max = 0xfffff;
+        if (p3 > p3_max) {
+            p2 *= p3_max;
+            p2 += (p3 / 2);
+            p2 /= p3;
+            p3 = p3_max;
+        }
 
-        case 12500000:
-            p1 = SI_INTDIV(32);  // 800MHz / 32 = 25 MHz (SGPIO), 12.5 MHz (codec)
-            break;
+        if (p2 >= p3) {
+            p1++;
+            p2 = 0;
+        }
+    } else {
+        p2 = 0;
+    }
 
-        case 16000000:
-            p1 = SI_INTDIV(25);  // 800MHz / 25 = 32 MHz (SGPIO), 16 MHz (codec)
-            break;
+    if (p1 > 0x3fe00) {
+        p1 = 0x3fe00;
+        p2 = 0;
+    }
 
-        case 18432000:
-            // 21.70138888889: a = 21; b = 101; c = 144
-            p1 = 2265;
-            p2 = 112;
-            p3 = 144;
-            break;
+    if (p2 == 0) {
+        p3 = 1;
+        n = (vco * 128);
+        d = (p1 + 512);
+        n += (d / 2);
+        resultant_rate = n / d;
+    } else {
+        const uint64_t vco_hz = vco / FP_ONE_HZ;
+        n = p3 * vco_hz * 128;
+        d = p3 * (p1 + 512) + p2;
+        const uint64_t rate_hz = n / d;
+        remainder = (n - (d * rate_hz)) * FP_ONE_HZ;
+        remainder += (d / 2);
+        q = remainder / d;
+        resultant_rate = (rate_hz * FP_ONE_HZ) + q;
+    }
 
-        case 20000000:
-            p1 = SI_INTDIV(20);  // 800MHz / 20 = 40 MHz (SGPIO), 20 MHz (codec)
-            break;
+    resultant_rate = (resultant_rate + 1) / 2;
 
-        default:
-            return false;
+    if (!program) {
+        return resultant_rate;
+    }
+
+    bool streaming = sgpio_cpld_stream_is_enabled(&sgpio_config);
+
+    if (streaming) {
+        sgpio_cpld_stream_disable(&sgpio_config);
+    }
+
+    if (p1 & 0x1 || p2) {
+        si5351c_set_int_mode(&clock_gen, 0, 0);
+    } else {
+        si5351c_set_int_mode(&clock_gen, 0, 1);
     }
 
     if (detected_platform() == BOARD_ID_HACKRF1_R9) {
-        /*
-         * On HackRF One r9 all sample clocks are externally derived
-         * from MS1/CLK1 operating at twice the sample rate.
-         */
         si5351c_configure_multisynth(&clock_gen, 1, p1, p2, p3, 0);
     } else {
-        /*
-         * On other platforms the clock generator produces three
-         * different sample clocks, all derived from multisynth 0.
-         */
-        /* MS0/CLK0 is the source for the MAX5864/CPLD (CODEC_CLK). */
         si5351c_configure_multisynth(&clock_gen, 0, p1, p2, p3, 1);
-
-        /* MS0/CLK1 is the source for the CPLD (CODEC_X2_CLK). */
-        si5351c_configure_multisynth(
-            &clock_gen,
-            1,
-            p1,
-            0,
-            1,
-            0);  // p1 doesn't matter
-
-        /* MS0/CLK2 is the source for SGPIO (CODEC_X2_CLK) */
-        si5351c_configure_multisynth(
-            &clock_gen,
-            2,
-            p1,
-            0,
-            1,
-            0);  // p1 doesn't matter
+        si5351c_configure_multisynth(&clock_gen, 1, 0, 0, 0, 0);
+        si5351c_configure_multisynth(&clock_gen, 2, 0, 0, 0, 0);
     }
 
-    return true;
+    if (streaming) {
+        sgpio_cpld_stream_enable(&sgpio_config);
+    }
+
+    return resultant_rate;
 }
 
 bool baseband_filter_bandwidth_set(const uint32_t bandwidth_hz) {
     uint32_t bandwidth_hz_real;
-    bandwidth_hz_real = max283x_set_lpf_bandwidth(&max283x, bandwidth_hz);
+    bandwidth_hz_real = max283x_set_lpf_bandwidth(&max283x, MAX283x_MODE_RX, bandwidth_hz);
 
     if (bandwidth_hz_real) {
         hackrf_ui()->set_filter_bw(bandwidth_hz_real);
@@ -615,8 +625,8 @@ void cpu_clock_init(void) {
     si5351c_power_down_all_clocks(&clock_gen);
     si5351c_set_crystal_configuration(&clock_gen);
     si5351c_enable_xo_and_ms_fanout(&clock_gen);
-    si5351c_configure_pll_sources(&clock_gen);
-    si5351c_configure_pll_multisynth(&clock_gen);
+    si5351c_configure_pll_sources(&clock_gen, PLL_SOURCE_XTAL);
+    si5351c_configure_pll_multisynth(&clock_gen, PLL_SOURCE_XTAL);
 
     /*
      * Clocks on HackRF One r9:
@@ -667,7 +677,7 @@ void cpu_clock_init(void) {
     /* MS7/CLK7 is unused. */
 
     /* Set to 10 MHz, the common rate between Jawbreaker and HackRF One. */
-    sample_rate_set(10000000);
+    sample_rate_set(10000000 * (fp_40_24_t)FP_ONE_HZ, true);
 
     si5351c_set_clock_source(&clock_gen, PLL_SOURCE_XTAL);
     // soft reset
@@ -854,6 +864,8 @@ void ssp1_set_mode_max5864(void) {
 }
 
 void pin_setup(void) {
+    const platform_scu_t* scu = platform_scu();
+
     /* Configure all GPIO as Input (safe state) */
     // gpio_init();
 
@@ -872,26 +884,26 @@ void pin_setup(void) {
      * LPC43xx pull-up and pull-down resistors are approximately 53K.
      */
 #ifdef HACKRF_ONE
-    scu_pinmux(SCU_PINMUX_PP_TMS, SCU_GPIO_PUP | SCU_CONF_FUNCTION0);
-    scu_pinmux(SCU_PINMUX_PP_TDO, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+    scu_pinmux(scu->PINMUX_PP_TMS, SCU_GPIO_PUP | SCU_CONF_FUNCTION0);
+    scu_pinmux(scu->PINMUX_PP_TDO, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
 #endif
-    scu_pinmux(SCU_PINMUX_CPLD_TMS, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
-    scu_pinmux(SCU_PINMUX_CPLD_TDI, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
-    scu_pinmux(SCU_PINMUX_CPLD_TDO, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
-    scu_pinmux(SCU_PINMUX_CPLD_TCK, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+    scu_pinmux(scu->PINMUX_CPLD_TMS, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
+    scu_pinmux(scu->PINMUX_CPLD_TDI, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
+    scu_pinmux(scu->PINMUX_CPLD_TDO, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+    scu_pinmux(scu->PINMUX_CPLD_TCK, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
 
     /* Configure SCU Pin Mux as GPIO */
-    scu_pinmux(SCU_PINMUX_LED1, SCU_GPIO_NOPULL);
-    scu_pinmux(SCU_PINMUX_LED2, SCU_GPIO_NOPULL);
-    scu_pinmux(SCU_PINMUX_LED3, SCU_GPIO_NOPULL);
+    scu_pinmux(scu->PINMUX_LED1, SCU_GPIO_NOPULL);
+    scu_pinmux(scu->PINMUX_LED2, SCU_GPIO_NOPULL);
+    scu_pinmux(scu->PINMUX_LED3, SCU_GPIO_NOPULL);
 #ifdef RAD1O
-    scu_pinmux(SCU_PINMUX_LED4, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION4);
+    scu_pinmux(scu->PINMUX_LED4, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION4);
 #endif
 
     /* Configure USB indicators */
 #ifdef JAWBREAKER
-    scu_pinmux(SCU_PINMUX_USB_LED0, SCU_CONF_FUNCTION3);
-    scu_pinmux(SCU_PINMUX_USB_LED1, SCU_CONF_FUNCTION3);
+    scu_pinmux(scu->PINMUX_USB_LED0, SCU_CONF_FUNCTION3);
+    scu_pinmux(scu->PINMUX_USB_LED1, SCU_CONF_FUNCTION3);
 #endif
 
     gpio_output(&gpio_led[0]);
@@ -905,11 +917,11 @@ void pin_setup(void) {
     if (detected_platform() == BOARD_ID_HACKRF1_R9) {
 #ifdef HACKRF_ONE
         gpio_output(&gpio_h1r9_1v8_enable);
-        scu_pinmux(SCU_H1R9_EN1V8, SCU_GPIO_FAST | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->H1R9_EN1V8, SCU_GPIO_FAST | SCU_CONF_FUNCTION0);
 #endif
     } else {
         gpio_output(&gpio_1v8_enable);
-        scu_pinmux(SCU_PINMUX_EN1V8, SCU_GPIO_FAST | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->PINMUX_EN1V8, SCU_GPIO_FAST | SCU_CONF_FUNCTION0);
     }
 
 #ifdef HACKRF_ONE
@@ -935,8 +947,8 @@ void pin_setup(void) {
     scu_pinmux(CLK0, SCU_CLK_IN | SCU_CONF_FUNCTION7);
     scu_pinmux(CLK2, SCU_CLK_IN | SCU_CONF_FUNCTION7);
 
-    scu_pinmux(SCU_PINMUX_GPIO3_10, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
-    scu_pinmux(SCU_PINMUX_GPIO3_11, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+    scu_pinmux(scu->PINMUX_GPIO3_10, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+    scu_pinmux(scu->PINMUX_GPIO3_11, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
 
 #endif
 
@@ -956,7 +968,7 @@ void pin_setup(void) {
     rf_path_pin_setup(&rf_path);
 
     /* Configure external clock in */
-    scu_pinmux(SCU_PINMUX_GP_CLKIN, SCU_CLK_IN | SCU_CONF_FUNCTION1);
+    scu_pinmux(scu->PINMUX_GP_CLKIN, SCU_CLK_IN | SCU_CONF_FUNCTION1);
 
     sgpio_configure_pin_functions(&sgpio_config);
 }

firmware/baseband/sd_over_usb/scsi.c

@@ -22,6 +22,7 @@
 
 #include "scsi.h"
 #include "diskio.h"
+#include "gpio_lpc.h"
 #include <libopencm3/lpc43xx/scu.h>
 #include <libopencm3/lpc43xx/rgu.h>
 #include <libopencm3/lpc43xx/wwdt.h>
@@ -286,7 +287,7 @@ void scsi_command(msd_cbw_t* msd_cbw_data) {
 
         case SCSI_CMD_START_STOP_UNIT:
             SCU_SFSP2_8 = (SCU_SFSP2_8 & ~(7)) | 4;
-            struct gpio_t dfu = GPIO(5, 7);
+            struct gpio dfu = GPIO(5, 7);
             gpio_output(&dfu);
             gpio_clear(&dfu);
 

firmware/chibios-portapack/boards/PORTAPACK_APPLICATION/fpga_bridge.h

@@ -17,16 +17,16 @@ extern "C" {
 #ifdef PRALINE
 
 /* FPGA Register Map Address 0x03 (Dual Purpose) */
-#define FPGA_REG_RX_DIGITAL_GAIN   0x03  /* Digital Shift / scaling (RX Mode) */
-#define FPGA_REG_TX_CONTROL        0x03  /* NCO_EN and TX flags (TX Mode) */
+#define FPGA_REG_RX_DIGITAL_GAIN 0x03 /* Digital Shift / scaling (RX Mode) */
+#define FPGA_REG_TX_CONTROL 0x03      /* NCO_EN and TX flags (TX Mode) */
 
 /* FPGA Register Map Address 0x04 (Shared) */
-#define FPGA_REG_RX_DC_BLOCK_WIDTH  0x04  /* Notch filter cutoff (RX Mode) */
-#define FPGA_REG_TX_INTERP           0x04  /* Interpolation ratio (TX Mode) */
+#define FPGA_REG_RX_DC_BLOCK_WIDTH 0x04 /* Notch filter cutoff (RX Mode) */
+#define FPGA_REG_TX_INTERP 0x04         /* Interpolation ratio (TX Mode) */
 
 /* FPGA Register Map Address 0x05 (Shared) */
-#define FPGA_REG_RX_DC_ADAPT_RATE   0x05  /* Settle time/Integration (RX Mode) */
-#define FPGA_REG_TX_PHASE_STEP      0x05  /* NCO frequency step (TX Mode) */
+#define FPGA_REG_RX_DC_ADAPT_RATE 0x05 /* Settle time/Integration (RX Mode) */
+#define FPGA_REG_TX_PHASE_STEP 0x05    /* NCO frequency step (TX Mode) */
 
 /*
  * FPGA Operating Mode
@@ -41,60 +41,60 @@ typedef enum {
  * FPGA Register Addresses
  * Note: Registers 3-5 are dual-purpose (meaning depends on RX/TX mode)
  */
-#define FPGA_REG_CTRL              0x01  /* Control register */
-#define FPGA_REG_DECIM             0x02  /* Decimation (RX) / unused (TX) */
-#define FPGA_REG_SHARED_3          0x03  /* Dual-purpose register */
-#define FPGA_REG_SHARED_4          0x04  /* Dual-purpose register */
-#define FPGA_REG_SHARED_5          0x05  /* Dual-purpose register */
+#define FPGA_REG_CTRL 0x01     /* Control register */
+#define FPGA_REG_DECIM 0x02    /* Decimation (RX) / unused (TX) */
+#define FPGA_REG_SHARED_3 0x03 /* Dual-purpose register */
+#define FPGA_REG_SHARED_4 0x04 /* Dual-purpose register */
+#define FPGA_REG_SHARED_5 0x05 /* Dual-purpose register */
 
 /*
  * Register 1 (CTRL) Bit Definitions
  */
-#define FPGA_CTRL_DC_BLOCK_EN      (1 << 0)  /* DC block enable */
-#define FPGA_CTRL_QUARTER_SHIFT_EN (1 << 1)  /* Quarter-rate shift enable */
-#define FPGA_CTRL_QUARTER_SHIFT_UP (1 << 2)  /* Shift direction: 1=up, 0=down */
-#define FPGA_CTRL_TX_MODE          (1 << 5)  /* TX mode indicator (if applicable) */
-#define FPGA_CTRL_PRBS_EN          (1 << 6)  /* PRBS test mode */
-#define FPGA_CTRL_TRIGGER_EN       (1 << 7)  /* External trigger enable */
+#define FPGA_CTRL_DC_BLOCK_EN (1 << 0)      /* DC block enable */
+#define FPGA_CTRL_QUARTER_SHIFT_EN (1 << 1) /* Quarter-rate shift enable */
+#define FPGA_CTRL_QUARTER_SHIFT_UP (1 << 2) /* Shift direction: 1=up, 0=down */
+#define FPGA_CTRL_TX_MODE (1 << 5)          /* TX mode indicator (if applicable) */
+#define FPGA_CTRL_PRBS_EN (1 << 6)          /* PRBS test mode */
+#define FPGA_CTRL_TRIGGER_EN (1 << 7)       /* External trigger enable */
 
 /*
  * Register 3 Dual-Purpose Definitions
  */
 /* RX Mode: Digital gain/shift */
-#define FPGA_REG3_RX_DIGITAL_GAIN  0x03
-#define FPGA_RX_GAIN_SHIFT_MASK    0x0F  /* Bits [3:0] - shift amount */
+#define FPGA_REG3_RX_DIGITAL_GAIN 0x03
+#define FPGA_RX_GAIN_SHIFT_MASK 0x0F /* Bits [3:0] - shift amount */
 
 /* TX Mode: NCO control */
-#define FPGA_REG3_TX_NCO_CTRL      0x03
-#define FPGA_TX_NCO_EN             (1 << 0)  /* NCO enable */
-#define FPGA_TX_NCO_INVERT         (1 << 1)  /* Invert spectrum */
+#define FPGA_REG3_TX_NCO_CTRL 0x03
+#define FPGA_TX_NCO_EN (1 << 0)     /* NCO enable */
+#define FPGA_TX_NCO_INVERT (1 << 1) /* Invert spectrum */
 
 /*
  * Register 4 Dual-Purpose Definitions
  */
 /* RX Mode: DC block notch width */
-#define FPGA_REG4_RX_DC_WIDTH      0x04
-#define FPGA_RX_DC_WIDTH_MASK      0x07  /* Bits [2:0] */
+#define FPGA_REG4_RX_DC_WIDTH 0x04
+#define FPGA_RX_DC_WIDTH_MASK 0x07 /* Bits [2:0] */
 
 /* TX Mode: Interpolation ratio */
-#define FPGA_REG4_TX_INTERP        0x04
-#define FPGA_TX_INTERP_MASK        0x07  /* Bits [2:0] */
+#define FPGA_REG4_TX_INTERP 0x04
+#define FPGA_TX_INTERP_MASK 0x07 /* Bits [2:0] */
 
 /*
  * Register 5 Dual-Purpose Definitions
  */
 /* RX Mode: DC block adaptation rate */
-#define FPGA_REG5_RX_DC_RATE       0x05
-#define FPGA_RX_DC_RATE_MASK       0xFF  /* Bits [7:0] */
+#define FPGA_REG5_RX_DC_RATE 0x05
+#define FPGA_RX_DC_RATE_MASK 0xFF /* Bits [7:0] */
 
 /* TX Mode: NCO phase step (frequency) */
-#define FPGA_REG5_TX_PHASE_STEP    0x05
-#define FPGA_TX_PHASE_STEP_MASK    0xFF  /* Bits [7:0] */
+#define FPGA_REG5_TX_PHASE_STEP 0x05
+#define FPGA_TX_PHASE_STEP_MASK 0xFF /* Bits [7:0] */
 
 /* Export default values so other methods can use them */
 #define FPGA_RX_DEFAULT_DIGITAL_GAIN 0x00
-#define FPGA_RX_DEFAULT_DC_WIDTH     0x04
-#define FPGA_RX_DEFAULT_ADAPT_RATE   0x08
+#define FPGA_RX_DEFAULT_DC_WIDTH 0x04
+#define FPGA_RX_DEFAULT_ADAPT_RATE 0x08
 
 /*
  * Core Functions
@@ -102,7 +102,7 @@ typedef enum {
 
 /* Initialize the FPGA - loads bitstream from SPIFI flash
  * Returns: 0 on success, non-zero on failure */
-int fpga_bridge_init(void);
+int fpga_bridge_init(uint8_t* mem_base);
 
 /* Set operating mode - MUST be called before using mode-specific functions
  * This ensures registers 3-5 are interpreted correctly */

firmware/common/i2cdev_max17055.cpp

@@ -214,6 +214,14 @@ bool I2cDev_MAX17055::init(uint8_t addr_) {
     return false;
 }
 
+bool I2cDev_MAX17055::reInit() {
+    if (!full_reset_and_init()) {
+        return false;
+    }
+    partialInit();
+    return true;
+}
+
 bool I2cDev_MAX17055::full_reset_and_init() {
     if (!soft_reset()) {
         return false;
@@ -235,12 +243,12 @@ bool I2cDev_MAX17055::soft_reset() {
 }
 
 bool I2cDev_MAX17055::initialize_custom_parameters() {
-    if (!write_register(0xD0, 0x03E8)) return false;                                                                                                  // Unknown register, possibly related to battery profile
-    if (!write_register(0xDB, 0x0000)) return false;                                                                                                  // ModelCfg
-    if (!write_register(0x05, 0x0000)) return false;                                                                                                  // RepCap
-    uint32_t designcap = portapack::device_type == portapack::DEV_PORTARF ? __MAX17055_Design_Capacity_PRF__ * 2 : __MAX17055_Design_Capacity__ * 2;  // the original design has a 2x multiplier here, so i keep it
-    if (!write_register(0x18, designcap)) return false;                                                                                               // DesignCap
-    if (!write_register(0x45, designcap / 32)) return false;                                                                                          // dQAcc  =  DesignCap / 32
+    if (!write_register(0xD0, 0x03E8)) return false;                           // Unknown register, possibly related to battery profile
+    if (!write_register(0xDB, 0x0000)) return false;                           // ModelCfg
+    if (!write_register(0x05, 0x0000)) return false;                           // RepCap
+    uint32_t designcap = portapack::persistent_memory::battery_cap_mah() * 2;  // the original design has a 2x multiplier here, so i keep it
+    if (!write_register(0x18, designcap)) return false;                        // DesignCap
+    if (!write_register(0x45, designcap / 32)) return false;                   // dQAcc  =  DesignCap / 32
 
     if (!write_register(0x1E, 0x03C0)) return false;                                  // IChgTerm
     if (!write_register(0x3A, 0x9661)) return false;                                  // VEmpty

firmware/common/i2cdev_max17055.hpp

@@ -290,7 +290,7 @@ class I2cDev_MAX17055 : public I2cDev {
     uint16_t averageMVoltage(void);
     int32_t instantCurrent(void);
     uint16_t stateOfCharge(void);
-
+    bool reInit();  // call when battery parameters changed from ui. don't call if not needed, or the battery is not changed!!!
    private:
     const RegisterEntry* findEntry(const char* name) const;
 

firmware/common/message.hpp

@@ -158,6 +158,8 @@ class Message {
         TimeSinkConfig = 100,
         EPIRBTXData = 101,
         P25TxConfigure = 102,
+        ToneDetectData = 103,
+        ToneDetectConfig = 104,
         MAX
     };
 
@@ -1861,4 +1863,25 @@ class NotificationDataMessage : public Message {
     uint16_t timeout = 10000;
 };
 
+// Sent M0→M4: a tone detection event (tone ended, or periodic update while active)
+class ToneDetectDataMessage : public Message {
+   public:
+    constexpr ToneDetectDataMessage()
+        : Message{ID::ToneDetectData} {}
+    uint32_t freq_hz{0};      // Dominant audio frequency in Hz (0 = silence)
+    uint32_t duration_ms{0};  // How long the tone lasted in milliseconds
+    bool tone_end{false};     // True = tone just ended; False = tone still active (periodic update)
+};
+
+// Sent M4→M0: configure the tone detector
+class ToneDetectConfigureMessage : public Message {
+   public:
+    constexpr ToneDetectConfigureMessage(uint8_t squelch = 0, uint32_t ctcss_freq_x10 = 0)
+        : Message{ID::ToneDetectConfig},
+          squelch_level{squelch},
+          ctcss_freq_x10{ctcss_freq_x10} {}
+    uint8_t squelch_level{0};
+    uint32_t ctcss_freq_x10{0};  // CTCSS frequency × 10 (e.g. 1000 = 100.0 Hz); 0 = None
+};
+
 #endif /*__MESSAGE_H__*/

firmware/common/portapack_persistent_memory.cpp

@@ -156,8 +156,7 @@ struct misc_config_t {
     bool tx_amp_disabled : 1;
 
     uint8_t tx_gain_max_db;
-    uint8_t PLACEHOLDER_1;
-    uint8_t PLACEHOLDER_2;
+    uint16_t batt_cap_mah;
 };
 static_assert(sizeof(misc_config_t) == sizeof(uint32_t));
 
@@ -445,6 +444,8 @@ void defaults() {
     set_config_tx_disabled(false);
     set_config_tx_amp_disabled(false);
     set_config_tx_gain_max_db(47);
+
+    set_battery_cap_mah(0);
 }
 
 void init() {
@@ -1243,6 +1244,32 @@ int load_persistent_settings_from_file() {
     return true;
 }
 
+bool battery_cap_valid() {
+    return (data->misc_config.batt_cap_mah >= BATT_18650_MIN_MAH && data->misc_config.batt_cap_mah <= BATT_18650_MAX_MAH);
+}
+
+void set_battery_cap_mah(uint16_t mah) {
+    if ((mah < BATT_18650_MIN_MAH || mah > BATT_18650_MAX_MAH) && mah != 0) {
+        // Invalid value, ignore it.
+        return;
+    }
+    if (data->misc_config.batt_cap_mah != mah) {
+        data->misc_config.batt_cap_mah = mah;
+    }
+}
+
+uint32_t battery_cap_mah() {
+    if (battery_cap_valid()) {
+        return data->misc_config.batt_cap_mah;
+    }
+    // we don't know, need to assume.
+    if (portapack::device_type == portapack::DEV_PORTARF) return 3000;
+#ifdef PRALINE
+    return 2000;  // with h4 + pro and h4pro + pro it is ~safe
+#endif
+    return 2500;  // h4 + one
+}
+
 // Pmem size helper
 
 size_t data_size() {

firmware/common/portapack_persistent_memory.hpp

@@ -45,6 +45,10 @@
 #define PMEM_SIZE_BYTES 256  // total amount of pmem space in bytes, including checksum
 #define PMEM_SIZE_WORDS (PMEM_SIZE_BYTES / 4)
 
+// to check battery mins and maxes in pmem, and validity
+#define BATT_18650_MIN_MAH 1000
+#define BATT_18650_MAX_MAH 5000
+
 using namespace modems;
 using namespace serializer;
 using namespace ui;
@@ -387,6 +391,11 @@ uint32_t pmem_data_word(uint32_t index);
 uint32_t pmem_stored_checksum(void);
 uint32_t pmem_calculated_checksum(void);
 
+// battery capacity settings
+void set_battery_cap_mah(uint16_t mah);  // 0 is not known; use assumed default based on device type/build config
+uint32_t battery_cap_mah();
+bool battery_cap_valid();
+
 size_t data_size();
 
 } /* namespace persistent_memory */

firmware/common/portapack_shared_memory.hpp

@@ -55,19 +55,6 @@ struct ToneData {
 
 /* NOTE: These structures must be located in the same location in both M4 and M0 binaries */
 struct SharedMemory {
-#ifdef PRALINE
-    /*
-     * Software RSSI: 8 packed I/Q samples from baseband_thread.
-     *
-     * baseband_thread copies 8 samples spread across buffer (no computation).
-     * Each sample is packed: Q in high 16 bits, I in low 16 bits.
-     * rssi_thread uses __SMUAD on each to compute I²+Q², finds peak.
-     *
-     * 8 samples avoids zero-crossing artifacts from single-sample approach.
-     */
-    volatile uint32_t software_rssi_iq[8]{0};  // 8 packed I/Q samples
-#endif
-
     static constexpr size_t application_queue_k = 11;
     static constexpr size_t app_local_queue_k = 11;
 

firmware/common/spi_image.hpp

@@ -131,6 +131,7 @@ constexpr image_tag_t image_tag_morse{'P', 'M', 'R', 'S'};
 constexpr image_tag_t image_tag_morsetx{'P', 'M', 'R', 'T'};
 constexpr image_tag_t image_tag_rttyrx{'P', 'R', 'T', 'R'};
 constexpr image_tag_t image_tag_rttytx{'P', 'R', 'T', 'T'};
+constexpr image_tag_t image_tag_tonedetect{'P', 'T', 'N', 'E'};
 
 constexpr image_tag_t image_tag_noop{'P', 'N', 'O', 'P'};
 

firmware/tools/external_app_info.py

@@ -24,4 +24,4 @@
 # external app address ranges below must match those in linker file "external.ld"
 maximum_application_size = 32*1024
 external_apps_address_start = 0xADB00000
-external_apps_address_end = 0xAE020000
+external_apps_address_end = 0xAE060000

sdcard/FREQMAN/DETECTOR.TXT

@@ -0,0 +1,21 @@
+# Around 315 MHz (common for older remotes, key fobs in some regions)
+# Window centered on 315 MHz, covers 314.625 - 315.375 MHz
+f=315000000,d=Remotes 315M
+
+# Around 433.92 MHz (very common for remotes, sensors, key fobs globally)
+# Window centered on 433.92 MHz, covers 433.545 - 434.295 MHz
+f=433920000,d=Remotes 433.92M
+
+# EU433 Band (Europe, typically 433.05 MHz to 434.79 MHz)
+# Scanning the approximate range 433.0 MHz to 434.8 MHz with 750kHz steps
+a=433375000,b=434875000,s=750kHz,d=LoRa EU433
+
+# EU868 Band (Europe, typically 863 MHz to 870 MHz, specific channels around 868 MHz)
+# Targeting common LoRaWAN channel groups (approx 867.0 - 868.6 MHz) with 750kHz steps
+a=867375000,b=868875000,s=750kHz,d=LoRa EU868
+
+# US915 Band (North America, typically 902 MHz to 928 MHz, specific channels around 915 MHz)
+a=902000000,b=928250000,s=750kHz,d=LoRa US915
+
+# TETRA Band starts at 380,000,000 Hz, ends at 390,000,000 Hz.
+a=380375000,b=390125000,s=750kHz,d=TETRA UP