BLE RX/TX Changes (#2752)

* Work on BLE Rx Tx improvements.
* Working on compile size.
* cleanup
* Formatting
* Fixes
* More Improvements + Custom Parsing for Tags
* Moving ERT to external apps.
* Fix Icon.

firmware/application/external/ert/ert_app.cpp

@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2023 Mark Thompson
+ *
+ * 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 "ert_app.hpp"
+
+#include "baseband_api.hpp"
+#include "audio.hpp"
+#include "portapack.hpp"
+using namespace portapack;
+
+#include "manchester.hpp"
+
+#include "crc.hpp"
+#include "string_format.hpp"
+#include "file_path.hpp"
+
+namespace pmem = portapack::persistent_memory;
+
+namespace ert {
+
+namespace format {
+
+std::string type(Packet::Type value) {
+    switch (value) {
+        default:
+        case Packet::Type::Unknown:
+            return "???";
+        case Packet::Type::IDM:
+            return "IDM";
+        case Packet::Type::SCM:
+            return "SCM";
+        case Packet::Type::SCMPLUS:
+            return "SCM+";
+    }
+}
+
+std::string id(ID value) {
+    return to_string_dec_uint(value, 10);
+}
+
+std::string consumption(Consumption value) {
+    return to_string_dec_uint(value, 8);
+}
+
+std::string commodity_type(CommodityType value) {
+    return to_string_dec_uint(value, 2);
+}
+
+std::string tamper_flags(TamperFlags value) {
+    return to_string_hex(value & 0xFFFF, 4);  // Note: ignoring bits 32-47 of tamper flags in IDM type due to screen width
+}
+
+std::string tamper_flags_scm(TamperFlags value) {
+    return " " + to_string_hex(value & 0x0F, 1) + "/" + to_string_hex(value >> 4, 1);  // Physical/Encoder flags
+}
+
+} /* namespace format */
+
+} /* namespace ert */
+
+void ERTLogger::on_packet(const ert::Packet& packet, const uint32_t target_frequency) {
+    const auto formatted = packet.symbols_formatted();
+    const auto target_frequency_str = to_string_dec_uint(target_frequency, 10);
+
+    std::string entry = target_frequency_str + " " + ert::format::type(packet.type()) + " " + formatted.data + "/" + formatted.errors + " ID:" + to_string_dec_uint(packet.id(), 1);
+
+    log_file.write_entry(packet.received_at(), entry);
+}
+
+const ERTRecentEntry::Key ERTRecentEntry::invalid_key{};
+
+void ERTRecentEntry::update(const ert::Packet& packet) {
+    received_count++;
+
+    last_consumption = packet.consumption();
+    last_tamper_flags = packet.tamper_flags();
+    packet_type = packet.type();
+}
+
+namespace ui::external_app::ert_app {
+
+ERTAppView::ERTAppView(NavigationView& nav)
+    : nav_{nav} {
+    baseband::run_image(portapack::spi_flash::image_tag_ert);
+
+    add_children({
+        &field_frequency,
+        &field_rf_amp,
+        &field_lna,
+        &field_vga,
+        &rssi,
+        &field_volume,
+        &recent_entries_view,
+    });
+
+    field_frequency.set_step(1000000);
+
+    receiver_model.enable();
+
+    logger = std::make_unique<ERTLogger>();
+    if (logger) {
+        logger->append(logs_dir / u"ERT.TXT");
+    }
+
+    if (pmem::beep_on_packets()) {
+        audio::set_rate(audio::Rate::Hz_24000);
+        audio::output::start();
+    }
+}
+
+ERTAppView::~ERTAppView() {
+    audio::output::stop();
+    receiver_model.disable();
+    baseband::shutdown();
+}
+
+void ERTAppView::focus() {
+    field_vga.focus();
+}
+
+void ERTAppView::set_parent_rect(const Rect new_parent_rect) {
+    View::set_parent_rect(new_parent_rect);
+    recent_entries_view.set_parent_rect({0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height});
+}
+
+void ERTAppView::on_packet(const ert::Packet& packet) {
+    if (logger) {
+        logger->on_packet(packet, receiver_model.target_frequency());
+    }
+
+    if (packet.crc_ok()) {
+        auto& entry = ::on_packet(recent, ERTRecentEntry::Key{packet.id(), packet.commodity_type()});
+        entry.update(packet);
+        recent_entries_view.set_dirty();
+    }
+
+    if (pmem::beep_on_packets()) {
+        baseband::request_audio_beep(1000, 24000, 60);
+    }
+}
+
+void ERTAppView::on_show_list() {
+    recent_entries_view.hidden(false);
+    recent_entries_view.focus();
+}
+
+void ERTAppView::on_freqchg(int64_t freq) {
+    field_frequency.set_value(freq);
+}
+
+} /* namespace ui::external_app::ert_app */
+
+namespace ui {
+template <>
+void RecentEntriesTable<ui::external_app::ert_app::ERTRecentEntries>::draw(
+    const Entry& entry,
+    const Rect& target_rect,
+    Painter& painter,
+    const Style& style) {
+    std::string line = ert::format::id(entry.id) + " " + ert::format::commodity_type(entry.commodity_type) + " " + ert::format::consumption(entry.last_consumption) + " ";
+
+    line += (entry.packet_type == ert::Packet::Type::SCM) ? ert::format::tamper_flags_scm(entry.last_tamper_flags) : ert::format::tamper_flags(entry.last_tamper_flags);
+    line += (entry.received_count > 99) ? " ++" : to_string_dec_uint(entry.received_count, 3);
+
+    line.resize(target_rect.width() / 8, ' ');
+    painter.draw_string(target_rect.location(), style, line);
+}
+}  // namespace ui

firmware/application/external/ert/ert_app.hpp

@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2023 Mark Thompson
+ *
+ * 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 __ERT_APP_H__
+#define __ERT_APP_H__
+
+#include "ui_navigation.hpp"
+#include "ui_receiver.hpp"
+#include "ui_freq_field.hpp"
+#include "ui_rssi.hpp"
+#include "ui_channel.hpp"
+
+#include "event_m0.hpp"
+#include "app_settings.hpp"
+#include "radio_state.hpp"
+#include "log_file.hpp"
+
+#include "ert_packet.hpp"
+
+#include "recent_entries.hpp"
+
+#include <cstddef>
+#include <string>
+
+struct ERTKey {
+    ert::ID id;
+    ert::CommodityType commodity_type;
+
+    constexpr ERTKey(
+        ert::ID id = ert::invalid_id,
+        ert::CommodityType commodity_type = ert::invalid_commodity_type)
+        : id{id},
+          commodity_type{commodity_type} {
+    }
+
+    ERTKey(const ERTKey& other) = default;
+
+    ERTKey& operator=(const ERTKey& other) {
+        id = other.id;
+        commodity_type = other.commodity_type;
+        return *this;
+    }
+
+    bool operator==(const ERTKey& other) const {
+        return (id == other.id) && (commodity_type == other.commodity_type);
+    }
+};
+
+struct ERTRecentEntry {
+    using Key = ERTKey;
+
+    // TODO: Is this the right choice of invalid key value?
+    static const Key invalid_key;
+
+    ert::ID id{ert::invalid_id};
+    ert::CommodityType commodity_type{ert::invalid_commodity_type};
+    ert::Consumption last_consumption{};
+    ert::TamperFlags last_tamper_flags{};
+    ert::Packet::Type packet_type{};
+
+    size_t received_count{0};
+
+    ERTRecentEntry(
+        const Key& key)
+        : id{key.id},
+          commodity_type{key.commodity_type} {
+    }
+
+    Key key() const {
+        return {id, commodity_type};
+    }
+
+    void update(const ert::Packet& packet);
+};
+
+class ERTLogger {
+   public:
+    Optional<File::Error> append(const std::filesystem::path& filename) {
+        return log_file.append(filename);
+    }
+
+    void on_packet(const ert::Packet& packet, const uint32_t target_frequency);
+
+   private:
+    LogFile log_file{};
+};
+
+namespace ui::external_app::ert_app {
+
+using ERTRecentEntries = RecentEntries<ERTRecentEntry>;
+using ERTRecentEntriesView = RecentEntriesView<ERTRecentEntries>;
+
+class ERTAppView : public View {
+   public:
+    ERTAppView(NavigationView& nav);
+    ~ERTAppView();
+
+    void set_parent_rect(const Rect new_parent_rect) override;
+
+    // Prevent painting of region covered entirely by a child.
+    // TODO: Add flag to View that specifies view does not need to be cleared before painting.
+    void paint(Painter&) override{};
+
+    void focus() override;
+
+    std::string title() const override { return "ERT RX"; };
+
+   private:
+    ERTRecentEntries recent{};
+    std::unique_ptr<ERTLogger> logger{};
+
+    NavigationView& nav_;
+    RxRadioState radio_state_{
+        911600000 /* frequency */,
+        2500000 /* bandwidth */,
+        4194304 /* sampling rate */};
+    app_settings::SettingsManager settings_{
+        "rx_ert", app_settings::Mode::RX};
+
+    const RecentEntriesColumns columns{{
+        {"ID", 10},
+        {"Ty", 2},
+        {"Consumpt", 8},
+        {"Tamp", 4},
+        {"Ct", 2},
+    }};
+    ERTRecentEntriesView recent_entries_view{columns, recent};
+
+    static constexpr auto header_height = 1 * 16;
+
+    RxFrequencyField field_frequency{
+        {0 * 8, 0 * 16},
+        nav_};
+
+    RFAmpField field_rf_amp{
+        {13 * 8, 0 * 16}};
+
+    LNAGainField field_lna{
+        {15 * 8, 0 * 16}};
+
+    VGAGainField field_vga{
+        {18 * 8, 0 * 16}};
+
+    RSSI rssi{
+        {21 * 8, 0, 6 * 8, 4},
+    };
+
+    AudioVolumeField field_volume{
+        {screen_width - 2 * 8, 0 * 16}};
+
+    MessageHandlerRegistration message_handler_packet{
+        Message::ID::ERTPacket,
+        [this](Message* const p) {
+            const auto message = static_cast<const ERTPacketMessage*>(p);
+            const ert::Packet packet{message->type, message->packet};
+            this->on_packet(packet);
+        }};
+
+    MessageHandlerRegistration message_handler_freqchg{
+        Message::ID::FreqChangeCommand,
+        [this](Message* const p) {
+            const auto message = static_cast<const FreqChangeCommandMessage*>(p);
+            this->on_freqchg(message->freq);
+        }};
+
+    void on_freqchg(int64_t freq);
+    void on_packet(const ert::Packet& packet);
+    void on_show_list();
+};
+
+} /* namespace ui::external_app::ert_app */
+
+#endif /*__ERT_APP_H__*/

firmware/application/external/ert/main.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "ui.hpp"
+#include "ert_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::ert_app {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<ERTAppView>();
+}
+}  // namespace ui::external_app::ert_app
+
+extern "C" {
+
+__attribute__((section(".external_app.app_ert.application_information"), used)) application_information_t _application_information_ert = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::ert_app::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "ERT Meter",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x0F,
+        0x80,
+        0x7F,
+        0xC0,
+        0x0F,
+        0xFC,
+        0x0F,
+        0xC2,
+        0x0F,
+        0x82,
+        0x7F,
+        0x01,
+        0x0F,
+        0x01,
+        0x00,
+        0x21,
+        0x05,
+        0x53,
+        0x09,
+        0x56,
+        0x09,
+        0x50,
+        0x05,
+        0x50,
+        0x05,
+        0x20,
+        0xAD,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_none */ {'P', 'E', 'R', 'T'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/external.cmake

@@ -232,6 +232,10 @@ set(EXTCPPSRC
 	#battleship
 	external/battleship/main.cpp
 	external/battleship/ui_battleship.cpp		
+
+	#ert
+	external/ert/main.cpp
+	external/ert/ert_app.cpp		
 )
 
 set(EXTAPPLIST
@@ -291,4 +295,5 @@ set(EXTAPPLIST
 	spaceinv
 	blackjack
 	battleship
+	ert
 )

firmware/application/external/external.ld

@@ -79,6 +79,7 @@ MEMORY
     ram_external_app_spaceinv   (rwx) : org = 0xADE60000, len = 32k
     ram_external_app_blackjack  (rwx) : org = 0xADE70000, len = 32k
     ram_external_app_battleship   (rwx) : org = 0xADE80000, len = 32k
+    ram_external_app_ert        (rwx) : org = 0xADE90000, len = 32k
 }
 
 SECTIONS
@@ -419,5 +420,10 @@ SECTIONS
         *(*ui*external_app*battleship*);
     } > ram_external_app_battleship
 
+        .external_app_ert : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_ert.application_information));
+        *(*ui*external_app*ert*);
+    } > ram_external_app_ert
 }