refactor: simplify audio volume handling in AudioVolumeField (#3246 )

Airband VOR receiver and trasmitter (#3244 )
* First test * Reorder includes for consistency and fix string dereference in VorCdiIndicator * Add memory section and linker script entry for vor_rx application * Testing VOR TX * Moving VOR TX to SD * Code refactoring to align with guidelines * Add TODO comment to verify radial sign convention in vor_tx_config * Remove unnecessary set_dirty() calls in VorRxView methods * Update Course Deviation Indicator label and adjust UI element positions * Update VorTxView to run prepared image from memory map * Update build condition in nightly release workflow to include workflow_dispatch event * Reverting action changes * Adjust Course Deviation Indicator layout and refine painting logic * Refactor VorRxView UI elements for improved layout and clarity * Add calibration field and update radial calculation logic in VorRxView * Enhance VOR processing: add renormalization to phase oscillator, improve signal handling, and update configuration parameters * Implement radial smoothing and TO/FROM state handling in VorRxView; update VOR processing logic * Setting comments inline * Refactor VorCdiIndicator and VorRxView: change normalize_signed_degrees to use int32_t, update radial smoothing to use fixed point arithmetic to reduce flash usage * Update external app address end to 0xAE0B0000 * Update set_vor_tx_config to include enabled parameter for consistency * Refactor VorRx to omit decim_2 stage and update comments for clarity on VOR processing * Add RSSI, Channel, and Audio fields to VorRxView to mimic existing apps * Refactor VorRxView labels and status messages * Update VorRxView calibration field range to allow full circle input * Completing Ident transmission logic * Fixing TX gain and moving log label * Refactor VOR phase calculations and update radial offset handling for accurate bearing representation * Add low-pass filters to strip 9960 Hz subcarrier from audio output
2026-09-13 18:19:33 +00:00 · 2026-07-04 08:53:28 +02:00 · 2026-07-04 08:49:21 +02:00 · 2026-07-02 16:14:17 +02:00 · 2026-07-02 10:19:53 +02:00 · 2026-07-02 10:05:34 +02:00
72 changed files with 3919 additions and 1107 deletions
@@ -83,3 +83,4 @@ venv/
 # generated bitmap arr file
 # TODO: generate bitmap during build, since we use python during build anyway, lemme know if this is a bad idea @zxkmm
 /firmware/tools/bitmap.hpp
+tmp/*
@@ -513,3 +513,5 @@ add_custom_target(
 	${PROJECT_NAME}
 	DEPENDS ${PROJECT_NAME}.bin
 )
+
+add_dependencies(${PROJECT_NAME} baseband)
@@ -50,6 +50,9 @@ void BoundSetting::parse(std::string_view value) {
        case SettingType::I64:
            parse_int(value, as<int64_t>());
            break;
+        case SettingType::U64:
+            parse_int(value, as<uint64_t>());
+            break;
        case SettingType::I32:
            parse_int(value, as<int32_t>());
            break;
@@ -87,6 +90,9 @@ void BoundSetting::write(File& file) const {
        case SettingType::I64:
            file.write(to_string_dec_int(as<int64_t>(), buffer, length), length);
            break;
+        case SettingType::U64:
+            file.write(to_string_dec_uint(as<uint64_t>(), buffer, length), length);
+            break;
        case SettingType::I32:
            file.write(to_string_dec_int(as<int32_t>(), buffer, length), length);
            break;
@@ -97,9 +103,8 @@ void BoundSetting::write(File& file) const {
            file.write(to_string_dec_uint(as<uint8_t>(), buffer, length), length);
            break;
        case SettingType::String: {
-            const auto& str = as<std::string>();
-            file.write(str.data(), str.length());
-            break;
+            file.write_line(as<std::string>());
+            return;
        }
        case SettingType::Bool:
            file.write(as<bool>() ? "1" : "0", 1);
@@ -48,6 +48,7 @@ class BoundSetting {
    /* The type of bound setting. */
    enum class SettingType : uint8_t {
        I64,
+        U64,
        I32,
        U32,
        U8,
@@ -60,6 +61,9 @@ class BoundSetting {
    BoundSetting(std::string_view name, int64_t* target)
        : name_{name}, target_{target}, type_{SettingType::I64} {}

+    BoundSetting(std::string_view name, uint64_t* target)
+        : name_{name}, target_{target}, type_{SettingType::U64} {}
+
    BoundSetting(std::string_view name, int32_t* target)
        : name_{name}, target_{target}, type_{SettingType::I32} {}

@@ -3176,9 +3176,9 @@ void RFFC5072StatusView::refresh_status() {

        // Blink LED
        /*for (int i = 0; i < 3; i++) {
-            hackrf::one::led_rx.on();
+            hackrf::one::led_rx.setActive();
            chThdSleepMilliseconds(100);
-            hackrf::one::led_rx.off();
+            hackrf::one::led_rx.setInactive();
            chThdSleepMilliseconds(100);
        }*/
    } else {
@@ -168,7 +168,7 @@ bool FlashUtilityView::flash_firmware(std::filesystem::path::string_type path) {
        {0, 0, portapack::display.width(), portapack::display.height()},
        Theme::getInstance()->bg_darkest->background);

-    painter.draw_string({12, 24}, this->nav_.style(), "This will take 15 seconds.");
+    painter.draw_string({12, 24}, this->nav_.style(), "This will take 15-45 sec.");
    painter.draw_string({12, 64}, this->nav_.style(), "Please wait while LED RX");
    painter.draw_string({12, 84}, this->nav_.style(), "is on and TX is flashing.");
    painter.draw_string({12, 124}, this->nav_.style(), "Device will then restart.");
@@ -1174,13 +1174,17 @@ SetBatteryView::SetBatteryView(NavigationView& nav) {
        pmem::set_battery_replaceable(checkbox_battery_replaceable.value());
        battery::BatteryManagement::set_calc_override(checkbox_overridebatt.value());
        i2cdev::I2cDev_MAX17055* dev = (i2cdev::I2cDev_MAX17055*)i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDEVMDL_MAX17055);
+        if (dev) dev->resetChangedFlag();
        if ((((uint32_t)field_battcap.value() != pmem::battery_cap_mah()) || (!pmem::battery_cap_valid())) || (dev && dev->getIsBattChanged())) {
            pmem::set_battery_cap_mah(field_battcap.value());
-            if (dev) dev->resetChangedFlag();
            if (dev && !dev->reInit()) {
                nav.display_modal("Error", "Battery gauge re-init failed");
                return;
            }
+            if (dev) {
+                dev->resetChangedFlag();
+                dev->update();  // resend the new data
+            }
        }
        send_system_refresh();
        nav.pop();
@@ -361,6 +361,16 @@ void set_noaaapt_config() {
    send_message(&message);
 }

+void set_vor_config(bool enabled) {
+    const VorRxConfigureMessage message{enabled};
+    send_message(&message);
+}
+
+void set_vor_tx_config(uint16_t radial_deg, bool ident_enabled, const std::string& ident, bool enabled) {
+    const VorTxConfigureMessage message{radial_deg, ident_enabled, ident.c_str(), enabled};
+    send_message(&message);
+}
+
 void set_flex_config() {
    const FlexConfigureMessage message{};
    send_message(&message);
@@ -113,6 +113,8 @@ 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);
 void set_noaaapt_config();
+void set_vor_config(bool enabled = true);
+void set_vor_tx_config(uint16_t radial_deg, bool ident_enabled = true, const std::string& ident = "", bool enabled = true);
 void set_flex_config();
 void set_bitstream_config(uint32_t deviation, uint8_t mode);                                                   // mode 0 for am, 1 for 2fsk
 void set_rtty_config(uint16_t baud, uint16_t shift, uint8_t* payload = nullptr, uint16_t payload_length = 0);  // baud*100
@@ -25,6 +25,8 @@
 #include "portapack_io.hpp"
 #include "portapack.hpp"

+#include "lpc43xx.inc"
+
 #include "hackrf_hal.hpp"
 using namespace hackrf::one;

@@ -417,7 +419,11 @@ std::string ClockManager::get_freq() {
           to_string_dec_uint((reference.frequency % 1000000) / 100, 4, '0') + " MHz";
 }

-static void portapack_tcxo_enable() {
+void ClockManager::portapack_tcxo_enable() {
+#ifdef PRALINE
+    gpio_control::clkin_ctrl.setActive();
+    set_p1_control(P1_Function::P22_ClkIn);
+#endif
    portapack::io.reference_oscillator(true);

    /* Delay >10ms at 96MHz clock speed for reference oscillator to start. */
@@ -426,7 +432,10 @@ static void portapack_tcxo_enable() {
    while (delay--);
 }

-static void portapack_tcxo_disable() {
+void ClockManager::portapack_tcxo_disable() {
+#ifdef PRALINE
+    gpio_control::clkin_ctrl.setInactive();
+#endif
    portapack::io.reference_oscillator(false);
 }

@@ -434,11 +443,6 @@ static void portapack_tcxo_disable() {
 using namespace hackrf::one;

 void ClockManager::init_clock_generator() {
-    if (hackrf_r9) {
-        gpio_r9_mcu_clk_en.output();
-        gpio_r9_mcu_clk_en.write(1);
-    }
-
    clock_generator.reset();
    clock_generator.set_crystal_internal_load_capacitance(CrystalInternalLoadCapacitance::XTAL_CL_8pF);
    clock_generator.enable_fanout();
@@ -676,7 +680,7 @@ ClockManager::Reference ClockManager::choose_reference() {
    }
 #else
    if (hackrf_r9) {
-        gpio_r9_clkin_en.write(1);
+        gpio_control::r9_clkin_en.setActive();
        volatile uint32_t delay = 240000 + 24000;
        while (delay--);
    }
@@ -691,7 +695,7 @@ ClockManager::Reference ClockManager::choose_reference() {
    }

    if (hackrf_r9) {
-        gpio_r9_clkin_en.write(0);
+        gpio_control::r9_clkin_en.setInactive();
    }
 #endif

@@ -1178,8 +1182,7 @@ void ClockManager::enable_clock_output(bool enable) {
    }
 #else
    if (hackrf_r9) {
-        gpio_r9_clkout_en.output();
-        gpio_r9_clkout_en.write(enable);
+        gpio_control::r9_clkout_en.setState(enable);

        // NOTE: RETURNING HERE IF HACKRF_R9 TO PREVENT CLK2 FROM BEING DISABLED OR FREQ MODIFIED SINCE CLK2 ON R9 IS
        // USED FOR BOTH CLKOUT AND FOR THE MCU_CLOCK (== GP_CLKIN) WHICH OTHER LP43XX CLOCKS CURRENTLY RELY ON.
@@ -1211,47 +1214,47 @@ void ClockManager::enable_clock_output(bool enable) {
 #ifdef PRALINE

 void ClockManager::set_p1_control(P1_Function func) {
-    // Truth table based on P1_Control.csv (L=clear, H=set)
+    // Truth table based on P1_Control.csv (L=setInactive, H=setActive)
    switch (func) {
        case P1_Function::TriggerIn:
-            gpio_control::p1_ctrl2.clear();
-            gpio_control::p1_ctrl1.clear();
-            gpio_control::p1_ctrl0.clear();
+            gpio_control::p1_ctrl2.setInactive();
+            gpio_control::p1_ctrl1.setInactive();
+            gpio_control::p1_ctrl0.setInactive();
            break;
        case P1_Function::AuxClk1:
-            gpio_control::p1_ctrl2.clear();
-            gpio_control::p1_ctrl1.clear();
-            gpio_control::p1_ctrl0.set();
+            gpio_control::p1_ctrl2.setInactive();
+            gpio_control::p1_ctrl1.setInactive();
+            gpio_control::p1_ctrl0.setActive();
            break;
        case P1_Function::ClkIn:
-            gpio_control::p1_ctrl2.clear();
-            gpio_control::p1_ctrl1.set();
-            gpio_control::p1_ctrl0.clear();
+            gpio_control::p1_ctrl2.setInactive();
+            gpio_control::p1_ctrl1.setActive();
+            gpio_control::p1_ctrl0.setInactive();
            break;
        case P1_Function::TriggerOut:
-            gpio_control::p1_ctrl2.clear();
-            gpio_control::p1_ctrl1.set();
-            gpio_control::p1_ctrl0.set();
+            gpio_control::p1_ctrl2.setInactive();
+            gpio_control::p1_ctrl1.setActive();
+            gpio_control::p1_ctrl0.setActive();
            break;
        case P1_Function::P22_ClkIn:
-            gpio_control::p1_ctrl2.set();
-            gpio_control::p1_ctrl1.clear();
-            gpio_control::p1_ctrl0.clear();
+            gpio_control::p1_ctrl2.setActive();
+            gpio_control::p1_ctrl1.setInactive();
+            gpio_control::p1_ctrl0.setInactive();
            break;
        case P1_Function::P2_5:
-            gpio_control::p1_ctrl2.set();
-            gpio_control::p1_ctrl1.clear();
-            gpio_control::p1_ctrl0.set();
+            gpio_control::p1_ctrl2.setActive();
+            gpio_control::p1_ctrl1.setInactive();
+            gpio_control::p1_ctrl0.setActive();
            break;
        case P1_Function::NotConnected:
-            gpio_control::p1_ctrl2.set();
-            gpio_control::p1_ctrl1.set();
-            gpio_control::p1_ctrl0.clear();
+            gpio_control::p1_ctrl2.setActive();
+            gpio_control::p1_ctrl1.setActive();
+            gpio_control::p1_ctrl0.setInactive();
            break;
        case P1_Function::AuxClk2:
-            gpio_control::p1_ctrl2.set();
-            gpio_control::p1_ctrl1.set();
-            gpio_control::p1_ctrl0.set();
+            gpio_control::p1_ctrl2.setActive();
+            gpio_control::p1_ctrl1.setActive();
+            gpio_control::p1_ctrl0.setActive();
            break;
    }
 }
@@ -1259,20 +1262,20 @@ void ClockManager::set_p1_control(P1_Function func) {
 void ClockManager::set_p2_control(P2_Function func) {
    // Ensure all P2 control pins are configured as outputs

-    // Truth table based on P2_Control.csv (L=clear, H=set)
+    // Truth table based on P2_Control.csv (L=setInactive, H=setActive)
    switch (func) {
        case P2_Function::Clk3:
-            // CTRL0 is 'X' (don't care) according to CSV, we default it to Low (clear)
-            gpio_control::p2_ctrl1.clear();
-            gpio_control::p2_ctrl0.clear();
+            // CTRL0 is 'X' (don't care) according to CSV, we default it to Low (setInactive)
+            gpio_control::p2_ctrl1.setInactive();
+            gpio_control::p2_ctrl0.setInactive();
            break;
        case P2_Function::TriggerIn:
-            gpio_control::p2_ctrl1.set();
-            gpio_control::p2_ctrl0.clear();
+            gpio_control::p2_ctrl1.setActive();
+            gpio_control::p2_ctrl0.setInactive();
            break;
        case P2_Function::TriggerOut:
-            gpio_control::p2_ctrl1.set();
-            gpio_control::p2_ctrl0.set();
+            gpio_control::p2_ctrl1.setActive();
+            gpio_control::p2_ctrl0.setActive();
            break;
    }
 }
@@ -116,6 +116,9 @@ class ClockManager {

    void enable_clock_output(bool enable);

+    void portapack_tcxo_enable();
+    void portapack_tcxo_disable();
+
   private:
    I2C& i2c0;
    si5351::Si5351& clock_generator;
@@ -24,6 +24,11 @@
 #include "hackrf_gpio.hpp"
 #include "portapack_hal.hpp"

+#include "board.h"
+
+#include "gpio.hpp"
+using namespace gpio_control;
+
 void config_mode_blink_until_dfu();

 void config_mode_set() {
@@ -103,16 +108,16 @@ void config_mode_run() {

        auto tx_value = ((tx_blink_pattern >> ((counter >> 0) & 31)) & 0x1) == 0x1;
        if (tx_value) {
-            hackrf::one::led_tx.on();
+            led_tx.setActive();
        } else {
-            hackrf::one::led_tx.off();
+            led_tx.setInactive();
        }

        auto rx_value = ((rx_blink_pattern >> ((counter >> 0) & 31)) & 0x1) == 0x1;
        if (rx_value) {
-            hackrf::one::led_rx.on();
+            led_rx.setActive();
        } else {
-            hackrf::one::led_rx.off();
+            led_rx.setInactive();
        }

        chThdSleepMilliseconds(100);
@@ -122,14 +127,14 @@ void config_mode_run() {

 void config_mode_blink_until_dfu() {
    while (true) {
-        hackrf::one::led_tx.on();
-        hackrf::one::led_rx.on();
-        hackrf::one::led_usb.on();
+        led_tx.setActive();
+        led_rx.setActive();
+        led_usb.setActive();
        chThdSleepMilliseconds(10);

-        hackrf::one::led_tx.off();
-        hackrf::one::led_rx.off();
-        hackrf::one::led_usb.off();
+        led_tx.setInactive();
+        led_rx.setInactive();
+        led_usb.setInactive();
        chThdSleepMilliseconds(115);

        auto dfu_btn = portapack::gpio_dfu.read();
@@ -33,6 +33,9 @@
 #include "irq_controls.hpp"
 #include "file_path.hpp"

+#include "gpio.hpp"
+using namespace gpio_control;
+
 using namespace ui;

 #define DEBUG_LOG_FILE "debug_log.txt"
@@ -134,9 +137,9 @@ void draw_line(int32_t y_offset, const char* label, regarm_t value) {
 }

 void runtime_error(uint8_t source) {
-    LED led = (source == CORTEX_M0) ? hackrf::one::led_rx : hackrf::one::led_tx;
+    const auto& led = (source == CORTEX_M0) ? led_rx : led_tx;

-    led.off();
+    led.setInactive();

    // wait for DFU button release if pressed, so we don't immediately jump into stack dump
    while (swizzled_switches() & (1 << (int)Switch::Dfu));
@@ -37,8 +37,8 @@

 #include "ch.h"

-#include "hackrf_gpio.hpp"
-using namespace hackrf::one;
+#include "gpio.hpp"
+using namespace gpio_control;

 #include "irq_rtc.hpp"

@@ -56,8 +56,6 @@ using namespace hackrf::one;

 #include "ui_navigation.hpp"

-#include "gpio.hpp"
-
 static int delayed_error = 0;

 extern "C" {
@@ -229,8 +227,8 @@ void EventDispatcher::charge_deep_sleep(const bool sleep) {

        LPC_ADC0->CR &= ~(1 << 21);
        LPC_ADC1->CR &= ~(1 << 21);
-        led_rx.off();
-        led_usb.off();
+        led_rx.setInactive();
+        led_usb.setInactive();

        rtc_wakeup_init();
        NVIC_EnableIRQ(I2C0_OR_I2C1_IRQn);
@@ -247,21 +245,21 @@ void EventDispatcher::charge_deep_sleep(const bool sleep) {

                if (is_full) {
                    // Case 1: Battery full (All LEDs off)
-                    led_rx.off();
-                    led_tx.off();
+                    led_rx.setInactive();
+                    led_tx.setInactive();
                } else if ((voltage < 4150 && current < 10) || valid_mask == 0) {
                    // Case 2: Not full but low current draw (<10mA) -> Charging error
-                    led_tx.on();  // LED indicates error/idle
-                    led_rx.off();
+                    led_tx.setActive();  // LED indicates error/idle
+                    led_rx.setInactive();
                } else {
                    // Case 3: Actively charging
-                    led_rx.on();  // LED indicates charging
-                    led_tx.off();
+                    led_rx.setActive();  // LED indicates charging
+                    led_tx.setInactive();
                }
            } else {
                // Case 4: Battery IC not detected -> Error or H2 or older, so don't show that as an error.
-                led_tx.on();
-                led_rx.on();
+                led_tx.setActive();
+                led_rx.setActive();
            }

            // Shut down I2C and power down the APB bus for sleep
@@ -294,11 +294,11 @@ void BLESpamView::createWindowsPacket() {
    std::copy(res.begin(), res.end(), advertisementData);
 }

-void BLESpamView::createNameSpamPacket() {
-    const char* names[] = {"PortaHack", "PwnBt", "iSpam", "GenericFoodVagon", "SignalSnoop", "ByteBandit", "RadioRogue", "RadioRebel", "ByteBlast"};
-
-    const char* name = names[rand() % 9];  //"PortaHack";
+// Builds a "Complete Local Name" HID advertisement for the given name.
+// Shared by NameSpam (built-in list) and Custom (SD card list) modes.
+void BLESpamView::buildNamePacket(const char* name) {
    uint8_t name_len = strlen(name);
+    if (name_len > 19) name_len = 19;  // clamp so the hex string fits advertisementData[63]

    uint8_t size = 12 + name_len;
    uint8_t i = 0;
@@ -327,6 +327,65 @@ void BLESpamView::createNameSpamPacket() {
    std::copy(res.begin(), res.end(), advertisementData);
 }

+void BLESpamView::createNameSpamPacket() {
+    const char* names[] = {"PortaHack", "PwnBt", "iSpam", "GenericFoodVagon", "SignalSnoop", "ByteBandit", "RadioRogue", "RadioRebel", "ByteBlast"};
+    buildNamePacket(names[rand() % 9]);
+}
+
+// Opens /BLESPAM/NAME.txt once and keeps it open for the session.
+void BLESpamView::open_custom_file() {
+    custom_loaded_ = true;  // attempt only once
+    auto open_error = custom_file_.open(u"/BLESPAM/NAME.txt");
+    custom_file_valid_ = !open_error;  // false -> caller falls back to NameSpam
+}
+
+// Reads the next line into custom_name_ (clamped to 19 chars), advancing the
+// file position. At end of file it seeks back to the start to cycle. Returns
+// false if the file holds no usable name. Only one line is ever held in RAM.
+bool BLESpamView::read_next_custom_name() {
+    if (!custom_file_valid_) return false;
+
+    custom_name_.clear();
+    bool wrapped = false;
+    char c;
+
+    while (true) {
+        auto read_result = custom_file_.read(&c, 1);
+        if (read_result.is_error()) return false;
+
+        if (read_result.value() == 0) {
+            // end of file
+            if (!custom_name_.empty()) break;
+            // use the final line
+            if (wrapped) return false;
+            // no usable name in file
+            if (custom_file_.seek(0).is_error()) return false;
+            // loop back to the first line
+            wrapped = true;
+            continue;
+        }
+
+        if (c == '\n' || c == '\r') {
+            if (!custom_name_.empty()) break;  // got a complete line
+            continue;                          // skip blank lines / CRLF pairs
+        }
+
+        if (custom_name_.size() < 19)  // clamp; keep scanning rest of long line
+            custom_name_.push_back(c);
+    }
+    return true;
+}
+
+void BLESpamView::createCustomPacket() {
+    if (!custom_loaded_) open_custom_file();
+
+    if (!read_next_custom_name()) {  // no file / unreadable / empty -> fall back
+        createNameSpamPacket();
+        return;
+    }
+    buildNamePacket(custom_name_.c_str());
+}
+
 char BLESpamView::randomNameChar() {
    int randVal = rand() % 62;  // 26 uppercase + 26 lowercase + 10 digits
    if (randVal < 26) {
@@ -622,6 +681,9 @@ void BLESpamView::createPacket(ATK_TYPE attackType) {
        case ATK_NAMERANDOM:
            createNameRandomPacket();
            break;
+        case ATK_CUSTOM:
+            createCustomPacket();
+            break;
        case ATK_ALL_SAFE:
            createAnyPacket(true);
            break;
@@ -39,6 +39,7 @@
 #include "radio_state.hpp"
 #include "log_file.hpp"
 #include "utility.hpp"
+#include "file.hpp"

 using namespace ui;

@@ -52,6 +53,7 @@ enum ATK_TYPE {
    ATK_SAMSUNG,
    ATK_NAMESPAM,
    ATK_NAMERANDOM,
+    ATK_CUSTOM,
    ATK_ALL_SAFE,
    ATK_ALL
 };
@@ -131,8 +133,9 @@ class BLESpamView : public View {
         {"Samsung", 4},
         {"NameSpam", 5},
         {"NameRandom", 6},
-         {"All-Safe", 7},
-         {"All", 8}}};
+         {"NameCustom", 7},
+         {"All-Safe", 8},
+         {"All", 9}}};

    bool is_running{false};

@@ -144,6 +147,11 @@ class BLESpamView : public View {
    bool randomMac{true};
    bool randomDev{true};

+    File custom_file_{};             // kept open while in Custom mode
+    std::string custom_name_{};      // holds only the current name (clamped)
+    bool custom_loaded_{false};      // true once an open attempt has been made
+    bool custom_file_valid_{false};  // true if /BLESPAM/NAME.txt opened successfully
+
    uint8_t channel_number = 37;
    char mac[13] = "010203040407";
    char advertisementData[63] = {"03032CFE06162CFED5A59E020AB4\0"};
@@ -156,7 +164,11 @@ class BLESpamView : public View {
    void createIosPacket(bool crash);
    void createSamsungPacket();
    void createWindowsPacket();
+    void buildNamePacket(const char* name);  // shared name advertisement builder (NameSpam / Custom)
    void createNameSpamPacket();
+    void createCustomPacket();
+    void open_custom_file();       // open /BLESPAM/NAME.txt once (one name per line)
+    bool read_next_custom_name();  // read next line into custom_name_, looping at EOF
    void createNameRandomPacket();
    void createAnyPacket(bool safe);
    void createPacket(ATK_TYPE attackType);
@@ -133,6 +133,14 @@ set(EXTCPPSRC
 	external/noaaapt_rx/main.cpp
 	external/noaaapt_rx/ui_noaaapt_rx.cpp

+	#vor_rx
+	external/vor_rx/main.cpp
+	external/vor_rx/ui_vor_rx.cpp
+
+	#vor_tx
+	external/vor_tx/main.cpp
+	external/vor_tx/ui_vor_tx.cpp
+
 	#shoppingcart_lock 272 bytes
 	external/shoppingcart_lock/main.cpp
 	external/shoppingcart_lock/shoppingcart_lock.cpp
@@ -327,7 +335,7 @@ set(EXTCPPSRC
 	external/rtty_tx/ui_rtty_tx.cpp
 	external/rtty_tx/baudot.cpp

-    #pocsag_tx
+	#pocsag_tx
 	external/pocsag_tx/main.cpp
 	external/pocsag_tx/ui_pocsag_tx.cpp

@@ -362,6 +370,11 @@ set(EXTCPPSRC
 	#hard_reset
 	external/hard_reset/main.cpp
 	external/hard_reset/ui_hard_reset.cpp
+
+	#secplustx
+	external/secplustx/main.cpp
+	external/secplustx/ui_secplustx.cpp
+	external/secplustx/secplustx.cpp
 )

 set(EXTAPPLIST
@@ -396,6 +409,8 @@ set(EXTAPPLIST
 	acars_rx
 	wefax_rx
 	noaaapt_rx
+	vor_rx
+	vor_tx
 	shoppingcart_lock
 	ookbrute
 	ook_editor
@@ -451,6 +466,7 @@ set(EXTAPPLIST
 	two_tone_pager
 	two_tone_rx
 	hard_reset
+	secplustx
 )

 # sdusb has type conflicts with PRALINE (HackRF Pro) - add only for non-PRALINE builds
@@ -110,6 +110,9 @@ MEMORY
    ram_external_app_two_tone_rx           (rwx) : org = 0xAE050000, len = 32k
    ram_external_app_flex_tx               (rwx) : org = 0xAE060000, len = 32k
    ram_external_app_hard_reset            (rwx) : org = 0xAE070000, len = 32k
+    ram_external_app_secplustx             (rwx) : org = 0xAE080000, len = 32k
+    ram_external_app_vor_rx                (rwx) : org = 0xAE090000, len = 32k
+    ram_external_app_vor_tx                (rwx) : org = 0xAE0A0000, len = 32k
 }

 SECTIONS
@@ -390,6 +393,18 @@ SECTIONS
        *(*ui*external_app*noaaapt_rx*);
    } > ram_external_app_noaaapt_rx

+    .external_app_vor_rx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_vor_rx.application_information));
+        *(*ui*external_app*vor_rx*);
+    } > ram_external_app_vor_rx
+
+    .external_app_vor_tx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_vor_tx.application_information));
+        *(*ui*external_app*vor_tx*);
+    } > ram_external_app_vor_tx
+
    .external_app_breakout : ALIGN(4) SUBALIGN(4)
    {
        KEEP(*(.external_app.app_breakout.application_information));
@@ -635,4 +650,10 @@ SECTIONS
        KEEP(*(.external_app.app_hard_reset.application_information));
        *(*ui*external_app*hard_reset*);
    } > ram_external_app_hard_reset
+
+    .external_app_secplustx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_secplustx.application_information));
+        *(*ui*external_app*secplustx*);
+    } > ram_external_app_secplustx
 }
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2026 Synray
+ *
+ * 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_navigation.hpp"
+#include "ui_secplustx.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::ui_secplustx {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<SecplusTXView>();
+}
+}  // namespace ui::external_app::ui_secplustx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_secplustx.application_information"), used)) application_information_t _application_information_secplustx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::ui_secplustx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+    /*.app_name = */ "Security+",
+    /*.bitmap_data = */ {
+        0b00100000,
+        0b00000000,
+        0b00100000,
+        0b00100000,
+        0b00100000,
+        0b01110000,
+        0b00100000,
+        0b00100000,
+        0b11100000,
+        0b00000111,
+        0b11110000,
+        0b00001111,
+        0b00110000,
+        0b00001100,
+        0b00110000,
+        0b00001100,
+        0b11110000,
+        0b00001111,
+        0b11110000,
+        0b00001111,
+        0b01110000,
+        0b00001101,
+        0b10110000,
+        0b00001110,
+        0b01110000,
+        0b00001101,
+        0b10110000,
+        0b00001110,
+        0b11110000,
+        0b00001111,
+        0b11100000,
+        0b00000111,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+    /*.m4_app_tag = portapack::spi_flash::image_tag_ook */ {'P', 'O', 'O', 'K'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2022 Clayton Smith (argilo@gmail.com)
+ *
+ * This file is part of secplus.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+#include "secplustx.hpp"
+
+namespace ui::external_app::ui_secplustx {
+
+static void v2_calc_parity(const uint64_t fixed, uint32_t* data) {
+    uint32_t parity = (fixed >> 32) & 0xf;
+    int8_t offset;
+
+    *data &= 0xffff0fff;
+    for (offset = 0; offset < 32; offset += 4) {
+        parity ^= ((*data >> offset) & 0xf);
+    }
+    *data |= (parity << 12);
+}
+
+static void encode_v2_rolling(const uint32_t rolling,
+                              uint32_t* rolling_halves) {
+    uint32_t rolling_reversed = 0;
+    int8_t i, half;
+
+    for (i = 0; i < 28; i++) {
+        rolling_reversed |= ((rolling >> i) & 1) << (28 - i - 1);
+    }
+
+    rolling_halves[0] = 0;
+    rolling_halves[1] = 0;
+
+    for (half = 0; half < 2; half++) {
+        for (i = 0; i < 8; i += 2) {
+            rolling_halves[half] |= rolling_reversed % 3 << i;
+            rolling_reversed /= 3;
+        }
+    }
+
+    for (half = 0; half < 2; half++) {
+        for (i = 10; i < 18; i += 2) {
+            rolling_halves[half] |= rolling_reversed % 3 << i;
+            rolling_reversed /= 3;
+        }
+    }
+
+    rolling_halves[0] |= (rolling_reversed % 3) << 8;
+    rolling_reversed /= 3;
+
+    rolling_halves[1] |= (rolling_reversed % 3) << 8;
+}
+
+static const int8_t ORDER[16] = {9, 33, 6, -1, 24, 18, 36, -1,
+                                 24, 36, 6, -1, -1, -1, -1, -1};
+static const int8_t INVERT[16] = {6, 2, 1, -1, 7, 5, 3, -1,
+                                  4, 0, 5, -1, -1, -1, -1, -1};
+
+static void v2_scramble(const uint32_t* parts, const uint8_t frame_type, uint8_t* packet_half) {
+    const int8_t order = ORDER[packet_half[0] >> 4];
+    const int8_t invert = INVERT[packet_half[0] & 0xf];
+    int8_t i;
+    uint8_t out_offset = 10;
+    int8_t end;
+    uint32_t parts_permuted[3];
+
+    end = (frame_type == 0 ? 5 : 8);
+    for (i = 1; i < end; i++) {
+        packet_half[i] = 0;
+    }
+
+    parts_permuted[0] =
+        (invert & 4) ? ~parts[(order >> 4) & 3] : parts[(order >> 4) & 3];
+    parts_permuted[1] =
+        (invert & 2) ? ~parts[(order >> 2) & 3] : parts[(order >> 2) & 3];
+    parts_permuted[2] = (invert & 1) ? ~parts[order & 3] : parts[order & 3];
+
+    end = (frame_type == 0 ? 8 : 0);
+    for (i = 18 - 1; i >= end; i--) {
+        packet_half[out_offset >> 3] |= ((parts_permuted[0] >> i) & 1)
+                                        << (7 - (out_offset % 8));
+        out_offset++;
+        packet_half[out_offset >> 3] |= ((parts_permuted[1] >> i) & 1)
+                                        << (7 - (out_offset % 8));
+        out_offset++;
+        packet_half[out_offset >> 3] |= ((parts_permuted[2] >> i) & 1)
+                                        << (7 - (out_offset % 8));
+        out_offset++;
+    }
+}
+
+static void encode_v2_half_parts(const uint32_t rolling, const uint32_t fixed, const uint16_t data, const uint8_t frame_type, uint8_t* packet_half) {
+    uint32_t parts[3];
+
+    parts[0] = ((fixed >> 10) << 8) | (data >> 8);
+    parts[1] = ((fixed & 0x3ff) << 8) | (data & 0xff);
+    parts[2] = rolling;
+
+    packet_half[0] = (uint8_t)rolling;
+
+    v2_scramble(parts, frame_type, packet_half);
+}
+
+static int8_t v2_check_limits(const uint32_t rolling, const uint64_t fixed) {
+    if ((rolling >> 28) != 0) {
+        return -1;
+    }
+
+    if ((fixed >> 40) != 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static void encode_v2_half(const uint32_t rolling, const uint32_t fixed, const uint16_t data, const uint8_t frame_type, uint8_t* packet_half) {
+    encode_v2_half_parts(rolling, fixed, data, frame_type, packet_half);
+
+    /* shift indicator two bits to the right */
+    packet_half[1] |= (packet_half[0] & 0x3) << 6;
+    packet_half[0] >>= 2;
+
+    /* set frame type */
+    packet_half[0] |= (frame_type << 6);
+}
+
+int8_t encode_v2(const uint32_t rolling, const uint64_t fixed, uint32_t data, const uint8_t frame_type, uint8_t* packet1, uint8_t* packet2) {
+    int8_t err = 0;
+    uint32_t rolling_halves[2];
+
+    err = v2_check_limits(rolling, fixed);
+    if (err < 0) {
+        return err;
+    }
+
+    encode_v2_rolling(rolling, rolling_halves);
+    v2_calc_parity(fixed, &data);
+
+    encode_v2_half(rolling_halves[0], fixed >> 20, data >> 16, frame_type,
+                   packet1);
+    encode_v2_half(rolling_halves[1], fixed & 0xfffff, data & 0xffff, frame_type,
+                   packet2);
+
+    return 0;
+}
+
+};  // namespace ui::external_app::ui_secplustx
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2022 Clayton Smith (argilo@gmail.com)
+ *
+ * This file is part of secplus.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+#ifndef __SECPLUSTX__
+#define __SECPLUSTX__
+
+#include <cstdint>
+
+namespace ui::external_app::ui_secplustx {
+int8_t encode_v2(const uint32_t rolling, const uint64_t fixed, uint32_t data, const uint8_t frame_type, uint8_t* packet1, uint8_t* packet2);
+};
+
+#endif
@@ -0,0 +1,227 @@
+#include "ui_secplustx.hpp"
+
+#include <string_view>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "secplustx.hpp"
+#include "ui_fileman.hpp"
+#include "file_reader.hpp"
+#include "baseband_api.hpp"
+#include "string_format.hpp"
+#include "optional.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+namespace fs = std::filesystem;
+
+namespace ui::external_app::ui_secplustx {
+
+static constexpr uint8_t secplus_repeat_count = 3;
+static constexpr float secplus_sample_rate = OOK_SAMPLERATE / 4000.0f;
+
+Optional<SecplusData> SecplusTXView::read_secplus_file(const fs::path& file_path) {
+    File file{};
+    if (auto error = file.open(file_path)) return {};
+
+    std::string raw = *FileLineReader{file}.begin();
+    std::vector chunks = split_string(raw, ';');
+    if (chunks.empty()) return {};
+
+    SecplusData data{};
+    data.version = static_cast<SecplusVersion>(std::strtoul(chunks[0].data(), NULL, 10));
+    switch (data.version) {
+        case SecplusVersion::V1:
+            return {};  // unimplemented
+        case SecplusVersion::V2: {
+            if (chunks.size() != 6) return {};
+            data.name = std::string{chunks[1]};
+            if (data.name.empty()) data.name = "Remote";
+            data.has_data = std::strtoul(chunks[2].data(), NULL, 10);
+            data.fixed_code = std::strtoull(chunks[3].data(), NULL, 16);
+            data.rolling_code = std::strtoul(chunks[4].data(), NULL, 16);
+            data.data = std::strtoul(chunks[5].data(), NULL, 16);
+            return data;
+        }
+        default:
+            return {};
+    }
+}
+
+bool SecplusTXView::write_secplus_file(const fs::path& file_path, const SecplusData& data) {
+    ensure_directory(secplus_dir);
+    File file{};
+    if (auto error = file.create(file_path)) {
+        return false;
+    }
+
+    switch (data.version) {
+        case SecplusVersion::V1:
+            return false;  // unimplemented
+        case SecplusVersion::V2: {
+            std::string formatted = to_string_dec_uint(static_cast<uint8_t>(data.version));
+            formatted += ';';
+            formatted += data.name;
+            formatted += ';';
+            formatted += to_string_dec_uint(data.has_data);
+            formatted += ';';
+            formatted += to_string_hex(data.fixed_code);
+            formatted += ';';
+            formatted += to_string_hex(data.rolling_code);
+            formatted += ';';
+            formatted += to_string_hex(data.data);
+            file.write_line(formatted);
+            file.close();
+            return true;
+        }
+        default:
+            return false;
+    }
+}
+
+SecplusTXView::SecplusTXView(NavigationView& nav)
+    : nav_{nav} {
+    if (!fs::file_exists(file_path)) write_secplus_file(file_path, data);
+    baseband::run_image(portapack::spi_flash::image_tag_ook);
+
+    add_children({&button_open,
+                  &button_save,
+                  &field_name,
+                  &labels,
+                  &field_fixed,
+                  &field_rolling,
+                  &has_data,
+                  &field_data,
+                  &learn_mode,
+                  &autosave,
+                  &progressbar,
+                  &tx_view});
+
+    button_open.on_select = [this](const Button&) {
+        ensure_directory(secplus_dir);
+        auto open_view = nav_.push<FileLoadView>(".SECPLUS");
+        open_view->push_dir(secplus_dir);
+        open_view->on_changed = [this](fs::path path) { file_path = path.string(); };
+        nav_.set_on_pop([this]() { reload_data(); });
+    };
+    button_save.on_select = [this](const Button&) { write_secplus_file(file_path, data); };
+
+    field_name.on_select = [this, &nav](TextField&) {
+        buffer = data.name;
+        text_prompt(nav_, buffer, field_name.parent_rect().width() / UI_POS_DEFAULT_WIDTH, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& new_name) {
+            data.name = new_name;
+            field_name.set_text(new_name);
+            save_data();
+        });
+    };
+    field_fixed.on_change = [this](SymField& field) { data.fixed_code = field.to_integer(); };
+    field_rolling.on_change = [this](SymField& field) { data.rolling_code = field.to_integer(); };
+    field_data.on_change = [this](SymField& field) { data.data = field.to_integer(); };
+    has_data.on_select = [this](Checkbox& checkbox, bool value) {
+        data.has_data = value;
+        // fade if inactive, otherwise use default style
+        const Style* new_style = value ? &style() : Theme::getInstance()->fg_medium;
+        checkbox.set_style(new_style);
+        field_data.set_style(new_style);
+        field_data.set_focusable(value);
+    };
+    tx_view.on_edit_frequency = [this]() {
+        auto new_view = nav_.push<FrequencyKeypadView>(transmitter_model.target_frequency());
+        new_view->on_changed = [](rf::Frequency f) {
+            transmitter_model.set_target_frequency(f);
+        };
+    };
+
+    tx_view.on_start = [this]() { start_tx(); };
+    tx_view.on_stop = [this]() {
+        baseband::kill_ook();
+        stop_tx();
+    };
+
+    autosave.set_value(true);
+    reload_data();
+}
+
+void SecplusTXView::save_data() {
+    if (autosave.value()) write_secplus_file(file_path, data);
+}
+
+void SecplusTXView::reload_data() {
+    if (auto result = read_secplus_file(file_path)) data = std::move(*result);
+    // always update data, use default values if read failed
+    field_name.set_text(data.name);
+    has_data.set_value(data.has_data);
+    field_rolling.set_value(data.rolling_code);
+    field_fixed.set_value(data.fixed_code);
+    field_data.set_value(data.data);
+}
+
+void SecplusTXView::start_tx() {
+    uint8_t packet1[8]{};
+    uint8_t packet2[8]{};
+    size_t bitstream_length = 0;
+
+    constexpr uint8_t packet1_indicator = 0b00;
+    constexpr uint8_t packet2_indicator = 0b01;
+    auto encode_packet = [&bitstream_length](uint8_t indicator, auto& packet, bool has_data) {
+        constexpr uint32_t preamble = 0b0000000000000000'1111;
+        constexpr uint32_t blank_size = 24;
+        auto manchester_encode = [&bitstream_length](auto& x, uint32_t size) {
+            for (uint32_t i = 0; i < size; ++i) {
+                bool bit = (x >> (size - 1 - i)) & 1;
+                encoders::bitstream_append(bitstream_length, 2, bit ? 0b01 : 0b10);
+            }
+        };
+        manchester_encode(preamble, 20);
+        manchester_encode(indicator, 2);
+        for (uint8_t byte = 0; byte < (has_data ? 8 : 5); ++byte) manchester_encode(packet[byte], 8);
+        encoders::bitstream_append(bitstream_length, blank_size, 0);
+    };
+
+    if (encode_v2(data.rolling_code, data.fixed_code, data.data, data.has_data, packet1, packet2) < 0) {
+        nav_.display_modal("Error", "Invalid rolling/fixed code");
+        return;
+    }
+    encode_packet(packet1_indicator, packet1, has_data.value());
+    encode_packet(packet2_indicator, packet2, has_data.value());
+
+    if (!learn_mode.value()) {
+        field_rolling.set_value(++data.rolling_code);
+        field_rolling.set_dirty();
+    }
+
+    progressbar.set_max(secplus_repeat_count);
+    progressbar.set_value(1);
+
+    tx_view.set_transmitting(true);
+    transmitter_model.enable();
+    baseband::set_ook_data(
+        bitstream_length,
+        secplus_sample_rate,
+        secplus_repeat_count,
+        0);
+}
+
+void SecplusTXView::stop_tx() {
+    transmitter_model.disable();
+    progressbar.set_value(0);
+    tx_view.set_transmitting(false);
+}
+
+void SecplusTXView::on_tx_progress(uint32_t progress, bool done) {
+    progressbar.set_value(progress + 1);
+    if (done) {
+        stop_tx();
+        save_data();
+    }
+}
+
+SecplusTXView::~SecplusTXView() {
+    transmitter_model.disable();
+    baseband::shutdown();
+    save_data();
+}
+
+}  // namespace ui::external_app::ui_secplustx
@@ -0,0 +1,96 @@
+#ifndef __UI_SECPLUSTX__
+#define __UI_SECPLUSTX__
+
+#include <cstdint>
+#include <string>
+
+#include "ui.hpp"
+#include "file.hpp"
+#include "ui_transmitter.hpp"
+#include "transmitter_model.hpp"
+#include "file_path.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "encoders.hpp"
+#include "string_format.hpp"
+
+namespace ui::external_app::ui_secplustx {
+
+enum class SecplusVersion : uint8_t {
+    V1,
+    V2,
+};
+
+struct SecplusData {
+    SecplusVersion version;
+    std::string name;
+    bool has_data;
+    uint64_t fixed_code;
+    uint32_t rolling_code;
+    uint32_t data;
+};
+
+class SecplusTXView : public View {
+   public:
+    void focus() override { button_open.focus(); }
+    SecplusTXView(NavigationView& nav);
+    ~SecplusTXView();
+
+    std::string title() const override {
+        return "Security+";
+    }
+
+   private:
+    std::string file_path = (secplus_dir / "DEFAULT.SECPLUS").string();
+    SecplusData data{SecplusVersion::V2, "Remote", false, 0, 0, 0};
+    std::string buffer{};
+
+    NavigationView& nav_;
+    TxRadioState radio_state_{
+        315000000,
+        1750000,
+        OOK_SAMPLERATE};
+
+    app_settings::SettingsManager settings_{"tx_secplus", app_settings::Mode::TX, {{"file_path"sv, &file_path}}};
+
+    Button button_open{{UI_POS_X(1), UI_POS_Y(1), screen_width / 2 - UI_POS_X(1), UI_POS_HEIGHT(2)}, "Open"};
+    Button button_save{{screen_width / 2, UI_POS_Y(1), screen_width / 2 - UI_POS_X(1), UI_POS_HEIGHT(2)}, "Save"};
+
+    // remote data
+    TextField field_name{{UI_POS_X(1), UI_POS_Y(3), UI_POS_WIDTH_REMAINING(2), UI_POS_HEIGHT(1)}, "Remote"};
+    Labels labels{
+        {{UI_POS_X(1), UI_POS_Y(4)}, "Fixed:", Theme::getInstance()->fg_medium->foreground},
+        {{UI_POS_X(1), UI_POS_Y(5)}, "Rolling:", Theme::getInstance()->fg_medium->foreground}};
+    SymField field_fixed{{UI_POS_X(10), UI_POS_Y(4)}, 10, SymField::Type::Hex, true};
+    SymField field_rolling{{UI_POS_X(10), UI_POS_Y(5)}, 7, SymField::Type::Hex, true};
+    Checkbox has_data{{UI_POS_X(1), UI_POS_Y(6)}, 5, "Data:", true};
+    SymField field_data{{UI_POS_X(10), UI_POS_Y(6)}, 8, SymField::Type::Hex, true};
+
+    // options
+    Checkbox learn_mode{{UI_POS_X(1), UI_POS_Y(7)}, 5, "Learn", true};
+    Checkbox autosave{{UI_POS_X(1), UI_POS_Y(8)}, 8, "Autosave", true};
+
+    ProgressBar progressbar{{UI_POS_X(2), UI_POS_Y_BOTTOM(5.75), UI_POS_WIDTH_REMAINING(4), UI_POS_HEIGHT(1)}};
+
+    TransmitterView tx_view{UI_POS_Y_BOTTOM(4), 1000000, 0};
+
+    Optional<SecplusData> read_secplus_file(const std::filesystem::path& file_path);
+    bool write_secplus_file(const std::filesystem::path& file_path, const SecplusData& data);
+    void save_data();
+    void reload_data();
+    void start_tx();
+    void stop_tx();
+
+    void on_tx_progress(uint32_t progress, bool done);
+
+    MessageHandlerRegistration message_handler_tx_progress{
+        Message::ID::TXProgress,
+        [this](const Message* const p) {
+            const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
+            this->on_tx_progress(message.progress, message.done);
+        }};
+};
+
+}  // namespace ui::external_app::ui_secplustx
+
+#endif
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2026 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; if not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_vor_rx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::vor_rx {
+
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<VorRxView>();
+}
+
+}  // namespace ui::external_app::vor_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_vor_rx.application_information"), used)) application_information_t _application_information_vor_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::vor_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "VOR RX",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x80,
+        0x01,
+        0xC0,
+        0x03,
+        0xE0,
+        0x07,
+        0xF0,
+        0x0F,
+        0xF8,
+        0x1F,
+        0xF8,
+        0x1F,
+        0xF0,
+        0x0F,
+        0xE0,
+        0x07,
+        0xC0,
+        0x03,
+        0x80,
+        0x01,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::orange().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_vor_rx */ {'P', 'V', 'R', 'X'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -0,0 +1,341 @@
+/*
+ * Copyright (C) 2026 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; if not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_vor_rx.hpp"
+
+#include "audio.hpp"
+#include "string_format.hpp"
+
+#include <algorithm>
+#include <cstdint>
+
+using namespace portapack;
+using namespace ui;
+
+namespace ui::external_app::vor_rx {
+
+void VorLogger::write_header() {
+    log_file.write_raw("Time;Course;Radial;Deviation;Quality;Flag;");
+}
+
+void VorLogger::log_status(const VorRxStatusDataMessage& message, uint16_t course_deg) {
+    const int16_t deviation = static_cast<int16_t>((static_cast<int32_t>(message.radial_deg) - static_cast<int32_t>(course_deg) + 540) % 360 - 180);
+    std::string row = ";";
+    row += to_string_dec_uint(course_deg);
+    row += ";" + to_string_dec_uint(message.radial_deg);
+    row += ";" + std::to_string(deviation);
+    row += ";" + to_string_dec_uint(message.quality);
+    row += ";" + std::string(message.valid ? (message.to_from ? "TO" : "FROM") : "--");
+    log_file.write_entry(rtc_time::now(), row);
+}
+
+VorCdiIndicator::VorCdiIndicator(Point position)
+    : Widget{{position, {screen_width, 32}}} {
+}
+
+void VorCdiIndicator::set_course(uint16_t course_deg) {
+    if (course_deg_ != course_deg) {
+        course_deg_ = course_deg;
+        set_dirty();
+    }
+}
+
+void VorCdiIndicator::set_radial(uint16_t radial_deg) {
+    if (radial_deg_ != radial_deg) {
+        radial_deg_ = radial_deg;
+        set_dirty();
+    }
+}
+
+void VorCdiIndicator::set_valid(bool valid) {
+    if (valid_ != valid) {
+        valid_ = valid;
+        set_dirty();
+    }
+}
+
+int32_t VorCdiIndicator::normalize_signed_degrees(int32_t degrees) {
+    while (degrees <= -180) {
+        degrees += 360;
+    }
+    while (degrees > 180) {
+        degrees -= 360;
+    }
+    return degrees;
+}
+
+void VorCdiIndicator::paint(Painter& painter) {
+    const auto r = screen_rect();
+    const auto theme = Theme::getInstance();
+    const auto line_color = valid_ ? theme->fg_light->foreground : theme->bg_medium->foreground;
+    const auto needle_color = valid_ ? theme->fg_red->foreground : theme->bg_medium->foreground;
+
+    // Clear background so old needle positions don't linger.
+    painter.fill_rectangle(r, theme->bg_darkest->background);
+
+    const auto center_x = static_cast<Coord>(r.left() + r.width() / 2);
+    const auto center_y = static_cast<Coord>(r.top() + r.height() / 2);
+
+    // Horizontal scale line.
+    painter.draw_hline({static_cast<Coord>(r.left() + 8), center_y}, r.width() - 16, line_color);
+
+    // Evenly spaced tick marks, longer at center.
+    constexpr int32_t tick_spacing = 40;
+    for (int32_t tick = -2; tick <= 2; ++tick) {
+        const auto x = static_cast<Coord>(center_x + tick * tick_spacing);
+        const auto len = (tick == 0) ? 14 : 8;
+        painter.draw_vline({x, static_cast<Coord>(center_y - len / 2)}, len, line_color);
+    }
+
+    // Deviation needle, clamped to +/-10 degrees full-scale.
+    const int32_t deviation = normalize_signed_degrees(static_cast<int32_t>(radial_deg_) - static_cast<int32_t>(course_deg_));
+    const int32_t scaled = std::max<int32_t>(-10, std::min<int32_t>(10, deviation));
+    // +/-10 deg full-scale maps to +/-2 ticks (2 * tick_spacing); the division
+    // is exact for the clamped range so no rounding is needed.
+    const int16_t needle_offset = static_cast<int16_t>((scaled * (2 * tick_spacing)) / 10);
+    const auto needle_x = static_cast<Coord>(center_x + needle_offset);
+    painter.draw_vline({needle_x, static_cast<Coord>(r.top() + 4)}, r.height() - 8, needle_color);
+}
+
+VorRxView::VorRxView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&field_rf_amp,
+                  &field_lna,
+                  &field_vga,
+                  &field_volume,
+                  &field_frequency,
+                  &rssi,
+                  &channel,
+                  &audio,
+                  &labels,
+                  &text_status,
+                  &text_band,
+                  &text_next,
+                  &field_course,
+                  &text_course_unit,
+                  &field_calibration,
+                  &text_calib_unit,
+                  &text_radial,
+                  &text_flag,
+                  &text_cdi_title,
+                  &cdi_indicator,
+                  &check_log,
+                  &button_start_stop});
+
+    field_frequency.set_step(8333);
+    if (field_frequency.value() == 0) {
+        field_frequency.set_value(110'000'000);
+    }
+
+    field_course.set_value(0);
+    field_course.on_change = [this](int32_t) {
+        update_cdi();
+    };
+
+    field_calibration.set_value(0);
+    field_calibration.on_change = [this](int32_t) {
+        refresh_radial();
+    };
+
+    logger = std::make_unique<VorLogger>();
+    check_log.set_value(logging_);
+    check_log.on_select = [this](Checkbox&, bool v) {
+        logging_ = v;
+        update_logging();
+    };
+    update_logging();
+
+    button_start_stop.on_select = [this](Button&) {
+        if (running_) {
+            stop_receiver();
+        } else {
+            start_receiver();
+        }
+    };
+
+    start_receiver();
+}
+
+VorRxView::~VorRxView() {
+    stop_receiver();
+}
+
+void VorRxView::focus() {
+    field_frequency.focus();
+}
+
+void VorRxView::start_receiver() {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+    baseband::set_vor_config(true);
+
+    radial_filter_valid_ = false;
+    flag_state_ = 0;
+
+    receiver_model.set_hidden_offset(0);
+    receiver_model.set_modulation(ReceiverModel::Mode::AMAudio);
+    receiver_model.set_frequency_step(8333);
+    receiver_model.set_sampling_rate(3072000);
+    receiver_model.set_baseband_bandwidth(1750000);
+    receiver_model.enable();
+
+    // enable() applies the AM configuration, which forces the audio codec to
+    // 12 kHz. The VOR baseband keeps its channel at 48 kHz (so the 9960 Hz
+    // subcarrier stays representable), so re-assert 48 kHz audio afterwards.
+    audio::set_rate(audio::Rate::Hz_48000);
+    audio::output::start();
+
+    running_ = true;
+    update_status();
+}
+
+void VorRxView::stop_receiver() {
+    if (!running_) {
+        return;
+    }
+
+    running_ = false;
+    baseband::set_vor_config(false);
+    receiver_model.disable();
+    baseband::shutdown();
+    audio::output::stop();
+    update_status();
+}
+
+void VorRxView::update_status() {
+    text_status.set(running_ ? "Running" : "Idle");
+    button_start_stop.set_text(running_ ? "Stop" : "Start");
+}
+
+void VorRxView::update_logging() {
+    if (logger && logging_) {
+        logger->append(logs_dir / (std::string("VOR_") + to_string_timestamp(rtc_time::now()) + ".CSV"));
+        logger->write_header();
+    }
+}
+
+void VorRxView::on_vor_status(const VorRxStatusDataMessage& message) {
+    if (!running_) {
+        return;
+    }
+
+    last_radial_deg_ = message.radial_deg;
+    last_valid_ = message.valid;
+    have_status_ = true;
+
+    if (message.valid) {
+        last_radial_deg_ = smooth_radial(message.radial_deg);
+    } else {
+        // Drop the filter history so a fresh lock doesn't drag from stale data.
+        radial_filter_valid_ = false;
+    }
+
+    text_next.set(message.valid ? "Locked" : "Searching");
+    refresh_radial();
+    if (logger && logging_) {
+        VorRxStatusDataMessage calibrated = message;
+        calibrated.radial_deg = calibrated_radial(last_radial_deg_);
+        calibrated.to_from = (flag_state_ == 2);
+        logger->log_status(calibrated, field_course.value());
+    }
+}
+
+uint16_t VorRxView::smooth_radial(uint16_t radial_deg) {
+    // Wrapped exponential moving average. At ~10 updates/s blending 20% of each
+    // new reading (alpha = 0.8) gives a ~0.5 s time constant while cutting the
+    // jitter by ~3x. Stepping along the shortest arc in 1/64 deg fixed point
+    // handles the 0/360 deg wrap without any trig (which would otherwise pull
+    // newlib's float sin/cos/atan2 argument-reduction code into flash ROM).
+    constexpr int32_t scale = 64;
+    constexpr int32_t full_circle = 360 * scale;
+    const int32_t target = static_cast<int32_t>(radial_deg) * scale;
+
+    if (!radial_filter_valid_) {
+        radial_smoothed_fp_ = target;
+        radial_filter_valid_ = true;
+    } else {
+        int32_t diff = (target - radial_smoothed_fp_) % full_circle;
+        if (diff < -full_circle / 2) {
+            diff += full_circle;
+        } else if (diff > full_circle / 2) {
+            diff -= full_circle;
+        }
+        // 20% step toward the new reading (1 - alpha).
+        radial_smoothed_fp_ += diff / 5;
+        radial_smoothed_fp_ %= full_circle;
+        if (radial_smoothed_fp_ < 0) {
+            radial_smoothed_fp_ += full_circle;
+        }
+    }
+
+    return static_cast<uint16_t>((radial_smoothed_fp_ + scale / 2) / scale) % 360;
+}
+
+uint16_t VorRxView::calibrated_radial(uint16_t radial_deg) const {
+    int32_t value = (static_cast<int32_t>(radial_deg) + field_calibration.value()) % 360;
+    if (value < 0) {
+        value += 360;
+    }
+    return static_cast<uint16_t>(value);
+}
+
+void VorRxView::refresh_radial() {
+    if (!have_status_) {
+        return;
+    }
+
+    const uint16_t radial = calibrated_radial(last_radial_deg_);
+    text_radial.set(to_string_dec_uint(radial, 3) + " deg");
+    text_flag.set(to_from_label(radial));
+    cdi_indicator.set_radial(radial);
+    cdi_indicator.set_valid(last_valid_);
+}
+
+const char* VorRxView::to_from_label(uint16_t radial_deg) {
+    if (!last_valid_) {
+        flag_state_ = 0;
+        return "--";
+    }
+
+    // TO/FROM is set by the selected OBS course relative to the received radial,
+    // not by the radial alone. Take the difference wrapped to [-180, 180]: the
+    // switch is at the 90 deg abeam point. |diff| < 90 means the selected course
+    // leads away from the station (FROM); |diff| > 90 means toward it (TO).
+    int32_t diff = (static_cast<int32_t>(radial_deg) - field_course.value() + 540) % 360 - 180;
+    const int32_t adiff = (diff < 0) ? -diff : diff;
+
+    // Hysteresis: hold the current flag within a +/-5 deg dead zone around the
+    // 90 deg boundary so noise near abeam doesn't rapidly toggle TO/FROM.
+    if (adiff < 85) {
+        flag_state_ = 1;  // FROM
+    } else if (adiff > 95) {
+        flag_state_ = 2;  // TO
+    }
+
+    if (flag_state_ == 1) return "FROM";
+    if (flag_state_ == 2) return "TO";
+    return "--";  // abeam / ambiguous
+}
+
+void VorRxView::update_cdi() {
+    cdi_indicator.set_course(field_course.value());
+}
+
+}  // namespace ui::external_app::vor_rx
@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2026 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; if not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_VOR_RX_H__
+#define __UI_VOR_RX_H__
+
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "file_path.hpp"
+#include "log_file.hpp"
+#include "rtc_time.hpp"
+#include "portapack.hpp"
+#include "ui.hpp"
+#include "ui_audio.hpp"
+#include "ui_channel.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_rssi.hpp"
+
+namespace ui::external_app::vor_rx {
+
+class VorLogger {
+   public:
+    Optional<File::Error> append(const std::filesystem::path& filename) {
+        return log_file.append(filename);
+    }
+
+    void write_header();
+    void log_status(const VorRxStatusDataMessage& message, uint16_t course_deg);
+
+   private:
+    LogFile log_file{};
+};
+
+class VorCdiIndicator : public Widget {
+   public:
+    VorCdiIndicator(Point position);
+
+    void set_course(uint16_t course_deg);
+    void set_radial(uint16_t radial_deg);
+    void set_valid(bool valid);
+
+    void paint(Painter& painter) override;
+
+   private:
+    static int32_t normalize_signed_degrees(int32_t degrees);
+
+    uint16_t course_deg_{0};
+    uint16_t radial_deg_{0};
+    bool valid_{false};
+};
+
+class VorRxView : public View {
+   public:
+    VorRxView(NavigationView& nav);
+    ~VorRxView();
+
+    void focus() override;
+
+    std::string title() const override { return "VOR RX"; }
+
+   private:
+    void start_receiver();
+    void stop_receiver();
+    void update_status();
+    void on_vor_status(const VorRxStatusDataMessage& message);
+    void update_cdi();
+    void refresh_radial();
+    uint16_t calibrated_radial(uint16_t radial_deg) const;
+    uint16_t smooth_radial(uint16_t radial_deg);
+    const char* to_from_label(uint16_t radial_deg);
+    void update_logging();
+
+    NavigationView& nav_;
+    bool running_{false};
+    bool logging_{false};
+    bool have_status_{false};
+    uint16_t last_radial_deg_{0};
+    bool last_valid_{false};
+    uint8_t flag_state_{0};  // TO/FROM hysteresis: 0=unknown, 1=FROM, 2=TO
+    // Circular exponential moving average of the radial. Each 100 ms estimate
+    // is noisy (~10 deg std even when locked), so blend it along the shortest
+    // arc in 1/64 deg fixed point to average correctly across the 0/360 deg
+    // wrap without trig.
+    bool radial_filter_valid_{false};
+    int32_t radial_smoothed_fp_{0};
+
+    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)}};
+    AudioVolumeField field_volume{
+        {screen_width - 2 * 8, UI_POS_Y(0)}};
+
+    RSSI rssi{
+        {UI_POS_X(21), 0, UI_POS_WIDTH_REMAINING(21) - UI_POS_WIDTH(2), 4}};
+    Channel channel{
+        {UI_POS_X(21), 5, UI_POS_WIDTH_REMAINING(21) - UI_POS_WIDTH(2), 4}};
+    Audio audio{
+        {UI_POS_X(21), 10, UI_POS_WIDTH_REMAINING(21) - UI_POS_WIDTH(2), 4}};
+
+    NumberField field_course{
+        {UI_POS_X(14), UI_POS_Y(4)},
+        3,
+        {0, 359},
+        1,
+        '0'};
+
+    NumberField field_calibration{
+        {UI_POS_X(14), UI_POS_Y(7)},
+        4,
+        {-359, 359},
+        1,
+        ' '};
+
+    Labels labels{
+        {{UI_POS_X(0), UI_POS_Y(1)}, "Status:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(2)}, "VOR Band:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(3)}, "Decoder:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(4)}, "Course (OBS):", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(5)}, "Rec. Radial:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(6)}, "Flag:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(7)}, "Calibration:", Theme::getInstance()->fg_light->foreground}};
+
+    Text text_status{
+        {UI_POS_X(14), UI_POS_Y(1), UI_POS_WIDTH_REMAINING(14), UI_POS_HEIGHT(1)},
+        "Idle"};
+    Text text_band{
+        {UI_POS_X(14), UI_POS_Y(2), UI_POS_WIDTH_REMAINING(14), UI_POS_HEIGHT(1)},
+        "108.00-117.95MHz"};
+    Text text_next{
+        {UI_POS_X(14), UI_POS_Y(3), UI_POS_WIDTH_REMAINING(14), UI_POS_HEIGHT(1)},
+        "Pending"};
+    Text text_course_unit{
+        {UI_POS_X(18), UI_POS_Y(4), UI_POS_WIDTH_REMAINING(18), UI_POS_HEIGHT(1)},
+        "deg"};
+    Text text_radial{
+        {UI_POS_X(14), UI_POS_Y(5), UI_POS_WIDTH_REMAINING(14), UI_POS_HEIGHT(1)},
+        "--"};
+    Text text_flag{
+        {UI_POS_X(14), UI_POS_Y(6), UI_POS_WIDTH_REMAINING(14), UI_POS_HEIGHT(1)},
+        "--"};
+    Text text_calib_unit{
+        {UI_POS_X(19), UI_POS_Y(7), UI_POS_WIDTH_REMAINING(19), UI_POS_HEIGHT(1)},
+        "deg"};
+
+    Text text_cdi_title{
+        {UI_POS_X(0), UI_POS_Y(9), UI_POS_WIDTH_REMAINING(0), UI_POS_HEIGHT(1)},
+        "Course Deviation Indicator"};
+
+    VorCdiIndicator cdi_indicator{
+        {UI_POS_X(0), UI_POS_Y(10)}};
+
+    std::unique_ptr<VorLogger> logger{};
+
+    Button button_start_stop{
+        {UI_POS_X(9), UI_POS_Y(14), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
+        "Start"};
+
+    Checkbox check_log{
+        {UI_POS_X(7), UI_POS_Y(17)},
+        3,
+        "LOG to SD Card",
+        true};
+
+    MessageHandlerRegistration message_handler_vor_status{
+        Message::ID::VorRxStatusData,
+        [this](const Message* p) {
+            const auto message = *reinterpret_cast<const VorRxStatusDataMessage*>(p);
+            on_vor_status(message);
+        }};
+};
+
+}  // namespace ui::external_app::vor_rx
+
+#endif  // __UI_VOR_RX_H__
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2026 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; if not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_vor_tx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::vor_tx {
+
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<VorTxView>();
+}
+
+}  // namespace ui::external_app::vor_tx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_vor_tx.application_information"), used)) application_information_t _application_information_vor_tx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::vor_tx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "VOR TX",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x80,
+        0x01,
+        0xC0,
+        0x03,
+        0xE0,
+        0x07,
+        0xF0,
+        0x0F,
+        0xF8,
+        0x1F,
+        0xF8,
+        0x1F,
+        0xF0,
+        0x0F,
+        0xE0,
+        0x07,
+        0xC0,
+        0x03,
+        0x80,
+        0x01,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_vor_tx */ {'P', 'V', 'T', 'X'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2026 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; if not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_vor_tx.hpp"
+
+#include "string_format.hpp"
+#include "ui_textentry.hpp"
+
+using namespace portapack;
+using namespace ui;
+
+namespace ui::external_app::vor_tx {
+
+VorTxView::VorTxView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+
+    add_children({&labels,
+                  &field_radial,
+                  &text_radial_unit,
+                  &check_ident,
+                  &button_ident_text,
+                  &text_status,
+                  &tx_view});
+
+    field_radial.set_value(radial_);
+    field_radial.on_change = [this](int32_t v) {
+        radial_ = v;
+        if (transmitting_) {
+            update_config();
+        }
+    };
+
+    check_ident.set_value(ident_);
+    check_ident.on_select = [this](Checkbox&, bool v) {
+        ident_ = v;
+        if (transmitting_) {
+            update_config();
+        }
+    };
+
+    button_ident_text.set_text(ident_text_);
+    button_ident_text.on_select = [this](Button&) {
+        text_prompt(nav_, ident_text_, 7, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string&) {
+            button_ident_text.set_text(ident_text_);
+            if (transmitting_) {
+                update_config();
+            }
+        });
+    };
+
+    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 (tx_acknowledged_) {
+            start_tx();
+            return;
+        }
+        nav_.display_modal(
+            "TX WARNING",
+            "VOR is an aviation nav\nband! TX only into a\ndummy load.",
+            YESNO,
+            [this](bool choice) {
+                if (choice) {
+                    tx_acknowledged_ = true;
+                    start_tx();
+                } else {
+                    tx_view.set_transmitting(false);
+                }
+            });
+    };
+
+    tx_view.on_stop = [this]() {
+        stop_tx();
+    };
+}
+
+VorTxView::~VorTxView() {
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+void VorTxView::focus() {
+    tx_view.focus();
+}
+
+void VorTxView::update_config() {
+    baseband::set_vor_tx_config(static_cast<uint16_t>(radial_), ident_, ident_text_);
+}
+
+void VorTxView::start_tx() {
+    transmitter_model.set_sampling_rate(1536000);
+    transmitter_model.set_baseband_bandwidth(1750000);
+    transmitter_model.enable();
+    update_config();
+    transmitting_ = true;
+    tx_view.set_transmitting(true);
+    text_status.set("TX radial " + to_string_dec_uint(radial_));
+    set_dirty();
+}
+
+void VorTxView::stop_tx() {
+    transmitter_model.disable();
+    transmitting_ = false;
+    tx_view.set_transmitting(false);
+    text_status.set("Idle");
+    set_dirty();
+}
+
+}  // namespace ui::external_app::vor_tx
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2026 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; if not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __UI_VOR_TX_H__
+#define __UI_VOR_TX_H__
+
+#include "app_settings.hpp"
+#include "baseband_api.hpp"
+#include "portapack.hpp"
+#include "radio_state.hpp"
+#include "ui.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_transmitter.hpp"
+
+namespace ui::external_app::vor_tx {
+
+class VorTxView : public View {
+   public:
+    VorTxView(NavigationView& nav);
+    ~VorTxView();
+
+    void focus() override;
+
+    std::string title() const override { return "VOR TX"; }
+
+   private:
+    void start_tx();
+    void stop_tx();
+    void update_config();
+
+    NavigationView& nav_;
+    bool transmitting_{false};
+    bool tx_acknowledged_{false};
+
+    uint32_t radial_{0};
+    bool ident_{true};
+    std::string ident_text_{"VOR"};
+
+    TxRadioState radio_state_{
+        113'500'000 /* frequency */,
+        1750000 /* bandwidth */,
+        1536000 /* sampling rate */
+    };
+
+    app_settings::SettingsManager settings_{
+        "tx_vor",
+        app_settings::Mode::TX,
+        {
+            {"radial"sv, &radial_},
+            {"ident"sv, &ident_},
+            {"ident_text"sv, &ident_text_},
+        }};
+
+    Labels labels{
+        {{UI_POS_X(0), UI_POS_Y(1)}, "Radial:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(5)}, "Ident:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(8)}, "Status:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(10)}, "Lab use: set any freq &", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(11)}, "TX into a dummy load.", Theme::getInstance()->fg_light->foreground}};
+
+    NumberField field_radial{
+        {UI_POS_X(8), UI_POS_Y(1)},
+        3,
+        {0, 359},
+        1,
+        '0'};
+
+    Text text_radial_unit{
+        {UI_POS_X(12), UI_POS_Y(1), UI_POS_WIDTH(4), UI_POS_HEIGHT(1)},
+        "deg"};
+
+    Checkbox check_ident{
+        {UI_POS_X(0), UI_POS_Y(3)},
+        13,
+        "CW identifier",
+        true};
+
+    Button button_ident_text{
+        {UI_POS_X(8), UI_POS_Y(5), UI_POS_WIDTH(10), UI_POS_HEIGHT(2)},
+        "VOR"};
+
+    Text text_status{
+        {UI_POS_X(8), UI_POS_Y(8), UI_POS_WIDTH_REMAINING(8), UI_POS_HEIGHT(1)},
+        "Idle"};
+
+    TransmitterView tx_view{
+        (int16_t)UI_POS_Y_BOTTOM(4),
+        8333,
+        1750000};
+};
+
+}  // namespace ui::external_app::vor_tx
+
+#endif  // __UI_VOR_TX_H__
@@ -57,4 +57,5 @@ const std::filesystem::path macaddress_dir = u"MACADDRESS";
 const std::filesystem::path splash_dot_bmp = u"/splash.bmp";
 const std::filesystem::path keeloq_keys_dir = u"KEELOQKEYS";
 const std::filesystem::path keeloq_remotes_dir = u"KEELOQREMOTES";
+const std::filesystem::path secplus_dir = u"SECPLUS";
 const std::filesystem::path epirb_dir = u"EPIRB";
@@ -58,6 +58,7 @@ extern const std::filesystem::path waterfalls_dir;
 extern const std::filesystem::path macaddress_dir;
 extern const std::filesystem::path keeloq_keys_dir;
 extern const std::filesystem::path keeloq_remotes_dir;
+extern const std::filesystem::path secplus_dir;
 extern const std::filesystem::path epirb_dir;

 extern const std::filesystem::path splash_dot_bmp;
@@ -347,9 +347,9 @@ void MAX2831::set_lpf_rf_bandwidth_rx(const uint32_t bandwidth_minimum) {
     * external Anti-Aliasing (AA) filter on pin P1_14 to prevent aliasing.
     */
    if (actual_bw <= 1750000) {
-        gpio_control::aa_en.set();  // Enable external narrow AA filter
+        gpio_control::aa_en.setActive();  // Enable external narrow AA filter
    } else {
-        gpio_control::aa_en.clear();  // Disable external AA filter for wideband operations
+        gpio_control::aa_en.setInactive();  // Disable external AA filter for wideband operations
    }

    _desired_lpf_bw = actual_bw;
@@ -131,6 +131,8 @@ void MAX2839::init() {

    _map.r.rssi_vga.RSSI_MODE = 1; /* RSSI independent of RXHP */

+    _map.r.rssi_vga.RSSI_INPUT = 0; /* Measure RSSI at VGA Output (stronger signal) */
+
    /*
     * There are two LNA band settings, but we only use one of them.
     * Switching to the other one doesn't make the overall spectrum any
@@ -305,9 +307,8 @@ void MAX2839::configure_rx_gain() {
    }

    _map.r.lpf_vga_2.L = lna::gain_ordinal(lna_gain);
-    _dirty[Register::RXRF_2] = 1;
    _map.r.lpf_vga_2.VGA = vga::gain_ordinal(vga_gain);
-    _dirty[Register::LPF_VGA_2] = 1;
+    _dirty[Register::LPF_VGA_2] = 1; /* both L (LNA) and VGA live in LPF_VGA_2 */
    flush();
 }

@@ -176,7 +176,7 @@ struct SynthConfig {

 void RFFC507x::init() {
 #ifdef PRALINE
-    gpio_control::rf5072_mix_en.set();  // RF5072_MIX_EN
+    gpio_control::rf5072_mix_en.setActive();  // RF5072_MIX_EN
 #endif

    gpio_rffc5072_resetx.set();
@@ -132,7 +132,6 @@ Continuous (Fox-oring)
 #include "spi_image.hpp"

 #include "debug.hpp"
-#include "led.hpp"

 #include "gcc.hpp"

@@ -53,6 +53,9 @@ using namespace hackrf::one;
 #include "baseband_api.hpp"
 #include "hal.h"  // For LPC_SGPIO

+#include "gpio.hpp"
+using namespace gpio_control;
+
 #include <array>

 /* Direct access to the radio. Setting values incorrectly can damage
@@ -148,10 +151,6 @@ void init() {
    /* PRALINE uses MAX2831 transceiver */
    second_if = (max283x::MAX283x*)&second_if_max2831;
 #else
-    if (hackrf_r9) {
-        gpio_r9_not_ant_pwr.write(1);
-        gpio_r9_not_ant_pwr.output();
-    }
    second_if = hackrf_r9
                    ? (max283x::MAX283x*)&second_if_max2839
                    : (max283x::MAX283x*)&second_if_max2837;
@@ -280,9 +279,9 @@ void set_direction(const rf::Direction new_direction) {
    baseband_codec.set_mode((direction == rf::Direction::Transmit) ? max5864::Mode::Transmit : max5864::Mode::Receive);

    if (direction == rf::Direction::Receive)
-        led_rx.on();
+        led_rx.setActive();
    else
-        led_tx.on();
+        led_tx.setActive();
 }

 bool set_tuning_frequency(const rf::Frequency frequency) {
@@ -395,7 +394,7 @@ void set_antenna_bias(const bool on) {
    rf_path.set_ant_bias(on);
 #else
    if (hackrf_r9) {
-        gpio_r9_not_ant_pwr.write(on ? 0 : 1);
+        rf_path.set_ant_bias(on);
    } else {
        first_if.set_gpo1(on ? 0 : 1);
    }
@@ -442,8 +441,8 @@ void disable() {
    first_if.disable();
    set_rf_amp(false);

-    led_rx.off();
-    led_tx.off();
+    led_rx.setInactive();
+    led_tx.setInactive();
 }

 #ifdef PRALINE
@@ -21,221 +21,26 @@

 #include "rf_path.hpp"
 #include "platform.hpp"
-
-#include <array>
-#include <initializer_list>
-
-#include "hackrf_gpio.hpp"
-using namespace hackrf::one;
-
 #include "utility.hpp"
+#include "gpio.hpp"
+using namespace gpio_control;

 namespace rf {
 namespace path {

-namespace {
-
-#ifdef PRALINE
-/* PRALINE uses a simplified RF path with only 5 control signals.
- * The RF path architecture is completely different from HackRF One.
- */
-struct PralineConfig {
-    bool tx_en;
-    bool mix_bypass;  // RF path mixer bypass (GPIO3[2])
-    bool lpf_en;
-    bool rf_amp_en;
-    bool ant_bias_en_n;  // Inverted: 0 = bias enabled
-
-    void apply() const {
-        gpio_tx_enable.write(tx_en);
-        gpio_mix_bypass.write(mix_bypass);  // Control RF path mixer
-        gpio_lpf_enable.write(lpf_en);
-        gpio_rf_amp_enable.write(rf_amp_en);
-        gpio_ant_bias_disable.write(ant_bias_en_n);
-    }
-};
-
-#else
-/* HackRF One uses 11 GPIOs for RF path control */
-using GPIOs = std::array<GPIO, 11>;
-
-/* TODO: ARM GCC 4.8 2014q3 doesn't like this array inside struct Config.
- * No idea why.
- */
-constexpr GPIOs gpios{
-    gpio_mix_bypass,
-    gpio_not_mix_bypass,
-    gpio_tx_mix_bp,
-    gpio_rx_mix_bp,
-    gpio_hp,
-    gpio_lp,
-    gpio_amp_bypass,
-    gpio_tx_amp,
-    gpio_not_tx_amp_pwr,
-    gpio_rx_amp,
-    gpio_not_rx_amp_pwr,
-};
-
-/* HackRF One Config struct - not used on PRALINE */
-struct Config {
-    using base_type = uint16_t;
-
-    union {
-        struct {
-            bool tx : 1;
-            bool rx : 1;
-            bool mix_bypass : 1;
-            bool not_mix_bypass : 1;
-            bool tx_mix_bp : 1;
-            bool rx_mix_bp : 1;
-            bool hp : 1;
-            bool lp : 1;
-            bool amp_bypass : 1;
-            bool tx_amp : 1;
-            bool not_tx_amp : 1;
-            bool rx_amp : 1;
-            bool not_rx_amp : 1;
-        };
-        base_type w;
-    };
-
-    constexpr Config(
-        const Direction direction,
-        const Band band,
-        const bool amplify)
-        : tx(direction == Direction::Transmit),
-          rx(direction == Direction::Receive),
-          mix_bypass(band == Band::Mid),
-          not_mix_bypass(band != Band::Mid),
-          tx_mix_bp((direction == Direction::Transmit) && (band == Band::Mid)),
-          rx_mix_bp((direction == Direction::Receive) && (band == Band::Mid)),
-          hp(band == Band::High),
-          lp(band == Band::Low),
-          amp_bypass(!amplify),
-          tx_amp((direction == Direction::Transmit) && amplify),
-          not_tx_amp(!tx_amp),
-          rx_amp((direction == Direction::Receive) && amplify),
-          not_rx_amp(!rx_amp) {
-    }
-
-    constexpr Config()
-        : Config(Direction::Receive, Band::Mid, false) {
-    }
-
-    constexpr Config(
-        const base_type w)
-        : w(w) {
-    }
-
-    constexpr Config operator^(const Config& r) const {
-        return w ^ r.w;
-    }
-
-    constexpr Config operator&(const Config& r) const {
-        return w & r.w;
-    }
-
-    constexpr bool operator[](const size_t n) const {
-        return (w >> n) & 1;
-    }
-
-    static void gpio_init() {
-        if (hackrf_r9) {
-            gpio_r9_rx.output();
-        } else {
-            gpio_og_tx.output();
-            gpio_og_rx.output();
-        }
-        for (auto gpio : gpios) {
-            gpio.output();
-        }
-    }
-
-    void apply() const {
-        /* NOTE: Assumes order in gpios[] and Config bitfield match,
-         * after the 'tx' and 'rx' fields which are handled specially. */
-        for (size_t n = 0; n < gpios.size() + 2; n++) {
-            bool value = (*this)[n];
-            switch (n) {
-                case 0:
-                    if (!hackrf_r9) {
-                        gpio_og_tx.write(value);
-                    }
-                    break;
-                case 1:
-                    if (hackrf_r9) {
-                        gpio_r9_rx.write(value);
-                    } else {
-                        gpio_og_rx.write(value);
-                    }
-                    break;
-                default:
-                    gpios[n - 2].write(value);
-                    break;
-            }
-        }
-    }
-};
-
-/* HackRF One config table - not used on PRALINE */
-using ConfigAmp = std::array<Config, 2>;
-using ConfigDirection = std::array<ConfigAmp, 2>;
-using ConfigBand = std::array<ConfigDirection, 3>;
-
-constexpr ConfigAmp config_amp(
-    const Direction direction,
-    const Band band) {
-    return {{
-        Config(direction, band, false),
-        Config(direction, band, true),
-    }};
-}
-
-constexpr ConfigDirection config_rx_tx(
-    const Band band) {
-    return {
-        config_amp(Direction::Receive, band),
-        config_amp(Direction::Transmit, band),
-    };
-}
-
-constexpr ConfigBand config_band() {
-    return {
-        config_rx_tx(Band::Low),
-        config_rx_tx(Band::Mid),
-        config_rx_tx(Band::High),
-    };
-}
-
-constexpr ConfigBand config_table = config_band();
-
-static_assert(sizeof(config_table) == sizeof(Config::base_type) * 3 * 2 * 2, "rf path config table unexpected size");
-
-constexpr Config get_config(
-    const Direction direction,
-    const Band band,
-    const bool amplify) {
-    return config_table[toUType(band)][toUType(direction)][amplify ? 1 : 0];
-}
-#endif /* PRALINE */
-
-} /* namespace */
-
 void Path::init() {
+    /* Set safe initial default states */
+    direction = Direction::Receive;
+    rf_amp_en = false;
+    ant_bias_en = false;
+
 #ifdef PRALINE
-    /* Set safe initial state: RX mode, mixer enabled, LPF on, amp off, no bias */
-    PralineConfig config = {
-        .tx_en = false,
-        .mix_bypass = false,   // RF path mixer bypass (GPIO3[2])
-        .lpf_en = true,        // LPF on for low band
-        .rf_amp_en = false,    // Amp off
-        .ant_bias_en_n = true  // Bias off (inverted)
-    };
-    config.apply();
+    band = Band::Low;
 #else
-    update();
-    Config::gpio_init();
+    band = Band::Mid;
 #endif
+
+    update();
 }

 void Path::set_direction(const Direction new_direction) {
@@ -245,73 +50,82 @@ void Path::set_direction(const Direction new_direction) {

 void Path::set_band(const Band new_band) {
    band = new_band;
-    _band = new_band;
    update();
 }

 void Path::set_rf_amp(const bool new_rf_amp) {
-    rf_amp = new_rf_amp;
+    rf_amp_en = new_rf_amp;
    update();
 }

 void Path::set_ant_bias(const bool new_ant_bias) {
-    ant_bias = new_ant_bias;
+    ant_bias_en = new_ant_bias;
    update();
 }

 bool Path::get_ant_bias() const {
-    return ant_bias;
+    return ant_bias_en;
 }

 void Path::update() {
-    /* 0 ^ 0 => 0 & 0 = 0 ^ 0 = 0 (no change)
-     * 0 ^ 1 => 1 & 0 = 0 ^ 0 = 0 (ignore change to 1)
-     * 1 ^ 0 => 1 & 1 = 1 ^ 1 = 0 (allow change to 0)
-     * 1 ^ 1 => 0 & 1 = 0 ^ 1 = 1 (no change) */
+    const bool is_tx = (direction == Direction::Transmit);

 #ifdef PRALINE
-    /* PRALINE RF path control:
-     * - tx_en: 1 for TX, 0 for RX
-     * - mix_bypass: 0 to enable RF path mixer bypass (GPIO3[2])
-     * - lpf_en: 1 for low band (< 2.4 GHz), 0 for high band
-     * - rf_amp_en: 1 to enable RF amplifier
-     * - ant_bias_en_n: 0 to enable antenna bias (inverted)
-     */
-    // const Config changed = _config ^ config_next;
-    // const Config turned_off = _config & changed;
+    // PRALINE specific RF path control directly applied to pins.
+    // Active-low pin inversion is handled internally inside setState().

-    PralineConfig config;
+    tx_enable.setState(is_tx);

-    /* In transition, ignore the bits that are turning on. So this transition phase
-     * only turns off signals. It doesn't turn on signals.
-     */
-    // const Config transition_config = _config ^ turned_off;
-    // update_signals(transition_config);
+    // On the PRALINE board, the mixer is used ONLY on the Low band.
+    // Since setState() internally handles the active-low (MIX_ENABLE_N) hardware inversion,
+    // we simply pass 'true' to enable the mixer on Low band, and 'false' for Mid/High bands.

-    config.tx_en = (direction == Direction::Transmit);
+    mix_bypass.setState(band == Band::Low);

-    // RF path mixer bypass: 0=enabled, 1=bypassed
-    config.mix_bypass = (band == Band::Mid);
-
-    /* Move to the final state by turning on required signals. */
-    /* LPF for low band */
-
-    config.lpf_en = (band == Band::Low);
-
-    /* RF amp when amplification requested */
-    config.rf_amp_en = rf_amp;
-
-    /* Antenna bias */
-    config.ant_bias_en_n = !ant_bias;
-
-    config.apply();
+    lpf.setState(band == Band::Low);
+    rf_amp_enable.setState(rf_amp_en);
+    ant_bias.setState(ant_bias_en);

 #else
-    /* HackRF One RF path control */
-    const auto config = get_config(direction, band, rf_amp);
-    config.apply();
+
+    const bool is_rx = (direction == Direction::Receive);
+
+    // HackRF One (OG & R9) RF path control
+    const bool mix_bypass_en = (band == Band::Mid);
+    const bool amplify = rf_amp_en;
+
+    // Primary TX/RX routing switches
+    if (!hackrf_r9) {
+        og_tx.setState(is_tx);
+    }
+
+    if (hackrf_r9) {
+        r9_rx.setState(is_rx);  // Single pin handles directional switching on R9
+    } else {
+        og_rx.setState(is_rx);
+    }
+
+    // RF path switch configuration matrix
+    rx_mix_bypass.setState(mix_bypass_en);
+    tx_mix_bp.setState(is_tx && mix_bypass_en);
+    rx_mix_bp.setState(is_rx && mix_bypass_en);
+
+    hpf.setState(band == Band::High);
+    lpf.setState(band == Band::Low);
+
+    amp_bypass.setState(!amplify);
+    tx_amp.setState(is_tx && amplify);
+    rx_amp.setState(is_rx && amplify);
+
+    tx_mix_bypass.setState(mix_bypass_en);
+    tx_amp_pwr.setState(is_tx && amplify);
+    rx_amp_pwr.setState(is_rx && amplify);
+
+    if (hackrf_r9) {
+        ant_bias.setState(ant_bias_en);
+    }
 #endif
 }

 }  // namespace path
-}  // namespace rf
+}  // namespace rf
@@ -41,15 +41,15 @@ namespace path {

 #ifdef PRALINE
 /* PRALINE: MAX2831 direct path is 2320-2740 MHz */
-constexpr FrequencyRange band_low{0, 2320'000'000};
-constexpr FrequencyRange band_high{2740'000'000, 7250'000'000};
-constexpr FrequencyRange band_mid{band_low.maximum, band_high.minimum};
+constexpr Frequency TRANSITION = 2320'000'000;
 #else
 /* HackRF One: Original band boundaries */
-constexpr FrequencyRange band_low{0, 2170'000'000};
+constexpr Frequency TRANSITION = 2170'000'000;
+#endif
+
+constexpr FrequencyRange band_low{0, TRANSITION};
 constexpr FrequencyRange band_high{2740'000'000, 7250'000'000};
 constexpr FrequencyRange band_mid{band_low.maximum, band_high.minimum};
-#endif

 enum class Band {
    /* Zero-based, used as index into frequency_bands table */
@@ -61,23 +61,20 @@ enum class Band {
 class Path {
   public:
    void init();
-
    void set_direction(const Direction direction);
    void set_band(const Band band);
    void set_rf_amp(const bool rf_amp);
    void set_ant_bias(const bool ant_bias);
    bool get_ant_bias() const;
-    Band get_band() const { return _band; }  //_band is used solely for debugging purposes.
+    Band get_band() const { return band; }

   private:
    Direction direction{Direction::Receive};
    Band band{Band::Mid};
-    bool rf_amp{false};
-    bool ant_bias{false};
+    bool rf_amp_en{false};
+    bool ant_bias_en{false};

    void update();
-
-    Band _band{Band::Mid};  //_band is solely used of debugging purposes
 };

 }  // namespace path
@@ -26,7 +26,9 @@
 #include "audio.hpp"
 #include "baseband_api.hpp"
 #include "event_m0.hpp"
-#include "hackrf_gpio.hpp"
+#include "gpio.hpp"
+using namespace gpio_control;
+
 #include "portapack.hpp"
 #include "portapack_persistent_memory.hpp"
 #include "radio.hpp"
@@ -237,26 +237,69 @@ void GeoMap::map_read_line_bin(ui::Color* buffer, uint16_t pixels) {
    if (map_zoom == 1) {
        map_file.read(buffer, pixels << 1);
    } else if (map_zoom > 1) {
-        map_file.read(buffer, (pixels / map_zoom) << 1);
-
-        // Zoom in: Expand each pixel to "map_zoom" number of pixels.
-        // Future TODO:  Add dithering to smooth out the pixelation.
-        // As long as MOD(width,map_zoom)==0 then we don't need to check buffer overflow case when stretching last pixel;
-        // For 240 width, than means no check is needed for map_zoom values up to 6.
-        // (Rectangle height must also divide evenly into map_zoom or we get black lines at end of screen)
-        // Note that zooming in results in a map offset of (1/map_zoom) pixels to the right & downward directions (see zoom_pixel_offset).
-        for (int i = (width / map_zoom) - 1; i >= 0; i--) {
-            for (int j = 0; j < map_zoom; j++) {
-                buffer[(i * map_zoom) + j] = buffer[i];
+        // Calculate how many source pixels we actually need from the file
+        uint16_t src_pixels_needed = (pixels + map_zoom - 1) / map_zoom;
+        if (src_pixels_needed == 0) src_pixels_needed = 1;
+        // Position the source data at the very END of the buffer.
+        // This allows us to overwrite the buffer from left-to-right safely.
+        uint16_t src_offset = pixels - src_pixels_needed;
+        // Read directly into the tail of the target buffer. Zero extra RAM needed.
+        map_file.read(&buffer[src_offset], src_pixels_needed << 1);
+        // Process forwards. Because `dst` grows by 1 and the source index grows by 1/map_zoom,
+        // `dst` will never catch up to overwrite a source pixel before we are done with it.
+        for (uint16_t dst = 0; dst < pixels; ++dst) {
+            uint16_t i0 = dst / map_zoom;
+            uint16_t i1 = i0 + 1;
+            // Clamp the right-hand pixel to avoid reading out of bounds on the last iteration
+            if (i1 >= src_pixels_needed) {
+                i1 = src_pixels_needed - 1;
+            }
+            // 'frac' represents the integer distance from the left pixel (0 to map_zoom - 1)
+            uint16_t frac = dst % map_zoom;
+            // Fetch colors from the tail of our buffer
+            ui::Color c0 = buffer[src_offset + i0];
+            ui::Color c1 = buffer[src_offset + i1];
+            if (frac == 0) {
+                // Exact pixel match, bypass the math entirely for a speed boost
+                buffer[dst] = c0;
+            } else {
+                uint32_t inv_frac = map_zoom - frac;
+                uint8_t r = ((uint32_t)c0.r() * inv_frac + (uint32_t)c1.r() * frac) / map_zoom;
+                uint8_t g = ((uint32_t)c0.g() * inv_frac + (uint32_t)c1.g() * frac) / map_zoom;
+                uint8_t b = ((uint32_t)c0.b() * inv_frac + (uint32_t)c1.b() * frac) / map_zoom;
+                buffer[dst] = ui::Color(r, g, b);
            }
        }
    } else {
-        ui::Color zoom_out_buffer[(pixels * (-map_zoom))];
-        map_file.read(zoom_out_buffer, (pixels * (-map_zoom)) << 1);
-        // Zoom out:  Collapse each group of "-map_zoom" pixels into one pixel.
-        // Future TODO: Average each group of pixels (in both X & Y directions if possible).
-        for (int i = 0; i < width; i++) {
-            buffer[i] = zoom_out_buffer[i * (-map_zoom)];
+        const int skip = -map_zoom;
+        const int MAX_BUFFER_ELEMENTS = 256;
+        // Fixed-size local array avoids VLA crashes.
+        ui::Color zoom_out_buffer[MAX_BUFFER_ELEMENTS];
+        const int total_elements_needed = pixels * skip;
+        // Use the default size, but strictly cap it at 256 to protect the stack
+        const int chunk_size = total_elements_needed < MAX_BUFFER_ELEMENTS ? total_elements_needed : MAX_BUFFER_ELEMENTS;
+        int target_i = 0;
+        int current_file_offset = 0;
+        // Sequentially read through the required portion of the file in chunks
+        while (target_i < width && current_file_offset < total_elements_needed) {
+            // Calculate how many pixels we can read in this specific pass
+            int read_size = chunk_size < (total_elements_needed - current_file_offset) ? chunk_size : (total_elements_needed - current_file_offset);
+            // Read the chunk (<< 1 converts pixel count to byte count)
+            map_file.read(zoom_out_buffer, read_size << 1);
+            // Determine where the first valid "zoomed" pixel is located inside this specific chunk
+            int first_valid_index = 0;
+            int offset_modulo = current_file_offset % skip;
+            if (offset_modulo != 0) {
+                first_valid_index = skip - offset_modulo;
+            }
+            // Extract only the pixels we need, skipping the rest
+            for (int j = first_valid_index; j < read_size; j += skip) {
+                if (target_i < width) {
+                    buffer[target_i] = zoom_out_buffer[j];
+                    target_i++;
+                }
+            }
+            current_file_offset += read_size;
        }
    }
 }
@@ -415,8 +458,7 @@ bool GeoMap::draw_osm_file(int zoom, int tile_x, int tile_y, int relative_x, int
        return true;
    }

-    BMPFile bmp{};
-    bmp.open("/OSM/" + to_string_dec_int(zoom) + "/" + to_string_dec_int(tile_x) + "/" + to_string_dec_int(tile_y) + ".bmp", true);
+    BMPFile* bmp = bmp_cache.get(zoom, tile_x, tile_y);
    // 1. Define the source and destination areas, starting with the full tile.
    int src_x = 0;
    int src_y = 0;
@@ -449,7 +491,7 @@ bool GeoMap::draw_osm_file(int zoom, int tile_x, int tile_y, int relative_x, int
        return true;
    }

-    if (!bmp.is_loaded()) {
+    if (!bmp || !bmp->is_loaded()) {
        // Draw an error rectangle using the calculated clipped dimensions
        ui::Rect error_rect{{dest_x + r.left(), dest_y + r.top()}, {clip_w, clip_h}};
        display.fill_rectangle(error_rect, Theme::getInstance()->bg_darkest->background);
@@ -458,20 +500,20 @@ bool GeoMap::draw_osm_file(int zoom, int tile_x, int tile_y, int relative_x, int

    map_line_buffer.resize(clip_w);

-    if (bmp.is_bottomup()) {
+    if (bmp->is_bottomup()) {
        for (int y = clip_h - 1; y >= 0; --y) {
            int source_row = src_y + y;
            int dest_row = dest_y + y;
-            bmp.seek(src_x, source_row);
-            bmp.read_next_px_cnt(map_line_buffer.data(), clip_w, false);
+            bmp->seek(src_x, source_row);
+            bmp->read_next_px_cnt(map_line_buffer.data(), clip_w, false);
            display.draw_pixels({dest_x + r.left(), dest_row + r.top(), clip_w, 1}, map_line_buffer);
        }
    } else {
        for (int y = 0; y < clip_h; ++y) {
            int source_row = src_y + y;
            int dest_row = dest_y + y;
-            bmp.seek(src_x, source_row);
-            bmp.read_next_px_cnt(map_line_buffer.data(), clip_w, false);
+            bmp->seek(src_x, source_row);
+            bmp->read_next_px_cnt(map_line_buffer.data(), clip_w, false);
            display.draw_pixels({dest_x + r.left(), dest_row + r.top(), clip_w, 1}, map_line_buffer);
        }
    }
@@ -30,13 +30,16 @@
 #include "bmpfile.hpp"
 #include "mathdef.hpp"

+#include <array>
+#include <cstdio>
+#include <inttypes.h>
 #include "portapack.hpp"

 namespace ui {

 #define MAX_MAP_ZOOM_IN 4000
-#define MAX_MAP_ZOOM_OUT 10
-#define MAP_ZOOM_RESOLUTION_LIMIT 5  // Max zoom-in to show map; rect height & width must divide into this evenly
+#define MAX_MAP_ZOOM_OUT 15
+#define MAP_ZOOM_RESOLUTION_LIMIT 10  // Max zoom-in to show map;

 #define INVALID_LAT_LON 200
 #define INVALID_ANGLE 400
@@ -74,6 +77,101 @@ struct GeoMarker {
    }
 };

+class BMPFileCache {
+   public:
+    static constexpr uint8_t SlotsCount = 9;
+
+    BMPFileCache() {
+    }
+
+    ~BMPFileCache() {
+        clear();
+    }
+
+    BMPFile* get(const int32_t z, const int32_t x, const int32_t y) {
+        // Cache hit.
+        for (auto& slot : slots_) {
+            if (slot.used && slot.x == x && slot.y == y && slot.z == z) {
+                slot.last_used = next_stamp();
+                return &slot.bmp;
+            }
+        }
+
+        // Select free slot first, otherwise LRU slot.
+        Slot* target = nullptr;
+        uint16_t oldest = 0xFFFFu;
+        for (auto& slot : slots_) {
+            if (!slot.used) {
+                target = &slot;
+                break;
+            }
+            if (slot.last_used < oldest) {
+                oldest = slot.last_used;
+                target = &slot;
+            }
+        }
+
+        if (!target) {
+            return nullptr;
+        }
+
+        if (target->used) {
+            target->bmp.close();
+            target->used = false;
+        }
+
+        // OSM tile path convention: <base>/<z>/<x>/<y>.bmp
+        char path_buffer[64];
+        snprintf(path_buffer, sizeof(path_buffer), "/OSM/%" PRId32 "/%" PRId32 "/%" PRId32 ".bmp", z, x, y);
+
+        if (!target->bmp.open(path_buffer, true)) {
+            target->bmp.close();
+            return nullptr;
+        }
+
+        target->x = x;
+        target->y = y;
+        target->z = z;
+        target->last_used = next_stamp();
+        target->used = true;
+        return &target->bmp;
+    }
+
+    void clear() {
+        for (auto& slot : slots_) {
+            if (slot.used) {
+                slot.bmp.close();
+                slot.used = false;
+            }
+        }
+    }
+
+   private:
+    struct Slot {
+        BMPFile bmp{};
+        int32_t x{};
+        int32_t y{};
+        int32_t z{};
+        uint16_t last_used{};
+        bool used{false};
+    };
+
+    uint16_t next_stamp() {
+        if (++stamp_ == 0) {
+            uint16_t v = 1;
+            for (auto& slot : slots_) {
+                if (slot.used) {
+                    slot.last_used = v++;
+                }
+            }
+            stamp_ = v;
+        }
+        return stamp_;
+    }
+    std::array<Slot, SlotsCount> slots_{};
+    uint16_t stamp_{0};
+};
+
 class GeoPos : public View {
   public:
    enum alt_unit {
@@ -276,6 +374,7 @@ class GeoMap : public Widget {
    bool hide_center_marker_{false};
    GeoMapMode mode_{};
    File map_file{};
+    BMPFileCache bmp_cache{};
    bool map_opened{};
    bool map_visible{};
    uint16_t map_width{}, map_height{};
@@ -26,10 +26,7 @@
 #include "string_format.hpp"
 #include "ui_receiver.hpp"
 #include "ui_freqman.hpp"
-
-#ifndef PRALINE
 #include "audio.hpp"
-#endif

 using namespace portapack;

@@ -595,18 +592,13 @@ AudioVolumeField::AudioVolumeField(
          /* fill char */ ' '} {
    set_value(receiver_model.normalized_headphone_volume());

-#ifdef PRALINE
-    on_change = [](int32_t v) {
-        receiver_model.set_normalized_headphone_volume(v);
-#else
    on_change = [](int32_t vol) {
-        // don't call receiver model, because this widget shuld be able to handle volume settinsg from any app, regardless of the receiver model's enables state. like the tx apps should be able to set volume too.
-        // this is identical to the receiver model's method
+        // Don't call receiver_model here so volume can be adjusted even when ReceiverModel is disabled (e.g. TX apps/games).
+        // The dB mapping mirrors ReceiverModel::set_normalized_headphone_volume().
        uint8_t v = clip<uint8_t>(vol, 0, 99);
        auto new_volume = volume_t::decibel(v - 99) + audio::headphone::volume_range().max;
        persistent_memory::set_headphone_volume(new_volume);
        audio::headphone::set_volume(new_volume);
-#endif
    };
 }

@@ -49,6 +49,7 @@
 #include "ui_recon.hpp"
 #include "ui_search.hpp"
 #include "ui_settings.hpp"
+#include "ui_textentry.hpp"
 #include "ui_sonde.hpp"
 #include "ui_ss_viewer.hpp"
 // #include "ui_test.hpp"
@@ -139,6 +140,115 @@ bool NavigationView::StartAppByName(const char* name) {
    return false;
 }

+/* App search ***********************************************************/
+
+namespace {
+
+// ASCII, allocation-free, case-insensitive lowering. Kept local so this TU
+// doesn't need to include <cctype> just for one small comparison.
+char ascii_lower(char c) {
+    return (c >= 'A' && c <= 'Z') ? static_cast<char>(c - 'A' + 'a') : c;
+}
+
+// True when 'needle' occurs anywhere in 'haystack', case-insensitive.
+bool name_contains(const char* haystack, const std::string& needle) {
+    const size_t n = needle.size();
+    if (n == 0)
+        return false;
+    for (size_t i = 0; haystack[i] != '\0'; ++i) {
+        size_t j = 0;
+        while (j < n && haystack[i + j] != '\0' &&
+               ascii_lower(haystack[i + j]) == ascii_lower(needle[j]))
+            ++j;
+        if (j == n)
+            return true;
+    }
+    return false;
+}
+
+}  // namespace
+
+void NavigationView::start_app_search() {
+    app_search_query_.clear();
+    app_search_committed_ = false;
+
+    // Reuse the shared keyboard view; it is destroyed as soon as the user
+    // confirms or cancels, so no search UI ever lingers in RAM.
+    text_prompt(*this, app_search_query_, 20, ENTER_KEYBOARD_MODE_ALPHA,
+                [this](std::string& query) {
+                    // Runs while the keyboard is still alive: only record that a
+                    // query was confirmed; results are built once it has popped.
+                    app_search_committed_ = !query.empty();
+                });
+
+    // Defer building/showing the results until the keyboard view has popped.
+    set_on_pop([this]() { open_app_search_results(); });
+}
+
+void NavigationView::open_app_search_results() {
+    if (!app_search_committed_)
+        return;  // user cancelled with Back, or the query was empty
+    app_search_committed_ = false;
+
+    std::vector<AppSearchEntry> matches;
+
+    // Internal apps: match on the name shown in the menus.
+    for (const auto& app : appList) {
+        if (app.displayName != nullptr && app.viewFactory != nullptr &&
+            name_contains(app.displayName, app_search_query_))
+            matches.push_back({app.displayName, app.viewFactory, {}});
+    }
+
+    // External (.ppma) and standalone (.ppmp) apps on the SD card. The
+    // enumerator hands back pointers to short-lived buffers, so the names are
+    // copied into owned strings here. Match on both the friendly name and the
+    // file (call) name. module_included=false: PPmod apps can't be launched by
+    // path, so they're intentionally excluded.
+    ExternalItemsMenuLoader::load_all_external_items_callback(
+        [this, &matches](AppInfoConsole& info) {
+            if (name_contains(info.appFriendlyName, app_search_query_) ||
+                name_contains(info.appCallName, app_search_query_))
+                matches.push_back({info.appFriendlyName, nullptr, info.appCallName});
+        },
+        false);
+
+    if (matches.empty()) {
+        display_modal("Search", "No matching app found.");
+        return;
+    }
+
+    push<AppSearchResultsView>(std::move(matches));
+}
+
+void NavigationView::launch_search_entry(ViewFactoryBase* factory, std::string call_name) {
+    // Same close-then-open contract as StartAppByName: drop the search UI
+    // (freeing the results view and the very button that called us) before
+    // starting the target, so only one app is ever resident. Everything used
+    // below is a by-value argument or this resident NavigationView.
+    home(false);
+
+    if (factory != nullptr) {
+        push_view(factory->produce(*this));
+        return;
+    }
+
+    // External/standalone: AppInfoConsole doesn't record which kind it is, so
+    // try both extensions the way handle_autostart() does.
+    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv;
+
+    std::string appwithpath = "/" + apps_dir.string() + "/" + call_name + ".ppma";
+    std::filesystem::path pth = conv.from_bytes(appwithpath.c_str());
+    if (ExternalItemsMenuLoader::run_external_app(*this, pth))
+        return;
+
+    appwithpath = "/" + apps_dir.string() + "/" + call_name + ".ppmp";
+    pth = conv.from_bytes(appwithpath.c_str());
+    if (ExternalItemsMenuLoader::run_standalone_app(*this, pth))
+        return;
+
+    display_modal("Search", "Failed to start:\n" + call_name);
+}
+
 /* StatusTray ************************************************************/

 StatusTray::StatusTray(Point pos)
@@ -561,6 +671,7 @@ InformationView::InformationView(
    NavigationView& nav)
    : nav_(nav) {
    add_children({&backdrop,
+                  &search_icon,
                  &version,
                  &ltime});

@@ -604,6 +715,19 @@ bool InformationView::firmware_checksum_error() {
    return fw_checksum_error;
 }

+bool InformationView::on_touch(const TouchEvent event) {
+    // The whole info bar is one touch target. Capture on Start so the End
+    // event is delivered here, then act on release like a normal button tap.
+    switch (event.type) {
+        case TouchEvent::Type::End:
+            if (nav_.is_valid())
+                nav_.start_app_search();
+            return true;
+        default:
+            return true;
+    }
+}
+
 /* Navigation ************************************************************/

 bool NavigationView::is_top() const {
@@ -873,6 +997,32 @@ void GamesMenuView::on_populate() {
    add_external_items(nav_, app_location_t::GAMES, *this, return_icon ? 1 : 0);
 }

+/* AppSearchResultsView *************************************************/
+
+AppSearchResultsView::AppSearchResultsView(NavigationView& nav, std::vector<AppSearchEntry>&& entries)
+    : nav_(nav), entries_(std::move(entries)) {
+    set_max_rows(2);  // wider buttons: app names need the room
+}
+
+void AppSearchResultsView::on_populate() {
+    for (size_t i = 0; i < entries_.size(); ++i) {
+        const auto& entry = entries_[i];
+        // Internal apps are green, external/standalone orange, matching the
+        // "yellow-ish external" convention used elsewhere. No icon: the cheap
+        // enumerator doesn't decode external bitmaps.
+        add_item({entry.display,
+                  entry.factory ? Color::green() : Color::orange(),
+                  nullptr,
+                  [this, i]() {
+                      // Read the target off entries_ and pass it by value: the
+                      // call below frees this view via home(), so nothing after
+                      // it may touch 'this' or its members.
+                      nav_.launch_search_entry(entries_[i].factory, entries_[i].call_name);
+                  }},
+                 true);
+    }
+}
+
 /* SystemMenuView ********************************************************/

 void SystemMenuView::hackrf_mode(NavigationView& nav) {
@@ -86,6 +86,14 @@ struct AppInfoConsole {
    const app_location_t appLocation;
 };

+// One row in the app-search results list. Strings are owned copies: the
+// external-app enumerator hands back pointers to short-lived buffers.
+struct AppSearchEntry {
+    std::string display;       // friendly name shown to the user
+    ViewFactoryBase* factory;  // internal app factory, or nullptr for external/standalone
+    std::string call_name;     // external/standalone file name (no extension); unused when internal
+};
+
 class NavigationView : public View {
   public:
    std::function<void(const View&)> on_view_changed{};
@@ -138,12 +146,34 @@ class NavigationView : public View {
    bool StartAppByName(const char* name);  // Starts a View  (app) by name stored in appListFC. This is to start apps from console
    void handle_autostart();

+    // Opens a keyboard; once confirmed, shows a pick-list of every internal,
+    // external (.ppma) and standalone (.ppmp) app whose name matches the query.
+    // Reuses the transient text-entry view, so the only steady-state cost is
+    // the two members below; the keyboard and the results list are allocated
+    // only while a search is in progress.
+    void start_app_search();
+
+    // Launches one search result and drops the search UI first, so only one app
+    // is ever resident. 'factory' non-null selects an internal app; otherwise
+    // 'call_name' is an external/standalone app file name (no extension).
+    // Arguments are taken by value on purpose: home() below frees the results
+    // view (and the button that called this), so nothing here may touch it.
+    void launch_search_entry(ViewFactoryBase* factory, std::string call_name);
+
   private:
    struct ViewState {
        std::unique_ptr<View> view;
        std::function<void()> on_pop;
    };

+    // Builds and pushes the results list. Runs from the keyboard view's on_pop,
+    // i.e. after that view is fully destroyed, so pushing here can't be
+    // clobbered by the keyboard's own trailing pop().
+    void open_app_search_results();
+
+    std::string app_search_query_{};    // keyboard buffer, owned across its lifetime
+    bool app_search_committed_{false};  // true only when the user confirmed a non-empty query
+
    std::vector<ViewState> view_stack{};

    Widget* view() const;
@@ -329,6 +359,9 @@ class InformationView : public View {
    void refresh();
    bool firmware_checksum_error();

+    // Whole info bar is a touch target that opens the app search.
+    bool on_touch(const TouchEvent event) override;
+
   private:
    // static constexpr auto version_string = "v1.4.4"; // This is commented out as we are now setting the version via ENV (VERSION_STRING=v1.0.0)
    NavigationView& nav_;
@@ -337,8 +370,15 @@ class InformationView : public View {
        {0, 0, screen_width, 16},
        Theme::getInstance()->bg_darker->background};

+    // Visual hint that the info bar starts an app search when tapped.
+    Image search_icon{
+        {2, 0, 16, 16},
+        &bitmap_icon_search,
+        Color::yellow(),
+        Theme::getInstance()->bg_darker->background};
+
    Text version{
-        {2, 0, 11 * 8, 16},
+        {18, 0, 9 * 8, 16},  // 9 chars keeps room for the "FLASH ERR" indicator; right edge unchanged from before the icon
        VERSION_STRING};

    LiveDateTime ltime{
@@ -422,6 +462,19 @@ class SystemMenuView : public BtnGridView {
    void hackrf_mode(NavigationView& nav);
 };

+// Pick-list of apps matching an app-search query. Reuses the button grid so it
+// behaves (and launches on tap) exactly like the normal app menus.
+class AppSearchResultsView : public BtnGridView {
+   public:
+    AppSearchResultsView(NavigationView& nav, std::vector<AppSearchEntry>&& entries);
+    std::string title() const override { return "Search"; };
+
+   private:
+    NavigationView& nav_;
+    std::vector<AppSearchEntry> entries_;
+    void on_populate() override;
+};
+
 class SystemView : public View {
   public:
    SystemView(
@@ -220,11 +220,17 @@ endif()

 # Upstream hackrf headers now gate on IS_* macros normally populated by
 # hackrf/firmware/platform-detect.cmake. We don't include that here, so derive
-# the IS_* set from BOARD ourselves. IS_H1_R9 is forced to 0 (compile-time
-# constant) so `if (IS_H1_R9)` branches resolve without needing the runtime
-# detected_platform() symbol, which mayhem doesn't link in.
+# the IS_* set from BOARD ourselves. IS_H1_R9 must mirror the upstream
+# HACKRF_ONE definition: a *runtime* check on detected_platform(). The only
+# baseband image that compiles IS_H1_R9-gated upstream files (rf_path.c,
+# si5351c.c, sgpio.c, platform_gpio.c, platform_scu.c) is sd_over_usb, which
+# does link platform_detect.c and calls detect_hardware_platform() at startup.
+# Forcing IS_H1_R9=0 here silently compiled out all H1R9 behaviour, so a real
+# HackRF One r9 was configured with the OG clock/GPIO/RF-path setup in that
+# image. All usages are `#ifdef IS_H1_R9` + `if (IS_H1_R9)` (never arithmetic
+# `#if`), so a function-call expression is safe.
 if(BOARD STREQUAL "HACKRF_ONE")
-    set(BOARD_IS_DEFS "-DIS_HACKRF_ONE=1 -DIS_NOT_PRALINE=1 -DIS_H1_R9=0 -DIS_NOT_H1_R9=1 -DIS_NOT_RAD1O=1 -DIS_NOT_JAWBREAKER=1 -DIS_H1_OR_PRALINE=1 -DIS_H1_OR_RAD1O=1 -DIS_H1_OR_JAWBREAKER=1 -DIS_EXPANSION_COMPATIBLE=1")
+    set(BOARD_IS_DEFS "-DIS_HACKRF_ONE=1 -DIS_NOT_PRALINE=1 -D'IS_H1_R9=(detected_platform()==BOARD_ID_HACKRF1_R9)' -D'IS_NOT_H1_R9=(!IS_H1_R9)' -DIS_NOT_RAD1O=1 -DIS_NOT_JAWBREAKER=1 -DIS_H1_OR_PRALINE=1 -DIS_H1_OR_RAD1O=1 -DIS_H1_OR_JAWBREAKER=1 -DIS_EXPANSION_COMPATIBLE=1")
 elseif(BOARD STREQUAL "PRALINE")
    set(BOARD_IS_DEFS "-DIS_PRALINE=1 -DIS_NOT_HACKRF_ONE=1 -DIS_NOT_H1_R9=1 -DIS_NOT_RAD1O=1 -DIS_NOT_JAWBREAKER=1 -DIS_H1_OR_PRALINE=1 -DIS_FOUR_LEDS=1 -DIS_EXPANSION_COMPATIBLE=1")
 elseif(BOARD STREQUAL "RAD1O")
@@ -510,6 +516,20 @@ DeclareTargets(PFUT flash_utility)
 set(add_to_firmware FALSE)
 set(MODE_FLAGS "-O3")

+### VOR TX
+
+set(MODE_CPPSRC
+	proc_vor_tx.cpp
+)
+DeclareTargets(PVTX vor_tx)
+
+### VOR RX
+
+set(MODE_CPPSRC
+	proc_vor_rx.cpp
+)
+DeclareTargets(PVRX vor_rx)
+
 ### FLEX RX

 set(MODE_CPPSRC
@@ -0,0 +1,272 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2026 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_vor_rx.hpp"
+
+#include "audio_output.hpp"
+#include "audio_dma.hpp"
+#include "dsp_iir_config.hpp"
+#include "portapack_shared_memory.hpp"
+
+#include "event_m4.hpp"
+
+#include <algorithm>
+
+namespace {
+constexpr float kPi = 3.14159265358979323846f;
+}
+
+VorRx::VorRx() {
+    channel_spectrum.set_decimation_factor(1);
+
+    baseband_thread.start();
+    rssi_thread.start();
+}
+
+void VorRx::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);
+
+    channel_spectrum.feed(decim_1_out, channel_filter_low_f, channel_filter_high_f, channel_filter_transition);
+
+    // No decim_2 stage: the standard AM decim_2 filter is a ~4.5 kHz low-pass
+    // that would attenuate the 9960 Hz VOR subcarrier by ~60 dB and destroy the
+    // reference phase. The channel stays at 48 kHz so the subcarrier survives.
+    const auto channel_out = channel_filter.execute(decim_1_out, dst_buffer);
+
+    feed_channel_stats(channel_out);
+
+    auto audio = demod_am.execute(channel_out, audio_buffer);
+    if (vor_enabled) {
+        process_vor_metrics(audio);
+        // Strip the 9960 Hz subcarrier from the audible signal (the metrics
+        // above still ran on the unfiltered audio so the decode is unaffected).
+        audio_lpf_1.execute_in_place(audio);
+        audio_lpf_2.execute_in_place(audio);
+    }
+    audio_compressor.execute_in_place(audio);
+    audio_output.write(audio);
+}
+
+void VorRx::on_message(const Message* const message) {
+    switch (message->id) {
+        case Message::ID::UpdateSpectrum:
+        case Message::ID::SpectrumStreamingConfig:
+            channel_spectrum.on_message(message);
+            break;
+
+        case Message::ID::VorRxConfigure:
+            configure_vor(*reinterpret_cast<const VorRxConfigureMessage*>(message));
+            break;
+
+        case Message::ID::AMConfigure:
+            configure(*reinterpret_cast<const AMConfigureMessage*>(message));
+            break;
+
+        default:
+            break;
+    }
+}
+
+void VorRx::configure(const AMConfigureMessage& message) {
+    decim_0.configure(message.decim_0_filter.taps);
+    decim_1.configure(message.decim_1_filter.taps);
+    channel_filter.configure(message.channel_filter.taps, channel_filter_decimation_factor);
+
+    constexpr size_t decim_0_output_fs = baseband_fs / decim_0.decimation_factor;
+    constexpr size_t decim_1_output_fs = decim_0_output_fs / decim_1.decimation_factor;
+    constexpr size_t channel_filter_input_fs = decim_1_output_fs;
+
+    channel_filter_low_f = message.channel_filter.low_frequency_normalized * channel_filter_input_fs;
+    channel_filter_high_f = message.channel_filter.high_frequency_normalized * channel_filter_input_fs;
+    channel_filter_transition = message.channel_filter.transition_normalized * channel_filter_input_fs;
+
+    channel_spectrum.set_decimation_factor(message.channel_spectrum_decimation_factor);
+    audio_output.configure(message.audio_hpf_lpf_config);
+
+    configured = true;
+}
+
+void VorRx::PhaseOscillator::configure(float frequency_hz, float sample_rate_hz) {
+    const float step = 2.0f * kPi * frequency_hz / sample_rate_hz;
+    step_sin = sinf(step);
+    step_cos = cosf(step);
+    sin_v = 0.0f;
+    cos_v = 1.0f;
+}
+
+void VorRx::PhaseOscillator::advance() {
+    const float next_cos = (cos_v * step_cos) - (sin_v * step_sin);
+    const float next_sin = (sin_v * step_cos) + (cos_v * step_sin);
+    cos_v = next_cos;
+    sin_v = next_sin;
+}
+
+void VorRx::PhaseOscillator::renormalize() {
+    // The recursive rotator slowly drifts in amplitude over long runs;
+    // rescale to the unit circle so accumulated tone levels stay meaningful.
+    const float mag = sqrtf((cos_v * cos_v) + (sin_v * sin_v));
+    if (mag > 0.0f) {
+        const float inv = 1.0f / mag;
+        cos_v *= inv;
+        sin_v *= inv;
+    }
+}
+
+void VorRx::configure_vor(const VorRxConfigureMessage& message) {
+    vor_enabled = message.enabled;
+    vor_reference_osc.configure(vor_reference_hz, 48000.0f);
+    vor_subcarrier_osc.configure(vor_subcarrier_hz, 48000.0f);
+    audio_lpf_1.configure(audio_48k_lpf_3200hz_config);
+    audio_lpf_2.configure(audio_48k_lpf_3200hz_config);
+    vor_ref_i = 0.0f;
+    vor_ref_q = 0.0f;
+    vor_var_i = 0.0f;
+    vor_var_q = 0.0f;
+    vor_dc_sum = 0.0f;
+    vor_sub_lp_i = 0.0f;
+    vor_sub_lp_q = 0.0f;
+    vor_sub_prev_i = 0.0f;
+    vor_sub_prev_q = 0.0f;
+    vor_sample_count = 0;
+}
+
+uint16_t VorRx::normalize_degrees(float degrees) {
+    while (degrees < 0.0f) {
+        degrees += 360.0f;
+    }
+    while (degrees >= 360.0f) {
+        degrees -= 360.0f;
+    }
+    return static_cast<uint16_t>(degrees + 0.5f);
+}
+
+void VorRx::send_vor_status(uint16_t phase_deg, uint16_t radial_deg, uint16_t ref_level, uint16_t var_level, uint8_t quality, bool valid, bool to_from) {
+    const VorRxStatusDataMessage message{phase_deg, radial_deg, ref_level, var_level, quality, valid, to_from};
+    shared_memory.application_queue.push(message);
+}
+
+void VorRx::process_vor_metrics(const buffer_f32_t& audio) {
+    for (size_t i = 0; i < audio.count; ++i) {
+        const float sample = audio.p[i];
+        const float ref_cos = vor_reference_osc.cosine();
+        const float ref_sin = vor_reference_osc.sine();
+        const float sub_cos = vor_subcarrier_osc.cosine();
+        const float sub_sin = vor_subcarrier_osc.sine();
+
+        // Variable signal: 30 Hz amplitude modulation of the carrier envelope.
+        // Correlate the envelope against a local 30 Hz tone (DC rejected because
+        // the window spans an exact integer number of 30 Hz cycles).
+        vor_dc_sum += sample;
+        vor_var_i += sample * ref_cos;
+        vor_var_q -= sample * ref_sin;
+
+        // Reference signal: 30 Hz FM on the 9960 Hz subcarrier. Quadrature
+        // down-convert the subcarrier, low-pass to its +/-480 Hz baseband, then
+        // FM-demodulate (phase difference between successive samples).
+        const float sc_i = sample * sub_cos;
+        const float sc_q = -sample * sub_sin;
+        vor_sub_lp_i += (1.0f - vor_sub_lp_alpha) * (sc_i - vor_sub_lp_i);
+        vor_sub_lp_q += (1.0f - vor_sub_lp_alpha) * (sc_q - vor_sub_lp_q);
+
+        const float num = (vor_sub_lp_q * vor_sub_prev_i) - (vor_sub_lp_i * vor_sub_prev_q);
+        const float den = (vor_sub_lp_i * vor_sub_prev_i) + (vor_sub_lp_q * vor_sub_prev_q);
+        const float fm = atan2f(num, den);
+        vor_sub_prev_i = vor_sub_lp_i;
+        vor_sub_prev_q = vor_sub_lp_q;
+
+        vor_ref_i += fm * ref_cos;
+        vor_ref_q -= fm * ref_sin;
+
+        vor_reference_osc.advance();
+        vor_subcarrier_osc.advance();
+
+        ++vor_sample_count;
+        if (vor_sample_count < vor_window_samples) {
+            continue;
+        }
+
+        const float inv_n = 1.0f / static_cast<float>(vor_window_samples);
+        const float variable_phase = atan2f(vor_var_q, vor_var_i);
+        const float reference_phase = atan2f(vor_ref_q, vor_ref_i);
+        // Real VOR radials increase clockwise, i.e. the variable tone lags the
+        // reference by the bearing. The decoder therefore reports
+        // (reference - variable); the opposite order mirrors every bearing to
+        // 360 - true. Add back the receive-chain phase lag (see
+        // vor_ref_phase_lag_deg): with this subtraction order the delayed
+        // reference makes the raw radial read low, so the correction is added.
+        float phase_diff = ((reference_phase - variable_phase) * 180.0f / kPi) + vor_ref_phase_lag_deg;
+        while (phase_diff < 0.0f) {
+            phase_diff += 360.0f;
+        }
+        while (phase_diff >= 360.0f) {
+            phase_diff -= 360.0f;
+        }
+
+        // Scale-invariant lock metrics (independent of RF/AGC level):
+        //  - var_ratio: 30 Hz AM depth vs. carrier DC (~0.30 for a real VOR).
+        //  - ref_amp:   FM-demodulated 30 Hz amplitude (phase-only, so it does
+        //               not depend on signal amplitude, ~0.065 when locked).
+        const float dc_level = vor_dc_sum * inv_n;
+        const float var_amp = 2.0f * sqrtf((vor_var_i * vor_var_i) + (vor_var_q * vor_var_q)) * inv_n;
+        const float ref_amp = 2.0f * sqrtf((vor_ref_i * vor_ref_i) + (vor_ref_q * vor_ref_q)) * inv_n;
+        const float var_ratio = (dc_level > 0.0f) ? (var_amp / dc_level) : 0.0f;
+
+        const auto phase_deg = normalize_degrees(phase_diff);
+        const auto radial_deg = phase_deg;
+        const auto ref_level = static_cast<uint16_t>(std::min(65535.0f, ref_amp * 10000.0f));
+        const auto var_level = static_cast<uint16_t>(std::min(65535.0f, var_ratio * 1000.0f));
+        const bool valid = (ref_amp > 0.03f) && (var_ratio > 0.15f);
+        // TO/FROM depends on the operator-selected OBS course, which only the
+        // application knows, so it is derived there (see VorRxView). Emit a
+        // stable placeholder here rather than a radial-only guess.
+        const bool to_from = false;
+        uint8_t quality = 0;
+        if (valid) {
+            const float q = (ref_amp / 0.065f) * 100.0f;
+            quality = static_cast<uint8_t>(std::min(100.0f, std::max(0.0f, q)));
+        }
+
+        send_vor_status(phase_deg, radial_deg, ref_level, var_level, quality, valid, to_from);
+
+        vor_reference_osc.renormalize();
+        vor_subcarrier_osc.renormalize();
+        vor_sample_count = 0;
+        vor_ref_i = 0.0f;
+        vor_ref_q = 0.0f;
+        vor_var_i = 0.0f;
+        vor_var_q = 0.0f;
+        vor_dc_sum = 0.0f;
+    }
+}
+
+int main() {
+    audio::dma::init_audio_out();
+
+    EventDispatcher event_dispatcher{std::make_unique<VorRx>()};
+    event_dispatcher.run();
+    return 0;
+}
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2026 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_VOR_RX_H__
+#define __PROC_VOR_RX_H__
+
+#include "baseband_processor.hpp"
+#include "baseband_thread.hpp"
+#include "rssi_thread.hpp"
+
+#include "dsp_decimate.hpp"
+#include "dsp_demodulate.hpp"
+#include "dsp_iir.hpp"
+#include "audio_compressor.hpp"
+
+#include "audio_output.hpp"
+#include "spectrum_collector.hpp"
+
+#include <array>
+#include <cstdint>
+#include <cmath>
+
+// Standalone VOR receiver baseband.
+// Demodulates the AM channel at 48 kHz (so the 9960 Hz subcarrier stays
+// representable) and decodes the 30 Hz reference vs. variable phase to derive
+// the radial.
+class VorRx : public BasebandProcessor {
+   public:
+    VorRx();
+
+    void execute(const buffer_c8_t& buffer) override;
+    void on_message(const Message* const message) override;
+
+   private:
+    static constexpr size_t baseband_fs = 3072000;
+    // VOR keeps the channel at 48 kHz instead of the AM audio 12 kHz, so the
+    // 9960 Hz subcarrier stays below Nyquist. The standard AM decim_2 stage is
+    // therefore omitted (its ~4.5 kHz low-pass would remove the subcarrier).
+    static constexpr size_t channel_filter_decimation_factor = 1;
+
+    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{};
+    int32_t channel_filter_low_f = 0;
+    int32_t channel_filter_high_f = 0;
+    int32_t channel_filter_transition = 0;
+    bool configured{false};
+    bool vor_enabled{false};
+
+    static constexpr float vor_reference_hz{30.0f};
+    static constexpr float vor_subcarrier_hz{9960.0f};
+    // 100 ms at 48 kHz (exactly 3 cycles of 30 Hz)
+    static constexpr uint32_t vor_window_samples{4800};
+    // One-pole low-pass to isolate the +/-480 Hz FM subcarrier baseband
+    // after quadrature down-conversion (corner ~600 Hz at 48 kHz).
+    static constexpr float vor_sub_lp_alpha{0.9245f};
+    // Fixed phase lag the receive chain adds to the recovered 30 Hz reference
+    // tone, expressed in degrees at 30 Hz. It comes almost entirely from the
+    // one-pole subcarrier low-pass above (~2.75 deg of lag at 30 Hz for
+    // alpha = 0.9245) plus a ~0.1 deg half-sample delay in the FM
+    // differentiator. Because the reference tone is delayed, the raw radial
+    // (reference - variable) reads low by this amount, so we add it back.
+    // Value verified by a TX->RX loopback (proc_vor_tx fed through this
+    // decoder): every transmitted radial decoded ~3.2 deg low before this
+    // correction, and on-bearing afterwards.
+    static constexpr float vor_ref_phase_lag_deg{3.2f};
+
+    struct PhaseOscillator {
+        float sin_v{0.0f};
+        float cos_v{1.0f};
+        float step_sin{0.0f};
+        float step_cos{1.0f};
+
+        void configure(float frequency_hz, float sample_rate_hz);
+        float cosine() const { return cos_v; }
+        float sine() const { return sin_v; }
+        void advance();
+        void renormalize();
+    } vor_reference_osc{}, vor_subcarrier_osc{};
+    // 30 Hz DFT accumulators for the variable (AM) and reference (FM) tones.
+    float vor_ref_i{0.0f};
+    float vor_ref_q{0.0f};
+    float vor_var_i{0.0f};
+    float vor_var_q{0.0f};
+    float vor_dc_sum{0.0f};
+    // Subcarrier quadrature down-converter / FM-demodulator state.
+    float vor_sub_lp_i{0.0f};
+    float vor_sub_lp_q{0.0f};
+    float vor_sub_prev_i{0.0f};
+    float vor_sub_prev_q{0.0f};
+    uint32_t vor_sample_count{0};
+
+    dsp::demodulate::AM demod_am{};
+    // Two cascaded 2nd-order Butterworth low-passes (4th-order total) that strip
+    // the 9960 Hz FM subcarrier out of the audio before it reaches the speaker.
+    // The channel is kept wide (48 kHz) so the subcarrier survives for the
+    // radial decode, so it must be filtered out of the audible path here.
+    IIRBiquadFilter audio_lpf_1{};
+    IIRBiquadFilter audio_lpf_2{};
+    FeedForwardCompressor audio_compressor{};
+    AudioOutput audio_output{};
+
+    SpectrumCollector channel_spectrum{};
+
+    /* NB: Threads should be the last members in the class definition. */
+#ifdef PRALINE
+    BasebandThread baseband_thread{baseband_fs, this, baseband::Direction::Receive,
+                                   /*auto_start*/ false};
+    RSSIThread rssi_thread{/*auto_start*/ false};
+#else
+    BasebandThread baseband_thread{baseband_fs, this, baseband::Direction::Receive};
+    RSSIThread rssi_thread{};
+#endif
+
+    void configure(const AMConfigureMessage& message);
+    void configure_vor(const VorRxConfigureMessage& message);
+    void process_vor_metrics(const buffer_f32_t& audio);
+    void send_vor_status(uint16_t phase_deg, uint16_t radial_deg, uint16_t ref_level, uint16_t var_level, uint8_t quality, bool valid, bool to_from);
+    static uint16_t normalize_degrees(float degrees);
+};
+
+#endif /*__PROC_VOR_RX_H__*/
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2026 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; if not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "proc_vor_tx.hpp"
+
+#include "morse.hpp"
+#include "sine_table_int8.hpp"
+#include "event_m4.hpp"
+
+void VorTxProcessor::execute(const buffer_c8_t& buffer) {
+    for (size_t i = 0; i < buffer.count; i++) {
+        if (!configured) {
+            buffer.p[i] = {0, 0};
+            continue;
+        }
+
+        // 30 Hz reference and variable tones (same frequency, offset by the radial).
+        const int32_t ref_sine = sine_table_i8[(phase_30 >> 24) & 0xFF];
+        const int32_t var_sine = sine_table_i8[((phase_30 - radial_offset) >> 24) & 0xFF];
+        phase_30 += delta_30;
+
+        // 9960 Hz subcarrier, FM-modulated +/- 480 Hz by the 30 Hz reference tone.
+        const int32_t sub_inc = static_cast<int32_t>(delta_sub) + ((ref_sine * static_cast<int32_t>(delta_480)) >> 7);
+        phase_sub += static_cast<uint32_t>(sub_inc);
+        const int32_t sub_sine = sine_table_i8[(phase_sub >> 24) & 0xFF];
+
+        // Optional 1020 Hz identification tone.
+        int32_t id_sine = 0;
+        if (ident_enabled && ident_tone_active()) {
+            id_sine = sine_table_i8[(phase_id >> 24) & 0xFF];
+            phase_id += delta_1020;
+        }
+
+        // DSB-AM envelope (carrier kept at LO -> Q = 0).
+        int32_t env = carrier_level + (((var_sine * var_depth) + (sub_sine * sub_depth) + (id_sine * id_depth)) >> 7);
+        if (env < 0) env = 0;
+        if (env > 127) env = 127;
+
+        buffer.p[i] = {static_cast<int8_t>(env), 0};
+    }
+}
+
+void VorTxProcessor::vor_tx_config(const VorTxConfigureMessage& message) {
+    // Real VOR radials increase clockwise: the variable tone lags the 30 Hz
+    // reference by the bearing, so the offset is subtracted (see the matching
+    // (reference - variable) decode in proc_vor_rx). A TX->RX loopback with this
+    // convention still decodes a transmitted radial of N degrees as N degrees,
+    // and it now matches real ground-station VOR bearings.
+    radial_offset = static_cast<uint32_t>(static_cast<uint64_t>(message.radial_deg % 360) * phase_period / 360);
+    ident_enabled = message.ident_enabled;
+
+    for (size_t i = 0; i < sizeof(ident_text); ++i)
+        ident_text[i] = message.ident_text[i];
+    ident_text[sizeof(ident_text) - 1] = '\0';
+    build_ident_schedule();
+
+    configured = message.enabled;
+}
+
+// Render the ident text into a repeating sequence of keyed-on / keyed-off
+// sample runs using the shared ITU Morse table. Timing is derived from the
+// standard "dot = 1200 / wpm" relation; letters are separated by a 3-unit gap,
+// words by 7 units, and a trailing gap pads each cycle to a fixed 10 s period.
+void VorTxProcessor::build_ident_schedule() {
+    ident_segment_count = 0;
+    ident_index = 0;
+    ident_sample_counter = 0;
+
+    const uint32_t dot_samples = static_cast<uint32_t>(1200ULL * baseband_fs / (ident_wpm * 1000ULL));
+
+    uint32_t total_samples = 0;
+    auto push_samples = [&](bool on, uint32_t samples) {
+        if (ident_segment_count >= max_ident_segments) return;
+        ident_segments[ident_segment_count++] = {on, samples};
+        total_samples += samples;
+    };
+    auto push = [&](bool on, uint32_t units) {
+        push_samples(on, units * dot_samples);
+    };
+
+    bool any = false;
+    for (size_t n = 0; n < sizeof(ident_text) && ident_text[n]; ++n) {
+        char ch = ident_text[n];
+        if (ch >= 'a' && ch <= 'z') ch -= 32;
+
+        uint16_t code = 0;
+        if (ch >= '!' && ch <= '_') code = morse::morse_ITU[ch - '!'];
+
+        if (!code) {
+            // Space or unsupported character: word gap between symbols.
+            if (any) push(false, MORSE_WORD_SPACE);
+            continue;
+        }
+
+        const uint16_t code_size = code & 7;
+        for (uint16_t c = 0; c < code_size; ++c) {
+            const bool dash = ((code << c) & 0x8000) != 0;
+            push(true, dash ? MORSE_DASH : MORSE_DOT);
+            if (c + 1 < code_size)
+                push(false, MORSE_SYMBOL_SPACE);
+        }
+        push(false, MORSE_LETTER_SPACE);
+        any = true;
+    }
+
+    if (!any) {
+        // No sendable characters: disable keying entirely.
+        ident_segment_count = 0;
+        return;
+    }
+
+    // Pad the trailing silence so ident-start to ident-start is a full 10 s.
+    // If the keyed sequence is somehow longer than the period, fall back to a
+    // one word-space gap so repeats never run back-to-back.
+    const uint32_t min_gap = MORSE_WORD_SPACE * dot_samples;
+    const uint32_t gap = (ident_period_samples > total_samples + min_gap)
+                             ? ident_period_samples - total_samples
+                             : min_gap;
+    push_samples(false, gap);
+}
+
+// Advances the keying schedule by one sample and returns whether the ident
+// tone should be sounding right now. Returns false when there is nothing to
+// send so the caller leaves the ident tone off.
+bool VorTxProcessor::ident_tone_active() {
+    if (ident_segment_count == 0) return false;
+
+    if (ident_sample_counter == 0)
+        ident_sample_counter = ident_segments[ident_index].length;
+
+    const bool on = ident_segments[ident_index].on;
+
+    if (ident_sample_counter == 0 || --ident_sample_counter == 0) {
+        ++ident_index;
+        if (ident_index >= ident_segment_count) ident_index = 0;
+    }
+
+    return on;
+}
+
+void VorTxProcessor::on_message(const Message* const msg) {
+    if (msg->id == Message::ID::VorTxConfigure) {
+        vor_tx_config(*reinterpret_cast<const VorTxConfigureMessage*>(msg));
+    }
+}
+
+int main() {
+    EventDispatcher event_dispatcher{std::make_unique<VorTxProcessor>()};
+    event_dispatcher.run();
+    return 0;
+}
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2026 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; if not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __PROC_VOR_TX_H__
+#define __PROC_VOR_TX_H__
+
+#include "baseband_processor.hpp"
+#include "baseband_thread.hpp"
+
+// Generates a conventional VOR composite signal as DSB-AM (carrier at LO, Q = 0):
+//   - 30 Hz "variable" tone, amplitude-modulated directly (phase = transmitted radial)
+//   - 9960 Hz subcarrier, FM-modulated (+/- 480 Hz) by a 30 Hz "reference" tone
+//   - optional 1020 Hz identification tone
+// The radial encoded is the phase difference between the variable and reference 30 Hz tones.
+class VorTxProcessor : public BasebandProcessor {
+   public:
+    void execute(const buffer_c8_t& buffer) override;
+    void on_message(const Message* const msg) override;
+
+   private:
+    static constexpr size_t baseband_fs = 1536000;
+    static constexpr uint64_t phase_period = 1ULL << 32;
+    // Per-sample phase increments (top byte indexes the 256-entry sine table).
+    static constexpr uint32_t delta_30 = static_cast<uint32_t>(30ULL * phase_period / baseband_fs);
+    static constexpr uint32_t delta_sub = static_cast<uint32_t>(9960ULL * phase_period / baseband_fs);
+    static constexpr uint32_t delta_1020 = static_cast<uint32_t>(1020ULL * phase_period / baseband_fs);
+    static constexpr uint32_t delta_480 = static_cast<uint32_t>(480ULL * phase_period / baseband_fs);
+
+    // AM levels (int8 scale). carrier_level + sum of contributions must stay <= 127.
+    static constexpr int32_t carrier_level = 60;
+    static constexpr int32_t var_depth = 18;  // ~30% of carrier
+    static constexpr int32_t sub_depth = 18;  // ~30% of carrier
+    static constexpr int32_t id_depth = 6;    // ~10% of carrier
+
+    // CW identifier keying. Real VOR stations key the 1020 Hz ident tone in
+    // Morse at ~7 words per minute, so the schedule below is expressed in
+    // "dot" time units and rendered to on/off sample runs at config time.
+    static constexpr uint32_t ident_wpm = 7;
+    static constexpr size_t max_ident_segments = 128;
+
+    // VOR ident is transmitted at least every 10 s; repeat the keyed identifier
+    // on a fixed 10 s cycle (ident start to next ident start).
+    static constexpr uint32_t ident_period_samples = 10 * baseband_fs;
+
+    struct IdentSegment {
+        bool on;
+        uint32_t length;  // duration in samples
+    };
+
+    uint32_t phase_30{0};
+    uint32_t phase_sub{0};
+    uint32_t phase_id{0};
+    uint32_t radial_offset{0};
+
+    bool ident_enabled{true};
+    bool configured{false};
+
+    char ident_text[8]{};
+    IdentSegment ident_segments[max_ident_segments]{};
+    size_t ident_segment_count{0};
+    size_t ident_index{0};
+    uint32_t ident_sample_counter{0};
+
+    void vor_tx_config(const VorTxConfigureMessage& message);
+    void build_ident_schedule();
+    bool ident_tone_active();
+
+    /* NB: Threads should be the last members in the class definition. */
+    BasebandThread baseband_thread{baseband_fs, this, baseband::Direction::Transmit};
+};
+
+#endif /* __PROC_VOR_TX_H__ */
@@ -772,7 +772,7 @@ void cpu_clock_init(void) {
 clock_source_t activate_best_clock_source(void) {
 #ifdef HACKRF_ONE
    /* Ensure PortaPack reference oscillator is off while checking for external clock input. */
-    if (portapack_reference_oscillator && portapack()) {
+    if (portapack_present()) {
        portapack_reference_oscillator(false);
    }
 #endif
@@ -785,7 +785,7 @@ clock_source_t activate_best_clock_source(void) {
    } else {
 #ifdef HACKRF_ONE
        /* Enable PortaPack reference oscillator (if present), and check for valid clock. */
-        if (portapack_reference_oscillator && portapack()) {
+        if (portapack_present()) {
            portapack_reference_oscillator(true);
            delay(510000); /* loop iterations @ 204MHz for >10ms for oscillator to enable. */
            if (si5351c_clkin_signal_valid(&clock_gen)) {
@@ -26,11 +26,12 @@
 #include <libopencm3/lpc43xx/scu.h>
 #include <libopencm3/lpc43xx/rgu.h>
 #include <libopencm3/lpc43xx/wwdt.h>
-#include "delay.h"
 #include "string.h"

 volatile bool usb_bulk_block_done = false;

+void delay(uint32_t duration);
+
 void usb_bulk_block_cb(void* user_data, unsigned int bytes_transferred) {
    usb_bulk_block_done = true;

@@ -52,9 +52,9 @@
 */

 #ifdef PRALINE
-#define SCU_ARRAY_SIZE 78
+#define SCU_ARRAY_SIZE 80
 #else
-#define SCU_ARRAY_SIZE 56
+#define SCU_ARRAY_SIZE 57
 #endif

 typedef struct {
@@ -41,7 +41,7 @@ void BatteryManagement::getBatteryInfo(uint8_t& valid_mask, uint8_t& percent, ui
    if (dev) {
        voltage = ((i2cdev::I2cDev_ADS1110*)dev)->readVoltage();
        percent = calc_percent_voltage(voltage);
-        valid_mask = 1;
+        valid_mask = BATT_VALID_VOLTAGE | BATT_VALID_PERCENT;
        return;
    }

@@ -105,6 +105,7 @@ bool BMPFile::open(const std::filesystem::path& file, bool readonly) {
    if (!((bmp_header.signature == 0x4D42) &&
          (bmp_header.planes == 1) &&
          (bmp_header.compression == 0 || bmp_header.compression == 3))) {
+        bmpimage.close();
        return false;
    }

@@ -114,6 +115,7 @@ bool BMPFile::open(const std::filesystem::path& file, bool readonly) {
            byte_per_px = 1;
            // bmpimage.seek(sizeof(bmp_header_t));
            // bmpimage.read(color_palette, 1024);
+            bmpimage.close();
            return false;  // niy
            break;

@@ -121,6 +123,7 @@ bool BMPFile::open(const std::filesystem::path& file, bool readonly) {
            byte_per_px = 2;
            type = 5;
            if (bmp_header.compression == 3) {
+                bmpimage.close();
                return false;
            }  // niy

@@ -135,6 +138,7 @@ bool BMPFile::open(const std::filesystem::path& file, bool readonly) {
            break;
        default:
            // not supported
+            bmpimage.close();
            return false;
    }
    byte_per_row = (bmp_header.width * byte_per_px + 3) & ~3;
@@ -119,4 +119,12 @@ constexpr iir_biquad_config_t apt_audio_12k_lpf_2000hz_config{
    {0.15505103f, 0.31010205f, 0.15505103f},
    {1.00000000f, -0.6202041f, 0.24040821f}};

+// scipy.signal.butter(2, 3200 / 24000.0, 'low', analog=False)
+// VOR RX audio low-pass. Removes the 9960 Hz FM subcarrier (the annoying
+// high-pitch whine) while passing voice and the 1020 Hz ident tone. Cascade
+// two of these sections for a 4th-order roll-off (~44 dB at 9960 Hz).
+constexpr iir_biquad_config_t audio_48k_lpf_3200hz_config{
+    {0.03357181f, 0.06714362f, 0.03357181f},
+    {1.00000000f, -1.41898265f, 0.55326989f}};
+
 #endif /*__DSP_IIR_CONFIG_H__*/
@@ -23,6 +23,8 @@

 #include "platform.hpp"

+using namespace gpio_control;
+
 namespace power_control {

 /* VAA powers:
@@ -53,7 +55,7 @@ void vaa_power_on(void) {
    }

    /* Latch VAA to ON state (Active LOW) */
-    LPC_GPIO->CLR[4] = (1 << 1);
+    VAA_en.setActive();

 #else
    if (hackrf_r9) {
@@ -104,8 +106,8 @@ void vaa_power_on(void) {
        }

        /* Hold !VAA_ENABLE active using a GPIO, so we can reclaim and shut down the MOTOCONPWM peripheral. */
-        LPC_GPIO->CLR[2] = (1 << 9);  // !VAA_ENABLE
-        LPC_GPIO->DIR[2] |= (1 << 9);
+        og_VAA_en.output();
+        og_VAA_en.setActive();
        setup_pin(pin_setup_vaa_enablex_gpio_og);  // P5_0 /GPIO2[ 9]/MCOB2: !VAA_ENABLE, 10K PU

        peripheral_reset(&motocon_pwm_resources.reset);
@@ -122,16 +124,13 @@ void vaa_power_off(void) {
     */
 #ifdef PRALINE
    /* Safe state: OFF (VAA RF is active LOW, so Set = OFF) */
-    LPC_GPIO->SET[4] = (1 << 1);
-
-    /* Turn OFF LED3 (TX) */
-    LPC_GPIO->SET[2] = (1 << 8);
+    VAA_en.setInactive();

 #else
    if (hackrf_r9) {
-        LPC_GPIO->W3[6] = 1;  // Turn OFF VAA for r9 P6_10
+        r9_VAA_en.setInactive();  // Turn OFF VAA for r9 P6_10
    } else {
-        LPC_GPIO->W2[9] = 1;  // Turn OFF VAA for OG P5_0
+        og_VAA_en.setInactive();  // Turn OFF VAA for OG P5_0
    }
 #endif
 }
@@ -150,34 +149,29 @@ void aux_power_off(void) {

 #endif /* PRALINE */

-void core_power_on(void) {  // Core power enable
+void core_power_on(void) {
 #ifdef PRALINE
    // 1.2V FPGA - P8_7 = GPIO4[7], Active HIGH (Set = ON)
-    LPC_GPIO->SET[4] = (1 << 7);
+    en_1v2.setActive();

 #else
    if (hackrf_r9) {
-        // P5_0 (GPIO2[9]) is the EN1V8 pin
-        LPC_GPIO->SET[2] = (1 << 9);
+        r9_1v8_en.setActive();
    } else {
-        // On older OG HackRF boards, P6_10 (GPIO3[6]) is the EN1V8 pin
-        LPC_GPIO->SET[3] = (1 << 6);
+        og_1v8_en.setActive();
    }
 #endif
 }

-void core_power_off(void) {  // Core power disable
+void core_power_off(void) {
 #ifdef PRALINE
-    // 1.2V FPGA - P8_7 = GPIO4[7], Active HIGH (Clear = OFF) */
-    LPC_GPIO->CLR[4] = (1 << 7);
+    en_1v2.setInactive();

 #else
    if (hackrf_r9) {
-        // P5_0 (GPIO2[9]) is the EN1V8 pin
-        LPC_GPIO->CLR[2] = (1 << 9);
+        r9_1v8_en.setInactive();
    } else {
-        // On older OG HackRF boards, P6_10 (GPIO3[6]) is the EN1V8 pin
-        LPC_GPIO->CLR[3] = (1 << 6);
+        og_1v8_en.setInactive();
    }
 #endif
 }
@@ -28,7 +28,7 @@

 #include "ch.h"
 #include "hal.h"
-#include "pal.h"
+#include "pal_lld.h"

 struct PinConfig {
    const uint32_t mode;
@@ -200,6 +200,12 @@ struct Pin {
    uint8_t _pin_pad;
 };

+// Defines the logical polarity of the GPIO pin
+enum class Polarity {
+    ActiveHigh,  // High physical state means the function is ON (default)
+    ActiveLow    // Low physical state means the function is ON (inverted)
+};
+
 struct GPIO {
    // GPIO() = delete;
    // GPIO(const GPIO& gpio) = delete;
@@ -209,22 +215,15 @@ struct GPIO {
        const Pin& pin,
        const ioportid_t gpio_port,
        const iopadid_t gpio_pad,
-        const uint16_t gpio_mode)
+        const uint16_t gpio_mode,
+        const Polarity polarity = Polarity::ActiveHigh)  // Default parameter ensures backward compatibility
        : _pin{pin},
          _gpio_port{gpio_port},
          _gpio_pad{gpio_pad},
-          _gpio_mode{gpio_mode} {
+          _gpio_mode{gpio_mode},
+          _polarity{polarity} {
    }
-    /*
-        constexpr GPIO(
-                const GPIO& gpio
-        ) : _pin { gpio._pin },
-                _gpio_port { gpio._gpio_port },
-                _gpio_pad { gpio._gpio_pad },
-                _gpio_mode { gpio._gpio_mode }
-        {
-        }
-*/
+
    constexpr ioportid_t port() const {
        return _gpio_port;
    }
@@ -237,6 +236,11 @@ struct GPIO {
        return _pin;
    }

+    // Returns the configured polarity of the pin
+    constexpr Polarity polarity() const {
+        return _polarity;
+    }
+
    void configure() const {
        _pin.mode(_gpio_mode);
    }
@@ -245,6 +249,8 @@ struct GPIO {
        return _gpio_mode;
    }

+    // Physical Level Operations
+
    void set() const {
        palSetPad(_gpio_port, _gpio_pad);
    }
@@ -273,6 +279,39 @@ struct GPIO {
        return palReadPad(_gpio_port, _gpio_pad);
    }

+    // Turns the feature ON based on its polarity
+    void setActive() const {
+        if (_polarity == Polarity::ActiveHigh) {
+            set();
+        } else {
+            clear();
+        }
+    }
+
+    // Turns the feature OFF based on its polarity
+    void setInactive() const {
+        if (_polarity == Polarity::ActiveHigh) {
+            clear();
+        } else {
+            set();
+        }
+    }
+
+    // Sets the logical state of the feature
+    void setState(const bool active) const {
+        if (active) {
+            setActive();
+        } else {
+            setInactive();
+        }
+    }
+
+    // Returns true if the feature is logically active/enabled
+    bool isEnabled() const {
+        const bool physical_state = read();
+        return (_polarity == Polarity::ActiveHigh) ? physical_state : !physical_state;
+    }
+
    bool operator!=(const GPIO& other) const {
        return (port() != other.port()) || (pad() != other.pad());
    }
@@ -281,6 +320,7 @@ struct GPIO {
    const ioportid_t _gpio_port;
    const iopadid_t _gpio_pad;
    const uint16_t _gpio_mode;
+    const Polarity _polarity;
 };

 constexpr uint32_t boot_bit(const GPIO& pin, bool state) {
@@ -306,7 +346,6 @@ inline void setup_pins(const std::array<scu_setup_t, N>& pins_setup) {
    }
 }

-#ifdef PRALINE
 namespace gpio_control {

 struct PinMap {
@@ -314,54 +353,325 @@ struct PinMap {
    uint8_t scu_pin;
    uint8_t gpio_port;
    uint8_t gpio_pad;
+    uint8_t gpio_mode;
 };

-constexpr PinMap map_p1_ctrl0{2, 10, 0, 14};  // SCU: 2, 10 | GPIO: 0, 14
-constexpr PinMap map_p1_ctrl1{6, 8, 5, 16};
-constexpr PinMap map_p1_ctrl2{6, 9, 3, 5};
-constexpr PinMap map_p2_ctrl0{8, 3, 7, 3};
-constexpr PinMap map_p2_ctrl1{8, 4, 7, 4};
-constexpr PinMap map_trigger_out{2, 6, 5, 6};
-constexpr PinMap map_trigger_in{13, 12, 6, 26};
+#ifdef PRALINE
+constexpr PinMap map_p1_ctrl0{2, 10, 0, 14, 0};  // SCU: 2, 10 | GPIO: 0, 14
+constexpr PinMap map_p1_ctrl1{6, 8, 5, 16, 4};
+constexpr PinMap map_p1_ctrl2{6, 9, 3, 5, 0};

-constexpr PinMap map_rf5072_mix_en{9, 0, 4, 12};
+constexpr PinMap map_p2_ctrl0{14, 3, 7, 3, 0};
+constexpr PinMap map_p2_ctrl1{14, 4, 7, 4, 0};

-constexpr PinMap map_aa_en{1, 14, 1, 7};  // Anti-Aliasing filter
+constexpr PinMap map_trigger_out{2, 6, 5, 6, 4};
+constexpr PinMap map_trigger_in{13, 12, 6, 26, 4};
+
+constexpr PinMap map_clkin_ctrl{1, 20, 0, 15, 0};
+
+constexpr PinMap map_rf5072_mix_en{9, 0, 4, 12, 0};
+
+constexpr PinMap map_aa_en{1, 14, 1, 7, 0};  // Anti-Aliasing filter
+
+constexpr PinMap map_sgpio_4{9, 4, 5, 17, 6};
+constexpr PinMap map_sgpio_8{8, 0, 4, 0, 4};
+constexpr PinMap map_sgpio_9{9, 3, 4, 15, 6};
+constexpr PinMap map_sgpio_10{8, 2, 4, 2, 4};
+
+constexpr PinMap map_vregmode{4, 9, 5, 13, 4};
+constexpr PinMap map_en_1v2{8, 7, 4, 7, 0};
+constexpr PinMap map_VAA_en{8, 1, 4, 1, 0};
+constexpr PinMap map_aux_power_enable{6, 7, 5, 15, 4};
+
+constexpr PinMap map_ant_bias{2, 12, 1, 12, 0};
+
+constexpr PinMap map_ant_bias_oc{2, 11, 1, 11, 0};
+constexpr PinMap map_aux_power_oc{6, 11, 3, 7, 0};
+
+constexpr PinMap map_led_mcu{8, 6, 4, 6, 0};
+constexpr PinMap map_mix_bypass{6, 3, 3, 2, 0};
+constexpr PinMap map_lpf{10, 1, 4, 8, 4};
+constexpr PinMap map_tx_enable{6, 5, 3, 4, 0};
+constexpr PinMap map_rf_amp_enable{10, 2, 4, 9, 0};
+constexpr PinMap map_pps_in_out{2, 5, 5, 5, 4};
+// constexpr PinMap map_unused_1{2, 7, 0, 7, 0};
+
+#else
+constexpr PinMap map_sgpio_4{6, 3, 3, 2, 2};
+constexpr PinMap map_sgpio_8{9, 6, 4, 11, 6};
+constexpr PinMap map_sgpio_9{4, 3, 2, 3, 7};
+constexpr PinMap map_sgpio_10{1, 14, 1, 7, 6};
+constexpr PinMap map_sgpio_13{4, 8, 5, 12, 4};
+constexpr PinMap map_og_1v8_en{6, 10, 3, 6, 0};
+constexpr PinMap map_r9_1v8_en{5, 0, 2, 9, 0};
+constexpr PinMap map_vregmode{6, 11, 3, 7, 0};
+constexpr PinMap map_og_VAA_en{5, 0, 2, 9, 0};
+constexpr PinMap map_r9_VAA_en{6, 10, 3, 6, 0};
+constexpr PinMap map_rx_mix_bypass{6, 8, 5, 16, 4};
+constexpr PinMap map_tx_mix_bp{5, 2, 2, 11, 0};
+constexpr PinMap map_rx_mix_bp{5, 3, 2, 12, 0};
+constexpr PinMap map_tx_mix_bypass{1, 7, 1, 0, 0};
+constexpr PinMap map_og_rx{2, 5, 5, 5, 4};
+constexpr PinMap map_og_tx{6, 7, 5, 15, 4};
+constexpr PinMap map_r9_rx{2, 7, 0, 7, 0};
+constexpr PinMap map_lpf{5, 1, 2, 10, 0};
+constexpr PinMap map_hpf{4, 0, 2, 0, 0};
+constexpr PinMap map_amp_bypass{2, 10, 0, 14, 0};
+constexpr PinMap map_tx_amp{5, 6, 2, 15, 0};
+constexpr PinMap map_rx_amp{2, 11, 1, 11, 0};
+constexpr PinMap map_tx_amp_pwr{6, 9, 3, 5, 0};
+constexpr PinMap map_rx_amp_pwr{2, 12, 1, 12, 0};
+constexpr PinMap map_ant_bias{4, 4, 2, 4, 0};
+constexpr PinMap map_r9_mcu_clk_en{1, 1, 0, 8, 0};
+constexpr PinMap map_r9_clkout_en{1, 2, 0, 9, 0};
+constexpr PinMap map_r9_clkin_en{6, 7, 5, 15, 4};
+#endif
+
+constexpr PinMap map_sgpio_0{0, 0, 0, 0, 3};
+constexpr PinMap map_sgpio_1{0, 1, 0, 1, 3};
+constexpr PinMap map_sgpio_2{1, 15, 0, 2, 2};
+constexpr PinMap map_sgpio_3{1, 16, 0, 3, 2};
+constexpr PinMap map_sgpio_5{6, 6, 0, 5, 2};
+constexpr PinMap map_sgpio_6{2, 2, 5, 2, 0};
+constexpr PinMap map_sgpio_7{1, 0, 0, 4, 6};
+constexpr PinMap map_sgpio_11{1, 17, 0, 12, 6};
+constexpr PinMap map_sgpio_12{1, 18, 0, 13, 0};
+constexpr PinMap map_led_usb{4, 1, 2, 1, 0};
+constexpr PinMap map_led_rx{4, 2, 2, 2, 0};
+constexpr PinMap map_led_tx{6, 12, 2, 8, 0};
+
+constexpr PinMap map_dfu_boot_0{1, 1, 0, 8, 0};
+constexpr PinMap map_dfu_boot_1{1, 2, 0, 9, 0};
+constexpr PinMap map_dfu_button{2, 8, 5, 7, 4};
+constexpr PinMap map_lcd_wrx{2, 9, 1, 10, 0};
+constexpr PinMap map_isp{2, 7, 0, 7, 0};
+#ifdef PRALINE

 // P1 Multiplexer control pins
-constexpr Pin pin_p1_ctrl0{map_p1_ctrl0.scu_port, map_p1_ctrl0.scu_pin};                                         // SCU: P2_10
-constexpr GPIO p1_ctrl0{pin_p1_ctrl0, map_p1_ctrl0.gpio_port, map_p1_ctrl0.gpio_pad, PAL_MODE_OUTPUT_PUSHPULL};  // GPIO[0]14
+constexpr Pin pin_p1_ctrl0{map_p1_ctrl0.scu_port, map_p1_ctrl0.scu_pin};                                       // SCU: P2_10
+constexpr GPIO p1_ctrl0{pin_p1_ctrl0, map_p1_ctrl0.gpio_port, map_p1_ctrl0.gpio_pad, map_p1_ctrl0.gpio_mode};  // GPIO[0]14

-constexpr Pin pin_p1_ctrl1{map_p1_ctrl1.scu_port, map_p1_ctrl1.scu_pin};                                         // SCU: P6_8
-constexpr GPIO p1_ctrl1{pin_p1_ctrl1, map_p1_ctrl1.gpio_port, map_p1_ctrl1.gpio_pad, PAL_MODE_OUTPUT_PUSHPULL};  // GPIO[5]16
+constexpr Pin pin_p1_ctrl1{map_p1_ctrl1.scu_port, map_p1_ctrl1.scu_pin};                                       // SCU: P6_8
+constexpr GPIO p1_ctrl1{pin_p1_ctrl1, map_p1_ctrl1.gpio_port, map_p1_ctrl1.gpio_pad, map_p1_ctrl1.gpio_mode};  // GPIO[5]16

-constexpr Pin pin_p1_ctrl2{map_p1_ctrl2.scu_port, map_p1_ctrl2.scu_pin};                                         // SCU: P6_9
-constexpr GPIO p1_ctrl2{pin_p1_ctrl2, map_p1_ctrl2.gpio_port, map_p1_ctrl2.gpio_pad, PAL_MODE_OUTPUT_PUSHPULL};  // GPIO[3]5
+constexpr Pin pin_p1_ctrl2{map_p1_ctrl2.scu_port, map_p1_ctrl2.scu_pin};                                       // SCU: P6_9
+constexpr GPIO p1_ctrl2{pin_p1_ctrl2, map_p1_ctrl2.gpio_port, map_p1_ctrl2.gpio_pad, map_p1_ctrl2.gpio_mode};  // GPIO[3]5

 // P2 Multiplexer control pins
-constexpr Pin pin_p2_ctrl0{map_p2_ctrl0.scu_port, map_p2_ctrl0.scu_pin};                                         // SCU: PE_3
-constexpr GPIO p2_ctrl0{pin_p2_ctrl0, map_p2_ctrl0.gpio_port, map_p2_ctrl0.gpio_pad, PAL_MODE_OUTPUT_PUSHPULL};  // GPIO[7]3
+constexpr Pin pin_p2_ctrl0{map_p2_ctrl0.scu_port, map_p2_ctrl0.scu_pin};                                       // SCU: PE_3
+constexpr GPIO p2_ctrl0{pin_p2_ctrl0, map_p2_ctrl0.gpio_port, map_p2_ctrl0.gpio_pad, map_p2_ctrl0.gpio_mode};  // GPIO[7]3

-constexpr Pin pin_p2_ctrl1{map_p2_ctrl1.scu_port, map_p2_ctrl1.scu_pin};                                         // SCU: PE_4
-constexpr GPIO p2_ctrl1{pin_p2_ctrl1, map_p2_ctrl1.gpio_port, map_p2_ctrl1.gpio_pad, PAL_MODE_OUTPUT_PUSHPULL};  // GPIO[7]4
+constexpr Pin pin_p2_ctrl1{map_p2_ctrl1.scu_port, map_p2_ctrl1.scu_pin};                                       // SCU: PE_4
+constexpr GPIO p2_ctrl1{pin_p2_ctrl1, map_p2_ctrl1.gpio_port, map_p2_ctrl1.gpio_pad, map_p2_ctrl1.gpio_mode};  // GPIO[7]4

 // Trigger pins
-constexpr Pin trigger_out_pin{map_trigger_out.scu_port, map_trigger_out.scu_pin};                                            // SCU: P2_6
-constexpr GPIO trigger_out{trigger_out_pin, map_trigger_out.gpio_port, map_trigger_out.gpio_pad, PAL_MODE_OUTPUT_PUSHPULL};  // GPIO[5]6
+constexpr Pin trigger_out_pin{map_trigger_out.scu_port, map_trigger_out.scu_pin};                                             // SCU: P2_6
+constexpr GPIO trigger_out{trigger_out_pin, map_trigger_out.gpio_port, map_trigger_out.gpio_pad, map_trigger_out.gpio_mode};  // GPIO[5]6

-constexpr Pin trigger_in_pin{map_trigger_in.scu_port, map_trigger_in.scu_pin};                                 // SCU: PD_12
-constexpr GPIO trigger_in{trigger_in_pin, map_trigger_in.gpio_port, map_trigger_in.gpio_pad, PAL_MODE_INPUT};  // GPIO[6]26
+constexpr Pin trigger_in_pin{map_trigger_in.scu_port, map_trigger_in.scu_pin};                                           // SCU: PD_12
+constexpr GPIO trigger_in{trigger_in_pin, map_trigger_in.gpio_port, map_trigger_in.gpio_pad, map_trigger_in.gpio_mode};  // GPIO[6]26
+
+// Clock input control
+constexpr Pin pin_clkin_ctrl{map_clkin_ctrl.scu_port, map_clkin_ctrl.scu_pin};                                           // SCU: P1_20
+constexpr GPIO clkin_ctrl{pin_clkin_ctrl, map_clkin_ctrl.gpio_port, map_clkin_ctrl.gpio_pad, map_clkin_ctrl.gpio_mode};  // GPIO[0]15

 // RF507x
-constexpr Pin pin_rf5072_mix_en{map_rf5072_mix_en.scu_port, map_rf5072_mix_en.scu_pin};
-constexpr GPIO rf5072_mix_en{pin_rf5072_mix_en, map_rf5072_mix_en.gpio_port, map_rf5072_mix_en.gpio_pad, 0};
+constexpr Pin pin_rf5072_mix_en{map_rf5072_mix_en.scu_port, map_rf5072_mix_en.scu_pin};                                                 // SCU: P9_0
+constexpr GPIO rf5072_mix_en{pin_rf5072_mix_en, map_rf5072_mix_en.gpio_port, map_rf5072_mix_en.gpio_pad, map_rf5072_mix_en.gpio_mode};  // GPIO[4]12

 // Anti-Aliasing filter
-constexpr Pin pin_aa_en{map_aa_en.scu_port, map_aa_en.scu_pin};
-constexpr GPIO aa_en{pin_aa_en, map_aa_en.gpio_port, map_aa_en.gpio_pad, 0};
+constexpr Pin pin_aa_en{map_aa_en.scu_port, map_aa_en.scu_pin};                                 // SCU: P1_14
+constexpr GPIO aa_en{pin_aa_en, map_aa_en.gpio_port, map_aa_en.gpio_pad, map_aa_en.gpio_mode};  // GPIO[1]7
+
+constexpr Pin pin_en_1v2{map_en_1v2.scu_port, map_en_1v2.scu_pin};                                   // SCU: P8_7
+constexpr GPIO en_1v2{pin_en_1v2, map_en_1v2.gpio_port, map_en_1v2.gpio_pad, map_en_1v2.gpio_mode};  // GPIO[4]7
+
+constexpr Pin pin_VAA_en{map_VAA_en.scu_port, map_VAA_en.scu_pin};                                                        // SCU: P8_1
+constexpr GPIO VAA_en{pin_VAA_en, map_VAA_en.gpio_port, map_VAA_en.gpio_pad, map_VAA_en.gpio_mode, Polarity::ActiveLow};  // GPIO[4]1
+
+constexpr Pin pin_led_usb{map_led_usb.scu_port, map_led_usb.scu_pin};                                                          // SCU: P4_1
+constexpr GPIO led_usb{pin_led_usb, map_led_usb.gpio_port, map_led_usb.gpio_pad, map_led_usb.gpio_mode, Polarity::ActiveLow};  // GPIO[2]1
+
+constexpr Pin pin_led_rx{map_led_rx.scu_port, map_led_rx.scu_pin};                                                        // SCU: P4_2
+constexpr GPIO led_rx{pin_led_rx, map_led_rx.gpio_port, map_led_rx.gpio_pad, map_led_rx.gpio_mode, Polarity::ActiveLow};  // GPIO[2]2
+
+constexpr Pin pin_led_tx{map_led_tx.scu_port, map_led_tx.scu_pin};                                                        // SCU: P6_12
+constexpr GPIO led_tx{pin_led_tx, map_led_tx.gpio_port, map_led_tx.gpio_pad, map_led_tx.gpio_mode, Polarity::ActiveLow};  // GPIO[2]8
+
+constexpr Pin pin_led_mcu{map_led_mcu.scu_port, map_led_mcu.scu_pin};                                                          // SCU: P8_6
+constexpr GPIO led_mcu{pin_led_mcu, map_led_mcu.gpio_port, map_led_mcu.gpio_pad, map_led_mcu.gpio_mode, Polarity::ActiveLow};  // GPIO[4]6
+
+constexpr Pin pin_mix_bypass{map_mix_bypass.scu_port, map_mix_bypass.scu_pin};                                                                // SCU: P6_3
+constexpr GPIO mix_bypass{pin_mix_bypass, map_mix_bypass.gpio_port, map_mix_bypass.gpio_pad, map_mix_bypass.gpio_mode, Polarity::ActiveLow};  // GPIO[3]2
+
+constexpr Pin pin_tx_enable{map_tx_enable.scu_port, map_tx_enable.scu_pin};                                         // SCU: P6_5
+constexpr GPIO tx_enable{pin_tx_enable, map_tx_enable.gpio_port, map_tx_enable.gpio_pad, map_tx_enable.gpio_mode};  // GPIO[3]4
+
+constexpr Pin pin_rf_amp_enable{map_rf_amp_enable.scu_port, map_rf_amp_enable.scu_pin};                                                 // SCU: PA_2
+constexpr GPIO rf_amp_enable{pin_rf_amp_enable, map_rf_amp_enable.gpio_port, map_rf_amp_enable.gpio_pad, map_rf_amp_enable.gpio_mode};  // GPIO[4]9
+
+constexpr Pin pin_aux_power_enable{map_aux_power_enable.scu_port, map_aux_power_enable.scu_pin};                                                                            // SCU: P6_7
+constexpr GPIO aux_power_enable{pin_aux_power_enable, map_aux_power_enable.gpio_port, map_aux_power_enable.gpio_pad, map_aux_power_enable.gpio_mode, Polarity::ActiveLow};  // GPIO[5]15
+
+constexpr Pin pin_aux_power_oc{map_aux_power_oc.scu_port, map_aux_power_oc.scu_pin};                                               // SCU: P6_11
+constexpr GPIO aux_power_oc{pin_aux_power_oc, map_aux_power_oc.gpio_port, map_aux_power_oc.gpio_pad, map_aux_power_oc.gpio_mode};  // GPIO[3]7
+
+constexpr Pin pin_ant_bias_oc{map_ant_bias_oc.scu_port, map_ant_bias_oc.scu_pin};                                                                  // SCU: P2_11
+constexpr GPIO ant_bias_oc{pin_ant_bias_oc, map_ant_bias_oc.gpio_port, map_ant_bias_oc.gpio_pad, map_ant_bias_oc.gpio_mode, Polarity::ActiveLow};  // GPIO[1]11
+
+constexpr Pin pin_pps_in_out{map_pps_in_out.scu_port, map_pps_in_out.scu_pin};                                           // SCU: P2_5
+constexpr GPIO pps_in_out{pin_pps_in_out, map_pps_in_out.gpio_port, map_pps_in_out.gpio_pad, map_pps_in_out.gpio_mode};  // GPIO[5]5
+
+#else
+constexpr Pin pin_sgpio_13{map_sgpio_13.scu_port, map_sgpio_13.scu_pin};                                       // SCU: P4_8
+constexpr GPIO sgpio_13{pin_sgpio_13, map_sgpio_13.gpio_port, map_sgpio_13.gpio_pad, map_sgpio_13.gpio_mode};  // GPIO[5]12
+
+constexpr Pin pin_og_1v8_en{map_og_1v8_en.scu_port, map_og_1v8_en.scu_pin};                                         // SCU: P6_10
+constexpr GPIO og_1v8_en{pin_og_1v8_en, map_og_1v8_en.gpio_port, map_og_1v8_en.gpio_pad, map_og_1v8_en.gpio_mode};  // GPIO[3]6
+
+constexpr Pin pin_r9_1v8_en{map_r9_1v8_en.scu_port, map_r9_1v8_en.scu_pin};                                         // SCU: P5_0
+constexpr GPIO r9_1v8_en{pin_r9_1v8_en, map_r9_1v8_en.gpio_port, map_r9_1v8_en.gpio_pad, map_r9_1v8_en.gpio_mode};  // GPIO[2]9
+
+constexpr Pin pin_og_VAA_en{map_og_VAA_en.scu_port, map_og_VAA_en.scu_pin};                                                              // SCU: P5_0
+constexpr GPIO og_VAA_en{pin_og_VAA_en, map_og_VAA_en.gpio_port, map_og_VAA_en.gpio_pad, map_og_VAA_en.gpio_mode, Polarity::ActiveLow};  // GPIO[2]9
+
+constexpr Pin pin_r9_VAA_en{map_r9_VAA_en.scu_port, map_r9_VAA_en.scu_pin};                                                              // SCU: P6_10
+constexpr GPIO r9_VAA_en{pin_r9_VAA_en, map_r9_VAA_en.gpio_port, map_r9_VAA_en.gpio_pad, map_r9_VAA_en.gpio_mode, Polarity::ActiveLow};  // GPIO[3]6
+
+constexpr Pin pin_led_usb{map_led_usb.scu_port, map_led_usb.scu_pin};                                     // SCU: P4_1
+constexpr GPIO led_usb{pin_led_usb, map_led_usb.gpio_port, map_led_usb.gpio_pad, map_led_usb.gpio_mode};  // GPIO[2]1
+
+constexpr Pin pin_led_rx{map_led_rx.scu_port, map_led_rx.scu_pin};                                   // SCU: P4_2
+constexpr GPIO led_rx{pin_led_rx, map_led_rx.gpio_port, map_led_rx.gpio_pad, map_led_rx.gpio_mode};  // GPIO[2]2
+
+constexpr Pin pin_led_tx{map_led_tx.scu_port, map_led_tx.scu_pin};                                   // SCU: P6_12
+constexpr GPIO led_tx{pin_led_tx, map_led_tx.gpio_port, map_led_tx.gpio_pad, map_led_tx.gpio_mode};  // GPIO[2]8
+
+constexpr Pin pin_rx_mix_bypass{map_rx_mix_bypass.scu_port, map_rx_mix_bypass.scu_pin};                                                 // SCU: P6_8
+constexpr GPIO rx_mix_bypass{pin_rx_mix_bypass, map_rx_mix_bypass.gpio_port, map_rx_mix_bypass.gpio_pad, map_rx_mix_bypass.gpio_mode};  // GPIO[5]16
+
+constexpr Pin pin_tx_mix_bp{map_tx_mix_bp.scu_port, map_tx_mix_bp.scu_pin};                                         // SCU: P5_2
+constexpr GPIO tx_mix_bp{pin_tx_mix_bp, map_tx_mix_bp.gpio_port, map_tx_mix_bp.gpio_pad, map_tx_mix_bp.gpio_mode};  // GPIO[2]11
+
+constexpr Pin pin_rx_mix_bp{map_rx_mix_bp.scu_port, map_rx_mix_bp.scu_pin};                                         // SCU: P5_3
+constexpr GPIO rx_mix_bp{pin_rx_mix_bp, map_rx_mix_bp.gpio_port, map_rx_mix_bp.gpio_pad, map_rx_mix_bp.gpio_mode};  // GPIO[2]12
+
+constexpr Pin pin_tx_mix_bypass{map_tx_mix_bypass.scu_port, map_tx_mix_bypass.scu_pin};                                                                      // SCU: P1_7
+constexpr GPIO tx_mix_bypass{pin_tx_mix_bypass, map_tx_mix_bypass.gpio_port, map_tx_mix_bypass.gpio_pad, map_tx_mix_bypass.gpio_mode, Polarity::ActiveLow};  // GPIO[1]0
+
+constexpr Pin pin_og_rx{map_og_rx.scu_port, map_og_rx.scu_pin};                                 // SCU: P2_5
+constexpr GPIO og_rx{pin_og_rx, map_og_rx.gpio_port, map_og_rx.gpio_pad, map_og_rx.gpio_mode};  // GPIO[5]5
+
+constexpr Pin pin_og_tx{map_og_tx.scu_port, map_og_tx.scu_pin};                                 // SCU: P6_7
+constexpr GPIO og_tx{pin_og_tx, map_og_tx.gpio_port, map_og_tx.gpio_pad, map_og_tx.gpio_mode};  // GPIO[5]15
+
+constexpr Pin pin_r9_rx{map_r9_rx.scu_port, map_r9_rx.scu_pin};                                 // SCU: P2_7
+constexpr GPIO r9_rx{pin_r9_rx, map_r9_rx.gpio_port, map_r9_rx.gpio_pad, map_r9_rx.gpio_mode};  // GPIO[0]7
+
+constexpr Pin pin_hpf{map_hpf.scu_port, map_hpf.scu_pin};                             // SCU: P4_0
+constexpr GPIO hpf{pin_hpf, map_hpf.gpio_port, map_hpf.gpio_pad, map_hpf.gpio_mode};  // GPIO[2]0
+
+constexpr Pin pin_amp_bypass{map_amp_bypass.scu_port, map_amp_bypass.scu_pin};                                           // SCU: P2_10
+constexpr GPIO amp_bypass{pin_amp_bypass, map_amp_bypass.gpio_port, map_amp_bypass.gpio_pad, map_amp_bypass.gpio_mode};  // GPIO[0]14
+
+constexpr Pin pin_tx_amp{map_tx_amp.scu_port, map_tx_amp.scu_pin};                                   // SCU: P5_6
+constexpr GPIO tx_amp{pin_tx_amp, map_tx_amp.gpio_port, map_tx_amp.gpio_pad, map_tx_amp.gpio_mode};  // GPIO[2]15
+
+constexpr Pin pin_rx_amp{map_rx_amp.scu_port, map_rx_amp.scu_pin};                                   // SCU: P2_11
+constexpr GPIO rx_amp{pin_rx_amp, map_rx_amp.gpio_port, map_rx_amp.gpio_pad, map_rx_amp.gpio_mode};  // GPIO[1]11
+
+constexpr Pin pin_tx_amp_pwr{map_tx_amp_pwr.scu_port, map_tx_amp_pwr.scu_pin};                                                                // SCU: P6_9
+constexpr GPIO tx_amp_pwr{pin_tx_amp_pwr, map_tx_amp_pwr.gpio_port, map_tx_amp_pwr.gpio_pad, map_tx_amp_pwr.gpio_mode, Polarity::ActiveLow};  // GPIO[3]5
+
+constexpr Pin pin_rx_amp_pwr{map_rx_amp_pwr.scu_port, map_rx_amp_pwr.scu_pin};                                                                // SCU: P2_12
+constexpr GPIO rx_amp_pwr{pin_rx_amp_pwr, map_rx_amp_pwr.gpio_port, map_rx_amp_pwr.gpio_pad, map_rx_amp_pwr.gpio_mode, Polarity::ActiveLow};  // GPIO[1]12
+
+constexpr Pin pin_r9_mcu_clk_en{map_r9_mcu_clk_en.scu_port, map_r9_mcu_clk_en.scu_pin};                                                 // SCU: P1_1
+constexpr GPIO r9_mcu_clk_en{pin_r9_mcu_clk_en, map_r9_mcu_clk_en.gpio_port, map_r9_mcu_clk_en.gpio_pad, map_r9_mcu_clk_en.gpio_mode};  // GPIO[0]8
+
+constexpr Pin pin_r9_clkout_en{map_r9_clkout_en.scu_port, map_r9_clkout_en.scu_pin};                                               // SCU: P1_2
+constexpr GPIO r9_clkout_en{pin_r9_clkout_en, map_r9_clkout_en.gpio_port, map_r9_clkout_en.gpio_pad, map_r9_clkout_en.gpio_mode};  // GPIO[0]9
+
+constexpr Pin pin_r9_clkin_en{map_r9_clkin_en.scu_port, map_r9_clkin_en.scu_pin};                                             // SCU: P6_7
+constexpr GPIO r9_clkin_en{pin_r9_clkin_en, map_r9_clkin_en.gpio_port, map_r9_clkin_en.gpio_pad, map_r9_clkin_en.gpio_mode};  // GPIO[5]15
+
+static const motocon_pwm_resources_t motocon_pwm_resources = {
+    .base = {.clk = &LPC_CGU->BASE_APB1_CLK, .stat = &LPC_CCU1->BASE_STAT, .stat_mask = (1 << 1)},
+    .branch = {.cfg = &LPC_CCU1->CLK_APB1_MOTOCON_PWM_CFG, .stat = &LPC_CCU1->CLK_APB1_MOTOCON_PWM_STAT},
+    .reset = {.output_index = 38},
+};
+
+static const scu_setup_t pin_setup_vaa_enablex_pwm = {5, 0, scu_config_normal_drive_t{.mode = 1, .epd = 0, .epun = 1, .ehs = 0, .ezi = 0, .zif = 0}};
+static const scu_setup_t pin_setup_vaa_enablex_gpio_og = {map_og_VAA_en.scu_port, map_og_VAA_en.scu_pin, scu_config_normal_drive_t{.mode = map_og_VAA_en.gpio_mode, .epd = 0, .epun = 1, .ehs = 0, .ezi = 0, .zif = 0}};
+static const scu_setup_t pin_setup_vaa_enablex_gpio_r9 = {map_r9_VAA_en.scu_port, map_r9_VAA_en.scu_pin, scu_config_normal_drive_t{.mode = map_r9_VAA_en.gpio_mode, .epd = 0, .epun = 1, .ehs = 0, .ezi = 0, .zif = 0}};
+
+#endif
+
+// SGPIO
+constexpr Pin pin_sgpio_0{map_sgpio_0.scu_port, map_sgpio_0.scu_pin};                                     // SCU: P0_0
+constexpr GPIO sgpio_0{pin_sgpio_0, map_sgpio_0.gpio_port, map_sgpio_0.gpio_pad, map_sgpio_0.gpio_mode};  // GPIO[0]0
+
+constexpr Pin pin_sgpio_1{map_sgpio_1.scu_port, map_sgpio_1.scu_pin};                                     // SCU: P0_1
+constexpr GPIO sgpio_1{pin_sgpio_1, map_sgpio_1.gpio_port, map_sgpio_1.gpio_pad, map_sgpio_1.gpio_mode};  // GPIO[0]1
+
+constexpr Pin pin_sgpio_2{map_sgpio_2.scu_port, map_sgpio_2.scu_pin};                                     // SCU: P1_15
+constexpr GPIO sgpio_2{pin_sgpio_2, map_sgpio_2.gpio_port, map_sgpio_2.gpio_pad, map_sgpio_2.gpio_mode};  // GPIO[0]2
+
+constexpr Pin pin_sgpio_3{map_sgpio_3.scu_port, map_sgpio_3.scu_pin};                                     // SCU: P1_16
+constexpr GPIO sgpio_3{pin_sgpio_3, map_sgpio_3.gpio_port, map_sgpio_3.gpio_pad, map_sgpio_3.gpio_mode};  // GPIO[0]3
+
+constexpr Pin pin_sgpio_4{map_sgpio_4.scu_port, map_sgpio_4.scu_pin};                                     // SCU: P6_3, PRALINE: P9_4
+constexpr GPIO sgpio_4{pin_sgpio_4, map_sgpio_4.gpio_port, map_sgpio_4.gpio_pad, map_sgpio_4.gpio_mode};  // GPIO[6]3 PRALINE: GPIO[5]17
+
+constexpr Pin pin_sgpio_5{map_sgpio_5.scu_port, map_sgpio_5.scu_pin};                                     // SCU: P6_6
+constexpr GPIO sgpio_5{pin_sgpio_5, map_sgpio_5.gpio_port, map_sgpio_5.gpio_pad, map_sgpio_5.gpio_mode};  // GPIO[0]5
+
+constexpr Pin pin_sgpio_6{map_sgpio_6.scu_port, map_sgpio_6.scu_pin};                                     // SCU: P2_2
+constexpr GPIO sgpio_6{pin_sgpio_6, map_sgpio_6.gpio_port, map_sgpio_6.gpio_pad, map_sgpio_6.gpio_mode};  // GPIO[5]2
+
+constexpr Pin pin_sgpio_7{map_sgpio_7.scu_port, map_sgpio_7.scu_pin};                                     // SCU: P1_0
+constexpr GPIO sgpio_7{pin_sgpio_7, map_sgpio_7.gpio_port, map_sgpio_7.gpio_pad, map_sgpio_7.gpio_mode};  // GPIO[0]4
+
+constexpr Pin pin_sgpio_8{map_sgpio_8.scu_port, map_sgpio_8.scu_pin};                                     // SCU: P9_6, PRALINE: P8_0
+constexpr GPIO sgpio_8{pin_sgpio_8, map_sgpio_8.gpio_port, map_sgpio_8.gpio_pad, map_sgpio_8.gpio_mode};  // GPIO[4]11, PRALINE: GPIO[4]0
+
+constexpr Pin pin_sgpio_9{map_sgpio_9.scu_port, map_sgpio_9.scu_pin};                                     // SCU: P4_3, PRALINE: P9_3
+constexpr GPIO sgpio_9{pin_sgpio_9, map_sgpio_9.gpio_port, map_sgpio_9.gpio_pad, map_sgpio_9.gpio_mode};  // GPIO[2]3, PRALINE: GPIO[4]12
+
+constexpr Pin pin_sgpio_10{map_sgpio_10.scu_port, map_sgpio_10.scu_pin};                                       // SCU: P1_14, PRALINE: P8_2
+constexpr GPIO sgpio_10{pin_sgpio_10, map_sgpio_10.gpio_port, map_sgpio_10.gpio_pad, map_sgpio_10.gpio_mode};  // GPIO[1]7, PRALINE: GPIO[4]2
+
+constexpr Pin pin_sgpio_11{map_sgpio_11.scu_port, map_sgpio_11.scu_pin};                                       // SCU: P1_17
+constexpr GPIO sgpio_11{pin_sgpio_11, map_sgpio_11.gpio_port, map_sgpio_11.gpio_pad, map_sgpio_11.gpio_mode};  // GPIO[0]17
+
+constexpr Pin pin_sgpio_12{map_sgpio_12.scu_port, map_sgpio_12.scu_pin};                                       // SCU: P1_18
+constexpr GPIO sgpio_12{pin_sgpio_12, map_sgpio_12.gpio_port, map_sgpio_12.gpio_pad, map_sgpio_12.gpio_mode};  // GPIO[0]13
+
+constexpr Pin pin_vregmode{map_vregmode.scu_port, map_vregmode.scu_pin};                                       // SCU: P6_11, PRALINE: P4_9
+constexpr GPIO vregmode{pin_vregmode, map_vregmode.gpio_port, map_vregmode.gpio_pad, map_vregmode.gpio_mode};  // GPIO[3]7, PRALINE: GPIO[5]13
+
+constexpr Pin pin_lpf{map_lpf.scu_port, map_lpf.scu_pin};                             // SCU: P5_1, PRALINE: PA_1
+constexpr GPIO lpf{pin_lpf, map_lpf.gpio_port, map_lpf.gpio_pad, map_lpf.gpio_mode};  // GPIO[2]10, PRALINE: GPIO[4]8
+
+constexpr Pin pin_ant_bias{map_ant_bias.scu_port, map_ant_bias.scu_pin};                                                            // SCU: R9: P4_4 , PRALINE: P2_12
+constexpr GPIO ant_bias{pin_ant_bias, map_ant_bias.gpio_port, map_ant_bias.gpio_pad, map_ant_bias.gpio_mode, Polarity::ActiveLow};  // R9: GPIO[2]4, PRALINE: GPIO[1]12
+
+constexpr Pin pin_dfu_boot_0{map_dfu_boot_0.scu_port, map_dfu_boot_0.scu_pin};                                           // SCU: P1_1
+constexpr GPIO dfu_boot_0{pin_dfu_boot_0, map_dfu_boot_0.gpio_port, map_dfu_boot_0.gpio_pad, map_dfu_boot_0.gpio_mode};  // GPIO[0]8
+
+constexpr Pin pin_dfu_boot_1{map_dfu_boot_1.scu_port, map_dfu_boot_1.scu_pin};                                           // SCU: P1_2
+constexpr GPIO dfu_boot_1{pin_dfu_boot_1, map_dfu_boot_1.gpio_port, map_dfu_boot_1.gpio_pad, map_dfu_boot_1.gpio_mode};  // GPIO[0]9
+
+constexpr Pin pin_dfu_button{map_dfu_button.scu_port, map_dfu_button.scu_pin};                                           // SCU: P2_8
+constexpr GPIO dfu_button{pin_dfu_button, map_dfu_button.gpio_port, map_dfu_button.gpio_pad, map_dfu_button.gpio_mode};  // GPIO[5]7
+
+constexpr Pin pin_lcd_wrx{map_lcd_wrx.scu_port, map_lcd_wrx.scu_pin};                                     // SCU: P2_9
+constexpr GPIO lcd_wrx{pin_lcd_wrx, map_lcd_wrx.gpio_port, map_lcd_wrx.gpio_pad, map_lcd_wrx.gpio_mode};  // GPIO[1]10
+
+constexpr Pin pin_isp{map_isp.scu_port, map_isp.scu_pin};                                 // SCU: P2_7
+constexpr GPIO dfu_isp{pin_isp, map_isp.gpio_port, map_isp.gpio_pad, map_isp.gpio_mode};  // GPIO[0]7

 }  // namespace gpio_control
-#endif

 namespace power_control {

@@ -376,16 +686,6 @@ void aux_power_off(void);
 void core_power_on(void);
 void core_power_off(void);

-static const motocon_pwm_resources_t motocon_pwm_resources = {
-    .base = {.clk = &LPC_CGU->BASE_APB1_CLK, .stat = &LPC_CCU1->BASE_STAT, .stat_mask = (1 << 1)},
-    .branch = {.cfg = &LPC_CCU1->CLK_APB1_MOTOCON_PWM_CFG, .stat = &LPC_CCU1->CLK_APB1_MOTOCON_PWM_STAT},
-    .reset = {.output_index = 38},
-};
-
-static const scu_setup_t pin_setup_vaa_enablex_pwm = {5, 0, scu_config_normal_drive_t{.mode = 1, .epd = 0, .epun = 1, .ehs = 0, .ezi = 0, .zif = 0}};
-static const scu_setup_t pin_setup_vaa_enablex_gpio_og = {5, 0, scu_config_normal_drive_t{.mode = 0, .epd = 0, .epun = 1, .ehs = 0, .ezi = 0, .zif = 0}};
-static const scu_setup_t pin_setup_vaa_enablex_gpio_r9 = {6, 10, scu_config_normal_drive_t{.mode = 0, .epd = 0, .epun = 1, .ehs = 0, .ezi = 0, .zif = 0}};
-
 }  // namespace power_control

 #endif /*__GPIO_H__*/
@@ -23,7 +23,6 @@
 #define __HACKRF_GPIO_H__

 #include "pins.hpp"
-#include "led.hpp"

 #include <array>

@@ -34,36 +33,6 @@ namespace one {

 /* GPIO */

-constexpr GPIO gpio_led_usb = gpio[GPIO2_1];
-constexpr GPIO gpio_led_rx = gpio[GPIO2_2];
-constexpr GPIO gpio_led_tx = gpio[GPIO2_8];
-
-constexpr GPIO gpio_og_1v8_enable = gpio[GPIO3_6];
-constexpr GPIO gpio_r9_1v8_enable = gpio[GPIO2_9];
-constexpr GPIO gpio_vregmode = gpio[GPIO3_7];
-
-constexpr GPIO gpio_rx_mix_bp = gpio[GPIO2_12];
-constexpr GPIO gpio_tx_mix_bp = gpio[GPIO2_11];
-#ifdef PRALINE
-constexpr GPIO gpio_mix_bypass = gpio[GPIO3_2];     // P6_3: PRALINE RF path mixer bypass inverted
-constexpr GPIO gpio_mix_en_n_r1_0 = gpio[GPIO5_6];  // P2_6: R1.0 board mixer bypass
-#else
-constexpr GPIO gpio_mix_bypass = gpio[GPIO5_16];
-#endif
-constexpr GPIO gpio_not_mix_bypass = gpio[GPIO1_0];
-
-constexpr GPIO gpio_og_rx = gpio[GPIO5_5];
-constexpr GPIO gpio_og_tx = gpio[GPIO5_15];
-constexpr GPIO gpio_r9_rx = gpio[GPIO0_7];
-
-constexpr GPIO gpio_lp = gpio[GPIO2_10];
-constexpr GPIO gpio_hp = gpio[GPIO2_0];
-
-constexpr GPIO gpio_rx_amp = gpio[GPIO1_11];
-constexpr GPIO gpio_tx_amp = gpio[GPIO2_15];
-constexpr GPIO gpio_amp_bypass = gpio[GPIO0_14];
-constexpr GPIO gpio_not_tx_amp_pwr = gpio[GPIO3_5];
-
 #ifdef PRALINE
 // PRALINE: GPIO2[13] is SPI CS only, FPGA controls ENX/RESETX
 constexpr GPIO gpio_rffc5072_select = gpio[GPIO2_13];  // P5_4: SPI CS (ENX)
@@ -71,7 +40,6 @@ constexpr GPIO gpio_rffc5072_resetx = gpio[GPIO2_14];  // P5_5: LPC43xx controls
 #else
 constexpr GPIO gpio_rffc5072_select = gpio[GPIO2_13];
 constexpr GPIO gpio_rffc5072_resetx = gpio[GPIO2_14];
-constexpr GPIO gpio_not_rx_amp_pwr = gpio[GPIO1_12];
 #endif

 #ifdef PRALINE
@@ -90,11 +58,11 @@ constexpr GPIO gpio_max283x_select = gpio[GPIO0_15];

 #ifdef PRALINE
 // PRALINE uses MAX2831 transceiver with different control pins
-constexpr GPIO gpio_max283x_enable = gpio[GPIO7_1];     // MAX2831 ENABLE (PE_1)
-constexpr GPIO gpio_max2831_enable = gpio[GPIO7_1];     // Alias
+constexpr GPIO gpio_max283x_enable = gpio[GPIO7_1];  // MAX2831 ENABLE (PE_1)
+// constexpr GPIO gpio_max2831_enable = gpio[GPIO7_1];     // Alias
 constexpr GPIO gpio_max2831_rx_enable = gpio[GPIO7_2];  // MAX2831 RX_ENABLE (PE_2)
-constexpr GPIO gpio_max2831_rxhp = gpio[GPIO6_29];      // MAX2831 RXHP (PD_15)
-constexpr GPIO gpio_max2831_ld = gpio[GPIO4_11];        // MAX2831 Lock Detect (P9_6)
+// constexpr GPIO gpio_max2831_rxhp = gpio[GPIO6_29];      // MAX2831 RXHP (PD_15)
+constexpr GPIO gpio_max2831_ld = gpio[GPIO4_11];  // MAX2831 Lock Detect (P9_6)
 // Legacy aliases for code compatibility
 constexpr GPIO gpio_max2837_rxenable = gpio[GPIO7_2];
 constexpr GPIO gpio_max2837_txenable = gpio[GPIO7_2];  // MAX2831 uses single RX/TX control
@@ -108,50 +76,12 @@ constexpr GPIO gpio_max2839_rxtx = gpio[GPIO2_5];

 #ifdef PRALINE
 constexpr GPIO gpio_max5864_select = gpio[GPIO6_30];  // PD_16: PRALINE MAX5864 CS
-constexpr GPIO gpio_fpga_select = gpio[GPIO2_10];     // FPGA SPI CS (P5_1)
 #else
 constexpr GPIO gpio_max5864_select = gpio[GPIO2_7];
 #endif

 constexpr GPIO gpio_q_invert = gpio[GPIO0_13];

-#ifdef PRALINE
-// PRALINE power control
-constexpr GPIO gpio_vaa_disable = gpio[GPIO4_1];      // VAA disable (P8_1)
-constexpr GPIO gpio_1v2_enable = gpio[GPIO4_7];       // 1V2 enable (P8_7)
-constexpr GPIO gpio_3v3aux_disable = gpio[GPIO5_15];  // 3V3 aux disable (P6_7)
-constexpr GPIO gpio_3v3aux_oc = gpio[GPIO1_11];       // 3.3V aux overcurrent input (P2_11)
-constexpr GPIO gpio_vbus_enable = gpio[GPIO4_4];      // VBUS_IN_EN P8_4 ->LOW
-constexpr GPIO gpio_vin_enable = gpio[GPIO4_5];       // VIN_IN_EN P8_5 ->HIGH
-// PRALINE RF path control
-constexpr GPIO gpio_tx_enable = gpio[GPIO3_4];  // TX enable (P6_5)
-// constexpr GPIO gpio_mix_enable_n = gpio[GPIO3_2];       // Mixer enable inverted (P6_3)
-constexpr GPIO gpio_lpf_enable = gpio[GPIO4_8];         // LPF enable (PA_1)
-constexpr GPIO gpio_rf_amp_enable = gpio[GPIO4_9];      // RF amp enable (PA_2)
-constexpr GPIO gpio_ant_bias_disable = gpio[GPIO1_12];  // Antenna bias disable (P2_12)
-constexpr GPIO gpio_bias_oc = gpio[GPIO3_7];            // Bias tee overcurrent input (P6_11)
-
-// PRALINE mixer lock detect (gpio_max2831_ld defined above at line 93)
-constexpr GPIO gpio_rffc5072_ld = gpio[GPIO6_25];  // Mixer lock detect (PD_11)
-
-// PRALINE LED4
-constexpr GPIO gpio_led4 = gpio[GPIO4_6];  // LED4 (P8_6)
-
-// PRALINE dual port control
-constexpr GPIO gpio_p1_ctrl0 = gpio[GPIO0_14];    // P1 control 0 (P2_10)
-constexpr GPIO gpio_p1_ctrl1 = gpio[GPIO5_16];    // P1 control 1 (P6_8)
-constexpr GPIO gpio_p1_ctrl2 = gpio[GPIO3_5];     // P1 control 2 (P6_9)
-constexpr GPIO gpio_p2_ctrl0 = gpio[GPIO7_3];     // P2 control 0 (PE_3)
-constexpr GPIO gpio_p2_ctrl1 = gpio[GPIO7_4];     // P2 control 1 (PE_4)
-constexpr GPIO gpio_clkin_ctrl = gpio[GPIO0_15];  // CLKIN control (P1_20)
-
-// PRALINE trigger/sync I/O
-constexpr GPIO gpio_trigger_in = gpio[GPIO6_26];  // Trigger input (PD_12)
-constexpr GPIO gpio_trigger_out = gpio[GPIO5_6];  // Trigger output (P2_6)
-constexpr GPIO gpio_pps_out = gpio[GPIO5_5];      // PPS output (P2_5)
-
-#endif
-
 #ifdef PRALINE
 /* PRALINE has no HackRF CPLD. These pins are used for RFFC5072 and TX_EN instead.
 * Dummy assignments here allow cpld_update.cpp to compile; the functions
@@ -165,17 +95,6 @@ constexpr GPIO gpio_cpld_tms = gpio[GPIO3_4];
 constexpr GPIO gpio_cpld_tck = gpio[GPIO3_0];
 constexpr GPIO gpio_cpld_tdi = gpio[GPIO3_1];

-constexpr GPIO gpio_r9_clkin_en = gpio[GPIO5_15];
-constexpr GPIO gpio_r9_clkout_en = gpio[GPIO0_9];
-constexpr GPIO gpio_r9_mcu_clk_en = gpio[GPIO0_8];
-constexpr GPIO gpio_r9_not_ant_pwr = gpio[GPIO2_4];
-
-/* LEDs */
-
-constexpr LED led_usb{gpio_led_usb};
-constexpr LED led_rx{gpio_led_rx};
-constexpr LED led_tx{gpio_led_tx};
-
 } /* namespace one */
 } /* namespace hackrf */

@@ -192,7 +192,10 @@ void I2cDev_MAX17055::update() {
    bool battChanged = false;

    getBatteryInfo(validity, batteryPercentage, voltage, current, battChanged);
-
+    if (validity == 0) {
+        // no valid data, don't send message
+        return;
+    }
    // send local message
    BatteryStateMessage msg{validity, batteryPercentage, current >= 25, voltage, battChanged};
    EventDispatcher::send_message(msg);
@@ -225,6 +228,7 @@ bool I2cDev_MAX17055::init(uint8_t addr_) {
        bool return_status = true;
        if (needsInitialization()) {
            // First-time or POR initialization
+            was_por = true;
            return_status = full_reset_and_init();
        }
        chThdSleepMilliseconds(300);  // wait for adc to fully wake up!
@@ -252,10 +256,9 @@ bool I2cDev_MAX17055::full_reset_and_init() {
    if (!load_custom_parameters()) {
        return false;
    }
-    /*if (!clear_por()) {
+    if (!clear_por()) {
        return false;
-    }*/
-    // don't clear it, we'll need to know the state
+    }
    return true;
 }

@@ -315,8 +318,8 @@ bool I2cDev_MAX17055::needsInitialization() {

 void I2cDev_MAX17055::partialInit() {
    // Only update necessary volatile settings
-    // setHibCFG(0x0000);  // If you always want hibernation disabled. this is a lower resolution mode, when the ic is on, and measuring, but on lower freq. depends un tha current (mA).
-    sleep_config(true);  // shut down the comm
+    setHibCFG(0x0000);    // If you always want hibernation disabled. this is a lower resolution mode, when the ic is on, and measuring, but on lower freq. depends un tha current (mA).
+    sleep_config(false);  // shut down the comm
    // Add any other volatile settings that need updating
 }

@@ -390,17 +393,25 @@ void I2cDev_MAX17055::getBatteryInfo(uint8_t& valid_mask, uint8_t& batteryPercen
        valid_mask = 0;
        return;
    }
+    if (status == 0xFFFF) {
+        valid_mask = 0;
+        return;
+    }
    bool requires_reset = false;

    if (((status & 0xFF) >> 1) & 0x01) {  // POR FLAG
        requires_reset = true;
+        was_por = true;
    }
    // Execute the reset if either flag was tripped
    if (requires_reset) {
-        reInit();  // todo maybe don't do it automatically, just signal. but for now it is safer to do it.
-        // battMayChanged = true && portapack::persistent_memory::battery_replaceable();  // only signal a change if the battery is replaceable. othervise do it silently
-        // We don't want to signal this for now. the Voltage drop during power up messes this up a bit.
+        reInit();  // reinit the ic. that takes time, so we'll return
+        valid_mask = 0;
+        return;
    }
+#ifdef MAX17055_REPORT_POR_FLAG
+    battMayChanged = was_por && portapack::persistent_memory::battery_replaceable();  // only signal a change if the battery is replaceable. othervise do it silently
+#endif

    batteryPercentage = stateOfCharge();
    current = instantCurrent();
@@ -29,6 +29,9 @@

 #include "i2cdevmanager.hpp"

+// if this define is set, the UI will show the battery has changed (POR flag is set) until the settings are saved (not ic reinited, but settings applyed by user!)
+#define MAX17055_REPORT_POR_FLAG 1
+
 #define MAX17055_POR 0
 #define MAX17055_IMin 1
 #define MAX17055_IMax 2
@@ -292,8 +295,11 @@ class I2cDev_MAX17055 : public I2cDev {
    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!!!
    bool getIsBattChanged() { return statusControl(MAX17055_POR); }  // true if the ic thinks we have a new battery
-    void resetChangedFlag() { clear_por(); }                         // reset the flag
-    void sleep_config(bool enable_sleep);                            // if true, the ic can sleep after 3 minutes of inactivity (over i2c). can be waken up on any i2c communication (first packet may be dropped)
+    void resetChangedFlag() {
+        clear_por();
+        was_por = false;
+    }  // reset the flag
+    void sleep_config(bool enable_sleep);  // if true, the ic can sleep after 3 minutes of inactivity (over i2c). can be waken up on any i2c communication (first packet may be dropped)
   private:
    const RegisterEntry* findEntry(const char* name) const;

@@ -326,6 +332,8 @@ class I2cDev_MAX17055 : public I2cDev {
    bool setModelCfg(const uint8_t _Model_ID);
    bool setHibCFG(const uint16_t _Config);
    void config(void);
+
+    bool was_por = false;
 };

 } /* namespace i2cdev */
@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
- *
- * This file is part of PortaPack.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-
-#ifndef __LED_H__
-#define __LED_H__
-
-#include "gpio.hpp"
-
-struct LED {
-    constexpr LED(const GPIO gpio)
-        : _gpio{gpio} {
-    }
-
-    void setup() const {
-#ifdef PRALINE
-// No-op: GPIO direction and initial OFF state are already
-// enforced globally at boot by pal_default_config in board.cpp.
-#else
-        _gpio.clear();
-        _gpio.output();
-        _gpio.configure();
-#endif
-    }
-
-    void on() const {
-#ifdef PRALINE
-        _gpio.clear(); /* LOW = ON for PRALINE */
-#else
-        _gpio.set();
-#endif
-    }
-
-    void off() const {
-#ifdef PRALINE
-        _gpio.set(); /* HIGH = OFF for PRALINE */
-#else
-        _gpio.clear();
-#endif
-    }
-
-    void toggle() const {
-        _gpio.toggle();
-    }
-
-    void write(const bool value) const {
-#ifdef PRALINE
-        _gpio.write(!value); /* Invert for PRALINE */
-#else
-        _gpio.write(value);
-#endif
-    }
-
-   private:
-    const GPIO _gpio;
-};
-
-#endif /*__LED_H__*/
@@ -162,6 +162,9 @@ class Message {
        ToneDetectConfig = 104,
        FlexTosend = 105,
        EPIRBRXConfig = 106,
+        VorRxConfigure = 107,
+        VorRxStatusData = 108,
+        VorTxConfigure = 109,
        MAX
    };

@@ -1899,6 +1902,68 @@ class ToneDetectConfigureMessage : public Message {
    uint32_t ctcss_freq_x10{0};  // CTCSS frequency × 10 (e.g. 1000 = 100.0 Hz); 0 = None
 };

+class VorRxConfigureMessage : public Message {
+   public:
+    constexpr VorRxConfigureMessage(bool enabled = true)
+        : Message{ID::VorRxConfigure},
+          enabled{enabled} {
+    }
+
+    bool enabled{true};
+};
+
+class VorRxStatusDataMessage : public Message {
+   public:
+    constexpr VorRxStatusDataMessage(
+        uint16_t phase_deg = 0,
+        uint16_t radial_deg = 0,
+        uint16_t reference_level = 0,
+        uint16_t variable_level = 0,
+        uint8_t quality = 0,
+        bool valid = false,
+        bool to_from = false)
+        : Message{ID::VorRxStatusData},
+          phase_deg{phase_deg},
+          radial_deg{radial_deg},
+          reference_level{reference_level},
+          variable_level{variable_level},
+          quality{quality},
+          valid{valid},
+          to_from{to_from} {
+    }
+
+    uint16_t phase_deg{0};
+    uint16_t radial_deg{0};
+    uint16_t reference_level{0};
+    uint16_t variable_level{0};
+    uint8_t quality{0};
+    bool valid{false};
+    bool to_from{false};
+};
+
+class VorTxConfigureMessage : public Message {
+   public:
+    VorTxConfigureMessage(
+        uint16_t radial_deg = 0,
+        bool ident_enabled = true,
+        const char* ident = "",
+        bool enabled = true)
+        : Message{ID::VorTxConfigure},
+          radial_deg{radial_deg},
+          ident_enabled{ident_enabled},
+          enabled{enabled} {
+        size_t i = 0;
+        for (; ident && ident[i] && i < sizeof(ident_text) - 1; ++i)
+            ident_text[i] = ident[i];
+        ident_text[i] = '\0';
+    }
+
+    uint16_t radial_deg{0};
+    bool ident_enabled{true};
+    bool enabled{true};
+    char ident_text[8]{};  // CW identifier, null-terminated (max 7 chars)
+};
+
 class FlexTosendMessage : public Message {
   public:
    constexpr FlexTosendMessage(
@@ -129,6 +129,8 @@ constexpr image_tag_t image_tag_noaaapt_rx{'P', 'N', 'O', 'A'};
 constexpr image_tag_t image_tag_sstv_rx{'P', 'S', 'R', 'X'};
 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_vor_tx{'P', 'V', 'T', 'X'};
+constexpr image_tag_t image_tag_vor_rx{'P', 'V', 'R', 'X'};
 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'};
@@ -26,6 +26,9 @@

 namespace ui {

+using Coord = int16_t;
+using Dim = int16_t;
+
 // Positioning helpers PER CHARACTERS (8*16)
 // EACH parameters must be used az CHAR position, not PX coordinates. So If you wanna use the 8,16 coordinates (that is the second character in X and second character in Y you must use UI_POS_X(1) UI_POS_Y(1) (since we count from 0)

@@ -36,31 +39,31 @@ namespace ui {
 // default font width
 #define UI_POS_DEFAULT_WIDTH 8
 // px position of the linenum-th character (Y)
-#define UI_POS_Y(linenum) ((int)((linenum) * UI_POS_DEFAULT_HEIGHT))
+#define UI_POS_Y(linenum) ((Coord)((linenum) * UI_POS_DEFAULT_HEIGHT))
 // px position of the linenum-th character from the bottom of the screen (Y) (please calculate the +1 line top-bar to it too if that is visible!)
-#define UI_POS_Y_BOTTOM(linenum) ((int)(screen_height - (linenum) * UI_POS_DEFAULT_HEIGHT))
+#define UI_POS_Y_BOTTOM(linenum) ((Coord)(screen_height - (int)((linenum) * UI_POS_DEFAULT_HEIGHT)))
 // px position of the linenum-th character from the left of the screen (X)
-#define UI_POS_X(charnum) ((int)((charnum) * UI_POS_DEFAULT_WIDTH))
+#define UI_POS_X(charnum) ((Coord)((charnum) * UI_POS_DEFAULT_WIDTH))
 // px position of the linenum-th character from the right of the screen (X)
-#define UI_POS_X_RIGHT(charnum) ((int)(screen_width - ((charnum) * UI_POS_DEFAULT_WIDTH)))
+#define UI_POS_X_RIGHT(charnum) ((Coord)(screen_width - (int)((charnum) * UI_POS_DEFAULT_WIDTH)))
 // px position of the left character from the center of the screen (X)  (for N character wide string)
-#define UI_POS_X_CENTER(charnum) ((int)((screen_width / 2) - ((charnum) * UI_POS_DEFAULT_WIDTH / 2)))
-// px position of the currcol in a table with colnum number of columns, where one coloumn is charnum characters wide maximum
-#define UI_POS_X_TABLE(colnum, currcol) ((currcol) * (screen_width / (colnum)))
+#define UI_POS_X_CENTER(charnum) ((Coord)((screen_width / 2) - (int)((charnum) * UI_POS_DEFAULT_WIDTH / 2)))
+// px position of the currcol in a table with colnum number of columns, where one column is charnum characters wide maximum
+#define UI_POS_X_TABLE(colnum, currcol) ((Coord)((currcol) * (screen_width / (colnum))))
 // px width of N characters
-#define UI_POS_WIDTH(charnum) ((int)((charnum) * UI_POS_DEFAULT_WIDTH))
+#define UI_POS_WIDTH(charnum) ((Dim)((charnum) * UI_POS_DEFAULT_WIDTH))
 // px width of the screen
 #define UI_POS_MAXWIDTH (screen_width)
 // px height of N line
-#define UI_POS_HEIGHT(linecount) ((int)((linecount) * UI_POS_DEFAULT_HEIGHT))
+#define UI_POS_HEIGHT(linecount) ((Dim)((linecount) * UI_POS_DEFAULT_HEIGHT))
 // px height of the screen's percent
-#define UI_POS_HEIGHT_PERCENT(percent) ((int)(screen_height * (percent) / 100))
+#define UI_POS_HEIGHT_PERCENT(percent) ((Dim)(screen_height * (percent) / 100))
 // remaining px from the linenum-th line to the bottom of the screen. (please calculate the +1 line top-bar to it too if that is visible!)
-#define UI_POS_HEIGHT_REMAINING(linenum) ((int)(screen_height - ((linenum) * UI_POS_DEFAULT_HEIGHT)))
+#define UI_POS_HEIGHT_REMAINING(linenum) ((Dim)(screen_height - (int)((linenum) * UI_POS_DEFAULT_HEIGHT)))
 // remaining px from the charnum-th character to the right of the screen
-#define UI_POS_WIDTH_REMAINING(charnum) ((int)(screen_width - ((charnum) * UI_POS_DEFAULT_WIDTH)))
+#define UI_POS_WIDTH_REMAINING(charnum) ((Dim)(screen_width - (int)((charnum) * UI_POS_DEFAULT_WIDTH)))
 // px width of the screen's percent
-#define UI_POS_WIDTH_PERCENT(percent) ((int)(screen_width * (percent) / 100))
+#define UI_POS_WIDTH_PERCENT(percent) ((Dim)(screen_width * (percent) / 100))
 // px width of the screen
 #define UI_POS_MAXHEIGHT (screen_height)

@@ -85,9 +88,6 @@ namespace ui {

 #define DEG_TO_RAD(d) (d * (2 * pi) / 360.0)

-using Coord = int16_t;
-using Dim = int16_t;
-
 extern uint16_t screen_width;
 extern uint16_t screen_height;

@@ -206,7 +206,11 @@ void Widget::set_style(const Style* new_style) {
 }

 const Style& Widget::style() const {
-    return style_ ? *style_ : parent()->style();
+    for (const Widget* curr = this; curr; curr = curr->parent()) {
+        if (curr->style_) return *curr->style_;
+    }
+    // default style should always be set by SystemView
+    return *style_;
 }

 void Widget::drawn(bool v) {
@@ -201,15 +201,11 @@ void Widget::set_style(const Style* new_style) {
 }

 const Style& Widget::style() const {
-    if (style_ != nullptr)
-        return *style_;
-    else {
-        auto p = parent();
-        if (p == nullptr)
-            // TODO: debug
-            while (true);
-        return p->style();
+    for (const Widget* curr = this; curr; curr = curr->parent()) {
+        if (curr->style_) return *curr->style_;
    }
+    // default style should always be set by SystemView
+    return *style_;
 }

 void Widget::drawn(bool v) {
@@ -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 = 0xAE060000
+external_apps_address_end = 0xAE0B0000
@@ -199,7 +199,7 @@ Build options:
  -G, --generator <name>         CMake generator (default: Ninja)
  -j, --jobs <n>                 Build parallelism (default: host CPU count)
  --target <name>                Build a specific target
-  --clean                        Remove build directory before configure
+    --clean                        Remove build directory, run libopencm3 clean, and exit
  --cmake-arg <arg>              Extra CMake configure arg (repeatable)
  --build-arg <arg>              Extra cmake --build arg (repeatable)
  -y, --non-interactive          Fail instead of prompting when required input is missing
@@ -308,6 +308,29 @@ mbt_detect_cached_device() {
    return 0
 }

+mbt_clean() {
+    local build_dir="$1"
+    local libopencm3_dir="$SCRIPT_PATH/hackrf/firmware/libopencm3"
+
+    mbt_log "cleaning build directory: $build_dir"
+    if ! rm -rf "$build_dir"; then
+        mbt_error "failed to delete build directory. Try running ./mbt --clean as root."
+        return 1
+    fi
+
+    if [[ -d "$libopencm3_dir" ]]; then
+        mbt_log "cleaning libopencm3: $libopencm3_dir"
+        make -C "$libopencm3_dir" clean
+    else
+        mbt_error "libopencm3 directory not found: $libopencm3_dir"
+        return 1
+    fi
+}
+
+mbt_report_build_error() {
+    printf '%s\n' 'Build error happened. Try to fix your code, or run ./mbt --clean and try again' >&2
+}
+
 mbt_build() {
    local build_dir="$1"
    local generator="$2"
@@ -331,8 +354,8 @@ mbt_build() {
    local previous_device=""

    if [[ "$clean_build" -eq 1 ]]; then
-        mbt_log "cleaning build directory: $build_dir"
-        rm -rf "$build_dir"
+        mbt_clean "$build_dir"
+        return 0
    else
        if [[ -f "$marker_file" ]]; then
            previous_device="$(<"$marker_file")"
@@ -383,7 +406,10 @@ mbt_build() {
    cmake_args+=("${cmake_extra_args[@]}")

    mbt_log "configuring build for $device in $build_dir"
-    cmake "${cmake_args[@]}"
+    if ! cmake "${cmake_args[@]}"; then
+        mbt_report_build_error
+        return 1
+    fi
    printf "%s\n" "$device" > "$marker_file"

    build_args=(--build "$build_dir" --parallel "$jobs")
@@ -393,7 +419,10 @@ mbt_build() {
    build_args+=("${build_extra_args[@]}")

    mbt_log "building..."
-    cmake "${build_args[@]}"
+    if ! cmake "${build_args[@]}"; then
+        mbt_report_build_error
+        return 1
+    fi
    mbt_log "build complete. Outputs are in $build_dir."
    mbt_log "The bare binary (for the hackrf_spiflash host tool), excluding external apps, is located at $build_dir/firmware/portapack-mayhem-firmware.bin"
    mbt_log "The full tar.gz package (for MayhemHub and the Flash Utility OTA app), including external apps and the firmware file, is located at $build_dir/firmware/portapack-mayhem_OCI.ppfw.tar"
@@ -574,6 +603,11 @@ main() {
        ;;
    esac

+    if [[ "$clean_build" -eq 1 ]]; then
+        mbt_clean "$build_dir"
+        exit 0
+    fi
+
    if [[ "$with_deps" -eq 1 ]]; then
        mbt_install_deps
    fi
@@ -0,0 +1,7 @@
+TEST
+Portapack
+HackRF
+1
+2
+3
+4
@@ -58,3 +58,21 @@ f=1258000000,d=FPV Ch 6
 f=1280000000,d=FPV Ch 7
 f=1320000000,d=FPV Ch 8
 f=1360000000,d=FPV Ch 9
+
+# 3.1GHz & 3.3GHz Analog FPV Channels
+f=3330000000,d=FPV Ch A-1
+f=3350000000,d=FPV Ch A-2
+f=3370000000,d=FPV Ch A-3
+f=3390000000,d=FPV Ch A-4
+f=3410000000,d=FPV Ch A-5
+f=3430000000,d=FPV Ch A-6
+f=3450000000,d=FPV Ch A-7
+f=3470000000,d=FPV Ch A-8
+f=3170000000,d=FPV Ch B-1
+f=3190000000,d=FPV Ch B-2
+f=3210000000,d=FPV Ch B-3
+f=3230000000,d=FPV Ch B-4
+f=3250000000,d=FPV Ch B-5
+f=3270000000,d=FPV Ch B-6
+f=3290000000,d=FPV Ch B-7
+f=3310000000,d=FPV Ch B-8
Author	SHA1	Message	Date
Pezsma	fe2ba80a10	refactor: simplify audio volume handling in AudioVolumeField (#3246 )	2026-07-04 08:53:28 +02:00
Luca	b5d84fcc4d	Airband VOR receiver and trasmitter (#3244 ) * First test * Reorder includes for consistency and fix string dereference in VorCdiIndicator * Add memory section and linker script entry for vor_rx application * Testing VOR TX * Moving VOR TX to SD * Code refactoring to align with guidelines * Add TODO comment to verify radial sign convention in vor_tx_config * Remove unnecessary set_dirty() calls in VorRxView methods * Update Course Deviation Indicator label and adjust UI element positions * Update VorTxView to run prepared image from memory map * Update build condition in nightly release workflow to include workflow_dispatch event * Reverting action changes * Adjust Course Deviation Indicator layout and refine painting logic * Refactor VorRxView UI elements for improved layout and clarity * Add calibration field and update radial calculation logic in VorRxView * Enhance VOR processing: add renormalization to phase oscillator, improve signal handling, and update configuration parameters * Implement radial smoothing and TO/FROM state handling in VorRxView; update VOR processing logic * Setting comments inline * Refactor VorCdiIndicator and VorRxView: change normalize_signed_degrees to use int32_t, update radial smoothing to use fixed point arithmetic to reduce flash usage * Update external app address end to 0xAE0B0000 * Update set_vor_tx_config to include enabled parameter for consistency * Refactor VorRx to omit decim_2 stage and update comments for clarity on VOR processing * Add RSSI, Channel, and Audio fields to VorRxView to mimic existing apps * Refactor VorRxView labels and status messages * Update VorRxView calibration field range to allow full circle input * Completing Ident transmission logic * Fixing TX gain and moving log label * Refactor VOR phase calculations and update radial offset handling for accurate bearing representation * Add low-pass filters to strip 9960 Hz subcarrier from audio output	2026-07-04 08:49:21 +02:00
Sandbox	7481aefe9f	customizable name attack option "CUSTOM" for the BLESPAM App (#3239 )	2026-07-02 16:14:17 +02:00
未来方舟	6b641c8a5d	You can search app now (#3241 )	2026-07-02 10:19:53 +02:00
Pezsma	2ad34bbc09	Gpio modify v3 (#3238 ) * Refactor GPIO mappings and definitions for improved clarity and functionality - Updated SCU_ARRAY_SIZE definitions in pal_lld.h for PRALINE and non-PRALINE configurations. - Modified pin mappings in gpio.hpp to reflect new hardware configurations, including additional control pins for RF and audio components. - Removed obsolete GPIO definitions from hackrf_gpio.hpp and streamlined the code for better maintainability. - Added new GPIO definitions for mix bypass, amplifier control, and other RF-related functionalities to enhance the system's capabilities. * Refactor GPIO mappings and update SCU_ARRAY_SIZE for LPC43xx platform - Updated SCU_ARRAY_SIZE to 80 for PRALINE configuration and 58 for others. - Added new GPIO mappings for auxiliary power control, antenna bias, and R9 clock enable signals in gpio.hpp. - Removed commented-out PPS output mapping in hackrf_gpio.hpp. - Adjusted GPIO definitions for R9 clock signals to ensure proper functionality. * Refactor RF path initialization and configuration for improved clarity and functionality * Refactor RF path configuration and GPIO mappings for improved clarity and functionality * Potential fix for pull request finding * comment * aux power polarrity * Fix formatting of pin_aux_power_enable declaration	2026-07-02 10:05:34 +02:00
Totoo	9c74a1f392	fix mbt build on rare errors (#3242 )	2026-07-01 14:42:25 +02:00
gullradriel	abadf35e06	Lna investigations and fix (#3240 ) * The LNA gain field 'L' lives in LPF_VGA_2 (reg 6), not RXRF_2 (reg 2). RXRF_2 only holds LNAgain_SPI_EN. The configure_rx_gain() function wrote 'L' into lpf_vga_2 but marked RXRF_2 dirty => the LNA value only got flushed incidentally because the following VGA write marks LPF_VGA_2 dirty. Drop the stray RXRF_2 dirty flag and rely on the LPF_VGA_2 flag, which carries both L and VGA. * The baseband build defined IS_H1_R9 as the compile-time constant 0, on the (now incorrect) assumption that detected_platform() isn't linked. The sd_over_usb image is the only baseband target that compiles the IS_H1_R9-gated upstream files (rf_path.c, si5351c.c, sgpio.c, platform_gpio.c, platform_scu.c), and it does link platform_detect.c and call detect_hardware_platform() at startup. Forcing IS_H1_R9=0 dead-stripped every 'if (IS_H1_R9)' branch, so a real HackRF One r9 was set up with the OG clock/GPIO/RF-path config in that image. Define IS_H1_R9 as the runtime '(detected_platform()==BOARD_ID_HACKRF1_R9)', mirroring upstream platform-detect.cmake for HACKRF_ONE. All usages are '#ifdef IS_H1_R9' + 'if (IS_H1_R9)' (no arithmetic '#if'), so a function-call expression is safe, single-quoted -D with no internal spaces keeps it intact through the shell-split DDEFS blob. --------- Co-authored-by: gullradriel <gullradriel@users.noreply.github.com>	2026-07-01 08:47:07 +02:00
Totoo	288e87537a	MAX 17055 sleep bug fixes.	2026-06-25 09:08:44 +02:00
gullradriel	d25899de10	Upgrade subm plus warning fix (#3235 )	2026-06-25 08:46:36 +02:00
Totoo	8a16ec829c	fix clock source change on praline (#3233 ) * fix clock source change on praline * whoops	2026-06-22 16:50:16 +02:00
Totoo	f6d6e3be4c	Fix battery display bug, and the flash time (#3232 ) * battfix * por again, but nicer	2026-06-22 16:20:49 +02:00
Pezsma	c16bac24c7	Add RSSI input configuration for VGA output measurement (#3231 )	2026-06-21 11:17:09 +02:00
Payalo64	4e6a2cc934	Add 3.3GHz Analog FPV Channels to FPV_ANALOG.TXT (#3230 )	2026-06-20 18:28:02 +02:00
Pezsma	cafe62564e	Gpio modify (#3229 ) * Refactor GPIO configuration for PRALINE and non-PRALINE setups - Updated PinMap structure to include gpio_mode for better flexibility. - Added new GPIO mappings for SGPIO pins with appropriate configurations. - Commented out unused GPIO definitions in hackrf_gpio.hpp to improve code clarity. - Adjusted GPIO initialization for control pins to utilize the new PinMap structure. - Ensured compatibility for both PRALINE and non-PRALINE configurations by using preprocessor directives. * Refactor GPIO handling and remove LED abstraction - Updated GPIO class to support logical polarity, enabling/disabling features based on their configured state. - Replaced direct GPIO manipulation in power control functions with new GPIO methods for better readability and maintainability. - Removed the LED class and its associated functionality, as it was deemed unnecessary for the current implementation. - Adjusted GPIO initialization for various components, ensuring correct polarity settings for VAA and power enable pins. - Cleaned up unused includes and commented-out code in hackrf_gpio.hpp. * Refactor GPIO LED control methods to use setActive() and setInactive() for improved clarity * Refactor GPIO control methods to use setActive() and setInactive() for improved clarity and consistency * copilot * Update GPIO control logic and pin definitions for clarity and consistency * Refactor GPIO methods for improved naming consistency and clarity	2026-06-19 07:48:55 +02:00
gullradriel	960e5b8329	Upgrade subm plus warning fix (#3227 ) * fix compilation warning * update submodule	2026-06-17 11:34:00 +02:00
Totoo	f5a5e8e5e8	Map improv. (#3226 )	2026-06-16 17:54:32 +02:00
Synray	d8a1e2530a	Add Security+ 2.0 TX App (#3217 ) * Add U64 BoundSetting * Add secplus-tx * Add secplus license * Update icon * UI update * Add filesystem::path BoundSetting * Add file UI * Rename file * Add save button * Fix warnings, add integer conversions to UI macros * UI update * Copilot suggestions, name edit UI * Fix buffer length * Style update * Avoid recursion in Widget::style() * Apply suggestions from code review * Move secplustx.cpp to external * Shorten title * Space optimizations, remove FilePath setting * Remove assertions * Change namespace * Change title to match	2026-06-15 19:28:47 +02:00
Totoo	b84a424875	MBT update	2026-06-13 09:50:25 +08:00