Move AIS receiver to external app

2026-08-22 07:29:03 +00:00 · 2026-07-27 21:23:32 +03:00
parent 838a8de5d0
commit 4a836aef86
8 changed files with 110 additions and 36 deletions
@@ -0,0 +1,515 @@
+/*
+ * 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.
+ */
+
+#include "ais_app.hpp"
+#include "audio.hpp"
+
+#include "string_format.hpp"
+#include "database.hpp"
+#include "file_path.hpp"
+
+#include "baseband_api.hpp"
+
+#include "portapack.hpp"
+using namespace portapack;
+
+#include <algorithm>
+
+namespace pmem = portapack::persistent_memory;
+
+namespace ui::external_app::ais_rx {
+
+namespace format {
+
+static std::string latlon_abs_normalized(const int32_t normalized, const char suffixes[2]) {
+    const auto suffix = suffixes[(normalized < 0) ? 0 : 1];
+    const uint32_t normalized_abs = std::abs(normalized);
+    const uint32_t t = (normalized_abs * 5) / 3;
+    const uint32_t degrees = t / (100 * 10000);
+    const uint32_t fraction = t % (100 * 10000);
+    return to_string_dec_uint(degrees) + "." + to_string_dec_uint(fraction, 6, '0') + suffix;
+}
+
+static std::string latlon(const ais::Latitude latitude, const ais::Longitude longitude) {
+    if (latitude.is_valid() && longitude.is_valid()) {
+        return latlon_abs_normalized(latitude.normalized(), "SN") + " " + latlon_abs_normalized(longitude.normalized(), "WE");
+    } else if (latitude.is_not_available() && longitude.is_not_available()) {
+        return "not available";
+    } else {
+        return "invalid";
+    }
+}
+
+static float latlon_float(const int32_t normalized) {
+    return ((((float)normalized) * 5) / 3) / (100 * 10000);
+}
+
+static std::string mmsi(
+    const ais::MMSI& mmsi) {
+    return to_string_dec_uint(mmsi, 9, '0');  // MMSI is always is always 9 characters pre-padded with zeros
+}
+
+static std::string mid(
+    const ais::MMSI& mmsi) {
+    database db;
+    std::string mid_code = "";
+    database::MidDBRecord mid_record = {};
+    int return_code = 0;
+
+    // Try getting the country name from mids.db using MID code for given MMSI
+    mid_code = to_string_dec_uint(mmsi, 9, ' ').substr(0, 3);
+    return_code = db.retrieve_mid_record(&mid_record, mid_code);
+    switch (return_code) {
+        case DATABASE_RECORD_FOUND:
+            return mid_record.country;
+        case DATABASE_NOT_FOUND:
+            return "No mids.db file";
+        default:
+            return "";
+    }
+}
+
+static std::string text(const std::string& text) {
+    size_t end = text.find_last_not_of("@");
+    return (end == std::string::npos) ? "" : text.substr(0, end + 1);
+}
+
+static std::string navigational_status(const unsigned int value) {
+    switch (value) {
+        case 0:
+            return "under way w/engine";
+        case 1:
+            return "at anchor";
+        case 2:
+            return "not under command";
+        case 3:
+            return "restricted maneuv";
+        case 4:
+            return "constrained draught";
+        case 5:
+            return "moored";
+        case 6:
+            return "aground";
+        case 7:
+            return "fishing";
+        case 8:
+            return "sailing";
+        case 9:
+        case 10:
+        case 13:
+            return "reserved";
+        case 11:
+            return "towing astern";
+        case 12:
+            return "towing ahead/along";
+        case 14:
+            return "SART/MOB/EPIRB";
+        case 15:
+            return "undefined";
+        default:
+            return "unknown";
+    }
+}
+
+static std::string rate_of_turn(const ais::RateOfTurn value) {
+    switch (value) {
+        case -128:
+            return "not available";
+        case -127:
+            return "left >5 deg/30sec";
+        case 0:
+            return "0 deg/min";
+        case 127:
+            return "right >5 deg/30sec";
+        default: {
+            std::string result = (value < 0) ? "left " : "right ";
+            const float value_deg_sqrt = value / 4.733f;
+            const int32_t value_deg = value_deg_sqrt * value_deg_sqrt;
+            result += to_string_dec_uint(value_deg);
+            result += " deg/min";
+            return result;
+        }
+    }
+}
+
+static std::string speed_over_ground(const ais::SpeedOverGround value) {
+    if (value == 1023) {
+        return "not available";
+    } else if (value == 1022) {
+        return ">= 102.2 knots";
+    } else {
+        return to_string_dec_uint(value / 10) + "." + to_string_dec_uint(value % 10, 1) + " knots";
+    }
+}
+
+static std::string course_over_ground(const ais::CourseOverGround value) {
+    if (value > 3600) {
+        return "invalid";
+    } else if (value == 3600) {
+        return "not available";
+    } else {
+        return to_string_dec_uint(value / 10) + "." + to_string_dec_uint(value % 10, 1) + " deg";
+    }
+}
+
+static std::string true_heading(const ais::TrueHeading value) {
+    if (value == 511) {
+        return "not available";
+    } else if (value > 359) {
+        return "invalid";
+    } else {
+        return to_string_dec_uint(value) + " deg";
+    }
+}
+
+} /* namespace format */
+
+void AISLogger::on_packet(const ais::Packet& packet) {
+    // TODO: Unstuff here, not in baseband!
+    std::string entry;
+    entry.reserve((packet.length() + 3) / 4);
+
+    for (size_t i = 0; i < packet.length(); i += 4) {
+        const auto nibble = packet.read(i, 4);
+        entry += (nibble >= 10) ? ('W' + nibble) : ('0' + nibble);
+    }
+
+    log_file.write_entry(packet.received_at(), entry);
+
+    if (pmem::beep_on_packets()) {
+        baseband::request_audio_beep(1000, 24000, 60);
+    }
+}
+
+void AISRecentEntry::update(const ais::Packet& packet) {
+    received_count++;
+
+    switch (packet.message_id()) {
+        case 1:
+        case 2:
+        case 3:
+            navigational_status = packet.read(38, 4);
+            last_position.rate_of_turn = packet.read(42, 8);
+            last_position.speed_over_ground = packet.read(50, 10);
+            last_position.timestamp = packet.received_at();
+            last_position.latitude = packet.latitude(89);
+            last_position.longitude = packet.longitude(61);
+            last_position.course_over_ground = packet.read(116, 12);
+            last_position.true_heading = packet.read(128, 9);
+            break;
+
+        case 4:
+            last_position.timestamp = packet.received_at();
+            last_position.latitude = packet.latitude(107);
+            last_position.longitude = packet.longitude(79);
+            break;
+
+        case 5:
+            call_sign = trim(packet.text(70, 7));
+            name = trim(packet.text(112, 20));
+            destination = trim(packet.text(302, 20));
+            break;
+
+        case 18:
+            last_position.timestamp = packet.received_at();
+            last_position.speed_over_ground = packet.read(46, 10);
+            last_position.latitude = packet.latitude(85);
+            last_position.longitude = packet.longitude(57);
+            last_position.course_over_ground = packet.read(112, 12);
+            last_position.true_heading = packet.read(124, 9);
+            break;
+
+        case 21:
+            name = trim(packet.text(43, 20));
+            last_position.timestamp = packet.received_at();
+            last_position.latitude = packet.latitude(192);
+            last_position.longitude = packet.longitude(164);
+            break;
+
+        case 24:
+            switch (packet.read(38, 2)) {
+                case 0:
+                    name = trim(packet.text(40, 20));
+                    break;
+
+                case 1:
+                    call_sign = trim(packet.text(90, 7));
+                    break;
+
+                default:
+                    break;
+            }
+
+            break;
+
+        default:
+            break;
+    }
+}
+
+}  // namespace ui::external_app::ais_rx
+
+namespace ui {
+
+template <>
+void RecentEntriesTable<external_app::ais_rx::AISRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style,
+    RecentEntriesColumns&) {
+    using namespace external_app::ais_rx;
+
+    std::string line = format::mmsi(entry.mmsi) + " ";
+    if (!entry.name.empty()) {
+        line += format::text(entry.name);
+    } else {
+        line += format::text(entry.call_sign);
+    }
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+
+}  // namespace ui
+
+namespace ui::external_app::ais_rx {
+
+AISRecentEntryDetailView::AISRecentEntryDetailView(NavigationView& nav) {
+    add_children({
+        &button_done,
+        &button_see_map,
+    });
+
+    button_done.on_select = [this](const ui::Button&) {
+        if (on_close) {
+            on_close();
+        }
+    };
+
+    button_see_map.on_select = [this, &nav](Button&) {
+        geomap_view = nav.push<GeoMapView>(
+            format::text(entry_.name),
+            0,
+            GeoPos::alt_unit::METERS,
+            GeoPos::spd_unit::KNOTS,
+            format::latlon_float(entry_.last_position.latitude.normalized()),
+            format::latlon_float(entry_.last_position.longitude.normalized()),
+            entry_.last_position.true_heading,
+            [this]() {
+                send_updates = false;
+            });
+        send_updates = true;
+    };
+}
+
+AISRecentEntryDetailView::AISRecentEntryDetailView(const AISRecentEntryDetailView& Entry)
+    : View() {
+    (void)Entry;
+}
+
+AISRecentEntryDetailView& AISRecentEntryDetailView::operator=(const AISRecentEntryDetailView& Entry) {
+    (void)Entry;
+    return *this;
+}
+
+void AISRecentEntryDetailView::update_position() {
+    if (send_updates)
+        geomap_view->update_position(format::latlon_float(entry_.last_position.latitude.normalized()), format::latlon_float(entry_.last_position.longitude.normalized()), (float)entry_.last_position.true_heading, 0, entry_.last_position.speed_over_ground > 1022 ? 0 : entry_.last_position.speed_over_ground / 10);
+}
+
+bool AISRecentEntryDetailView::add_map_marker(const AISRecentEntry& entry) {
+    if (geomap_view && send_updates) {
+        GeoMarker marker{};
+        marker.lon = format::latlon_float(entry.last_position.longitude.normalized());
+        marker.lat = format::latlon_float(entry.last_position.latitude.normalized());
+        marker.angle = entry.last_position.true_heading;
+        marker.tag = entry.call_sign.empty() ? to_string_dec_uint(entry.mmsi) : entry.call_sign;
+        auto markerStored = geomap_view->store_marker(marker);
+        return markerStored == MARKER_STORED;
+    }
+    return false;
+}
+void AISRecentEntryDetailView::update_map_markers(AISRecentEntries& entries) {
+    if (geomap_view && send_updates) {
+        geomap_view->clear_markers();
+        for (const auto& entry : entries) {
+            // if (entry.last_position.latitude.is_valid() && entry.last_position.longitude.is_valid()) {
+            add_map_marker(entry);
+            // }
+        }
+        update_position();  // to update view
+    }
+}
+
+void AISRecentEntryDetailView::focus() {
+    button_done.focus();
+}
+
+Rect AISRecentEntryDetailView::draw_field(
+    Painter& painter,
+    const Rect& draw_rect,
+    const Style& style,
+    const std::string& label,
+    const std::string& value) {
+    const int label_length_max = 4;
+
+    painter.draw_string(Point{draw_rect.left(), draw_rect.top()}, style, label);
+    painter.draw_string(Point{draw_rect.left() + (label_length_max + 1) * 8, draw_rect.top()}, style, value);
+
+    return {draw_rect.left(), draw_rect.top() + draw_rect.height(), draw_rect.width(), draw_rect.height()};
+}
+
+void AISRecentEntryDetailView::paint(Painter& painter) {
+    View::paint(painter);
+
+    const auto s = style();
+    const auto rect = screen_rect();
+
+    auto field_rect = Rect{rect.left(), rect.top() + 16, rect.width(), 16};
+
+    field_rect = draw_field(painter, field_rect, s, "MMSI", format::mmsi(entry_.mmsi));
+    field_rect = draw_field(painter, field_rect, s, "Ctry", format::mid(entry_.mmsi));
+    field_rect = draw_field(painter, field_rect, s, "Name", format::text(entry_.name));
+    field_rect = draw_field(painter, field_rect, s, "Call", format::text(entry_.call_sign));
+    field_rect = draw_field(painter, field_rect, s, "Dest", format::text(entry_.destination));
+    field_rect = draw_field(painter, field_rect, s, "Last", to_string_datetime(entry_.last_position.timestamp));
+    field_rect = draw_field(painter, field_rect, s, "Pos ", format::latlon(entry_.last_position.latitude, entry_.last_position.longitude));
+    field_rect = draw_field(painter, field_rect, s, "Stat", format::navigational_status(entry_.navigational_status));
+    field_rect = draw_field(painter, field_rect, s, "RoT ", format::rate_of_turn(entry_.last_position.rate_of_turn));
+    field_rect = draw_field(painter, field_rect, s, "SoG ", format::speed_over_ground(entry_.last_position.speed_over_ground));
+    field_rect = draw_field(painter, field_rect, s, "CoG ", format::course_over_ground(entry_.last_position.course_over_ground));
+    field_rect = draw_field(painter, field_rect, s, "Head", format::true_heading(entry_.last_position.true_heading));
+    field_rect = draw_field(painter, field_rect, s, "Rx #", to_string_dec_uint(entry_.received_count));
+}
+
+void AISRecentEntryDetailView::set_entry(const AISRecentEntry& entry) {
+    entry_ = entry;
+    set_dirty();
+}
+
+AISAppView::AISAppView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_ais);
+
+    add_children({
+        &label_channel,
+        &options_channel,
+        &field_rf_amp,
+        &field_lna,
+        &field_vga,
+        &rssi,
+        &field_volume,
+        &channel,
+        &recent_entries_view,
+        &recent_entry_detail_view,
+    });
+
+    recent_entry_detail_view.hidden(true);
+
+    receiver_model.enable();
+
+    options_channel.on_change = [this](size_t, OptionsField::value_t v) {
+        receiver_model.set_target_frequency(v);
+    };
+    options_channel.set_by_value(receiver_model.target_frequency());
+
+    recent_entries_view.on_select = [this](const AISRecentEntry& entry) {
+        on_show_detail(entry);
+    };
+    recent_entry_detail_view.on_close = [this]() {
+        on_show_list();
+    };
+
+    logger = std::make_unique<AISLogger>();
+    if (logger) {
+        logger->append(logs_dir / u"AIS.TXT");
+    }
+
+    if (pmem::beep_on_packets()) {
+        audio::set_rate(audio::Rate::Hz_24000);
+        audio::output::start();
+    }
+
+    signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
+        on_tick_second();
+    };
+}
+
+AISAppView::~AISAppView() {
+    rtc_time::signal_tick_second -= signal_token_tick_second;
+    audio::output::stop();
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+void AISAppView::on_tick_second() {
+    ++timer_seconds;
+    if (timer_seconds % 10 == 0) {
+        if (recent_entry_detail_view.hidden()) return;
+        if (got_new_packet) {
+            got_new_packet = false;
+            recent_entry_detail_view.update_map_markers(recent);
+        }
+    }
+}
+
+void AISAppView::focus() {
+    options_channel.focus();
+}
+
+void AISAppView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    const Rect content_rect{0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height};
+    recent_entries_view.set_parent_rect(content_rect);
+    recent_entry_detail_view.set_parent_rect(content_rect);
+}
+
+void AISAppView::on_packet(const ais::Packet& packet) {
+    if (logger) {
+        logger->on_packet(packet);
+    }
+    got_new_packet = true;
+    auto& entry = ::on_packet(recent, packet.source_id());
+    entry.update(packet);
+    recent_entries_view.set_dirty();
+
+    // TODO: Crude hack, should be a more formal listener arrangement...
+    if (entry.key() == recent_entry_detail_view.entry().key()) {
+        recent_entry_detail_view.set_entry(entry);
+        recent_entry_detail_view.update_position();
+    }
+}
+
+void AISAppView::on_show_list() {
+    recent_entries_view.hidden(false);
+    recent_entry_detail_view.hidden(true);
+    recent_entries_view.focus();
+}
+
+void AISAppView::on_show_detail(const AISRecentEntry& entry) {
+    recent_entries_view.hidden(true);
+    recent_entry_detail_view.hidden(false);
+    recent_entry_detail_view.set_entry(entry);
+    recent_entry_detail_view.focus();
+    recent_entry_detail_view.update_map_markers(recent);
+}
+
+}  // namespace ui::external_app::ais_rx
@@ -0,0 +1,244 @@
+/*
+ * 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 __AIS_APP_H__
+#define __AIS_APP_H__
+
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_rssi.hpp"
+#include "ui_channel.hpp"
+
+#include "ui_geomap.hpp"
+
+#include "event_m0.hpp"
+
+#include "log_file.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "ais_packet.hpp"
+
+#include "lpc43xx_cpp.hpp"
+using namespace lpc43xx;
+
+#include <cstdint>
+#include <cstddef>
+#include <string>
+#include <list>
+#include <utility>
+
+#include <iterator>
+
+#include "recent_entries.hpp"
+
+namespace ui::external_app::ais_rx {
+
+struct AISPosition {
+    rtc::RTC timestamp{};
+    ais::Latitude latitude{};
+    ais::Longitude longitude{};
+    ais::RateOfTurn rate_of_turn{-128};
+    ais::SpeedOverGround speed_over_ground{1023};
+    ais::CourseOverGround course_over_ground{3600};
+    ais::TrueHeading true_heading{511};
+};
+
+struct AISRecentEntry {
+    using Key = ais::MMSI;
+
+    static constexpr Key invalid_key = 0xffffffff;
+
+    ais::MMSI mmsi;
+    std::string name;
+    std::string call_sign;
+    std::string destination;
+    AISPosition last_position;
+    size_t received_count;
+    int8_t navigational_status;
+
+    AISRecentEntry()
+        : AISRecentEntry{0} {
+    }
+
+    AISRecentEntry(
+        const ais::MMSI& mmsi)
+        : mmsi{mmsi},
+          name{},
+          call_sign{},
+          destination{},
+          last_position{},
+          received_count{0},
+          navigational_status{-1} {
+    }
+
+    Key key() const {
+        return mmsi;
+    }
+
+    void update(const ais::Packet& packet);
+};
+
+using AISRecentEntries = RecentEntries<AISRecentEntry>;
+
+class AISLogger {
+   public:
+    Optional<File::Error> append(const std::filesystem::path& filename) {
+        return log_file.append(filename);
+    }
+
+    void on_packet(const ais::Packet& packet);
+
+   private:
+    LogFile log_file{};
+};
+
+using AISRecentEntriesView = RecentEntriesView<AISRecentEntries>;
+
+class AISRecentEntryDetailView : public View {
+   public:
+    std::function<void(void)> on_close{};
+
+    AISRecentEntryDetailView(NavigationView& nav);
+
+    void set_entry(const AISRecentEntry& new_entry);
+    const AISRecentEntry& entry() const { return entry_; };
+
+    void update_position();
+    void focus() override;
+    void paint(Painter&) override;
+    bool add_map_marker(const AISRecentEntry& entry);
+    void update_map_markers(AISRecentEntries& entries);
+
+    AISRecentEntryDetailView(const AISRecentEntryDetailView& Entry);
+    AISRecentEntryDetailView& operator=(const AISRecentEntryDetailView& Entry);
+
+    GeoMapView* get_geomap_view() { return geomap_view; }
+
+   private:
+    AISRecentEntry entry_{};
+
+    Button button_done{
+        {UI_POS_X_CENTER(12) + UI_POS_WIDTH(6), UI_POS_Y(14), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
+        "Done"};
+    Button button_see_map{
+        {UI_POS_X_CENTER(12) - UI_POS_WIDTH(8), UI_POS_Y(14), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
+        "See on map"};
+    GeoMapView* geomap_view{nullptr};
+    bool send_updates{false};
+
+    Rect draw_field(
+        Painter& painter,
+        const Rect& draw_rect,
+        const Style& style,
+        const std::string& label,
+        const std::string& value);
+};
+
+class AISAppView : public View {
+   public:
+    AISAppView(NavigationView& nav);
+    ~AISAppView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+    void paint(Painter&) override {};
+
+    void focus() override;
+
+    std::string title() const override { return "AIS RX"; };
+
+   private:
+    RxRadioState radio_state_{
+        162025000 /* frequency*/,
+        1750000 /* bandwidth */,
+        2457600 /* sampling rate */
+    };
+    app_settings::SettingsManager settings_{
+        "rx_ais", app_settings::Mode::RX};
+
+    NavigationView& nav_;
+
+    AISRecentEntries recent{};
+    std::unique_ptr<AISLogger> logger{};
+
+    RecentEntriesColumns columns{{
+        {"MMSI", 9},
+        {"Name/Call", 0},
+    }};
+    AISRecentEntriesView recent_entries_view{columns, recent};
+    AISRecentEntryDetailView recent_entry_detail_view{nav_};
+
+    static constexpr auto header_height = 1 * 16;
+
+    Text label_channel{
+        {UI_POS_X(0), UI_POS_Y(0), 2 * 8, 1 * 16},
+        "Ch"};
+
+    OptionsField options_channel{
+        {3 * 8, UI_POS_Y(0)},
+        3,
+        {
+            {"87B", 161975000},
+            {"88B", 162025000},
+        }};
+
+    RFAmpField field_rf_amp{
+        {13 * 8, UI_POS_Y(0)}};
+
+    LNAGainField field_lna{
+        {15 * 8, UI_POS_Y(0)}};
+
+    VGAGainField field_vga{
+        {18 * 8, UI_POS_Y(0)}};
+
+    RSSI rssi{
+        {UI_POS_X(21), UI_POS_Y(0), UI_POS_WIDTH_REMAINING(23), 4},
+    };
+
+    AudioVolumeField field_volume{
+        {UI_POS_X_RIGHT(2), UI_POS_Y(0)}};
+
+    Channel channel{
+        {UI_POS_X(21), 5, UI_POS_WIDTH_REMAINING(23), 4},
+    };
+    SignalToken signal_token_tick_second{};
+    uint8_t timer_seconds = 0;
+    bool got_new_packet{false};  // got any new packet since latest screen update?
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::AISPacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const AISPacketMessage*>(p);
+            const ais::Packet packet{message->packet};
+            if (packet.is_valid()) {
+                this->on_packet(packet);
+            }
+        }};
+
+    void on_packet(const ais::Packet& packet);
+    void on_show_list();
+    void on_show_detail(const AISRecentEntry& entry);
+    void on_tick_second();
+};
+
+}  // namespace ui::external_app::ais_rx
+
+#endif /*__AIS_APP_H__*/
@@ -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 "ais_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::ais_rx {
+
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<AISAppView>();
+}
+
+}  // namespace ui::external_app::ais_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_ais_rx.application_information"), used)) application_information_t _application_information_ais_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::ais_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "AIS Boats",
+    /*.bitmap_data = */ {
+        0x00, 0x01, 0x80, 0x01, 0xC0, 0x01, 0xC0, 0x0D,
+        0xE0, 0x3D, 0xF0, 0x3D, 0xF8, 0x7D, 0xFC, 0x7D,
+        0xFC, 0x7D, 0xFE, 0x7D, 0xFF, 0x7D, 0x00, 0x00,
+        0xF8, 0x7F, 0xF8, 0x3F, 0xF0, 0x0F, 0x00, 0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_ais */ {'P', 'A', 'I', 'S'},
+    /*.m4_app_offset = */ 0x00000000,
+};
+
+}  // extern "C"
@@ -395,6 +395,10 @@ set(EXTCPPSRC
 	external/adsbrx/main.cpp
 	external/adsbrx/ui_adsb_rx.cpp

+	#ais rx
+	external/ais_rx/main.cpp
+	external/ais_rx/ais_app.cpp
+
 )

 set(EXTAPPLIST
@@ -490,6 +494,7 @@ set(EXTAPPLIST
  signal_hunter
 	tetra_rx
 	adsbrx
+	ais_rx
 )

 # sdusb has type conflicts with PRALINE (HackRF Pro) - add only for non-PRALINE builds
@@ -116,6 +116,7 @@ MEMORY
    ram_external_app_signal_hunter         (rwx) : org = 0xAE0B0000, len = 32k
    ram_external_app_tetra_rx              (rwx) : org = 0xAE0C0000, len = 32k
    ram_external_app_adsbrx                (rwx) : org = 0xAE0D0000, len = 32k
+    ram_external_app_ais_rx                (rwx) : org = 0xAE0E0000, len = 32k
 }

 SECTIONS
@@ -678,6 +679,12 @@ SECTIONS
        *(*ui*external_app*adsbrx*);
    } > ram_external_app_adsbrx

+    .external_app_ais_rx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_ais_rx.application_information));
+        *(*ui*external_app*ais_rx*);
+    } > ram_external_app_ais_rx
+


 }