Move APRS transmitter to external app

firmware/application/external/aprs_tx/main.cpp

@@ -0,0 +1,57 @@
+/*
+ * 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 "ui_aprs_tx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::aprs_tx {
+
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<APRSTXView>();
+}
+
+}  // namespace ui::external_app::aprs_tx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_aprs_tx.application_information"), used)) application_information_t _application_information_aprs_tx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::aprs_tx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "APRS TX",
+    /*.bitmap_data = */ {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F,
+        0x4C, 0x32, 0xFE, 0x7F, 0x25, 0xA4, 0x25, 0xA4,
+        0xFF, 0xFF, 0x25, 0xA4, 0x25, 0xA4, 0xFE, 0x7F,
+        0x4C, 0x32, 0xF0, 0x0F, 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_afsk */ {'P', 'A', 'F', 'T'},
+    /*.m4_app_offset = */ 0x00000000,
+};
+
+}  // extern "C"

firmware/application/external/aprs_tx/ui_aprs_tx.cpp

@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui_aprs_tx.hpp"
+#include "ui_alphanum.hpp"
+
+#include "aprs.hpp"
+#include "string_format.hpp"
+#include "portapack.hpp"
+#include "baseband_api.hpp"
+#include "portapack_shared_memory.hpp"
+#include "portapack_persistent_memory.hpp"
+#include "ui_geomap.hpp"
+
+#include <cstring>
+#include <stdio.h>
+
+using namespace aprs;
+using namespace portapack;
+
+namespace ui::external_app::aprs_tx {
+
+void APRSTXView::focus() {
+    tx_view.focus();
+}
+
+APRSTXView::~APRSTXView() {
+    transmitter_model.disable();
+    baseband::shutdown();
+}
+
+void APRSTXView::start_tx() {
+    // TODO: Clean up this API to take string_views to avoid allocations.
+    std::string new_payload = payload;
+
+    std::string gps = text_gps_coord.get();
+    std::string token = "?GPS?";
+    size_t pos = 0;
+    while ((pos = new_payload.find(token, pos)) != std::string::npos) {
+        new_payload.replace(pos, token.size(), gps);
+        pos += gps.size();
+    }
+
+    text_payload.set(new_payload);
+
+    std::string path = text_path.get();
+
+    make_aprs_frame(
+        sym_source.to_string().c_str(), num_ssid_source.value(),
+        sym_dest.to_string().c_str(), num_ssid_dest.value(),
+        new_payload, path);
+
+    // uint8_t * bb_data_ptr = shared_memory.bb_data.data;
+    // text_payload.set(to_string_hex_array(bb_data_ptr + 56, 15));
+
+    transmitter_model.enable();
+
+    baseband::set_afsk_data(
+        AFSK_TX_SAMPLERATE / 1200,
+        1200,
+        2200,
+        1,
+        10000,  // APRS uses fixed 10k bandwidth
+        8);
+}
+
+void APRSTXView::on_tx_progress(const uint32_t progress, const bool done) {
+    (void)progress;
+
+    if (done) {
+        transmitter_model.disable();
+        tx_view.set_transmitting(false);
+    }
+}
+
+void APRSTXView::process_coordinates(float lat_, float lon_) {
+    std::string s;
+
+    char ns = lat_ >= 0 ? 'N' : 'S';
+    float lat = (lat_ >= 0) ? lat_ : -lat_;
+    uint32_t lat_d = (uint32_t)lat;
+    uint32_t lat_m = (uint32_t)((lat - lat_d) * 6000.0f + 0.5f);
+
+    if (lat_m >= 6000) {
+        lat_m = 0;
+        lat_d++;
+    }
+
+    s += to_string_dec_uint(lat_d, 2, '0');
+    s += to_string_dec_uint(lat_m / 100, 2, '0');
+    s += ".";
+    s += to_string_dec_uint(lat_m % 100, 2, '0');
+    s += ns;
+
+    s += "/";
+
+    char ew = lon_ >= 0 ? 'E' : 'W';
+    float lon = (lon_ >= 0) ? lon_ : -lon_;
+    uint32_t lon_d = (uint32_t)lon;
+    uint32_t lon_m = (uint32_t)((lon - lon_d) * 6000.0f + 0.5f);
+
+    if (lon_m >= 6000) {
+        lon_m = 0;
+        lon_d++;
+    }
+
+    s += to_string_dec_uint(lon_d, 3, '0');
+    s += to_string_dec_uint(lon_m / 100, 2, '0');
+    s += ".";
+    s += to_string_dec_uint(lon_m % 100, 2, '0');
+    s += ew;
+    text_gps_coord.set(s);
+}
+
+void APRSTXView::on_gps(const GPSPosDataMessage* message) {
+    if (manual_gps_mode) {
+        return;  // no more update once set manually
+    }
+    if (message->lat < -90.0 || message->lat > 90.0 ||
+        message->lon < -180.0 || message->lon > 180.0) {
+        return;
+    }
+    if (message->lat == 0.0f && message->lon == 0.0f) {
+        return;
+    }
+    last_lat = message->lat;
+    last_lon = message->lon;
+    process_coordinates(message->lat, message->lon);
+}
+
+APRSTXView::APRSTXView(NavigationView& nav) {
+    baseband::run_image(portapack::spi_flash::image_tag_afsk);
+
+    add_children({&labels,
+                  &sym_source,
+                  &num_ssid_source,
+                  &sym_dest,
+                  &num_ssid_dest,
+                  &text_payload,
+                  &button_set,
+                  &text_gps_coord,
+                  &button_mangps,
+                  &gps_is_manual,
+                  &text_path,
+                  &button_setpath,
+                  &tx_view});
+
+    sym_source.set_value(symsrc);
+    num_ssid_source.set_value(ssidsrc);
+    sym_dest.set_value(symdst);
+    num_ssid_dest.set_value(ssiddst);
+    text_payload.set(payload);
+    text_path.set(path_cache);
+
+    sym_source.on_change = [this](SymField&) {
+        symsrc = sym_source.to_string();
+    };
+    num_ssid_source.on_change = [this](int32_t v) {
+        ssidsrc = v;
+    };
+    sym_dest.on_change = [this](SymField&) {
+        symdst = sym_dest.to_string();
+    };
+    num_ssid_dest.on_change = [this](int32_t v) {
+        ssiddst = v;
+    };
+
+    button_set.on_select = [this, &nav](Button&) {
+        text_prompt(
+            nav,
+            payload,
+            30,
+            ENTER_KEYBOARD_MODE_ALPHA,
+            [this](std::string& s) {
+                text_payload.set(s);
+            });
+    };
+    button_setpath.on_select = [this, &nav](Button&) {
+        text_prompt(
+            nav,
+            path_cache,
+            60,
+            ENTER_KEYBOARD_MODE_ALPHA,
+            [this](std::string& s) {
+                text_path.set(s);
+                path_cache = s;
+            });
+    };
+
+    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]() {
+        start_tx();
+        tx_view.set_transmitting(true);
+    };
+
+    tx_view.on_stop = [this]() {
+        tx_view.set_transmitting(false);
+        transmitter_model.disable();
+    };
+
+    button_mangps.on_select = [this, &nav](Button&) {
+        nav.push<GeoMapView>(
+            0,
+            GeoPos::alt_unit::METERS,
+            GeoPos::spd_unit::HIDDEN,
+            last_lat,
+            last_lon,
+            [this](int32_t, float lat, float lon, int32_t) {
+                last_lat = lat;
+                last_lon = lon;
+                manual_gps_mode = true;
+                gps_is_manual.set("MANUAL");
+                process_coordinates(lat, lon);
+            });
+    };
+
+    // process_coordinates(last_lat, last_lon); //don't load last, so won't confuse users
+}
+
+}  // namespace ui::external_app::aprs_tx

firmware/application/external/aprs_tx/ui_aprs_tx.hpp

@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2017 Furrtek
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ui_textentry.hpp"
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_transmitter.hpp"
+
+#include "message.hpp"
+#include "modems.hpp"
+#include "transmitter_model.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "portapack.hpp"
+
+namespace ui::external_app::aprs_tx {
+
+class APRSTXView : public View {
+   public:
+    APRSTXView(NavigationView& nav);
+    ~APRSTXView();
+
+    void focus() override;
+
+    std::string title() const override { return "APRS TX"; };
+
+   private:
+    TxRadioState radio_state_{
+        144390000 /* frequency */,
+        1750000 /* bandwidth */,
+        AFSK_TX_SAMPLERATE /* sampling rate */
+    };
+
+    std::string symsrc = "";
+    std::string symdst = "";
+    std::string payload{""};
+    std::string path_cache = "";
+    int32_t ssidsrc = 0;
+    int32_t ssiddst = 0;
+
+    bool manual_gps_mode = false;
+    float last_lat = 0.0f;
+    float last_lon = 0.0f;
+
+    app_settings::SettingsManager settings_{
+        "tx_aprs",
+        app_settings::Mode::TX,
+        {{"symsrc"sv, &symsrc},
+         {"symdst"sv, &symdst},
+         {"ssidsrc"sv, &ssidsrc},
+         {"ssiddst"sv, &ssiddst},
+         {"payload"sv, &payload},
+         {"last_lat"sv, &last_lat},
+         {"last_lon"sv, &last_lon},
+         {"path"sv, &path_cache}}};
+
+    void start_tx();
+    void generate_frame();
+    void generate_frame_pos();
+    void on_tx_progress(const uint32_t progress, const bool done);
+    void on_gps(const GPSPosDataMessage* message);
+    void process_coordinates(float lat, float lon);
+
+    Labels labels{
+        {{UI_POS_X(0), UI_POS_Y(0)}, "Source:       SSID:", Theme::getInstance()->fg_light->foreground},  // 6 alphanum + SSID
+        {{UI_POS_X(0), UI_POS_Y(1)}, " Dest.:       SSID:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(2)}, "Path: (ex.: WIDE1-1,WIDE2-1)", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(6)}, "Info field:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X(0), UI_POS_Y(10)}, "GPS:", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_CENTER(22), UI_POS_Y(14)}, "Use ?GPS? in the info", Theme::getInstance()->fg_light->foreground},
+        {{UI_POS_X_CENTER(17), UI_POS_Y(15)}, "as a placeholder.", Theme::getInstance()->fg_light->foreground},
+    };
+
+    Text text_path{
+        {UI_POS_X(0), UI_POS_Y(3), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)},
+        "WIDE1-1",
+    };
+    Text gps_is_manual{
+        {UI_POS_X(6), UI_POS_Y(10), UI_POS_WIDTH(10), UI_POS_HEIGHT(1)},
+        "",
+    };
+
+    SymField sym_source{
+        {UI_POS_X(7), UI_POS_Y(0)},
+        6,
+        SymField::Type::Alpha};
+
+    NumberField num_ssid_source{
+        {UI_POS_X(19), UI_POS_Y(0)},
+        2,
+        {0, 15},
+        1,
+        ' '};
+
+    SymField sym_dest{
+        {UI_POS_X(7), UI_POS_Y(1)},
+        6,
+        SymField::Type::Alpha};
+
+    NumberField num_ssid_dest{
+        {UI_POS_X(19), UI_POS_Y(1)},
+        2,
+        {0, 15},
+        1,
+        ' '};
+
+    Text text_payload{
+        {UI_POS_X(0), UI_POS_Y(7), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)},
+        ""};
+    Button button_set{
+        {UI_POS_X(0), UI_POS_Y(8), UI_POS_WIDTH(10), UI_POS_HEIGHT(2)},
+        "Set"};
+
+    Text text_gps_coord{
+        {UI_POS_X(0), UI_POS_Y(11), UI_POS_WIDTH(20), UI_POS_HEIGHT(1)},
+        "-"};
+
+    Button button_mangps{
+        {UI_POS_X(0), UI_POS_Y(12), UI_POS_WIDTH(14), UI_POS_HEIGHT(2)},
+        "Manual GPS"};
+    Button button_setpath{
+        {UI_POS_X(0), UI_POS_Y(4), UI_POS_WIDTH(14), UI_POS_HEIGHT(2)},
+        "Set Path"};
+    TransmitterView tx_view{
+        (int16_t)UI_POS_Y_BOTTOM(4),
+        5000,
+        0  // disable setting bandwith, since APRS used fixed 10k bandwidth
+    };
+
+    MessageHandlerRegistration message_handler_gps{
+        Message::ID::GPSPosData,
+        [this](Message* const p) {
+            const auto message = static_cast<const GPSPosDataMessage*>(p);
+            this->on_gps(message);
+        }};
+    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::aprs_tx

firmware/application/external/external.cmake

@@ -403,6 +403,10 @@ set(EXTCPPSRC
 	external/aprs_rx/main.cpp
 	external/aprs_rx/ui_aprs_rx.cpp
 
+	#aprs tx
+	external/aprs_tx/main.cpp
+	external/aprs_tx/ui_aprs_tx.cpp
+
 )
 
 set(EXTAPPLIST
@@ -500,6 +504,7 @@ set(EXTAPPLIST
 	adsbrx
 	ais_rx
 	aprs_rx
+	aprs_tx
 )
 
 # sdusb has type conflicts with PRALINE (HackRF Pro) - add only for non-PRALINE builds

firmware/application/external/external.ld

@@ -118,6 +118,7 @@ MEMORY
     ram_external_app_adsbrx                (rwx) : org = 0xAE0D0000, len = 32k
     ram_external_app_ais_rx                (rwx) : org = 0xAE0E0000, len = 32k
     ram_external_app_aprs_rx               (rwx) : org = 0xAE0F0000, len = 32k
+    ram_external_app_aprs_tx               (rwx) : org = 0xAE100000, len = 32k
 }
 
 SECTIONS
@@ -692,6 +693,12 @@ SECTIONS
         *(*ui*external_app*aprs_rx*);
     } > ram_external_app_aprs_rx
 
+    .external_app_aprs_tx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_aprs_tx.application_information));
+        *(*ui*external_app*aprs_tx*);
+    } > ram_external_app_aprs_tx
+
 
 
 }