user can disable battery change hint (#2612)

* theme fix again

* _

* _

.github/ISSUE_TEMPLATE/04_hardware_related.yml

@@ -2,6 +2,7 @@ name: Hardware / QC / QA / selling
 description: Issues that related with hardware, quality control, quality assurance, selling, etc.
 labels:
   - question
+  - hardware problem
 body:
 - type: markdown
   attributes:
@@ -11,9 +12,6 @@ body:
       We would like to inform you that we can't provide much help regarding hardware/QC/QA/selling issues because we are not controlling various vendors/manufacturers, and also we are not profiting from you buying your device.
   
       You are still welcome to ask, but please be aware that for this kind of issue, ask the seller would be the best option.
-
-      > [!IMPORTANT]  
-      If you are a seller/vendor and your customer has directed you to this page as a reference/evidence of a "broken device" or similar issue, please be aware that we are not providing any "official guarantee of a faulty device." We are only offering suggestions based on what the submitter has stated. We do not guarantee that the device is broken or anything else.
 - type: textarea
   id: description
   attributes:

.github/workflows/hardware_issue_warning.yml

@@ -0,0 +1,20 @@
+name: Hardware Issue Warning
+
+on:
+  issues:
+    types: [labeled]
+
+jobs:
+  add-comment:
+    if: github.event.label.name == 'hardware problem'
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - name: Add warning comment
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            > [!IMPORTANT]  
+            If you are a seller/vendor and your customer has directed you to this page as a reference/evidence of a "broken device" or similar issue, please be aware that we are not providing any "official guarantee of a faulty device." We are only offering suggestions based on what the submitter has stated. We do not guarantee that the device is broken or anything else.

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+https://github.com/portapack-mayhem/mayhem-firmware/issues/new/.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -0,0 +1 @@
+Please see [How-to-collaborate](https://github.com/portapack-mayhem/mayhem-firmware/wiki/How-to-collaborate)

README.md

@@ -9,7 +9,9 @@
 
 This is a fork of the [Havoc](https://github.com/furrtek/portapack-havoc/) firmware, which itself was a fork of the [PortaPack](https://github.com/sharebrained/portapack-hackrf) firmware, an add-on for the [HackRF](http://greatscottgadgets.com/hackrf/). A fork is a derivate, in this case one that has extra features and fixes when compared to the older versions.
 
-[<img src="https://github.com/user-attachments/assets/dea337ab-fb64-4a2a-b419-69afd272e815" height="400">](https://github.com/portapack-mayhem/mayhem-firmware/wiki/PortaPack-Versions#new-h4m-mayhem-edition) [<img src="https://camo.githubusercontent.com/5c1f1da0688240ac7b2ccca0c8dbfd1d73f2540741ad8b1828ba4d5ea68af248/68747470733a2f2f6769746875622d70726f64756374696f6e2d757365722d61737365742d3632313064662e73332e616d617a6f6e6177732e636f6d2f343339333937392f3239353533323731382d38653562363631632d663934362d346365652d386232642d3061363135663737313566342e706e67" height="400">](https://github.com/portapack-mayhem/mayhem-firmware/wiki/PortaPack-Versions#h2m-mayhem-edition)
+[<img src="https://github.com/user-attachments/assets/dea337ab-fb64-4a2a-b419-69afd272e815" height="310">](https://github.com/portapack-mayhem/mayhem-firmware/wiki/PortaPack-Versions#new-h4m-mayhem-edition) 
+[<img src="https://camo.githubusercontent.com/5c1f1da0688240ac7b2ccca0c8dbfd1d73f2540741ad8b1828ba4d5ea68af248/68747470733a2f2f6769746875622d70726f64756374696f6e2d757365722d61737365742d3632313064662e73332e616d617a6f6e6177732e636f6d2f343339333937392f3239353533323731382d38653562363631632d663934362d346365652d386232642d3061363135663737313566342e706e67" height="310">](https://github.com/portapack-mayhem/mayhem-firmware/wiki/PortaPack-Versions#h2m-mayhem-edition)
+[<img src="https://camo.githubusercontent.com/c1f7dd1e7672324f60a513f0de23de76da6a669e63896a9de535d8c8093fc3c7/68747470733a2f2f7261772e6769746875622e636f6d2f7368617265627261696e65642f706f7274617061636b2d6861636b72662f6d61737465722f646f632f696d616765732f68617264776172652f706f7274617061636b5f68315f6f7065726174696e672e6a7067" height="310">]([https://github.com/portapack-mayhem/mayhem-firmware/wiki/PortaPack-Versions#h2m-mayhem-edition](https://github.com/portapack-mayhem/mayhem-firmware/wiki/PortaPack-Versions#h1r1r2))
 
 # What is this?
 

SECURITY.md

@@ -0,0 +1 @@
+Please check [Intended-Use-and-Legality](https://github.com/portapack-mayhem/mayhem-firmware/wiki/)

firmware/application/CMakeLists.txt

@@ -191,7 +191,6 @@ set(CPPSRC
 	clock_manager.cpp
 	core_control.cpp
 	database.cpp
-	de_bruijn.cpp
 	rfm69.cpp
 	event_m0.cpp
 	file_reader.cpp
@@ -294,7 +293,6 @@ set(CPPSRC
 	apps/ui_flash_utility.cpp
 	apps/ui_freqman.cpp
 	apps/ui_iq_trim.cpp
-	apps/ui_level.cpp
 	apps/ui_looking_glass_app.cpp
 	apps/ui_mictx.cpp
 	apps/ui_modemsetup.cpp
@@ -303,7 +301,6 @@ set(CPPSRC
 	apps/ui_rds.cpp
 	apps/ui_recon_settings.cpp
 	apps/ui_recon.cpp
-	apps/ui_scanner.cpp
 	apps/ui_sd_over_usb.cpp
 	apps/ui_search.cpp
 	apps/ui_settings.cpp

firmware/application/apps/analog_audio_app.cpp

@@ -40,6 +40,7 @@ namespace ui {
 /* AMOptionsView *********************************************************/
 
 AMOptionsView::AMOptionsView(
+    AnalogAudioView* view,
     Rect parent_rect,
     const Style* style)
     : View{parent_rect} {
@@ -48,12 +49,23 @@ AMOptionsView::AMOptionsView(
     add_children({
         &label_config,
         &options_config,
+        &zoom_config,
     });
 
-    freqman_set_bandwidth_option(AM_MODULATION, options_config);  // adding the common message from freqman.cpp to the options_config
-    options_config.set_by_value(receiver_model.am_configuration());
-    options_config.on_change = [this](size_t, OptionsField::value_t n) {
-        receiver_model.set_am_configuration(n);
+    zoom_config.on_change = [this, view](size_t, OptionsField::value_t n) {            // n , has two option values. when GUI =zoom+1 => (0), when GUI=zoom+2 (6)
+        receiver_model.set_am_configuration(view->get_previous_AM_mode_option() + n);  // n (0 or 6)
+        view->set_zoom_factor(AM_MODULATION, n);
+        view->set_previous_zoom_option(n);
+    };
+
+    // restore zoom selection
+    zoom_config.set_by_value(view->get_zoom_factor(AM_MODULATION));
+
+    freqman_set_bandwidth_option(AM_MODULATION, options_config);                                        // freqman.cpp to the options_config, only allowing 5 modes  freqman_bandwidths[AM]  {"DSB 9k", 0},  {"DSB 6k", 1},  {"USB+3k", 2}, {"LSB-3k", 3}, {"CW", 4},
+    options_config.set_by_value(receiver_model.am_configuration() - view->get_previous_zoom_option());  // restore AM GUI option mode ,   AM FIR index filters (0..11) values ,  <baseband::AMConfig, 12> am_configs has 12 fir  index elements.
+    options_config.on_change = [this, view](size_t, OptionsField::value_t n) {
+        receiver_model.set_am_configuration(n + view->get_previous_zoom_option());  // we select proper FIR AM filter (0..11), = 0..4 GUI AM modes + offset +6 (if zoom+2)
+        view->set_previous_AM_mode_option(n);                                       // (0..4) allowing 5 AM modes (DSB9K, DSB6K, USB,LSB, CW)
     };
 }
 
@@ -105,6 +117,7 @@ WFMOptionsView::WFMOptionsView(
 /* AMFMAptOptionsView *********************************************************/
 
 AMFMAptOptionsView::AMFMAptOptionsView(
+    AnalogAudioView* view,
     Rect parent_rect,
     const Style* style)
     : View{parent_rect} {
@@ -113,11 +126,20 @@ AMFMAptOptionsView::AMFMAptOptionsView(
     add_children({
         &label_config,
         &options_config,
+        &zoom_config,
     });
 
     freqman_set_bandwidth_option(AMFM_MODULATION, options_config);  // adding the common message from freqman.cpp to the options_config
     receiver_model.set_amfm_configuration(5);                       // Fix index 5 manually, not from freqman: set to  RX AM (USB+FM) mode to demod audio tone, and get Wefax_APT signal.
     options_config.set_by_value(receiver_model.amfm_configuration());
+
+    zoom_config.on_change = [this, view](size_t, OptionsField::value_t n) {
+        receiver_model.set_amfm_configuration(5 + n);
+        view->set_zoom_factor(AMFM_MODULATION, n);
+    };
+
+    // restore zoom selection
+    zoom_config.set_by_value(view->get_zoom_factor(AMFM_MODULATION));
 }
 
 /* SPECOptionsView *******************************************************/
@@ -245,11 +267,42 @@ void AnalogAudioView::set_spec_bw(size_t index, uint32_t bw) {
     receiver_model.set_baseband_bandwidth(bw / 2);
 }
 
-uint8_t AnalogAudioView::get_spec_iq_phase_calibration_value() {  // define accessor functions inside AnalogAudioView to read & write real iq_phase_calibration_value
+uint8_t AnalogAudioView::get_zoom_factor(uint8_t mode) {  // define accessor functions inside AnalogAudioView to read zoom value
+    if (mode == AM_MODULATION)
+        return zoom_factor_am;
+    else if (mode == AMFM_MODULATION)
+        return zoom_factor_amfm;
+    return 0;  // default if unsupported mode
+}
+
+void AnalogAudioView::set_zoom_factor(uint8_t mode, uint8_t zoom) {  // define accessor functions inside AnalogAudioView to write zoom value
+    if (mode == AM_MODULATION)
+        zoom_factor_am = zoom;
+    else if (mode == AMFM_MODULATION)
+        zoom_factor_amfm = zoom;
+}
+
+uint8_t AnalogAudioView::get_previous_AM_mode_option() {
+    return previous_AM_mode_option;
+}
+
+void AnalogAudioView::set_previous_AM_mode_option(uint8_t mode) {
+    previous_AM_mode_option = mode;
+}
+
+uint8_t AnalogAudioView::get_previous_zoom_option() {
+    return previous_zoom;
+}
+
+void AnalogAudioView::set_previous_zoom_option(uint8_t zoom) {
+    previous_zoom = zoom;
+}
+
+uint8_t AnalogAudioView::get_spec_iq_phase_calibration_value() {  // define accessor functions inside AnalogAudioView to read iq_phase_calibration_value
     return iq_phase_calibration_value;
 }
 
-void AnalogAudioView::set_spec_iq_phase_calibration_value(uint8_t cal_value) {  // define accessor functions
+void AnalogAudioView::set_spec_iq_phase_calibration_value(uint8_t cal_value) {  // define accessor functions inside AnalogAudioView to write iq_phase_calibration_value
     iq_phase_calibration_value = cal_value;
     radio::set_rx_max283x_iq_phase_calibration(iq_phase_calibration_value);
 }
@@ -345,7 +398,7 @@ void AnalogAudioView::on_show_options_modulation() {
     const auto modulation = receiver_model.modulation();
     switch (modulation) {
         case ReceiverModel::Mode::AMAudio:
-            widget = std::make_unique<AMOptionsView>(options_view_rect, Theme::getInstance()->option_active);
+            widget = std::make_unique<AMOptionsView>(this, options_view_rect, Theme::getInstance()->option_active);
             waterfall.show_audio_spectrum_view(false);
             text_ctcss.hidden(true);
             break;
@@ -363,7 +416,7 @@ void AnalogAudioView::on_show_options_modulation() {
             break;
 
         case ReceiverModel::Mode::AMAudioFMApt:
-            widget = std::make_unique<AMFMAptOptionsView>(options_view_rect, Theme::getInstance()->option_active);
+            widget = std::make_unique<AMFMAptOptionsView>(this, options_view_rect, Theme::getInstance()->option_active);
             waterfall.show_audio_spectrum_view(false);
             text_ctcss.hidden(true);
             break;

firmware/application/apps/analog_audio_app.hpp

@@ -35,9 +35,11 @@
 
 namespace ui {
 
+class AnalogAudioView;
+
 class AMOptionsView : public View {
    public:
-    AMOptionsView(Rect parent_rect, const Style* style);
+    AMOptionsView(AnalogAudioView* view, Rect parent_rect, const Style* style);
 
    private:
     Text label_config{
@@ -51,11 +53,18 @@ class AMOptionsView : public View {
         {
             // Using common messages from freqman_ui.cpp
         }};
+
+    OptionsField zoom_config{
+        {23 * 8, 0 * 16},
+        7,
+        {{"ZOOM x1", 0},
+         {"ZOOM x2", 6}}  // offset index AM modes array FIR filters.
+    };
 };
 
 class AMFMAptOptionsView : public View {
    public:
-    AMFMAptOptionsView(Rect parent_rect, const Style* style);
+    AMFMAptOptionsView(AnalogAudioView* view, Rect parent_rect, const Style* style);
 
    private:
     Text label_config{
@@ -65,10 +74,17 @@ class AMFMAptOptionsView : public View {
 
     OptionsField options_config{
         {3 * 8, 0 * 16},
-        6,  // Max option length
+        6,  // Max option length chars
         {
             // Using common messages from freqman_ui.cpp In HF USB , Here  we only need USB Audio demod, + post-FM demod fsubcarrier FM tone to get APT signal.
         }};
+
+    OptionsField zoom_config{
+        {23 * 8, 0 * 16},
+        7,
+        {{"ZOOM x1", 0},
+         {"ZOOM x2", 6}}  // offset index array filters.
+    };
 };
 
 class NBFMOptionsView : public View {
@@ -116,8 +132,6 @@ class WFMOptionsView : public View {
         }};
 };
 
-class AnalogAudioView;
-
 class SPECOptionsView : public View {
    public:
     SPECOptionsView(AnalogAudioView* view, Rect parent_rect, const Style* style);
@@ -182,17 +196,35 @@ class AnalogAudioView : public View {
     uint8_t get_spec_iq_phase_calibration_value();
     void set_spec_iq_phase_calibration_value(uint8_t cal_value);
 
+    uint8_t get_zoom_factor(uint8_t mode);
+    void set_zoom_factor(uint8_t mode, uint8_t zoom);
+
+    uint8_t get_previous_AM_mode_option();
+    void set_previous_AM_mode_option(uint8_t mode);
+
+    uint8_t get_previous_zoom_option();
+    void set_previous_zoom_option(uint8_t zoom);
+
    private:
     static constexpr ui::Dim header_height = 3 * 16;
 
     NavigationView& nav_;
     RxRadioState radio_state_{};
     uint8_t iq_phase_calibration_value{15};  // initial default RX IQ phase calibration value , used for both max2837 & max2839
+    uint8_t zoom_factor_am{0};               // initial zoom factor in AM mode
+    uint8_t zoom_factor_amfm{0};             // initial zoom factor in AMFM mode
+    uint8_t previous_AM_mode_option{0};      // GUI 5 AM modes :  (0..4 ) (DSB9K, DSB6K, USB,LSB, CW). Used to select proper FIR filter (0..11) AM mode  + offset 0 (zoom+1) or +6 (if zoom+2)
+    uint8_t previous_zoom{0};                // GUI ZOOM+1, ZOOM+2 , equivalent to two values offset 0 (zoom+1) or +6 (if zoom+2)
+                                             //
     app_settings::SettingsManager settings_{
         "rx_audio",
         app_settings::Mode::RX,
         {
             {"iq_phase_calibration"sv, &iq_phase_calibration_value},  // we are saving and restoring that CAL from Settings.
+            {"zoom_factor_am"sv, &zoom_factor_am},                    // we are saving and restoring AM ZOOM factor from Settings.
+            {"zoom_factor_amfm"sv, &zoom_factor_amfm},                // we are saving and restoring AMFM ZOOM factor from Settings.
+            {"previous_AM_mode_option"sv, &previous_AM_mode_option},  // we are saving and restoring AMFM ZOOM factor from Settings.
+            {"previous_zoom"sv, &previous_zoom},                      // we are saving and restoring AMFM ZOOM factor from Settings.
         }};
 
     const Rect options_view_rect{0 * 8, 1 * 16, 30 * 8, 1 * 16};

firmware/application/apps/ble_rx_app.cpp

@@ -203,6 +203,7 @@ BleRecentEntryDetailView::BleRecentEntryDetailView(NavigationView& nav, const Bl
             nav,
             packetFileBuffer,
             64,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this, packetToSave](std::string& buffer) {
                 on_save_file(buffer, packetToSave);
             });
@@ -471,6 +472,7 @@ BLERxView::BLERxView(NavigationView& nav)
             nav_,
             filterBuffer,
             64,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& buffer) {
                 on_filter_change(buffer);
             });
@@ -493,6 +495,7 @@ BLERxView::BLERxView(NavigationView& nav)
             nav,
             listFileBuffer,
             64,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& buffer) {
                 on_save_file(buffer);
             });

firmware/application/apps/ble_tx_app.cpp

@@ -399,6 +399,7 @@ BLETxView::BLETxView(NavigationView& nav)
             nav,
             packetFileBuffer,
             64,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& buffer) {
                 on_save_file(buffer);
             });

firmware/application/apps/ui_aprs_tx.cpp

@@ -94,6 +94,7 @@ APRSTXView::APRSTXView(NavigationView& nav) {
             nav,
             payload,
             30,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& s) {
                 text_payload.set(s);
             });

firmware/application/apps/ui_debug.cpp

@@ -419,7 +419,6 @@ void DebugMenuView::on_populate() {
     }
     add_items({
         {"Buttons Test", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_controls, [this]() { nav_.push<DebugControlsView>(); }},
-        {"Debug Dump", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_memory, [this]() { portapack::persistent_memory::debug_dump(); }},
         {"M0 Stack Dump", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_memory, [this]() { stack_dump(); }},
         {"Memory Dump", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_memory, [this]() { nav_.push<DebugMemoryDumpView>(); }},
         {"Peripherals", ui::Theme::getInstance()->fg_darkcyan->foreground, &bitmap_icon_peripherals, [this]() { nav_.push<DebugPeripheralsMenuView>(); }},

firmware/application/apps/ui_encoders.hpp

@@ -25,7 +25,6 @@
 #include "ui_transmitter.hpp"
 #include "transmitter_model.hpp"
 #include "encoders.hpp"
-#include "de_bruijn.hpp"
 #include "app_settings.hpp"
 #include "radio_state.hpp"
 

firmware/application/apps/ui_fileman.cpp

@@ -499,7 +499,7 @@ FileSaveView::FileSaveView(
 
         button_edit_path.on_select = [this](Button&) {
                 buffer_ = path_.string();
-                text_prompt(nav_, buffer_, max_filename_length,
+                text_prompt(nav_, buffer_, max_filename_length,ENTER_KEYBOARD_MODE_ALPHA,
                         [this](std::string&) {
                                 path_ = buffer_;
                                 refresh_widgets();
@@ -508,7 +508,7 @@ FileSaveView::FileSaveView(
 
         button_edit_name.on_select = [this](Button&) {
                 buffer_ = file_.string();
-                text_prompt(nav_, buffer_, max_filename_length,
+                text_prompt(nav_, buffer_, max_filename_length,ENTER_KEYBOARD_MODE_ALPHA,
                         [this](std::string&) {
                                 file_ = buffer_;
                                 refresh_widgets();
@@ -566,7 +566,7 @@ void FileManagerView::on_rename(std::string_view hint) {
         cursor_pos = pos;
 
     text_prompt(
-        nav_, name_buffer, cursor_pos, max_filename_length,
+        nav_, name_buffer, cursor_pos, max_filename_length, ENTER_KEYBOARD_MODE_ALPHA,
         [this](std::string& renamed) {
             auto renamed_path = fs::path{renamed};
             rename_file(get_selected_full_path(), current_path / renamed_path);
@@ -640,7 +640,7 @@ void FileManagerView::on_clean() {
 
 void FileManagerView::on_new_dir() {
     name_buffer = "";
-    text_prompt(nav_, name_buffer, max_filename_length, [this](std::string& dir_name) {
+    text_prompt(nav_, name_buffer, max_filename_length, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& dir_name) {
         make_new_directory(current_path / dir_name);
         reload_current(true);
     });
@@ -671,7 +671,7 @@ void FileManagerView::on_paste() {
 
 void FileManagerView::on_new_file() {
     name_buffer = "";
-    text_prompt(nav_, name_buffer, max_filename_length, [this](std::string& file_name) {
+    text_prompt(nav_, name_buffer, max_filename_length, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& file_name) {
         make_new_file(current_path / file_name);
         reload_current(true);
     });

firmware/application/apps/ui_freqman.cpp

@@ -240,7 +240,7 @@ void FrequencyManagerView::on_edit_freq() {
 
 void FrequencyManagerView::on_edit_desc() {
     temp_buffer_ = current_entry().description;
-    text_prompt(nav_, temp_buffer_, freqman_max_desc_size, [this](std::string& new_desc) {
+    text_prompt(nav_, temp_buffer_, freqman_max_desc_size, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& new_desc) {
         auto entry = current_entry();
         entry.description = std::move(new_desc);
         db_.replace_entry(current_index(), entry);
@@ -250,7 +250,7 @@ void FrequencyManagerView::on_edit_desc() {
 
 void FrequencyManagerView::on_add_category() {
     temp_buffer_.clear();
-    text_prompt(nav_, temp_buffer_, 20, [this](std::string& new_name) {
+    text_prompt(nav_, temp_buffer_, 20, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& new_name) {
         if (!new_name.empty()) {
             create_freqman_file(new_name);
             refresh_categories();

firmware/application/apps/ui_pocsag_tx.cpp

@@ -153,7 +153,7 @@ void POCSAGTXView::paint(Painter&) {
 }
 
 void POCSAGTXView::on_set_text(NavigationView& nav) {
-    text_prompt(nav, buffer, MAX_POCSAG_LENGTH);
+    text_prompt(nav, buffer, MAX_POCSAG_LENGTH, ENTER_KEYBOARD_MODE_ALPHA);
 }
 
 POCSAGTXView::POCSAGTXView(

firmware/application/apps/ui_rds.cpp

@@ -65,6 +65,7 @@ RDSPSNView::RDSPSNView(
             nav,
             PSN,
             8,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& s) {
                 text_psn.set(s);
             });
@@ -86,6 +87,7 @@ RDSRadioTextView::RDSRadioTextView(
             nav,
             radiotext,
             28,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& s) {
                 text_radiotext.set(s);
             });

firmware/application/apps/ui_recon.cpp

@@ -517,11 +517,7 @@ ReconView::ReconView(NavigationView& nav)
     };
     set_loop_config(continuous);
 
-    rssi.set_focusable(true);
     rssi.set_peak(true, 500);
-    rssi.on_select = [this](RSSI&) {
-        nav_.replace<LevelView>();
-    };
 
     // TODO: *BUG* Both transmitter_model and receiver_model share the same pmem setting for target_frequency.
     button_mic_app.on_select = [this](Button&) {
@@ -1227,16 +1223,6 @@ size_t ReconView::change_mode(freqman_index_t new_mod) {
             text_ctcss.set("        ");
             recording_sampling_rate = 48000;
             break;
-        case AMFM_MODULATION:
-            freqman_set_bandwidth_option(new_mod, field_bw);
-            baseband::run_image(portapack::spi_flash::image_tag_am_audio);
-            receiver_model.set_modulation(ReceiverModel::Mode::AMAudioFMApt);
-            receiver_model.set_amfm_configuration(5);  // Fix index 5 manually, not from freqman: set to  RX AM (USB+FM) mode to demod audio tone, and get Wefax_APT signal.
-            field_bw.on_change = [this](size_t, OptionsField::value_t n) { (void)n; };
-            field_bw.set_by_value(0);
-            text_ctcss.set("        ");
-            recording_sampling_rate = 12000;
-            break;
         case SPEC_MODULATION:
             freqman_set_bandwidth_option(new_mod, field_bw);
             baseband::run_image(portapack::spi_flash::image_tag_capture);
@@ -1267,9 +1253,17 @@ size_t ReconView::change_mode(freqman_index_t new_mod) {
 
     field_mode.set_selected_index(new_mod);
     field_mode.on_change = [this](size_t, OptionsField::value_t v) {
-        if (v != -1) {
-            change_mode(v);
+        // initialize to a value under SPEC
+        static freqman_index_t last_mode = WFM_MODULATION;
+        if (v > SPEC_MODULATION) {
+            if (last_mode == SPEC_MODULATION)
+                v = AM_MODULATION;
+            else
+                v = SPEC_MODULATION;
+            field_mode.set_selected_index(v);
         }
+        last_mode = v;
+        change_mode(v);
     };
     // for some motive, audio output gets stopped.
     if (!recon && field_mode.selected_index_value() != SPEC_MODULATION)

firmware/application/apps/ui_recon.hpp

@@ -31,7 +31,6 @@
 #include "analog_audio_app.hpp"
 #include "audio.hpp"
 #include "ui_mictx.hpp"
-#include "ui_level.hpp"
 #include "ui_looking_glass_app.hpp"
 #include "portapack_persistent_memory.hpp"
 #include "baseband_api.hpp"

firmware/application/apps/ui_recon_settings.cpp

@@ -82,7 +82,7 @@ ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, st
     };
 
     button_choose_output_name.on_select = [this, &nav](Button&) {
-        text_prompt(nav, _output_file, 28, [this](std::string& buffer) {
+        text_prompt(nav, _output_file, 28, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& buffer) {
             _output_file = buffer;
             button_choose_output_name.set_text(_output_file);
         });

firmware/application/apps/ui_settings.cpp

@@ -1044,12 +1044,14 @@ SetBatteryView::SetBatteryView(NavigationView& nav) {
     add_children({&labels,
                   &button_save,
                   &button_cancel,
-                  &checkbox_overridebatt});
+                  &checkbox_overridebatt,
+                  &checkbox_battery_charge_hint});
 
     if (i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDEVMDL_MAX17055)) add_children({&button_reset, &labels2});
 
     button_save.on_select = [&nav, this](Button&) {
         pmem::set_ui_override_batt_calc(checkbox_overridebatt.value());
+        pmem::set_ui_battery_charge_hint(checkbox_battery_charge_hint.value());
         battery::BatteryManagement::set_calc_override(checkbox_overridebatt.value());
         send_system_refresh();
         nav.pop();
@@ -1064,6 +1066,7 @@ SetBatteryView::SetBatteryView(NavigationView& nav) {
     };
 
     checkbox_overridebatt.set_value(pmem::ui_override_batt_calc());
+    checkbox_battery_charge_hint.set_value(pmem::ui_battery_charge_hint());
 
     button_cancel.on_select = [&nav, this](Button&) {
         nav.pop();

firmware/application/apps/ui_settings.hpp

@@ -978,9 +978,13 @@ class SetBatteryView : public View {
     int32_t selected = 0;
     Labels labels{
         {{1 * 8, 1 * 16}, "Override batt calculation", Theme::getInstance()->fg_light->foreground},
-        {{1 * 8, 2 * 16}, "method to voltage based", Theme::getInstance()->fg_light->foreground}};
-    Labels labels2{
-        {{1 * 8, 6 * 16}, "Reset IC's learned params.", Theme::getInstance()->fg_light->foreground}};
+        {{1 * 8, 2 * 16}, "method to voltage based", Theme::getInstance()->fg_light->foreground},
+        /**/
+        {{1 * 8, 6 * 16}, "Display a hint to remind you", Theme::getInstance()->fg_light->foreground},
+        {{1 * 8, 7 * 16}, "when you charge", Theme::getInstance()->fg_light->foreground}};
+
+    Labels labels2{{{1 * 8, 11 * 16}, "Reset IC's learned params.", Theme::getInstance()->fg_light->foreground}};
+
     Button button_save{
         {2 * 8, 16 * 16, 12 * 8, 32},
         "Save"};
@@ -990,13 +994,18 @@ class SetBatteryView : public View {
         23,
         "Override"};
 
+    Checkbox checkbox_battery_charge_hint{
+        {2 * 8, 9 * 16},
+        23,
+        "Charge hint"};
+
     Button button_cancel{
         {16 * 8, 16 * 16, 12 * 8, 32},
         "Cancel",
     };
 
     Button button_reset{
-        {2 * 8, 8 * 16, 12 * 8, 32},
+        {2 * 8, 13 * 16, 12 * 8, 32},
         "Reset",
     };
 };

firmware/application/apps/ui_text_editor.cpp

@@ -617,6 +617,7 @@ void TextEditorView::show_edit_line() {
         edit_line_buffer_,
         viewer.col(),
         max_edit_length,
+        ENTER_KEYBOARD_MODE_ALPHA,
         [this](std::string& buffer) {
             auto range = file_->line_range(viewer.line());
             if (!range)

firmware/application/baseband_api.cpp

@@ -66,12 +66,13 @@ static void send_message(const Message* const message) {
 
 void AMConfig::apply() const {
     const AMConfigureMessage message{
-        taps_6k0_decim_0,              // common FIR filter taps pre-decim_0 to all 6 x AM mod types.(AM-9K, AM-6K, USB, LSB, CW, AMFM-WFAX)
-        taps_6k0_decim_1,              // common FIR filter taps pre-decim_1 to all 6 x AM mod. types. (")
-        decim_2,                       // var decim_2 FIR taps filter , variable values, depending selected  AM mod(AM  9k / 6k and all rest AM modes)
-        channel,                       // var channel FIR taps filter , variable values, depending selected  AM mode, each one different  (DSB-9K, DSB-6K, USB-3K, LSB-3K,CW,AMFM-WFAX)
-        modulation,                    // var parameter . enum class Modulation : int32_t {DSB = 0, SSB = 1, SSB_FM = 2}
-        audio_12k_iir_filter_config};  // var parameter , 300 Hz hpf all except Wefax (1.500Hz lpf)
+        taps_6k0_decim_0,             // common FIR filter taps pre-decim_0 to all 6 x AM mod types.(AM-9K, AM-6K, USB, LSB, CW, AMFM-WFAX)
+        decim_1,                      // var decim_1 FIR taps filter , variable values , to handle two spectrum decim factor 1 and 2 (zoom) and more APT LPF filtered .
+        decim_2,                      // var decim_2 FIR taps filter , variable values, depending selected  AM mod(AM  9k / 6k and all rest AM modes)
+        channel,                      // var channel FIR taps filter , variable values, depending selected  AM mode, each one different  (DSB-9K, DSB-6K, USB-3K, LSB-3K,CW,AMFM-WFAX)
+        modulation,                   // var parameter . enum class Modulation : int32_t {DSB = 0, SSB = 1, SSB_FM = 2}
+        audio_12k_iir_filter_config,  // var parameter , 300 Hz hpf all except Wefax (1.500Hz lpf)
+        spectrum_decimation_factor};  // var parameter , waterfall no zoom : 1 ,for zoom x 2 : 2
     send_message(&message);
     audio::set_rate(audio::Rate::Hz_12000);
 }

firmware/application/baseband_api.hpp

@@ -36,10 +36,12 @@
 namespace baseband {
 
 struct AMConfig {
+    const fir_taps_real<32> decim_1;  // added to handle two var LPF in AMFM to avoid aliasing when spectrum zoom factor 2.
     const fir_taps_real<32> decim_2;  // added to handle two var types decim_2 9k, 6k
     const fir_taps_complex<64> channel;
     const AMConfigureMessage::Modulation modulation;
     const iir_biquad_config_t audio_12k_iir_filter_config;  // added to handle two var IIR filter types : 300 hpf(as before) , 1500Hz lpf for Wefax.
+    const size_t spectrum_decimation_factor;                // used to handle LCD AM waterfall zoom x1 / zoom x2.
 
     void apply() const;
 };

firmware/application/binder.hpp

@@ -25,6 +25,7 @@
 #include "ui.hpp"
 #include "ui_navigation.hpp"
 #include "ui_widget.hpp"
+#include "ui_textentry.hpp"
 
 namespace ui {
 
@@ -105,7 +106,7 @@ void bind(TextField& field, T& value, NavigationView& nav, Fn fn = Fn{}) {
     // Capture a new string and make the lambda mutable so it can be modified.
     field.on_select = [&nav, buf = std::string{}](TextField& tf) mutable {
         buf = tf.get_text();
-        text_prompt(nav, buf, /*max_length*/ 255,
+        text_prompt(nav, buf, /*max_length*/ 255, ENTER_KEYBOARD_MODE_ALPHA,
                     [&tf](std::string& str) {
                         tf.set_text(str);
                     });

firmware/application/bmps/bmp_modal_warning.hpp

@@ -1,72 +0,0 @@
-unsigned char modal_warning_bmp[] = {
-    0x42, 0x4d, 0xfa, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x96, 0x00,
-    0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00,
-    0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0xa8, 0x02,
-    0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x07, 0x00,
-    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x42, 0x47, 0x52, 0x73, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0xff, 0x00, 0x00, 0x5a,
-    0xff, 0x00, 0x78, 0x78, 0x78, 0x00, 0x00, 0x7c, 0xff, 0x00, 0x00, 0xa9,
-    0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x02, 0x03, 0x24, 0x66, 0x02, 0x30,
-    0x00, 0x00, 0x02, 0x36, 0x24, 0x66, 0x02, 0x63, 0x00, 0x00, 0x02, 0x66,
-    0x02, 0x63, 0x20, 0x00, 0x02, 0x36, 0x02, 0x66, 0x00, 0x00, 0x02, 0x36,
-    0x02, 0x60, 0x20, 0x00, 0x02, 0x06, 0x02, 0x63, 0x00, 0x00, 0x02, 0x06,
-    0x02, 0x60, 0x0c, 0x00, 0x00, 0x08, 0x03, 0x66, 0x66, 0x30, 0x0c, 0x00,
-    0x02, 0x06, 0x02, 0x60, 0x00, 0x00, 0x02, 0x03, 0x02, 0x66, 0x0c, 0x00,
-    0x00, 0x08, 0x06, 0x11, 0x11, 0x60, 0x0c, 0x00, 0x02, 0x66, 0x02, 0x30,
-    0x00, 0x00, 0x02, 0x00, 0x02, 0x66, 0x0c, 0x00, 0x00, 0x08, 0x06, 0x21,
-    0x21, 0x60, 0x0c, 0x00, 0x02, 0x66, 0x02, 0x00, 0x00, 0x00, 0x00, 0x06,
-    0x00, 0x36, 0x60, 0x00, 0x0a, 0x00, 0x00, 0x08, 0x06, 0x42, 0x42, 0x60,
-    0x0a, 0x00, 0x00, 0x06, 0x06, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
-    0x00, 0x06, 0x60, 0x00, 0x0a, 0x00, 0x00, 0x08, 0x06, 0x54, 0x45, 0x60,
-    0x0a, 0x00, 0x00, 0x06, 0x06, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
-    0x00, 0x03, 0x66, 0x00, 0x0a, 0x00, 0x00, 0x08, 0x03, 0x66, 0x66, 0x30,
-    0x0a, 0x00, 0x00, 0x06, 0x66, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
-    0x00, 0x00, 0x66, 0x00, 0x1c, 0x00, 0x00, 0x06, 0x66, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x36, 0x60, 0x18, 0x00, 0x00, 0x08,
-    0x06, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x06, 0x60,
-    0x0a, 0x00, 0x02, 0x36, 0x02, 0x63, 0x0a, 0x00, 0x00, 0x08, 0x06, 0x60,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x03, 0x66, 0x08, 0x00,
-    0x00, 0x08, 0x03, 0x61, 0x16, 0x30, 0x08, 0x00, 0x00, 0x08, 0x66, 0x30,
-    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x02, 0x66, 0x08, 0x00, 0x00, 0x08,
-    0x06, 0x11, 0x11, 0x60, 0x08, 0x00, 0x02, 0x66, 0x06, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x02, 0x36, 0x02, 0x60, 0x06, 0x00, 0x00, 0x08, 0x06, 0x11,
-    0x11, 0x60, 0x06, 0x00, 0x02, 0x06, 0x02, 0x63, 0x06, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x02, 0x06, 0x02, 0x60, 0x06, 0x00, 0x00, 0x08, 0x06, 0x11,
-    0x11, 0x60, 0x06, 0x00, 0x02, 0x06, 0x02, 0x60, 0x06, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x02, 0x03, 0x02, 0x66, 0x06, 0x00, 0x00, 0x08, 0x06, 0x11,
-    0x11, 0x60, 0x06, 0x00, 0x02, 0x66, 0x02, 0x30, 0x06, 0x00, 0x00, 0x00,
-    0x08, 0x00, 0x02, 0x66, 0x06, 0x00, 0x00, 0x08, 0x06, 0x11, 0x11, 0x60,
-    0x06, 0x00, 0x02, 0x66, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x18,
-    0x36, 0x60, 0x00, 0x00, 0x06, 0x11, 0x11, 0x60, 0x00, 0x00, 0x06, 0x63,
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x18, 0x06, 0x60, 0x00, 0x00,
-    0x06, 0x21, 0x21, 0x60, 0x00, 0x00, 0x06, 0x60, 0x08, 0x00, 0x00, 0x00,
-    0x08, 0x00, 0x00, 0x18, 0x03, 0x66, 0x00, 0x00, 0x06, 0x12, 0x12, 0x60,
-    0x00, 0x00, 0x66, 0x30, 0x08, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x14,
-    0x66, 0x00, 0x00, 0x06, 0x21, 0x21, 0x60, 0x00, 0x00, 0x66, 0x0a, 0x00,
-    0x00, 0x00, 0x0a, 0x00, 0x00, 0x14, 0x36, 0x60, 0x00, 0x06, 0x22, 0x22,
-    0x60, 0x00, 0x06, 0x63, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x14,
-    0x06, 0x60, 0x00, 0x06, 0x24, 0x24, 0x60, 0x00, 0x06, 0x60, 0x0a, 0x00,
-    0x00, 0x00, 0x0a, 0x00, 0x00, 0x14, 0x03, 0x66, 0x00, 0x06, 0x42, 0x42,
-    0x60, 0x00, 0x66, 0x30, 0x0a, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10,
-    0x66, 0x00, 0x06, 0x54, 0x45, 0x60, 0x00, 0x66, 0x0c, 0x00, 0x00, 0x00,
-    0x0c, 0x00, 0x00, 0x10, 0x36, 0x60, 0x03, 0x66, 0x66, 0x30, 0x06, 0x63,
-    0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x02, 0x06, 0x02, 0x60, 0x08, 0x00,
-    0x02, 0x06, 0x02, 0x60, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x02, 0x03,
-    0x02, 0x66, 0x08, 0x00, 0x02, 0x66, 0x02, 0x30, 0x0c, 0x00, 0x00, 0x00,
-    0x0e, 0x00, 0x02, 0x66, 0x08, 0x00, 0x02, 0x66, 0x0e, 0x00, 0x00, 0x00,
-    0x0e, 0x00, 0x00, 0x0c, 0x36, 0x60, 0x00, 0x00, 0x06, 0x63, 0x0e, 0x00,
-    0x00, 0x00, 0x0e, 0x00, 0x00, 0x0c, 0x06, 0x60, 0x00, 0x00, 0x06, 0x60,
-    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x0c, 0x03, 0x66, 0x00, 0x00,
-    0x66, 0x30, 0x0e, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x66, 0x00,
-    0x00, 0x66, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x36, 0x60,
-    0x06, 0x63, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x06, 0x60,
-    0x06, 0x60, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x03, 0x66,
-    0x66, 0x30, 0x10, 0x00, 0x00, 0x00, 0x12, 0x00, 0x02, 0x66, 0x02, 0x66,
-    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x02, 0x36, 0x02, 0x63, 0x12, 0x00,
-    0x00, 0x01};
-unsigned int modal_warning_bmp_len = 830;

firmware/application/bmps/bmp_splash.hpp

@@ -1,327 +0,0 @@
-// converted by bmp_to_hex_cpp_arr.py at the firmware/tools dir
-// fake transparent px should be the exact color rgb dec(41,24,22), then use true for the last arg when drawing bmp with the draw func
-
-const unsigned char splash_bmp[] = {
-    0x42, 0x4d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x00,
-    0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0x32, 0x00,
-    0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x9c, 0x0e,
-    0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x0f, 0x00,
-    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x19, 0xf6, 0x00, 0x00, 0x14,
-    0xc9, 0x00, 0x00, 0x0c, 0x78, 0x00, 0x16, 0x18, 0x29, 0x00, 0xfd, 0xfd,
-    0xfd, 0x00, 0xf0, 0xf0, 0xf0, 0x00, 0xe7, 0xe7, 0xe7, 0x00, 0xda, 0xda,
-    0xda, 0x00, 0xcd, 0xcd, 0xcd, 0x00, 0xc7, 0xc7, 0xc7, 0x00, 0xba, 0xba,
-    0xba, 0x00, 0xad, 0xad, 0xad, 0x00, 0x96, 0x96, 0x96, 0x00, 0x5c, 0x5c,
-    0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x33, 0x00, 0x00, 0xe6, 0x33,
-    0x00, 0x00, 0xe6, 0x33, 0x00, 0x00, 0xe6, 0x33, 0x00, 0x00, 0x00, 0x08,
-    0x33, 0x44, 0x44, 0x47, 0x0a, 0x33, 0x00, 0x06, 0xd5, 0x44, 0x7d, 0x00,
-    0x0a, 0x33, 0x00, 0x0a, 0x44, 0x44, 0x48, 0x33, 0x3a, 0x00, 0x06, 0x44,
-    0x02, 0xd3, 0x12, 0x33, 0x00, 0x08, 0xa4, 0x44, 0x45, 0x9d, 0x08, 0x33,
-    0x00, 0x08, 0xc4, 0x44, 0x45, 0xc3, 0x10, 0x33, 0x00, 0x08, 0x34, 0x44,
-    0x44, 0x6d, 0x16, 0x33, 0x00, 0x08, 0x34, 0x44, 0x44, 0x6d, 0x08, 0x33,
-    0x02, 0xd5, 0x1a, 0x44, 0x00, 0x0c, 0x45, 0xc3, 0x33, 0x44, 0x44, 0x47,
-    0x0a, 0x33, 0x00, 0x06, 0xd5, 0x44, 0x7d, 0x00, 0x0a, 0x33, 0x00, 0x08,
-    0x44, 0x44, 0x48, 0x33, 0x00, 0x00, 0x00, 0x0a, 0x33, 0x49, 0x99, 0x95,
-    0xd3, 0x00, 0x06, 0x33, 0x00, 0x0a, 0xd4, 0x46, 0x89, 0x98, 0xb3, 0x00,
-    0x08, 0x33, 0x00, 0x12, 0x49, 0x99, 0x94, 0x33, 0x3d, 0x79, 0x99, 0x99,
-    0x73, 0x00, 0x10, 0x33, 0x00, 0x0a, 0x3d, 0x47, 0x99, 0x95, 0xa3, 0x00,
-    0x08, 0x33, 0x00, 0x08, 0xc7, 0x99, 0x97, 0xa3, 0x10, 0x33, 0x00, 0x08,
-    0x34, 0x99, 0x99, 0x7c, 0x16, 0x33, 0x00, 0x08, 0x34, 0x99, 0x99, 0x7c,
-    0x06, 0x33, 0x00, 0x06, 0xb4, 0x56, 0x89, 0x00, 0x18, 0x99, 0x00, 0x0e,
-    0x97, 0xa3, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x00, 0x06, 0x33, 0x00, 0x0a,
-    0xd4, 0x46, 0x89, 0x98, 0xb3, 0x00, 0x08, 0x33, 0x00, 0x08, 0x49, 0x99,
-    0x94, 0x33, 0x00, 0x00, 0x00, 0x0a, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x00,
-    0x06, 0x33, 0x02, 0x55, 0x06, 0x99, 0x02, 0x9b, 0x08, 0x33, 0x00, 0x12,
-    0x49, 0x99, 0x94, 0x33, 0x33, 0xb9, 0x99, 0x99, 0x8d, 0x00, 0x10, 0x33,
-    0x00, 0x0a, 0x37, 0x69, 0x99, 0x74, 0xd3, 0x00, 0x08, 0x33, 0x00, 0x08,
-    0xc7, 0x99, 0x97, 0xa3, 0x10, 0x33, 0x00, 0x08, 0x34, 0x99, 0x99, 0x7c,
-    0x16, 0x33, 0x00, 0x10, 0x34, 0x99, 0x99, 0x7c, 0x33, 0x33, 0x3a, 0x47,
-    0x1c, 0x99, 0x00, 0x0e, 0x97, 0xa3, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x00,
-    0x06, 0x33, 0x02, 0x55, 0x06, 0x99, 0x02, 0x9b, 0x08, 0x33, 0x00, 0x08,
-    0x49, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00, 0x12, 0x33, 0x49, 0x99, 0x95,
-    0xd3, 0x33, 0x33, 0x3a, 0x48, 0x00, 0x06, 0x99, 0x02, 0x98, 0x02, 0xd3,
-    0x06, 0x33, 0x00, 0x12, 0x49, 0x99, 0x94, 0x33, 0x33, 0xd7, 0x99, 0x99,
-    0x98, 0x00, 0x10, 0x33, 0x00, 0x08, 0xd4, 0x89, 0x99, 0x5a, 0x0a, 0x33,
-    0x00, 0x08, 0xc7, 0x99, 0x97, 0xa3, 0x10, 0x33, 0x00, 0x08, 0x34, 0x99,
-    0x99, 0x7c, 0x16, 0x33, 0x00, 0x10, 0x34, 0x99, 0x99, 0x7c, 0x33, 0x33,
-    0xb4, 0x79, 0x1c, 0x99, 0x00, 0x16, 0x97, 0xa3, 0x33, 0x49, 0x99, 0x95,
-    0xd3, 0x33, 0x33, 0x3a, 0x48, 0x00, 0x06, 0x99, 0x02, 0x98, 0x02, 0xd3,
-    0x06, 0x33, 0x00, 0x08, 0x49, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00, 0x12,
-    0x33, 0x49, 0x99, 0x95, 0xd3, 0x33, 0x33, 0xd4, 0x79, 0x00, 0x08, 0x99,
-    0x02, 0x73, 0x06, 0x33, 0x00, 0x0c, 0x49, 0x99, 0x94, 0x33, 0x33, 0x3b,
-    0x06, 0x99, 0x02, 0xc3, 0x0e, 0x33, 0x00, 0x08, 0x56, 0x99, 0x97, 0x4d,
-    0x0a, 0x33, 0x00, 0x08, 0xc7, 0x99, 0x97, 0xa3, 0x10, 0x33, 0x00, 0x08,
-    0x34, 0x99, 0x99, 0x7c, 0x16, 0x33, 0x00, 0x0e, 0x34, 0x99, 0x99, 0x7c,
-    0x33, 0x3d, 0x47, 0x00, 0x1e, 0x99, 0x00, 0x16, 0x97, 0xa3, 0x33, 0x49,
-    0x99, 0x95, 0xd3, 0x33, 0x33, 0xd4, 0x79, 0x00, 0x08, 0x99, 0x02, 0x73,
-    0x06, 0x33, 0x00, 0x08, 0x49, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00, 0x10,
-    0x33, 0x49, 0x99, 0x95, 0xd3, 0x33, 0x33, 0xa5, 0x0a, 0x99, 0x02, 0x8d,
-    0x06, 0x33, 0x00, 0x14, 0x49, 0x99, 0x94, 0x33, 0x33, 0x3d, 0x79, 0x99,
-    0x99, 0x73, 0x0c, 0x33, 0x00, 0x0a, 0x3c, 0x48, 0x99, 0x95, 0xa3, 0x00,
-    0x0a, 0x33, 0x00, 0x08, 0xc7, 0x99, 0x97, 0xa3, 0x10, 0x33, 0x00, 0x08,
-    0x34, 0x99, 0x99, 0x7c, 0x16, 0x33, 0x00, 0x0e, 0x34, 0x99, 0x99, 0x7c,
-    0x33, 0x37, 0x69, 0x00, 0x1e, 0x99, 0x00, 0x14, 0x97, 0xa3, 0x33, 0x49,
-    0x99, 0x95, 0xd3, 0x33, 0x33, 0xa5, 0x0a, 0x99, 0x02, 0x8d, 0x06, 0x33,
-    0x00, 0x08, 0x49, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00, 0x1c, 0x33, 0x49,
-    0x99, 0x95, 0xd3, 0x33, 0x3d, 0x47, 0x99, 0x97, 0x89, 0x99, 0x99, 0x97,
-    0x06, 0x33, 0x00, 0x06, 0x49, 0x99, 0x94, 0x00, 0x06, 0x33, 0x00, 0x08,
-    0xb9, 0x99, 0x99, 0x9d, 0x0c, 0x33, 0x00, 0x0a, 0x34, 0x69, 0x99, 0x74,
-    0xd3, 0x00, 0x0a, 0x33, 0x00, 0x08, 0xc7, 0x99, 0x98, 0xa3, 0x10, 0x33,
-    0x00, 0x08, 0x34, 0x99, 0x99, 0x7c, 0x16, 0x33, 0x00, 0x12, 0x34, 0x99,
-    0x99, 0x7c, 0x33, 0x34, 0x89, 0x99, 0x64, 0x00, 0x1c, 0x44, 0x00, 0x1e,
-    0xa3, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x33, 0x3d, 0x47, 0x99, 0x97, 0x89,
-    0x99, 0x99, 0x97, 0x00, 0x06, 0x33, 0x00, 0x08, 0x49, 0x99, 0x94, 0x33,
-    0x00, 0x00, 0x00, 0x28, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x33, 0x3c, 0x59,
-    0x99, 0x95, 0xbc, 0x99, 0x99, 0x98, 0xd3, 0x33, 0x33, 0x49, 0x99, 0x94,
-    0x06, 0x33, 0x02, 0xd7, 0x06, 0x99, 0x02, 0x74, 0x0c, 0x44, 0x00, 0x06,
-    0x99, 0x99, 0x4b, 0x00, 0x0c, 0x33, 0x00, 0x08, 0xb7, 0x99, 0x99, 0xa3,
-    0x10, 0x33, 0x00, 0x08, 0x34, 0x99, 0x99, 0x7c, 0x16, 0x33, 0x00, 0x12,
-    0x34, 0x99, 0x99, 0x7c, 0x33, 0xd5, 0x99, 0x99, 0x6d, 0x00, 0x20, 0x33,
-    0x00, 0x28, 0x49, 0x99, 0x95, 0xd3, 0x33, 0x3c, 0x59, 0x99, 0x95, 0xbc,
-    0x99, 0x99, 0x98, 0xd3, 0x33, 0x33, 0x49, 0x99, 0x94, 0x33, 0x00, 0x00,
-    0x00, 0x28, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x33, 0x34, 0x79, 0x99, 0x84,
-    0xdd, 0x89, 0x99, 0x99, 0x83, 0x33, 0x33, 0x49, 0x99, 0x94, 0x06, 0x33,
-    0x02, 0x3b, 0x16, 0x99, 0x02, 0x97, 0x02, 0x43, 0x0a, 0x33, 0x00, 0x0a,
-    0x3d, 0x47, 0x99, 0x99, 0x9d, 0x00, 0x10, 0x33, 0x00, 0x08, 0x34, 0x99,
-    0x99, 0x9d, 0x16, 0x33, 0x00, 0x12, 0x34, 0x99, 0x99, 0x7c, 0x33, 0xd6,
-    0x99, 0x99, 0x6d, 0x00, 0x20, 0x33, 0x00, 0x28, 0x49, 0x99, 0x95, 0xd3,
-    0x33, 0x34, 0x79, 0x99, 0x84, 0xdd, 0x89, 0x99, 0x99, 0x83, 0x33, 0x33,
-    0x49, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00, 0x28, 0x33, 0x49, 0x99, 0x95,
-    0xd3, 0x33, 0xc4, 0x99, 0x99, 0x67, 0x33, 0x79, 0x99, 0x99, 0x8d, 0x33,
-    0x33, 0x49, 0x99, 0x94, 0x06, 0x33, 0x02, 0x3d, 0x02, 0x79, 0x14, 0x99,
-    0x02, 0x94, 0x02, 0xc3, 0x0a, 0x33, 0x00, 0x0a, 0x35, 0x59, 0x99, 0x99,
-    0x98, 0x00, 0x10, 0x33, 0x02, 0x34, 0x06, 0x99, 0x02, 0x74, 0x16, 0x44,
-    0x00, 0x10, 0x99, 0x99, 0x7c, 0x33, 0xd6, 0x99, 0x99, 0x9d, 0x20, 0x33,
-    0x00, 0x28, 0x49, 0x99, 0x95, 0xd3, 0x33, 0xc4, 0x99, 0x99, 0x67, 0x33,
-    0x79, 0x99, 0x99, 0x8d, 0x33, 0x33, 0x49, 0x99, 0x94, 0x33, 0x00, 0x00,
-    0x00, 0x28, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x33, 0x57, 0x99, 0x99, 0x4d,
-    0x33, 0xd8, 0x99, 0x99, 0x98, 0x33, 0x33, 0x49, 0x99, 0x94, 0x08, 0x33,
-    0x02, 0xc9, 0x14, 0x99, 0x02, 0x74, 0x0c, 0x33, 0x02, 0x84, 0x02, 0x89,
-    0x06, 0x99, 0x02, 0xa3, 0x0e, 0x33, 0x02, 0x34, 0x22, 0x99, 0x00, 0x06,
-    0x7c, 0x33, 0xd6, 0x00, 0x06, 0x99, 0x02, 0x64, 0x18, 0x44, 0x00, 0x2e,
-    0x45, 0xc3, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x33, 0x57, 0x99, 0x99, 0x4d,
-    0x33, 0xd8, 0x99, 0x99, 0x98, 0x33, 0x33, 0x49, 0x99, 0x94, 0x33, 0x00,
-    0x00, 0x00, 0x00, 0x28, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x3d, 0x48, 0x99,
-    0x97, 0x43, 0x33, 0x37, 0x99, 0x99, 0x97, 0xd3, 0x33, 0x49, 0x99, 0x94,
-    0x08, 0x33, 0x02, 0x37, 0x14, 0x99, 0x02, 0x4c, 0x0a, 0x33, 0x02, 0x3b,
-    0x02, 0x48, 0x08, 0x99, 0x02, 0x9b, 0x0e, 0x33, 0x02, 0x34, 0x22, 0x99,
-    0x00, 0x06, 0x7c, 0x33, 0xd6, 0x00, 0x20, 0x99, 0x00, 0x2e, 0x97, 0xa3,
-    0x33, 0x49, 0x99, 0x95, 0xd3, 0x3d, 0x48, 0x99, 0x97, 0x43, 0x33, 0x37,
-    0x99, 0x99, 0x97, 0xd3, 0x33, 0x49, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00,
-    0x00, 0x28, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x35, 0x69, 0x99, 0x95, 0xc3,
-    0x33, 0x3c, 0x89, 0x99, 0x99, 0xb3, 0x33, 0x49, 0x99, 0x94, 0x08, 0x33,
-    0x02, 0x3c, 0x12, 0x99, 0x02, 0x97, 0x02, 0x43, 0x0a, 0x33, 0x02, 0xd4,
-    0x02, 0x79, 0x0a, 0x99, 0x02, 0xd3, 0x0c, 0x33, 0x02, 0x34, 0x22, 0x99,
-    0x00, 0x06, 0x7c, 0x33, 0xd6, 0x00, 0x20, 0x99, 0x00, 0x2e, 0x97, 0xa3,
-    0x33, 0x49, 0x99, 0x95, 0xd3, 0x35, 0x69, 0x99, 0x95, 0xc3, 0x33, 0x3c,
-    0x89, 0x99, 0x99, 0xb3, 0x33, 0x49, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00,
-    0x00, 0x12, 0x33, 0x49, 0x99, 0x95, 0xd3, 0xd4, 0x89, 0x99, 0x74, 0x00,
-    0x06, 0x33, 0x00, 0x10, 0x79, 0x99, 0x99, 0x7d, 0x33, 0x49, 0x99, 0x94,
-    0x0a, 0x33, 0x00, 0x16, 0x79, 0x99, 0x99, 0x64, 0x44, 0x44, 0x89, 0x99,
-    0x99, 0x94, 0xc3, 0x00, 0x08, 0x33, 0x00, 0x0a, 0x3d, 0x46, 0x99, 0x98,
-    0x59, 0x00, 0x06, 0x99, 0x02, 0x8d, 0x0c, 0x33, 0x02, 0x34, 0x22, 0x99,
-    0x00, 0x06, 0x7c, 0x33, 0xd6, 0x00, 0x20, 0x99, 0x00, 0x16, 0x97, 0xa3,
-    0x33, 0x49, 0x99, 0x95, 0xd3, 0xd4, 0x89, 0x99, 0x74, 0x00, 0x06, 0x33,
-    0x00, 0x12, 0x79, 0x99, 0x99, 0x7d, 0x33, 0x49, 0x99, 0x94, 0x33, 0x00,
-    0x00, 0x00, 0x00, 0x12, 0x33, 0x49, 0x99, 0x95, 0xd3, 0x76, 0x99, 0x99,
-    0x6a, 0x00, 0x06, 0x33, 0x00, 0x10, 0xa9, 0x99, 0x99, 0x9b, 0x33, 0x49,
-    0x99, 0x94, 0x0a, 0x33, 0x00, 0x14, 0xc9, 0x99, 0x99, 0x9c, 0x33, 0x33,
-    0x3b, 0x99, 0x99, 0x74, 0x0a, 0x33, 0x00, 0x0a, 0x35, 0x59, 0x99, 0x95,
-    0x7d, 0x00, 0x06, 0x99, 0x02, 0x9a, 0x0c, 0x33, 0x02, 0x34, 0x22, 0x99,
-    0x00, 0x06, 0x7c, 0x33, 0xd6, 0x00, 0x20, 0x99, 0x00, 0x16, 0x97, 0xa3,
-    0x33, 0x49, 0x99, 0x95, 0xd3, 0x76, 0x99, 0x99, 0x6a, 0x00, 0x06, 0x33,
-    0x00, 0x12, 0xa9, 0x99, 0x99, 0x9b, 0x33, 0x49, 0x99, 0x94, 0x33, 0x00,
-    0x00, 0x00, 0x00, 0x12, 0x33, 0x49, 0x99, 0x95, 0x3d, 0x48, 0x99, 0x98,
-    0x4d, 0x00, 0x06, 0x33, 0x00, 0x10, 0xd7, 0x99, 0x99, 0x97, 0xd3, 0x49,
-    0x99, 0x94, 0x0a, 0x33, 0x00, 0x14, 0x37, 0x99, 0x99, 0x97, 0x33, 0x33,
-    0xc4, 0x89, 0x99, 0x4c, 0x0a, 0x33, 0x00, 0x0c, 0x84, 0x89, 0x99, 0x64,
-    0x33, 0xd9, 0x06, 0x99, 0x02, 0xa3, 0x0a, 0x33, 0x00, 0x08, 0x34, 0x99,
-    0x99, 0x64, 0x16, 0x44, 0x06, 0x99, 0x00, 0x06, 0x7c, 0x33, 0xd6, 0x00,
-    0x20, 0x99, 0x00, 0x16, 0x97, 0xa3, 0x33, 0x49, 0x99, 0x95, 0x3d, 0x48,
-    0x99, 0x98, 0x4d, 0x00, 0x06, 0x33, 0x00, 0x12, 0xd7, 0x99, 0x99, 0x97,
-    0xd3, 0x49, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00, 0x00, 0x12, 0x33, 0x49,
-    0x99, 0x96, 0x3b, 0x69, 0x99, 0x96, 0x53, 0x00, 0x06, 0x33, 0x02, 0x38,
-    0x06, 0x99, 0x00, 0x08, 0xc3, 0x49, 0x99, 0x94, 0x0a, 0x33, 0x02, 0x3c,
-    0x06, 0x99, 0x00, 0x0c, 0xb3, 0x33, 0x46, 0x99, 0x96, 0x43, 0x08, 0x33,
-    0x00, 0x0e, 0x3b, 0x48, 0x99, 0x97, 0x4d, 0x33, 0x3d, 0x00, 0x06, 0x99,
-    0x02, 0x9c, 0x0a, 0x33, 0x00, 0x08, 0x34, 0x99, 0x99, 0x6d, 0x16, 0x33,
-    0x00, 0x12, 0x39, 0x99, 0x99, 0x7c, 0x33, 0xd6, 0x99, 0x99, 0x54, 0x00,
-    0x1c, 0x44, 0x00, 0x14, 0xa3, 0x33, 0x49, 0x99, 0x96, 0x3b, 0x69, 0x99,
-    0x96, 0x53, 0x06, 0x33, 0x02, 0x38, 0x06, 0x99, 0x00, 0x0a, 0xc3, 0x49,
-    0x99, 0x94, 0x33, 0x00, 0x00, 0x00, 0x00, 0x12, 0x33, 0x49, 0x99, 0x98,
-    0xd5, 0x79, 0x99, 0x94, 0xd3, 0x00, 0x06, 0x33, 0x00, 0x10, 0x3d, 0x89,
-    0x99, 0x99, 0x73, 0x49, 0x99, 0x94, 0x0c, 0x33, 0x00, 0x12, 0x79, 0x99,
-    0x99, 0x8d, 0x3a, 0x59, 0x99, 0x84, 0xd3, 0x00, 0x08, 0x33, 0x00, 0x10,
-    0xd4, 0x79, 0x99, 0x84, 0xb3, 0x33, 0x33, 0xb9, 0x06, 0x99, 0x02, 0xd3,
-    0x08, 0x33, 0x00, 0x08, 0x34, 0x99, 0x99, 0x6d, 0x16, 0x33, 0x00, 0x12,
-    0x34, 0x99, 0x99, 0x7c, 0x33, 0xd6, 0x99, 0x99, 0x5d, 0x00, 0x20, 0x33,
-    0x00, 0x10, 0x49, 0x99, 0x98, 0xd5, 0x79, 0x99, 0x94, 0xd3, 0x06, 0x33,
-    0x00, 0x12, 0x3d, 0x89, 0x99, 0x99, 0x73, 0x49, 0x99, 0x94, 0x33, 0x00,
-    0x00, 0x00, 0x00, 0x10, 0x33, 0x49, 0x99, 0x99, 0xa6, 0x99, 0x99, 0x74,
-    0x0a, 0x33, 0x00, 0x0e, 0x79, 0x99, 0x99, 0x9c, 0x59, 0x99, 0x94, 0x00,
-    0x0c, 0x33, 0x00, 0x10, 0xc9, 0x99, 0x99, 0x9a, 0xd4, 0x79, 0x99, 0x65,
-    0x08, 0x33, 0x00, 0x0a, 0x3d, 0x46, 0x99, 0x98, 0x48, 0x00, 0x06, 0x33,
-    0x02, 0x3a, 0x06, 0x99, 0x02, 0x83, 0x08, 0x33, 0x00, 0x08, 0x34, 0x99,
-    0x99, 0x6d, 0x16, 0x33, 0x00, 0x12, 0x34, 0x99, 0x99, 0x7c, 0x33, 0xd6,
-    0x99, 0x99, 0x93, 0x00, 0x20, 0x33, 0x00, 0x0e, 0x49, 0x99, 0x99, 0xa6,
-    0x99, 0x99, 0x74, 0x00, 0x0a, 0x33, 0x00, 0x10, 0x79, 0x99, 0x99, 0x9c,
-    0x59, 0x99, 0x94, 0x33, 0x00, 0x00, 0x00, 0x10, 0x33, 0x49, 0x99, 0x99,
-    0x98, 0x99, 0x99, 0x5c, 0x0a, 0x33, 0x02, 0xd8, 0x06, 0x99, 0x00, 0x06,
-    0x79, 0x99, 0x84, 0x00, 0x0c, 0x33, 0x02, 0x37, 0x06, 0x99, 0x00, 0x08,
-    0x86, 0x99, 0x98, 0x4d, 0x08, 0x33, 0x00, 0x0a, 0x35, 0x59, 0x99, 0x95,
-    0x53, 0x00, 0x08, 0x33, 0x00, 0x08, 0x89, 0x99, 0x99, 0x9a, 0x08, 0x33,
-    0x00, 0x08, 0x34, 0x99, 0x99, 0x6d, 0x16, 0x33, 0x00, 0x0c, 0x34, 0x99,
-    0x99, 0x7c, 0x33, 0x36, 0x06, 0x99, 0x02, 0x54, 0x18, 0x44, 0x00, 0x14,
-    0x45, 0xc3, 0x33, 0x49, 0x99, 0x99, 0x98, 0x99, 0x99, 0x5c, 0x0a, 0x33,
-    0x02, 0xd8, 0x06, 0x99, 0x00, 0x08, 0x79, 0x99, 0x84, 0x33, 0x00, 0x00,
-    0x02, 0x33, 0x02, 0x59, 0x08, 0x99, 0x02, 0x97, 0x02, 0x4d, 0x0a, 0x33,
-    0x02, 0x36, 0x0a, 0x99, 0x02, 0x75, 0x0c, 0x33, 0x02, 0x3c, 0x0a, 0x99,
-    0x02, 0x96, 0x02, 0x53, 0x08, 0x33, 0x00, 0x0a, 0x84, 0x89, 0x99, 0x64,
-    0xd3, 0x00, 0x08, 0x33, 0x02, 0xd9, 0x06, 0x99, 0x02, 0xb3, 0x06, 0x33,
-    0x00, 0x08, 0x34, 0x99, 0x99, 0x6d, 0x16, 0x33, 0x00, 0x0c, 0x34, 0x99,
-    0x99, 0x7c, 0x33, 0x36, 0x20, 0x99, 0x00, 0x08, 0x97, 0xa3, 0x33, 0x59,
-    0x08, 0x99, 0x02, 0x97, 0x02, 0x4d, 0x0a, 0x33, 0x02, 0x36, 0x0a, 0x99,
-    0x02, 0x75, 0x02, 0x33, 0x00, 0x00, 0x02, 0x33, 0x02, 0xa8, 0x08, 0x99,
-    0x02, 0x95, 0x02, 0xa3, 0x0a, 0x33, 0x02, 0x3c, 0x0a, 0x99, 0x02, 0x5b,
-    0x0e, 0x33, 0x02, 0x89, 0x08, 0x99, 0x02, 0x84, 0x02, 0xd3, 0x06, 0x33,
-    0x00, 0x0a, 0x3b, 0x48, 0x99, 0x97, 0x4c, 0x00, 0x0a, 0x33, 0x02, 0x3d,
-    0x06, 0x99, 0x02, 0x9d, 0x06, 0x33, 0x00, 0x08, 0x34, 0x99, 0x99, 0x6d,
-    0x16, 0x33, 0x00, 0x0e, 0x34, 0x99, 0x99, 0x7c, 0x33, 0x3d, 0x89, 0x00,
-    0x1e, 0x99, 0x00, 0x08, 0x97, 0xa3, 0x33, 0xa8, 0x08, 0x99, 0x02, 0x95,
-    0x02, 0xa3, 0x0a, 0x33, 0x02, 0x3c, 0x0a, 0x99, 0x02, 0x5b, 0x02, 0x33,
-    0x00, 0x00, 0x02, 0x33, 0x02, 0xd7, 0x08, 0x99, 0x02, 0x64, 0x0e, 0x33,
-    0x02, 0x79, 0x06, 0x99, 0x02, 0x96, 0x02, 0x4d, 0x0e, 0x33, 0x02, 0xd8,
-    0x06, 0x99, 0x02, 0x98, 0x02, 0x48, 0x08, 0x33, 0x00, 0x0a, 0xd4, 0x79,
-    0x99, 0x84, 0xb3, 0x00, 0x0c, 0x33, 0x00, 0x16, 0xb9, 0x99, 0x99, 0x98,
-    0xd3, 0x33, 0x33, 0x34, 0x99, 0x99, 0x6d, 0x00, 0x16, 0x33, 0x00, 0x0c,
-    0x34, 0x99, 0x99, 0x7c, 0x33, 0x33, 0x20, 0x99, 0x00, 0x08, 0x97, 0xa3,
-    0x33, 0xd7, 0x08, 0x99, 0x02, 0x64, 0x0e, 0x33, 0x02, 0x79, 0x06, 0x99,
-    0x00, 0x06, 0x96, 0x4d, 0x33, 0x00, 0x00, 0x00, 0x02, 0x33, 0x02, 0x3c,
-    0x06, 0x99, 0x02, 0x96, 0x02, 0x4d, 0x0e, 0x33, 0x02, 0xd9, 0x06, 0x99,
-    0x02, 0x74, 0x02, 0xc3, 0x0e, 0x33, 0x02, 0x3d, 0x06, 0x99, 0x02, 0x85,
-    0x02, 0x53, 0x06, 0x33, 0x00, 0x0a, 0x3d, 0x46, 0x99, 0x99, 0x57, 0x00,
-    0x0e, 0x33, 0x02, 0x39, 0x06, 0x99, 0x00, 0x0e, 0xa3, 0x33, 0x33, 0x34,
-    0x99, 0x99, 0x6d, 0x00, 0x16, 0x33, 0x00, 0x0e, 0x34, 0x99, 0x99, 0x7c,
-    0x33, 0x33, 0x3a, 0x00, 0x1e, 0x99, 0x00, 0x08, 0x97, 0xa3, 0x33, 0x3c,
-    0x06, 0x99, 0x02, 0x96, 0x02, 0x4d, 0x0e, 0x33, 0x02, 0xd9, 0x06, 0x99,
-    0x00, 0x06, 0x74, 0xc3, 0x33, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x33, 0x33,
-    0xc8, 0x99, 0x96, 0x44, 0xd3, 0x00, 0x0e, 0x33, 0x00, 0x0a, 0x3d, 0x79,
-    0x99, 0x76, 0x4b, 0x00, 0x12, 0x33, 0x00, 0x0a, 0xc7, 0x99, 0x96, 0x45,
-    0xd3, 0x00, 0x06, 0x33, 0x00, 0x0a, 0x35, 0x59, 0x99, 0x96, 0x43, 0x00,
-    0x10, 0x33, 0x00, 0x14, 0x89, 0x99, 0x99, 0x9a, 0x33, 0x33, 0x34, 0x99,
-    0x99, 0x6d, 0x16, 0x33, 0x00, 0x08, 0x34, 0x99, 0x99, 0x7c, 0x06, 0x33,
-    0x02, 0xa6, 0x1c, 0x99, 0x00, 0x12, 0x97, 0xa3, 0x33, 0x33, 0xc8, 0x99,
-    0x96, 0x44, 0xd3, 0x00, 0x0e, 0x33, 0x00, 0x0e, 0x3d, 0x79, 0x99, 0x76,
-    0x4b, 0x33, 0x33, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x33, 0x33, 0x3d, 0x84,
-    0x44, 0xc3, 0x12, 0x33, 0x00, 0x08, 0xdc, 0x44, 0x4a, 0xd3, 0x12, 0x33,
-    0x00, 0x08, 0x3d, 0xa4, 0x44, 0xd3, 0x08, 0x33, 0x02, 0xc8, 0x06, 0x44,
-    0x02, 0xd3, 0x10, 0x33, 0x02, 0xd4, 0x06, 0x44, 0x00, 0x0c, 0xa3, 0x33,
-    0x38, 0x44, 0x44, 0x4d, 0x16, 0x33, 0x00, 0x08, 0x38, 0x44, 0x44, 0x4c,
-    0x06, 0x33, 0x02, 0x3d, 0x02, 0xc4, 0x1c, 0x44, 0x00, 0x0e, 0xa3, 0x33,
-    0x33, 0x3d, 0x84, 0x44, 0xc3, 0x00, 0x12, 0x33, 0x00, 0x0c, 0xdc, 0x44,
-    0x4a, 0xd3, 0x33, 0x33, 0x00, 0x00, 0xe6, 0x33, 0x00, 0x00, 0xe6, 0x33,
-    0x00, 0x00, 0xe6, 0x33, 0x00, 0x00, 0xe6, 0x33, 0x00, 0x00, 0xe6, 0x33,
-    0x00, 0x00, 0x00, 0x1e, 0x33, 0x20, 0x00, 0x23, 0x30, 0x00, 0x13, 0x31,
-    0x00, 0x02, 0x33, 0x00, 0x01, 0x33, 0x32, 0x00, 0x08, 0x00, 0x00, 0x26,
-    0x13, 0x31, 0x00, 0x02, 0x33, 0x00, 0x01, 0x33, 0x00, 0x00, 0x13, 0x33,
-    0x00, 0x00, 0x13, 0x32, 0x00, 0x00, 0x23, 0x00, 0x24, 0x33, 0x00, 0x06,
-    0x32, 0x00, 0x02, 0x00, 0x08, 0x33, 0x02, 0x32, 0x06, 0x00, 0x00, 0x30,
-    0x01, 0x33, 0x31, 0x00, 0x02, 0x33, 0x00, 0x01, 0x33, 0x33, 0x32, 0x00,
-    0x02, 0x33, 0x33, 0x30, 0x00, 0x13, 0x32, 0x00, 0x02, 0x33, 0x00, 0x01,
-    0x08, 0x33, 0x00, 0x10, 0x30, 0x00, 0x13, 0x31, 0x00, 0x02, 0x33, 0x30,
-    0x08, 0x00, 0x00, 0x10, 0x23, 0x30, 0x00, 0x13, 0x31, 0x00, 0x02, 0x33,
-    0x00, 0x00, 0x00, 0x20, 0x33, 0x20, 0x11, 0x13, 0x30, 0x11, 0x03, 0x31,
-    0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x10, 0x10, 0x06, 0x00, 0x00, 0x26,
-    0x03, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x01, 0x11, 0x03, 0x33,
-    0x01, 0x11, 0x13, 0x32, 0x01, 0x11, 0x23, 0x00, 0x24, 0x33, 0x00, 0x06,
-    0x32, 0x01, 0x11, 0x00, 0x08, 0x33, 0x00, 0x38, 0x10, 0x10, 0x00, 0x11,
-    0x11, 0x03, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x33, 0x32, 0x01,
-    0x11, 0x33, 0x33, 0x30, 0x11, 0x03, 0x32, 0x01, 0x11, 0x33, 0x01, 0x10,
-    0x08, 0x33, 0x00, 0x12, 0x30, 0x11, 0x03, 0x31, 0x11, 0x02, 0x33, 0x00,
-    0x10, 0x00, 0x06, 0x00, 0x00, 0x10, 0x23, 0x30, 0x11, 0x03, 0x31, 0x11,
-    0x02, 0x33, 0x00, 0x00, 0x00, 0x22, 0x33, 0x20, 0x11, 0x13, 0x30, 0x11,
-    0x03, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x11, 0x10, 0x23, 0x00,
-    0x06, 0x33, 0x00, 0x24, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x01,
-    0x11, 0x13, 0x33, 0x01, 0x10, 0x13, 0x32, 0x01, 0x11, 0x23, 0x24, 0x33,
-    0x00, 0x06, 0x32, 0x01, 0x11, 0x00, 0x08, 0x33, 0x00, 0x38, 0x11, 0x10,
-    0x23, 0x31, 0x11, 0x03, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x33,
-    0x32, 0x01, 0x11, 0x33, 0x33, 0x30, 0x11, 0x03, 0x32, 0x01, 0x11, 0x33,
-    0x01, 0x10, 0x08, 0x33, 0x00, 0x12, 0x30, 0x11, 0x03, 0x31, 0x11, 0x02,
-    0x33, 0x01, 0x10, 0x00, 0x08, 0x33, 0x00, 0x0e, 0x30, 0x11, 0x03, 0x31,
-    0x11, 0x02, 0x33, 0x00, 0x00, 0x00, 0x00, 0x22, 0x33, 0x20, 0x11, 0x23,
-    0x30, 0x11, 0x03, 0x31, 0x11, 0x12, 0x33, 0x01, 0x10, 0x33, 0x11, 0x10,
-    0x23, 0x00, 0x06, 0x33, 0x00, 0x28, 0x31, 0x11, 0x12, 0x33, 0x01, 0x00,
-    0x33, 0x01, 0x11, 0x11, 0x00, 0x01, 0x12, 0x33, 0x32, 0x01, 0x11, 0x11,
-    0x00, 0x23, 0x20, 0x33, 0x00, 0x06, 0x32, 0x01, 0x12, 0x00, 0x08, 0x33,
-    0x00, 0x38, 0x11, 0x10, 0x23, 0x30, 0x11, 0x03, 0x31, 0x11, 0x12, 0x33,
-    0x01, 0x00, 0x33, 0x33, 0x32, 0x01, 0x11, 0x33, 0x33, 0x30, 0x11, 0x13,
-    0x32, 0x01, 0x11, 0x33, 0x01, 0x11, 0x08, 0x33, 0x00, 0x12, 0x30, 0x11,
-    0x03, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x00, 0x08, 0x33, 0x00, 0x0e,
-    0x30, 0x11, 0x03, 0x31, 0x11, 0x02, 0x33, 0x00, 0x00, 0x00, 0x00, 0x22,
-    0x33, 0x20, 0x11, 0x11, 0x00, 0x11, 0x03, 0x31, 0x11, 0x11, 0x00, 0x01,
-    0x10, 0x33, 0x11, 0x10, 0x23, 0x00, 0x06, 0x33, 0x00, 0x10, 0x31, 0x11,
-    0x11, 0x00, 0x01, 0x13, 0x33, 0x01, 0x08, 0x11, 0x00, 0x10, 0x12, 0x33,
-    0x32, 0x01, 0x11, 0x11, 0x10, 0x23, 0x20, 0x33, 0x00, 0x60, 0x32, 0x01,
-    0x11, 0x10, 0x00, 0x03, 0x33, 0x11, 0x10, 0x23, 0x30, 0x11, 0x03, 0x31,
-    0x11, 0x12, 0x22, 0x01, 0x02, 0x33, 0x33, 0x32, 0x01, 0x11, 0x33, 0x33,
-    0x30, 0x11, 0x12, 0x21, 0x01, 0x11, 0x33, 0x01, 0x11, 0x22, 0x22, 0x23,
-    0x33, 0x30, 0x11, 0x12, 0x21, 0x11, 0x02, 0x33, 0x01, 0x10, 0x08, 0x33,
-    0x00, 0x0e, 0x30, 0x11, 0x12, 0x21, 0x10, 0x13, 0x33, 0x00, 0x00, 0x00,
-    0x00, 0x22, 0x33, 0x20, 0x11, 0x00, 0x11, 0x11, 0x03, 0x31, 0x11, 0x00,
-    0x01, 0x11, 0x10, 0x33, 0x11, 0x10, 0x23, 0x00, 0x06, 0x33, 0x00, 0x28,
-    0x31, 0x11, 0x00, 0x01, 0x11, 0x13, 0x33, 0x01, 0x11, 0x00, 0x01, 0x11,
-    0x12, 0x33, 0x32, 0x01, 0x11, 0x00, 0x00, 0x23, 0x20, 0x33, 0x00, 0x60,
-    0x32, 0x01, 0x10, 0x01, 0x11, 0x12, 0x33, 0x11, 0x10, 0x23, 0x30, 0x11,
-    0x03, 0x31, 0x11, 0x10, 0x10, 0x11, 0x13, 0x33, 0x33, 0x32, 0x01, 0x11,
-    0x33, 0x33, 0x30, 0x11, 0x10, 0x10, 0x11, 0x11, 0x33, 0x01, 0x11, 0x01,
-    0x00, 0x01, 0x23, 0x30, 0x11, 0x00, 0x10, 0x11, 0x02, 0x33, 0x01, 0x10,
-    0x08, 0x33, 0x00, 0x0e, 0x30, 0x11, 0x00, 0x10, 0x11, 0x23, 0x33, 0x00,
-    0x00, 0x00, 0x00, 0x22, 0x33, 0x20, 0x11, 0x13, 0x31, 0x11, 0x03, 0x31,
-    0x11, 0x02, 0x33, 0x11, 0x10, 0x33, 0x11, 0x10, 0x23, 0x00, 0x06, 0x33,
-    0x00, 0x24, 0x31, 0x11, 0x02, 0x33, 0x11, 0x10, 0x33, 0x01, 0x11, 0x03,
-    0x33, 0x11, 0x11, 0x13, 0x32, 0x01, 0x11, 0x23, 0x24, 0x33, 0x00, 0x60,
-    0x32, 0x01, 0x11, 0x33, 0x11, 0x10, 0x33, 0x11, 0x10, 0x23, 0x30, 0x11,
-    0x03, 0x31, 0x11, 0x01, 0x22, 0x11, 0x12, 0x33, 0x33, 0x32, 0x01, 0x11,
-    0x33, 0x33, 0x30, 0x11, 0x02, 0x22, 0x11, 0x11, 0x33, 0x01, 0x10, 0x22,
-    0x21, 0x11, 0x13, 0x30, 0x11, 0x02, 0x21, 0x11, 0x02, 0x33, 0x01, 0x10,
-    0x08, 0x33, 0x00, 0x0e, 0x30, 0x11, 0x02, 0x21, 0x11, 0x23, 0x33, 0x00,
-    0x00, 0x00, 0x00, 0x22, 0x33, 0x20, 0x11, 0x13, 0x30, 0x11, 0x03, 0x31,
-    0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x11, 0x10, 0x23, 0x00, 0x06, 0x33,
-    0x00, 0x24, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x01, 0x11, 0x13,
-    0x33, 0x01, 0x11, 0x13, 0x32, 0x01, 0x11, 0x23, 0x24, 0x33, 0x00, 0x60,
-    0x32, 0x01, 0x11, 0x33, 0x01, 0x10, 0x33, 0x11, 0x11, 0x23, 0x30, 0x11,
-    0x03, 0x31, 0x11, 0x12, 0x33, 0x11, 0x10, 0x33, 0x33, 0x32, 0x01, 0x11,
-    0x33, 0x33, 0x30, 0x11, 0x13, 0x32, 0x11, 0x11, 0x33, 0x01, 0x11, 0x33,
-    0x21, 0x11, 0x13, 0x30, 0x11, 0x03, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10,
-    0x08, 0x33, 0x00, 0x0e, 0x30, 0x11, 0x03, 0x31, 0x11, 0x02, 0x33, 0x00,
-    0x00, 0x00, 0x00, 0x22, 0x33, 0x20, 0x11, 0x13, 0x30, 0x11, 0x03, 0x31,
-    0x11, 0x12, 0x33, 0x01, 0x00, 0x33, 0x11, 0x11, 0x23, 0x00, 0x06, 0x33,
-    0x00, 0x2c, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x01, 0x11, 0x11,
-    0x00, 0x01, 0x10, 0x13, 0x32, 0x01, 0x11, 0x11, 0x00, 0x00, 0x01, 0x23,
-    0x1c, 0x33, 0x00, 0x60, 0x32, 0x01, 0x12, 0x33, 0x01, 0x00, 0x33, 0x11,
-    0x11, 0x22, 0x20, 0x11, 0x03, 0x31, 0x11, 0x12, 0x22, 0x01, 0x10, 0x33,
-    0x33, 0x32, 0x01, 0x12, 0x33, 0x33, 0x30, 0x11, 0x12, 0x21, 0x01, 0x11,
-    0x33, 0x01, 0x11, 0x22, 0x10, 0x11, 0x13, 0x30, 0x11, 0x12, 0x21, 0x11,
-    0x02, 0x33, 0x01, 0x11, 0x08, 0x33, 0x00, 0x0e, 0x30, 0x11, 0x03, 0x31,
-    0x11, 0x02, 0x33, 0x00, 0x00, 0x00, 0x00, 0x38, 0x33, 0x20, 0x11, 0x13,
-    0x30, 0x11, 0x03, 0x32, 0x11, 0x11, 0x00, 0x01, 0x02, 0x33, 0x21, 0x11,
-    0x10, 0x00, 0x00, 0x13, 0x31, 0x11, 0x02, 0x33, 0x01, 0x10, 0x33, 0x01,
-    0x08, 0x11, 0x00, 0x08, 0x12, 0x33, 0x33, 0x21, 0x08, 0x11, 0x02, 0x10,
-    0x02, 0x23, 0x1c, 0x33, 0x00, 0x0e, 0x32, 0x01, 0x11, 0x10, 0x01, 0x02,
-    0x33, 0x00, 0x06, 0x11, 0x00, 0x62, 0x01, 0x10, 0x03, 0x31, 0x11, 0x11,
-    0x10, 0x11, 0x00, 0x33, 0x10, 0x00, 0x01, 0x11, 0x10, 0x13, 0x30, 0x11,
-    0x11, 0x10, 0x11, 0x01, 0x33, 0x01, 0x11, 0x11, 0x01, 0x10, 0x13, 0x30,
-    0x11, 0x11, 0x00, 0x10, 0x02, 0x33, 0x01, 0x11, 0x10, 0x00, 0x00, 0x23,
-    0x30, 0x11, 0x03, 0x31, 0x11, 0x02, 0x33, 0x00, 0x00, 0x00, 0x00, 0x12,
-    0x33, 0x20, 0x00, 0x13, 0x31, 0x00, 0x03, 0x33, 0x20, 0x00, 0x06, 0x00,
-    0x00, 0x06, 0x13, 0x33, 0x32, 0x00, 0x08, 0x00, 0x00, 0x12, 0x03, 0x32,
-    0x00, 0x02, 0x33, 0x10, 0x00, 0x33, 0x10, 0x00, 0x08, 0x00, 0x00, 0x08,
-    0x02, 0x33, 0x33, 0x30, 0x0a, 0x00, 0x02, 0x23, 0x1c, 0x33, 0x02, 0x32,
-    0x08, 0x00, 0x00, 0x06, 0x03, 0x33, 0x32, 0x00, 0x06, 0x00, 0x00, 0x06,
-    0x01, 0x33, 0x32, 0x00, 0x08, 0x00, 0x00, 0x06, 0x13, 0x33, 0x20, 0x00,
-    0x08, 0x00, 0x00, 0x06, 0x03, 0x33, 0x10, 0x00, 0x06, 0x00, 0x00, 0x06,
-    0x23, 0x33, 0x10, 0x00, 0x06, 0x00, 0x00, 0x06, 0x02, 0x33, 0x33, 0x00,
-    0x08, 0x00, 0x00, 0x06, 0x23, 0x33, 0x30, 0x00, 0x08, 0x00, 0x00, 0x10,
-    0x23, 0x31, 0x00, 0x03, 0x32, 0x00, 0x02, 0x33, 0x00, 0x00, 0xe6, 0x33,
-    0x00, 0x00, 0xe6, 0x33, 0x00, 0x00, 0xe6, 0x33, 0x00, 0x00, 0xe6, 0x33,
-    0x00, 0x01};
-unsigned int splash_new__new_t_len = 3854;

firmware/application/de_bruijn.cpp

@@ -1,104 +0,0 @@
-/*
- * Copyright (C) 2014 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 "de_bruijn.hpp"
-
-/* How this works:
- * B(2,4) means:
- * 	Alphabet size = 2 (binary)
- * 	Code length = 4
- * The length of the bitstream is (2 ^ 4) + (4 - 1) = 19 bits
- * The primitive polynomials come from the de_bruijn_polys[] array (one for each code length)
- * The shift register is init with 1 and shifted left each step
- * The polynomial is kept on the right, and used as a AND mask applied on the corresponding shift register bits
- * The resulting bits are XORed together to produce the new bit pushed in the shift register
- *
- * 		0001 (init)
- * AND	1001 (polynomial)
- *      0001 XOR'd -> 1
- *
- * 		00011 (shift left)
- * AND	 1001
- *       0001 XOR'd -> 1
- *
- * 		000111 (shift left)
- * AND	  1001
- *        0001 XOR'd -> 1
- *
- * 		0001111 (shift left)
- * AND	   1001
- *         1001 XOR'd -> 0
- *
- * 		00011110 (shift left)
- * AND	    1001
- *          1000 XOR'd -> 1
- * ...
- * After 16 steps: (0+) 000111101011001000
- * Each of the 16 possible values appears in the sequence:
- * -0000-111101011001000 0
- * 0-0001-11101011001000 1
- * 0000111101011-0010-00 2
- * 00-0011-1101011001000 3
- * 00001111010110-0100-0 4
- * 00001111-0101-1001000 5
- * 0000111101-0110-01000 6
- * 000-0111-101011001000 7
- * 000011110101100-1000- 8
- * 000011110101-1001-000 9
- * 0000111-1010-11001000 10
- * 000011110-1011-001000 11
- * 00001111010-1100-1000 12
- * 000011-1101-011001000 13
- * 00001-1110-1011001000 14
- * 0000-1111-01011001000 15
- */
-
-size_t de_bruijn::init(const uint32_t n) {
-    // Cap
-    if ((n < 3) || (n > 16))
-        length = 3;
-    else
-        length = n;
-
-    poly = de_bruijn_polys[length - 3];
-    shift_register = 1;
-
-    return (1U << length) + (length - 1);
-}
-
-uint32_t de_bruijn::compute(const uint32_t steps) {
-    uint32_t step, bits, masked;
-    uint8_t new_bit;
-
-    for (step = 0; step < steps; step++) {
-        masked = shift_register & poly;
-        new_bit = 0;
-        for (bits = 0; bits < length; bits++) {
-            new_bit ^= (masked & 1);
-            masked >>= 1;
-        }
-        shift_register <<= 1;
-        shift_register |= new_bit;
-    }
-
-    return shift_register;
-}

firmware/application/de_bruijn.hpp

@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2014 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 <string>
-#include <cstdint>
-
-#ifndef __DE_BRUIJN_H__
-#define __DE_BRUIJN_H__
-
-// n from 3 to 16
-const uint32_t de_bruijn_polys[14]{
-    0b0000000000000101,
-    0b0000000000001001,
-    0b0000000000011011,
-    0b0000000000110011,
-    0b0000000001010011,
-    0b0000000010001101,
-    0b0000000100100001,
-    0b0000001000100001,
-    0b0000010001100001,
-    0b0000110101000011,
-    0b0001001001100101,
-    0b0010101100000011,
-    0b0101000000001001,
-    0b1010000101000101};
-
-struct de_bruijn {
-   public:
-    size_t init(const uint32_t n);
-    uint32_t compute(const uint32_t steps);
-
-   private:
-    uint32_t length{};
-    uint32_t poly{};
-    uint32_t shift_register{};
-};
-
-#endif /*__DE_BRUIJN_H__*/

firmware/application/external/adsbtx/ui_adsb_tx.cpp

@@ -131,6 +131,7 @@ ADSBCallsignView::ADSBCallsignView(
             nav,
             callsign,
             8,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& s) {
                 button_callsign.set_text(s);
             });

firmware/application/external/breakout/Arial12x12.h

@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2024 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.
- */
-
-// dummy include file to avoid changing original source
-
-#ifndef __UI_Arial12x12_H__
-#define __UI_Arial12x12_H__
-
-#define Arial12x12 (0)
-
-#endif /*__UI_Arial12x12_H__*/

firmware/application/external/breakout/SPI_TFT_ILI9341.h

@@ -1,68 +0,0 @@
-/*
- * ------------------------------------------------------------
- * |  Made by RocketGod                                       |
- * |  Find me at https://betaskynet.com                       |
- * |  Argh matey!                                             |
- * ------------------------------------------------------------
- */
-
-#ifndef __UI_SPI_TFT_ILI9341_H__
-#define __UI_SPI_TFT_ILI9341_H__
-
-ui::Painter painter;
-
-static int bg_color;
-
-enum {
-    White,
-    Blue,
-    Yellow,
-    Purple,
-    Green,
-    Red,
-    Maroon,
-    Orange,
-    Black,
-};
-
-static const Color pp_colors[] = {
-    Color::white(),
-    Color::blue(),
-    Color::yellow(),
-    Color::purple(),
-    Color::green(),
-    Color::red(),
-    Color::magenta(),
-    Color::orange(),
-    Color::black(),
-};
-
-static void claim(__FILE* x) {
-    (void)x;
-};
-
-static void cls() {
-    painter.fill_rectangle({0, 0, portapack::display.width(), portapack::display.height()}, Color::black());
-};
-
-static void background(int color) {
-    bg_color = color;
-};
-
-static void set_orientation(int x) {
-    (void)x;
-};
-
-static void set_font(unsigned char* x) {
-    (void)x;
-};
-
-static void fillrect(int x1, int y1, int x2, int y2, int color) {
-    painter.fill_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
-};
-
-static void rect(int x1, int y1, int x2, int y2, int color) {
-    painter.draw_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
-};
-
-#endif /*__UI_SPI_TFT_ILI9341_H__*/

firmware/application/external/breakout/breakout.cpp

@@ -1,429 +0,0 @@
-/*
- * ------------------------------------------------------------
- * |  Made by RocketGod                                       |
- * |  Find me at https://betaskynet.com                       |
- * |  Argh matey!                                             |
- * ------------------------------------------------------------
- */
-
-#include "mbed.h"
-#include "SPI_TFT_ILI9341.h"
-#include "Arial12x12.h"
-#include "ui.hpp"
-
-#define SCREEN_WIDTH 240
-#define SCREEN_HEIGHT 320
-#define PADDLE_WIDTH 40
-#define PADDLE_HEIGHT 10
-#define BALL_SIZE 8
-#define BRICK_WIDTH 20
-#define BRICK_HEIGHT 10
-#define BRICK_ROWS 5
-#define BRICK_COLS 10
-#define BRICK_GAP 2
-#define GAME_AREA_TOP 50
-#define GAME_AREA_BOTTOM 310
-#define PADDLE_Y (GAME_AREA_BOTTOM - PADDLE_HEIGHT)
-#define BALL_SPEED_INCREASE 0.1f
-
-#define STATE_MENU 0
-#define STATE_PLAYING 1
-#define STATE_GAME_OVER 3
-
-#define COLOR_BACKGROUND Black
-#define COLOR_PADDLE Blue
-#define COLOR_BALL White
-#define COLOR_BORDER White
-#define COLOR_BRICK_COLORS \
-    { Red, Orange, Yellow, Green, Purple }
-
-Ticker game_timer;
-
-int paddle_x = (SCREEN_WIDTH - PADDLE_WIDTH) / 2;
-float ball_x = SCREEN_WIDTH / 2;
-float ball_y = GAME_AREA_BOTTOM - PADDLE_HEIGHT - BALL_SIZE - 1;
-float ball_dx = 1.5f;
-float ball_dy = -2.0f;
-int score = 0;
-int lives = 3;
-int level = 1;
-int game_state = STATE_MENU;
-bool initialized = false;
-bool ball_attached = true;
-unsigned int brick_count = 0;
-
-bool bricks[BRICK_ROWS][BRICK_COLS];
-int brick_colors[BRICK_ROWS];
-
-extern ui::Painter painter;
-
-void init_game();
-void init_level();
-void draw_screen();
-void draw_bricks();
-void draw_paddle();
-void draw_ball();
-void draw_score();
-void draw_lives();
-void draw_level();
-void draw_borders();
-void move_paddle_left();
-void move_paddle_right();
-void launch_ball();
-void update_game();
-void check_collisions();
-bool check_brick_collision(int row, int col);
-void handle_game_over();
-void show_menu();
-void show_game_over();
-bool check_level_complete();
-void next_level();
-void reset_game();
-
-void game_timer_check() {
-    if (game_state == STATE_PLAYING) {
-        update_game();
-    }
-}
-
-void init_game() {
-    claim(stdout);
-    set_orientation(2);
-    set_font((unsigned char*)Arial12x12);
-
-    paddle_x = (SCREEN_WIDTH - PADDLE_WIDTH) / 2;
-    score = 0;
-    lives = 3;
-    level = 1;
-
-    brick_colors[0] = Red;
-    brick_colors[1] = Orange;
-    brick_colors[2] = Yellow;
-    brick_colors[3] = Green;
-    brick_colors[4] = Purple;
-
-    init_level();
-
-    game_state = STATE_MENU;
-    show_menu();
-}
-
-void init_level() {
-    ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
-    ball_y = GAME_AREA_BOTTOM - PADDLE_HEIGHT - BALL_SIZE - 1;
-
-    float speed_multiplier = (level == 1) ? 1.0f : 1.0f + ((level - 1) * BALL_SPEED_INCREASE);
-    ball_dx = (ball_dx > 0 ? 1.5f : -1.5f) * speed_multiplier;
-    ball_dy = -2.0f * speed_multiplier;
-
-    ball_attached = true;
-
-    brick_count = 0;
-    for (int row = 0; row < BRICK_ROWS; row++) {
-        for (int col = 0; col < BRICK_COLS; col++) {
-            bricks[row][col] = true;
-            brick_count++;
-        }
-    }
-}
-
-void draw_screen() {
-    cls();
-    background(COLOR_BACKGROUND);
-
-    draw_borders();
-    draw_bricks();
-    draw_paddle();
-    draw_ball();
-    draw_score();
-    draw_lives();
-    draw_level();
-}
-
-void draw_borders() {
-    rect(0, GAME_AREA_TOP - 1, SCREEN_WIDTH, GAME_AREA_TOP, COLOR_BORDER);
-}
-
-void draw_bricks() {
-    for (int row = 0; row < BRICK_ROWS; row++) {
-        for (int col = 0; col < BRICK_COLS; col++) {
-            if (bricks[row][col]) {
-                int x = col * (BRICK_WIDTH + BRICK_GAP);
-                int y = GAME_AREA_TOP + row * (BRICK_HEIGHT + BRICK_GAP) + 5;
-                fillrect(x, y, x + BRICK_WIDTH, y + BRICK_HEIGHT, brick_colors[row]);
-                rect(x, y, x + BRICK_WIDTH, y + BRICK_HEIGHT, Black);
-            }
-        }
-    }
-}
-
-void draw_paddle() {
-    fillrect(paddle_x, PADDLE_Y, paddle_x + PADDLE_WIDTH, PADDLE_Y + PADDLE_HEIGHT, COLOR_PADDLE);
-}
-
-void draw_ball() {
-    fillrect(ball_x, ball_y, ball_x + BALL_SIZE, ball_y + BALL_SIZE, COLOR_BALL);
-}
-
-void draw_score() {
-    auto style = *ui::Theme::getInstance()->fg_green;
-    painter.draw_string({5, 10}, style, "Score: " + std::to_string(score));
-}
-
-void draw_lives() {
-    auto style = *ui::Theme::getInstance()->fg_red;
-    painter.draw_string({5, 30}, style, "Lives: " + std::to_string(lives));
-}
-
-void draw_level() {
-    auto style = *ui::Theme::getInstance()->fg_yellow;
-    painter.draw_string({80, 30}, style, "Level: " + std::to_string(level));
-}
-
-void move_paddle_left() {
-    if (paddle_x > 0) {
-        fillrect(paddle_x, PADDLE_Y, paddle_x + PADDLE_WIDTH, PADDLE_Y + PADDLE_HEIGHT, COLOR_BACKGROUND);
-        if (ball_attached) {
-            fillrect(ball_x, ball_y, ball_x + BALL_SIZE, ball_y + BALL_SIZE, COLOR_BACKGROUND);
-        }
-
-        paddle_x -= 10;
-        if (paddle_x < 0) paddle_x = 0;
-
-        if (ball_attached) {
-            ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
-        }
-
-        draw_paddle();
-        if (ball_attached) {
-            draw_ball();
-        }
-    }
-}
-
-void move_paddle_right() {
-    if (paddle_x < SCREEN_WIDTH - PADDLE_WIDTH) {
-        fillrect(paddle_x, PADDLE_Y, paddle_x + PADDLE_WIDTH, PADDLE_Y + PADDLE_HEIGHT, COLOR_BACKGROUND);
-        if (ball_attached) {
-            fillrect(ball_x, ball_y, ball_x + BALL_SIZE, ball_y + BALL_SIZE, COLOR_BACKGROUND);
-        }
-
-        paddle_x += 10;
-        if (paddle_x > SCREEN_WIDTH - PADDLE_WIDTH) paddle_x = SCREEN_WIDTH - PADDLE_WIDTH;
-
-        if (ball_attached) {
-            ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
-        }
-
-        draw_paddle();
-        if (ball_attached) {
-            draw_ball();
-        }
-    }
-}
-
-void launch_ball() {
-    if (ball_attached) {
-        ball_attached = false;
-        ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
-        ball_y = GAME_AREA_BOTTOM - PADDLE_HEIGHT - BALL_SIZE - 1;
-        float speed_multiplier = (level == 1) ? 1.0f : 1.0f + ((level - 1) * BALL_SPEED_INCREASE);
-        ball_dx = 1.5f * speed_multiplier;
-        ball_dy = -2.0f * speed_multiplier;
-    }
-}
-
-void update_game() {
-    if (ball_attached) {
-        return;
-    }
-
-    fillrect(ball_x, ball_y, ball_x + BALL_SIZE, ball_y + BALL_SIZE, COLOR_BACKGROUND);
-
-    float next_ball_y = ball_y + ball_dy;
-    if (next_ball_y > GAME_AREA_BOTTOM) {
-        lives--;
-        draw_lives();
-        if (lives <= 0) {
-            handle_game_over();
-        } else {
-            ball_attached = true;
-            ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
-            ball_y = GAME_AREA_BOTTOM - PADDLE_HEIGHT - BALL_SIZE - 1;
-            draw_ball();
-        }
-        return;
-    }
-
-    ball_x += ball_dx;
-    ball_y = next_ball_y;
-
-    if (ball_x < 0) {
-        ball_x = 0;
-        ball_dx = -ball_dx;
-    } else if (ball_x > SCREEN_WIDTH - BALL_SIZE) {
-        ball_x = SCREEN_WIDTH - BALL_SIZE;
-        ball_dx = -ball_dx;
-    }
-
-    if (ball_y < GAME_AREA_TOP) {
-        ball_y = GAME_AREA_TOP;
-        ball_dy = -ball_dy;
-    }
-
-    if (ball_y + BALL_SIZE >= PADDLE_Y && ball_y <= PADDLE_Y + PADDLE_HEIGHT) {
-        if (ball_x + BALL_SIZE >= paddle_x && ball_x <= paddle_x + PADDLE_WIDTH) {
-            ball_y = PADDLE_Y - BALL_SIZE;
-            float hit_position = (ball_x + (BALL_SIZE / 2)) - paddle_x;
-            float angle = (hit_position / PADDLE_WIDTH) - 0.5f;
-            ball_dx = angle * 4.0f;
-            if (ball_dx > -0.5f && ball_dx < 0.5f) {
-                ball_dx = (ball_dx > 0) ? 0.5f : -0.5f;
-            }
-            ball_dy = -ball_dy;
-        }
-    }
-
-    check_collisions();
-
-    draw_ball();
-
-    if (check_level_complete()) {
-        next_level();
-    }
-}
-
-void check_collisions() {
-    int grid_x = ball_x / (BRICK_WIDTH + BRICK_GAP);
-    int grid_y = (ball_y - GAME_AREA_TOP - 5) / (BRICK_HEIGHT + BRICK_GAP);
-
-    for (int row = grid_y - 1; row <= grid_y + 1; row++) {
-        for (int col = grid_x - 1; col <= grid_x + 1; col++) {
-            if (row >= 0 && row < BRICK_ROWS && col >= 0 && col < BRICK_COLS) {
-                if (bricks[row][col] && check_brick_collision(row, col)) {
-                    return;
-                }
-            }
-        }
-    }
-}
-
-bool check_brick_collision(int row, int col) {
-    int brick_x = col * (BRICK_WIDTH + BRICK_GAP);
-    int brick_y = GAME_AREA_TOP + row * (BRICK_HEIGHT + BRICK_GAP) + 5;
-
-    if (ball_x + BALL_SIZE >= brick_x && ball_x <= brick_x + BRICK_WIDTH &&
-        ball_y + BALL_SIZE >= brick_y && ball_y <= brick_y + BRICK_HEIGHT) {
-        fillrect(brick_x, brick_y, brick_x + BRICK_WIDTH, brick_y + BRICK_HEIGHT, COLOR_BACKGROUND);
-
-        bricks[row][col] = false;
-        brick_count--;
-
-        score += (5 - row) * 10;
-        draw_score();
-
-        float center_x = brick_x + BRICK_WIDTH / 2;
-        float center_y = brick_y + BRICK_HEIGHT / 2;
-        float ball_center_x = ball_x + BALL_SIZE / 2;
-        float ball_center_y = ball_y + BALL_SIZE / 2;
-        float dx = std::abs(ball_center_x - center_x);
-        float dy = std::abs(ball_center_y - center_y);
-
-        if (dx * BRICK_HEIGHT > dy * BRICK_WIDTH) {
-            ball_dx = -ball_dx;
-        } else {
-            ball_dy = -ball_dy;
-        }
-
-        return true;
-    }
-
-    return false;
-}
-
-bool check_level_complete() {
-    return brick_count == 0;
-}
-
-void next_level() {
-    level++;
-    init_level();
-    draw_screen();
-}
-
-void handle_game_over() {
-    game_state = STATE_GAME_OVER;
-    show_game_over();
-}
-
-void show_menu() {
-    cls();
-    background(COLOR_BACKGROUND);
-
-    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
-    auto style_white = *ui::Theme::getInstance()->fg_light;
-    auto style_green = *ui::Theme::getInstance()->fg_green;
-    auto style_red = *ui::Theme::getInstance()->fg_red;
-
-    painter.draw_string({0, 40}, style_yellow, "* * * BREAKOUT * * *");
-    painter.draw_string({0, 70}, style_white, "========================");
-    painter.draw_string({0, 120}, style_green, "| ROTARY: MOVE PADDLE  |");
-    painter.draw_string({0, 150}, style_green, "| SELECT: START/LAUNCH |");
-    painter.draw_string({0, 190}, style_white, "========================");
-    painter.draw_string({24, 230}, style_red, "* PRESS SELECT *");
-}
-
-void show_game_over() {
-    cls();
-    background(COLOR_BACKGROUND);
-
-    auto style_red = *ui::Theme::getInstance()->fg_red;
-    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
-    auto style_green = *ui::Theme::getInstance()->fg_green;
-
-    painter.draw_string({72, 120}, style_red, "GAME OVER");
-    painter.draw_string({12, 160}, style_yellow, "FINAL SCORE: " + std::to_string(score));
-    painter.draw_string({0, 200}, style_green, "PRESS SELECT TO RESTART");
-
-    wait(1);
-}
-
-void reset_game() {
-    level = 1;
-    score = 0;
-    lives = 3;
-    game_state = STATE_PLAYING;
-    init_level();
-    draw_screen();
-}
-
-int main() {
-    if (!initialized) {
-        initialized = true;
-        game_timer.attach(&game_timer_check, 1.0 / 60.0);
-        init_game();
-    }
-
-    while (1) {
-        if (but_SELECT && game_state == STATE_MENU) {
-            game_state = STATE_PLAYING;
-            reset_game();
-        }
-
-        if (but_SELECT && game_state == STATE_GAME_OVER) {
-            reset_game();
-        }
-
-        if (but_SELECT && game_state == STATE_PLAYING && ball_attached) {
-            launch_ball();
-        }
-
-        if (but_LEFT && game_state == STATE_PLAYING) {
-            move_paddle_left();
-        }
-
-        if (but_RIGHT && game_state == STATE_PLAYING) {
-            move_paddle_right();
-        }
-    }
-}

firmware/application/external/breakout/main.cpp

@@ -20,13 +20,13 @@ void initialize_app(ui::NavigationView& nav) {
 extern "C" {
 
 __attribute__((section(".external_app.app_breakout.application_information"), used)) application_information_t _application_information_breakout = {
-    /*.memory_location = */ (uint8_t*)0x00000000,  // will be filled at compile time
-    /*.externalAppEntry = */ ui::external_app::breakout::initialize_app,
-    /*.header_version = */ CURRENT_HEADER_VERSION,
-    /*.app_version = */ VERSION_MD5,
+    (uint8_t*)0x00000000,
+    ui::external_app::breakout::initialize_app,
+    CURRENT_HEADER_VERSION,
+    VERSION_MD5,
 
-    /*.app_name = */ "Breakout",
-    /*.bitmap_data = */ {
+    "Breakout",
+    {
         0x00,
         0x00,
         0x7F,
@@ -60,11 +60,11 @@ __attribute__((section(".external_app.app_breakout.application_information"), us
         0xF7,
         0xF7,
     },
-    /*.icon_color = */ ui::Color::green().v,
-    /*.menu_location = */ app_location_t::GAMES,
-    /*.desired_menu_position = */ -1,
+    ui::Color::green().v,
+    app_location_t::GAMES,
+    -1,
 
-    /*.m4_app_tag = portapack::spi_flash::image_tag_none */ {0, 0, 0, 0},
-    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+    {0, 0, 0, 0},
+    0x00000000,
 };
-}
+}  // namespace ui::external_app::breakout

firmware/application/external/breakout/mbed.h

@@ -1,105 +0,0 @@
-/*
- * ------------------------------------------------------------
- * |  Made by RocketGod                                       |
- * |  Find me at https://betaskynet.com                       |
- * |  Argh matey!                                             |
- * ------------------------------------------------------------
- */
-
-#ifndef __UI_mbed_H__
-#define __UI_mbed_H__
-
-using Callback = void (*)(void);
-
-#define wait_us(x) (void)0
-#define wait(x) chThdSleepMilliseconds(x * 1000)
-#define PullUp 1
-
-#include "ui_navigation.hpp"
-
-enum {
-    dp0,
-    dp1,
-    dp2,
-    dp3,
-    dp4,
-    dp5,
-    dp6,
-    dp7,
-    dp8,
-    dp9,
-    dp10,
-    dp11,
-    dp12,
-    dp13,
-    dp14,
-    dp15,
-    dp16,
-    dp17,
-    dp18,
-    dp19,
-    dp20,
-    dp21,
-    dp22,
-    dp23,
-    dp24,
-    dp25,
-};
-
-static bool but_RIGHT;
-static bool but_LEFT;
-static bool but_SELECT;
-
-class Timer {
-   public:
-    Timer() { (void)0; };
-    void reset() { (void)0; };
-    void start() { (void)0; }
-    uint32_t read_ms() { return 1000; };
-
-   private:
-};
-
-static Callback game_update_callback;
-static uint32_t game_update_timeout;
-static uint32_t game_update_counter;
-
-static void check_game_timer() {
-    if (game_update_callback) {
-        if (++game_update_counter >= game_update_timeout) {
-            game_update_counter = 0;
-            game_update_callback();
-        }
-    }
-}
-
-class Ticker {
-   public:
-    Ticker() { (void)0; };
-
-    void attach(Callback func, double delay_sec) {
-        game_update_callback = func;
-        game_update_timeout = delay_sec * 60;
-    }
-
-    void detach() {
-        game_update_callback = nullptr;
-    }
-
-   private:
-};
-
-static Callback button_callback;
-
-class InterruptIn {
-   public:
-    InterruptIn(int reg) {
-        (void)reg;
-    };
-    void fall(Callback func) { button_callback = func; };
-    void mode(int v) { (void)v; };
-
-   private:
-};
-
-#endif /*__UI_mbed_H__*/

firmware/application/external/breakout/ui_breakout.cpp

@@ -10,10 +10,477 @@
 
 namespace ui::external_app::breakout {
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Weffc++"
-#include "breakout.cpp"
-#pragma GCC diagnostic pop
+Ticker game_timer;
+
+int paddle_x = (SCREEN_WIDTH - PADDLE_WIDTH) / 2;
+float ball_x = SCREEN_WIDTH / 2;
+float ball_y = GAME_AREA_BOTTOM - PADDLE_HEIGHT - BALL_SIZE - 1;
+float ball_dx = 1.5f;
+float ball_dy = -2.0f;
+int score = 0;
+int lives = 3;
+int level = 1;
+int game_state = STATE_MENU;
+bool initialized = false;
+bool ball_attached = true;
+unsigned int brick_count = 0;
+
+bool menu_initialized = false;
+bool blink_state = true;
+uint32_t blink_counter = 0;
+int16_t prompt_x = 0;
+
+bool gameover_initialized = false;
+bool gameover_blink_state = true;
+uint32_t gameover_blink_counter = 0;
+int16_t restart_x = 0;
+
+bool bricks[BRICK_ROWS][BRICK_COLS];
+int brick_colors[BRICK_ROWS];
+
+const Color pp_colors[] = {
+    Color::white(),
+    Color::blue(),
+    Color::yellow(),
+    Color::purple(),
+    Color::green(),
+    Color::red(),
+    Color::magenta(),
+    Color::orange(),
+    Color::black(),
+};
+
+Painter painter;
+
+bool but_RIGHT = false;
+bool but_LEFT = false;
+bool but_SELECT = false;
+
+static Callback game_update_callback = nullptr;
+static uint32_t game_update_timeout = 0;
+static uint32_t game_update_counter = 0;
+
+void cls() {
+    painter.fill_rectangle({0, 0, portapack::display.width(), portapack::display.height()}, Color::black());
+}
+
+void background(int color) {
+    (void)color;
+}
+
+void fillrect(int x1, int y1, int x2, int y2, int color) {
+    painter.fill_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
+}
+
+void rect(int x1, int y1, int x2, int y2, int color) {
+    painter.draw_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
+}
+
+void check_game_timer() {
+    if (game_update_callback) {
+        if (++game_update_counter >= game_update_timeout) {
+            game_update_counter = 0;
+            game_update_callback();
+        }
+    }
+}
+
+void Ticker::attach(Callback func, double delay_sec) {
+    game_update_callback = func;
+    game_update_timeout = delay_sec * 60;
+}
+
+void Ticker::detach() {
+    game_update_callback = nullptr;
+}
+
+void game_timer_check() {
+    if (game_state == STATE_PLAYING) {
+        update_game();
+    } else if (game_state == STATE_MENU) {
+        show_menu();
+    } else if (game_state == STATE_GAME_OVER) {
+        show_game_over();
+    }
+}
+
+void init_game() {
+    paddle_x = (SCREEN_WIDTH - PADDLE_WIDTH) / 2;
+    score = 0;
+    lives = 3;
+    level = 1;
+
+    brick_colors[0] = Red;
+    brick_colors[1] = Orange;
+    brick_colors[2] = Yellow;
+    brick_colors[3] = Green;
+    brick_colors[4] = Purple;
+
+    init_level();
+
+    game_state = STATE_MENU;
+    menu_initialized = false;
+    blink_state = true;
+    blink_counter = 0;
+}
+
+void init_level() {
+    ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
+    ball_y = GAME_AREA_BOTTOM - PADDLE_HEIGHT - BALL_SIZE - 1;
+
+    float speed_multiplier = (level == 1) ? 1.0f : 1.0f + ((level - 1) * BALL_SPEED_INCREASE);
+    ball_dx = (ball_dx > 0 ? 1.5f : -1.5f) * speed_multiplier;
+    ball_dy = -2.0f * speed_multiplier;
+
+    ball_attached = true;
+
+    brick_count = 0;
+    for (int row = 0; row < BRICK_ROWS; row++) {
+        for (int col = 0; col < BRICK_COLS; col++) {
+            bricks[row][col] = true;
+            brick_count++;
+        }
+    }
+}
+
+void draw_screen() {
+    cls();
+    background(COLOR_BACKGROUND);
+
+    draw_borders();
+    draw_bricks();
+    draw_paddle();
+    draw_ball();
+    draw_score();
+    draw_lives();
+    draw_level();
+}
+
+void draw_borders() {
+    rect(0, GAME_AREA_TOP - 1, SCREEN_WIDTH, GAME_AREA_TOP, COLOR_BORDER);
+}
+
+void draw_bricks() {
+    for (int row = 0; row < BRICK_ROWS; row++) {
+        for (int col = 0; col < BRICK_COLS; col++) {
+            if (bricks[row][col]) {
+                int x = col * (BRICK_WIDTH + BRICK_GAP);
+                int y = GAME_AREA_TOP + row * (BRICK_HEIGHT + BRICK_GAP) + 5;
+                fillrect(x, y, x + BRICK_WIDTH, y + BRICK_HEIGHT, brick_colors[row]);
+                rect(x, y, x + BRICK_WIDTH, y + BRICK_HEIGHT, Black);
+            }
+        }
+    }
+}
+
+void draw_paddle() {
+    fillrect(paddle_x, PADDLE_Y, paddle_x + PADDLE_WIDTH, PADDLE_Y + PADDLE_HEIGHT, COLOR_PADDLE);
+}
+
+void draw_ball() {
+    fillrect(ball_x, ball_y, ball_x + BALL_SIZE, ball_y + BALL_SIZE, COLOR_BALL);
+}
+
+void draw_score() {
+    auto style = *ui::Theme::getInstance()->fg_green;
+    painter.draw_string({5, 10}, style, "Score: " + std::to_string(score));
+}
+
+void draw_lives() {
+    auto style = *ui::Theme::getInstance()->fg_red;
+    painter.draw_string({5, 30}, style, "Lives: " + std::to_string(lives));
+}
+
+void draw_level() {
+    auto style = *ui::Theme::getInstance()->fg_yellow;
+    painter.draw_string({80, 30}, style, "Level: " + std::to_string(level));
+}
+
+void move_paddle_left() {
+    if (paddle_x > 0) {
+        fillrect(paddle_x, PADDLE_Y, paddle_x + PADDLE_WIDTH, PADDLE_Y + PADDLE_HEIGHT, COLOR_BACKGROUND);
+        if (ball_attached) {
+            fillrect(ball_x, ball_y, ball_x + BALL_SIZE, ball_y + BALL_SIZE, COLOR_BACKGROUND);
+        }
+
+        paddle_x -= 10;
+        if (paddle_x < 0) paddle_x = 0;
+
+        if (ball_attached) {
+            ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
+        }
+
+        draw_paddle();
+        if (ball_attached) {
+            draw_ball();
+        }
+    }
+}
+
+void move_paddle_right() {
+    if (paddle_x < SCREEN_WIDTH - PADDLE_WIDTH) {
+        fillrect(paddle_x, PADDLE_Y, paddle_x + PADDLE_WIDTH, PADDLE_Y + PADDLE_HEIGHT, COLOR_BACKGROUND);
+        if (ball_attached) {
+            fillrect(ball_x, ball_y, ball_x + BALL_SIZE, ball_y + BALL_SIZE, COLOR_BACKGROUND);
+        }
+
+        paddle_x += 10;
+        if (paddle_x > SCREEN_WIDTH - PADDLE_WIDTH) paddle_x = SCREEN_WIDTH - PADDLE_WIDTH;
+
+        if (ball_attached) {
+            ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
+        }
+
+        draw_paddle();
+        if (ball_attached) {
+            draw_ball();
+        }
+    }
+}
+
+void launch_ball() {
+    if (ball_attached) {
+        ball_attached = false;
+        ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
+        ball_y = GAME_AREA_BOTTOM - PADDLE_HEIGHT - BALL_SIZE - 1;
+        float speed_multiplier = (level == 1) ? 1.0f : 1.0f + ((level - 1) * BALL_SPEED_INCREASE);
+        ball_dx = 1.5f * speed_multiplier;
+        ball_dy = -2.0f * speed_multiplier;
+    }
+}
+
+void update_game() {
+    if (ball_attached) {
+        return;
+    }
+
+    fillrect(ball_x, ball_y, ball_x + BALL_SIZE, ball_y + BALL_SIZE, COLOR_BACKGROUND);
+
+    float next_ball_y = ball_y + ball_dy;
+    if (next_ball_y > GAME_AREA_BOTTOM) {
+        lives--;
+        draw_lives();
+        if (lives <= 0) {
+            handle_game_over();
+        } else {
+            ball_attached = true;
+            ball_x = paddle_x + (PADDLE_WIDTH / 2) - (BALL_SIZE / 2);
+            ball_y = GAME_AREA_BOTTOM - PADDLE_HEIGHT - BALL_SIZE - 1;
+            draw_ball();
+        }
+        return;
+    }
+
+    ball_x += ball_dx;
+    ball_y = next_ball_y;
+
+    if (ball_x < 0) {
+        ball_x = 0;
+        ball_dx = -ball_dx;
+    } else if (ball_x > SCREEN_WIDTH - BALL_SIZE) {
+        ball_x = SCREEN_WIDTH - BALL_SIZE;
+        ball_dx = -ball_dx;
+    }
+
+    if (ball_y < GAME_AREA_TOP) {
+        ball_y = GAME_AREA_TOP;
+        ball_dy = -ball_dy;
+    }
+
+    if (ball_y + BALL_SIZE >= PADDLE_Y && ball_y <= PADDLE_Y + PADDLE_HEIGHT) {
+        if (ball_x + BALL_SIZE >= paddle_x && ball_x <= paddle_x + PADDLE_WIDTH) {
+            ball_y = PADDLE_Y - BALL_SIZE;
+            float hit_position = (ball_x + (BALL_SIZE / 2)) - paddle_x;
+            float angle = (hit_position / PADDLE_WIDTH) - 0.5f;
+            ball_dx = angle * 4.0f;
+            if (ball_dx > -0.5f && ball_dx < 0.5f) {
+                ball_dx = (ball_dx > 0) ? 0.5f : -0.5f;
+            }
+            ball_dy = -ball_dy;
+        }
+    }
+
+    check_collisions();
+
+    draw_ball();
+
+    if (check_level_complete()) {
+        next_level();
+    }
+}
+
+void check_collisions() {
+    int grid_x = ball_x / (BRICK_WIDTH + BRICK_GAP);
+    int grid_y = (ball_y - GAME_AREA_TOP - 5) / (BRICK_HEIGHT + BRICK_GAP);
+
+    for (int row = grid_y - 1; row <= grid_y + 1; row++) {
+        for (int col = grid_x - 1; col <= grid_x + 1; col++) {
+            if (row >= 0 && row < BRICK_ROWS && col >= 0 && col < BRICK_COLS) {
+                if (bricks[row][col] && check_brick_collision(row, col)) {
+                    return;
+                }
+            }
+        }
+    }
+}
+
+bool check_brick_collision(int row, int col) {
+    int brick_x = col * (BRICK_WIDTH + BRICK_GAP);
+    int brick_y = GAME_AREA_TOP + row * (BRICK_HEIGHT + BRICK_GAP) + 5;
+
+    if (ball_x + BALL_SIZE >= brick_x && ball_x <= brick_x + BRICK_WIDTH &&
+        ball_y + BALL_SIZE >= brick_y && ball_y <= brick_y + BRICK_HEIGHT) {
+        fillrect(brick_x, brick_y, brick_x + BRICK_WIDTH, brick_y + BRICK_HEIGHT, COLOR_BACKGROUND);
+
+        bricks[row][col] = false;
+        brick_count--;
+
+        score += (5 - row) * 10;
+        draw_score();
+
+        float center_x = brick_x + BRICK_WIDTH / 2;
+        float center_y = brick_y + BRICK_HEIGHT / 2;
+        float ball_center_x = ball_x + BALL_SIZE / 2;
+        float ball_center_y = ball_y + BALL_SIZE / 2;
+        float dx = std::abs(ball_center_x - center_x);
+        float dy = std::abs(ball_center_y - center_y);
+
+        if (dx * BRICK_HEIGHT > dy * BRICK_WIDTH) {
+            ball_dx = -ball_dx;
+        } else {
+            ball_dy = -ball_dy;
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+bool check_level_complete() {
+    return brick_count == 0;
+}
+
+void next_level() {
+    level++;
+    init_level();
+    draw_screen();
+}
+
+void handle_game_over() {
+    game_state = STATE_GAME_OVER;
+    gameover_initialized = false;
+    show_game_over();
+}
+
+void init_menu() {
+    cls();
+    background(COLOR_BACKGROUND);
+
+    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
+    auto style_blue = *ui::Theme::getInstance()->fg_blue;
+    auto style_cyan = *ui::Theme::getInstance()->fg_cyan;
+
+    int16_t screen_width = 240;
+    int16_t title_x = (screen_width - 17 * 8) / 2;
+    int16_t divider_width = 24 * 8;
+    int16_t divider_x = (screen_width - divider_width) / 2;
+    int16_t instruction_width = 22 * 8;
+    int16_t instruction_x = (screen_width - instruction_width) / 2;
+    int16_t prompt_width = 16 * 8;
+    prompt_x = (screen_width - prompt_width) / 2;
+
+    painter.fill_rectangle({0, 30, screen_width, 30}, Color::black());
+    painter.draw_string({title_x + 2, 42}, style_yellow, "*** BREAKOUT ***");
+    painter.draw_string({divider_x, 70}, style_blue, "========================");
+    painter.fill_rectangle({instruction_x - 5, 110, instruction_width + 10, 70}, Color::black());
+    painter.draw_rectangle({instruction_x - 5, 110, instruction_width + 10, 70}, Color::white());
+    painter.draw_string({instruction_x, 120}, style_cyan, "  ROTARY: MOVE PADDLE");
+    painter.draw_string({instruction_x, 150}, style_cyan, " SELECT: START/LAUNCH");
+    painter.draw_string({divider_x, 190}, style_blue, "========================");
+
+    menu_initialized = true;
+}
+
+void show_menu() {
+    if (!menu_initialized) {
+        init_menu();
+    }
+
+    auto style_red = *ui::Theme::getInstance()->fg_red;
+
+    if (++blink_counter >= 30) {
+        blink_counter = 0;
+        blink_state = !blink_state;
+
+        painter.fill_rectangle({prompt_x - 2, 228, 16 * 8 + 4, 20}, Color::black());
+
+        if (blink_state) {
+            painter.draw_string({prompt_x, 230}, style_red, "* PRESS SELECT *");
+        }
+    }
+}
+
+void init_game_over() {
+    cls();
+    background(COLOR_BACKGROUND);
+
+    auto style_red = *ui::Theme::getInstance()->fg_red;
+    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
+
+    int16_t screen_width = 240;
+    int16_t title_width = 9 * 8;
+    int16_t title_x = (screen_width - title_width) / 2;
+    int16_t score_text_width = (16 + std::to_string(score).length()) * 8;
+    int16_t score_x = (screen_width - score_text_width) / 2;
+
+    painter.draw_rectangle({20, 80, screen_width - 40, 160}, Color::red());
+    painter.draw_rectangle({22, 82, screen_width - 44, 156}, Color::white());
+
+    painter.draw_string({title_x, 100}, style_red, "GAME OVER");
+
+    painter.fill_rectangle({40, 140, screen_width - 80, 30}, Color::black());
+    painter.draw_rectangle({40, 140, screen_width - 80, 30}, Color::yellow());
+    painter.draw_string({score_x, 150}, style_yellow, " FINAL SCORE: " + std::to_string(score));
+
+    int16_t restart_width = 12 * 8;
+    restart_x = (screen_width - restart_width) / 2;
+
+    gameover_initialized = true;
+    gameover_blink_state = true;
+    gameover_blink_counter = 0;
+}
+
+void show_game_over() {
+    if (!gameover_initialized) {
+        init_game_over();
+    }
+
+    auto style_green = *ui::Theme::getInstance()->fg_green;
+
+    if (++gameover_blink_counter >= 30) {
+        gameover_blink_counter = 0;
+        gameover_blink_state = !gameover_blink_state;
+
+        painter.fill_rectangle({restart_x - 2, 198, 12 * 8 + 4, 20}, Color::black());
+
+        if (gameover_blink_state) {
+            painter.draw_string({restart_x, 200}, style_green, "PRESS SELECT");
+        }
+    }
+}
+
+void reset_game() {
+    level = 1;
+    score = 0;
+    lives = 3;
+    game_state = STATE_PLAYING;
+    init_level();
+    draw_screen();
+    gameover_initialized = false;
+    gameover_blink_state = true;
+    gameover_blink_counter = 0;
+}
 
 BreakoutView::BreakoutView(NavigationView& nav)
     : nav_{nav} {
@@ -53,6 +520,10 @@ bool BreakoutView::on_encoder(const EncoderEvent delta) {
 }
 
 bool BreakoutView::on_key(const KeyEvent key) {
+    but_SELECT = (key == KeyEvent::Select);
+    but_LEFT = (key == KeyEvent::Left);
+    but_RIGHT = (key == KeyEvent::Right);
+
     if (key == KeyEvent::Select) {
         if (game_state == STATE_MENU) {
             game_state = STATE_PLAYING;

firmware/application/external/breakout/ui_breakout.hpp

@@ -9,25 +9,128 @@
 #ifndef __UI_BREAKOUT_H__
 #define __UI_BREAKOUT_H__
 
+#include "ui.hpp"
 #include "ui_navigation.hpp"
 #include "event_m0.hpp"
 #include "message.hpp"
 #include "irq_controls.hpp"
 #include "random.hpp"
 #include "lpc43xx_cpp.hpp"
-#include "limits.h"
 #include "ui_widget.hpp"
 
 namespace ui::external_app::breakout {
 
+enum {
+    White,
+    Blue,
+    Yellow,
+    Purple,
+    Green,
+    Red,
+    Maroon,
+    Orange,
+    Black,
+};
+
+extern const Color pp_colors[];
+extern Painter painter;
+extern bool but_RIGHT;
+extern bool but_LEFT;
+extern bool but_SELECT;
+
+void cls();
+void background(int color);
+void fillrect(int x1, int y1, int x2, int y2, int color);
+void rect(int x1, int y1, int x2, int y2, int color);
+
+#define wait(x) chThdSleepMilliseconds(x * 1000)
+
+using Callback = void (*)(void);
+
+void check_game_timer();
+
+class Ticker {
+   public:
+    Ticker() = default;
+    void attach(Callback func, double delay_sec);
+    void detach();
+};
+
+#define SCREEN_WIDTH 240
+#define SCREEN_HEIGHT 320
+#define PADDLE_WIDTH 40
+#define PADDLE_HEIGHT 10
+#define BALL_SIZE 8
+#define BRICK_WIDTH 20
+#define BRICK_HEIGHT 10
+#define BRICK_ROWS 5
+#define BRICK_COLS 10
+#define BRICK_GAP 2
+#define GAME_AREA_TOP 50
+#define GAME_AREA_BOTTOM 310
+#define PADDLE_Y (GAME_AREA_BOTTOM - PADDLE_HEIGHT)
+#define BALL_SPEED_INCREASE 0.1f
+
+#define STATE_MENU 0
+#define STATE_PLAYING 1
+#define STATE_GAME_OVER 3
+
+#define COLOR_BACKGROUND Black
+#define COLOR_PADDLE Blue
+#define COLOR_BALL White
+#define COLOR_BORDER White
+#define COLOR_BRICK_COLORS \
+    { Red, Orange, Yellow, Green, Purple }
+
+extern Ticker game_timer;
+
+extern int paddle_x;
+extern float ball_x;
+extern float ball_y;
+extern float ball_dx;
+extern float ball_dy;
+extern int score;
+extern int lives;
+extern int level;
+extern int game_state;
+extern bool initialized;
+extern bool ball_attached;
+extern unsigned int brick_count;
+extern bool bricks[BRICK_ROWS][BRICK_COLS];
+extern int brick_colors[BRICK_ROWS];
+
+void game_timer_check();
+void init_game();
+void init_level();
+void draw_screen();
+void draw_bricks();
+void draw_paddle();
+void draw_ball();
+void draw_score();
+void draw_lives();
+void draw_level();
+void draw_borders();
+void move_paddle_left();
+void move_paddle_right();
+void launch_ball();
+void update_game();
+void check_collisions();
+bool check_brick_collision(int row, int col);
+void handle_game_over();
+void show_menu();
+void show_game_over();
+bool check_level_complete();
+void next_level();
+void reset_game();
+
 class BreakoutView : public View {
    public:
     BreakoutView(NavigationView& nav);
     void on_show() override;
 
-    std::string title() const override { return "Breakout"; };
+    std::string title() const override { return "Breakout"; }
 
-    void focus() override { dummy.focus(); };
+    void focus() override { dummy.focus(); }
     void paint(Painter& painter) override;
     void frame_sync();
     bool on_encoder(const EncoderEvent event) override;
@@ -50,4 +153,4 @@ class BreakoutView : public View {
 
 }  // namespace ui::external_app::breakout
 
-#endif /*__UI_BREAKOUT_H__*/
+#endif /* __UI_BREAKOUT_H__ */

firmware/application/external/cvs_spam/cvs_spam.cpp

@@ -81,8 +81,6 @@ void CVSSpamView::start_tx(const uint32_t id) {
         return;
     }
 
-    const uint32_t sample_rate = 250000;
-
     current_file = cvsfiles_dir / file_list[id].filename();
 
     File capture_file;
@@ -99,20 +97,13 @@ void CVSSpamView::start_tx(const uint32_t id) {
         return;
     }
 
-    auto metadata_path = get_metadata_path(current_file);
-    auto metadata = read_metadata_file(metadata_path);
-    if (!metadata) {
-        metadata = capture_metadata{transmitter_model.target_frequency(), sample_rate};
-    }
-
-    auto file_size = capture_file.size();
     capture_file.close();
 
     replay_thread.reset();
     transmitter_model.disable();
     ready_signal = false;
 
-    baseband::set_sample_rate(metadata->sample_rate, get_oversample_rate(metadata->sample_rate));
+    baseband::set_sample_rate(SAMPLE_RATE, get_oversample_rate(SAMPLE_RATE));
 
     auto reader = std::make_unique<FileConvertReader>();
     if (auto error = reader->open(current_file)) {
@@ -120,10 +111,7 @@ void CVSSpamView::start_tx(const uint32_t id) {
                    "Cannot read C16 data.\n"
                    "Check file format/perms.\n"
                    "Rate: " +
-                       to_string_dec_uint(metadata->sample_rate) +
-                       "\n"
-                       "Size: " +
-                       to_string_dec_uint(file_size) +
+                       to_string_dec_uint(SAMPLE_RATE) +
                        "\n"
                        "Error: " +
                        std::to_string(static_cast<uint32_t>(error)));
@@ -132,9 +120,9 @@ void CVSSpamView::start_tx(const uint32_t id) {
 
     progressbar.set_value(0);
 
-    transmitter_model.set_sampling_rate(get_actual_sample_rate(metadata->sample_rate));
-    transmitter_model.set_baseband_bandwidth(metadata->sample_rate <= 500000 ? 1750000 : 2500000);
-    transmitter_model.set_target_frequency(metadata->center_frequency);
+    transmitter_model.set_sampling_rate(get_actual_sample_rate(SAMPLE_RATE));
+    transmitter_model.set_baseband_bandwidth(SAMPLE_RATE <= 500000 ? 1750000 : 2500000);
+    transmitter_model.set_target_frequency(TARGET_FREQUENCY);
     transmitter_model.enable();
 
     chThdSleepMilliseconds(100);
@@ -164,7 +152,6 @@ void CVSSpamView::start_random_tx() {
     lfsr_v = lfsr_iterate(lfsr_v);
     size_t random_index = lfsr_v % file_list.size();
 
-    const uint32_t sample_rate = 250000;
     current_file = cvsfiles_dir / file_list[random_index].filename();
 
     File capture_file;
@@ -174,19 +161,13 @@ void CVSSpamView::start_random_tx() {
         return;
     }
 
-    auto metadata_path = get_metadata_path(current_file);
-    auto metadata = read_metadata_file(metadata_path);
-    if (!metadata) {
-        metadata = capture_metadata{transmitter_model.target_frequency(), sample_rate};
-    }
-
     capture_file.close();
 
     replay_thread.reset();
     transmitter_model.disable();
     ready_signal = false;
 
-    baseband::set_sample_rate(metadata->sample_rate, get_oversample_rate(metadata->sample_rate));
+    baseband::set_sample_rate(SAMPLE_RATE, get_oversample_rate(SAMPLE_RATE));
 
     auto reader = std::make_unique<FileConvertReader>();
     if (auto error = reader->open(current_file)) {
@@ -196,9 +177,9 @@ void CVSSpamView::start_random_tx() {
 
     progressbar.set_value(0);
 
-    transmitter_model.set_sampling_rate(get_actual_sample_rate(metadata->sample_rate));
-    transmitter_model.set_baseband_bandwidth(metadata->sample_rate <= 500000 ? 1750000 : 2500000);
-    transmitter_model.set_target_frequency(metadata->center_frequency);
+    transmitter_model.set_sampling_rate(get_actual_sample_rate(SAMPLE_RATE));
+    transmitter_model.set_baseband_bandwidth(SAMPLE_RATE <= 500000 ? 1750000 : 2500000);
+    transmitter_model.set_target_frequency(TARGET_FREQUENCY);
     transmitter_model.enable();
 
     chThdSleepMilliseconds(100);

firmware/application/external/cvs_spam/cvs_spam.hpp

@@ -16,6 +16,9 @@ using namespace portapack;
 
 namespace ui::external_app::cvs_spam {
 
+constexpr uint32_t SAMPLE_RATE = 250000;
+constexpr uint64_t TARGET_FREQUENCY = 433920000;
+
 class CVSSpamView : public View {
    public:
     explicit CVSSpamView(NavigationView& nav);

firmware/application/external/debug_pmem/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 "ui_debug_pmem.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::debug_pmem {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<DebugDumpView>();
+}
+}  // namespace ui::external_app::debug_pmem
+
+extern "C" {
+
+__attribute__((section(".external_app.app_debug_pmem.application_information"), used)) application_information_t _application_information_debug_pmem = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::debug_pmem::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "DebugPMem",
+    /*.bitmap_data = */ {
+        0x54,
+        0x15,
+        0x54,
+        0x15,
+        0xFF,
+        0x7F,
+        0xFC,
+        0x1F,
+        0xFF,
+        0x7F,
+        0xCC,
+        0x19,
+        0xAF,
+        0x7A,
+        0x6C,
+        0x1B,
+        0xEF,
+        0x7B,
+        0xEC,
+        0x1B,
+        0xFF,
+        0x7F,
+        0xFC,
+        0x1F,
+        0xFF,
+        0x7F,
+        0x54,
+        0x15,
+        0x54,
+        0x15,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::cyan().v,
+    /*.menu_location = */ app_location_t::DEBUG,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_none */ {0, 0, 0, 0},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/debug_pmem/ui_debug_pmem.cpp

@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2018 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_debug_pmem.hpp"
+
+namespace ui::external_app::debug_pmem {
+
+// Dump pmem, receiver and transmitter models internals in human readable format
+bool DebugDumpView::debug_dump_func() {
+    std::string debug_dir = "DEBUG";
+    std::filesystem::path filename{};
+    File pmem_dump_file{};
+    // create new dump file name and DEBUG directory
+    ensure_directory(debug_dir);
+    filename = next_filename_matching_pattern(debug_dir + "/DEBUG_DUMP_????.TXT");
+    if (filename.empty()) {
+        dump_output.set("COULD NOT GET DUMP NAME !");
+        dump_output.set_style(ui::Theme::getInstance()->fg_red);
+        return false;
+    }
+    // dump data fo filename
+    auto error = pmem_dump_file.create(filename);
+    if (error) {
+        dump_output.set("ERROR DUMPING " + filename.filename().string() + " !");
+        dump_output.set_style(ui::Theme::getInstance()->fg_red);
+        return false;
+    }
+    pmem_dump_file.write_line("FW version: " VERSION_STRING);
+    pmem_dump_file.write_line("Ext APPS version req'd: 0x" + to_string_hex(VERSION_MD5));
+    pmem_dump_file.write_line("GCC version: " + to_string_dec_int(__GNUC__) + "." + to_string_dec_int(__GNUC_MINOR__) + "." + to_string_dec_int(__GNUC_PATCHLEVEL__));
+
+    // firmware checksum
+    pmem_dump_file.write_line("Firmware calculated checksum: 0x" + to_string_hex(simple_checksum(FLASH_STARTING_ADDRESS, FLASH_ROM_SIZE), 8));
+
+    // write persistent memory
+    pmem_dump_file.write_line("\n[Persistent Memory]");
+
+    // full variables
+    pmem_dump_file.write_line("structure_version: 0x" + to_string_hex(get_data_structure_version(), 8));
+    pmem_dump_file.write_line("target_frequency: " + to_string_dec_int(target_frequency()));
+    pmem_dump_file.write_line("correction_ppb: " + to_string_dec_int(correction_ppb()));
+    pmem_dump_file.write_line("modem_def_index: " + to_string_dec_uint(get_modem_def_index()));
+    pmem_dump_file.write_line("serial_format.data_bit: " + to_string_dec_uint(serial_format().data_bits));
+    pmem_dump_file.write_line("serial_format.parity: " + to_string_dec_uint(serial_format().parity));
+    pmem_dump_file.write_line("serial_format.stop_bits: " + to_string_dec_uint(serial_format().stop_bits));
+    pmem_dump_file.write_line("serial_format.bit_order: " + to_string_dec_uint(serial_format().bit_order));
+    pmem_dump_file.write_line("modem_bw: " + to_string_dec_int(modem_bw()));
+    pmem_dump_file.write_line("afsk_mark_freq: " + to_string_dec_int(afsk_mark_freq()));
+    pmem_dump_file.write_line("afsk_space_freq: " + to_string_dec_int(afsk_space_freq()));
+    pmem_dump_file.write_line("modem_baudrate: " + to_string_dec_int(modem_baudrate()));
+    pmem_dump_file.write_line("modem_repeat: " + to_string_dec_int(modem_repeat()));
+    pmem_dump_file.write_line("pocsag_last_address: " + to_string_dec_uint(pocsag_last_address()));
+    pmem_dump_file.write_line("pocsag_ignore_address: " + to_string_dec_uint(pocsag_ignore_address()));
+    pmem_dump_file.write_line("tone_mix: " + to_string_dec_uint(tone_mix()));
+    pmem_dump_file.write_line("hardware_config: " + to_string_dec_uint(config_cpld()));
+    pmem_dump_file.write_line("recon_config: 0x" + to_string_hex(get_recon_config(), 16));
+    pmem_dump_file.write_line("recon_repeat_nb: " + to_string_dec_int(recon_repeat_nb()));
+    pmem_dump_file.write_line("recon_repeat_gain: " + to_string_dec_int(recon_repeat_gain()));
+    pmem_dump_file.write_line("recon_repeat_delay: " + to_string_dec_int(recon_repeat_delay()));
+    pmem_dump_file.write_line("converter: " + to_string_dec_int(config_converter()));
+    pmem_dump_file.write_line("updown_converter: " + to_string_dec_int(config_updown_converter()));
+    pmem_dump_file.write_line("updown_frequency_rx_correction: " + to_string_dec_int(config_freq_rx_correction_updown()));
+    pmem_dump_file.write_line("updown_frequency_tx_correction: " + to_string_dec_int(config_freq_tx_correction_updown()));
+    pmem_dump_file.write_line("lcd_inverted_mode: " + to_string_dec_uint(config_lcd_inverted_mode()));
+    pmem_dump_file.write_line("converter_frequency_offset: " + to_string_dec_int(config_converter_freq()));
+    pmem_dump_file.write_line("frequency_rx_correction: " + to_string_dec_uint(config_freq_rx_correction()));
+    pmem_dump_file.write_line("frequency_tx_correction: " + to_string_dec_uint(config_freq_tx_correction()));
+    pmem_dump_file.write_line("encoder_dial_sensitivity: " + to_string_dec_uint(encoder_dial_sensitivity()));
+    pmem_dump_file.write_line("encoder_rate_multiplier: " + to_string_dec_uint(encoder_rate_multiplier()));
+    pmem_dump_file.write_line("encoder_dial_direction: " + to_string_dec_uint(encoder_dial_direction()));  // 0 = normal, 1 = reverse
+    pmem_dump_file.write_line("config_mode_storage: 0x" + to_string_hex(config_mode_storage_direct(), 8));
+    pmem_dump_file.write_line("dst_config: 0x" + to_string_hex((uint32_t)config_dst().v, 8));
+    pmem_dump_file.write_line("fake_brightness_level: " + to_string_dec_uint(fake_brightness_level()));
+    pmem_dump_file.write_line("menu_color: 0x" + to_string_hex(menu_color().v, 4));
+    pmem_dump_file.write_line("touchscreen_threshold: " + to_string_dec_uint(touchscreen_threshold()));
+
+    // ui_config bits
+    const auto backlight_timer = portapack::persistent_memory::config_backlight_timer();
+    pmem_dump_file.write_line("ui_config clkout_freq: " + to_string_dec_uint(clkout_freq()));
+    pmem_dump_file.write_line("ui_config backlight_timer.timeout_enabled: " + to_string_dec_uint(backlight_timer.timeout_enabled()));
+    pmem_dump_file.write_line("ui_config backlight_timer.timeout_seconds: " + to_string_dec_uint(backlight_timer.timeout_seconds()));
+    pmem_dump_file.write_line("ui_config show_gui_return_icon: " + to_string_dec_uint(show_gui_return_icon()));
+    pmem_dump_file.write_line("ui_config load_app_settings: " + to_string_dec_uint(load_app_settings()));
+    pmem_dump_file.write_line("ui_config save_app_settings: " + to_string_dec_uint(save_app_settings()));
+    pmem_dump_file.write_line("ui_config disable_touchscreen: " + to_string_dec_uint(disable_touchscreen()));
+    pmem_dump_file.write_line("ui_config hide_clock: " + to_string_dec_uint(hide_clock()));
+    pmem_dump_file.write_line("ui_config clock_with_date: " + to_string_dec_uint(clock_with_date()));
+    pmem_dump_file.write_line("ui_config clkout_enabled: " + to_string_dec_uint(clkout_enabled()));
+    pmem_dump_file.write_line("ui_config apply_fake_brightness: " + to_string_dec_uint(apply_fake_brightness()));
+    pmem_dump_file.write_line("ui_config stealth_mode: " + to_string_dec_uint(stealth_mode()));
+    pmem_dump_file.write_line("ui_config config_login: " + to_string_dec_uint(config_login()));
+    pmem_dump_file.write_line("ui_config config_splash: " + to_string_dec_uint(config_splash()));
+
+    // ui_config2 bits
+    pmem_dump_file.write_line("ui_config2 hide_speaker: " + to_string_dec_uint(ui_hide_speaker()));
+    pmem_dump_file.write_line("ui_config2 hide_converter: " + to_string_dec_uint(ui_hide_converter()));
+    pmem_dump_file.write_line("ui_config2 hide_stealth: " + to_string_dec_uint(ui_hide_stealth()));
+    pmem_dump_file.write_line("ui_config2 hide_camera: " + to_string_dec_uint(ui_hide_camera()));
+    pmem_dump_file.write_line("ui_config2 hide_sleep: " + to_string_dec_uint(ui_hide_sleep()));
+    pmem_dump_file.write_line("ui_config2 hide_bias_tee: " + to_string_dec_uint(ui_hide_bias_tee()));
+    pmem_dump_file.write_line("ui_config2 hide_clock: " + to_string_dec_uint(ui_hide_clock()));
+    pmem_dump_file.write_line("ui_config2 hide_sd_card: " + to_string_dec_uint(ui_hide_sd_card()));
+    pmem_dump_file.write_line("ui_config2 hide_mute: " + to_string_dec_uint(ui_hide_mute()));
+    pmem_dump_file.write_line("ui_config2 hide_fake_brightness: " + to_string_dec_uint(ui_hide_fake_brightness()));
+    pmem_dump_file.write_line("ui_config2 hide_battery_icon: " + to_string_dec_uint(ui_hide_battery_icon()));
+    pmem_dump_file.write_line("ui_config2 hide_numeric_battery: " + to_string_dec_uint(ui_hide_numeric_battery()));
+    pmem_dump_file.write_line("ui_config2 theme_id: " + to_string_dec_uint(ui_theme_id()));
+    pmem_dump_file.write_line("ui_config2 override_batt_calc: " + to_string_dec_uint(ui_override_batt_calc()));
+    pmem_dump_file.write_line("ui_config2 button_repeat_delay: " + to_string_dec_uint(ui_button_repeat_delay()));
+    pmem_dump_file.write_line("ui_config2 button_repeat_speed: " + to_string_dec_uint(ui_button_repeat_speed()));
+    pmem_dump_file.write_line("ui_config2 button_long_press_delay: " + to_string_dec_uint(ui_button_long_press_delay()));
+    pmem_dump_file.write_line("ui_config2 battery_charge_hint: " + to_string_dec_uint(ui_battery_charge_hint()));
+
+    // misc_config bits
+    pmem_dump_file.write_line("misc_config config_audio_mute: " + to_string_dec_int(config_audio_mute()));
+    pmem_dump_file.write_line("misc_config config_speaker_disable: " + to_string_dec_int(config_speaker_disable()));
+    pmem_dump_file.write_line("misc_config config_disable_external_tcxo: " + to_string_dec_uint(config_disable_external_tcxo()));
+    pmem_dump_file.write_line("misc_config config_sdcard_high_speed_io: " + to_string_dec_uint(config_sdcard_high_speed_io()));
+    pmem_dump_file.write_line("misc_config config_disable_config_mode: " + to_string_dec_uint(config_disable_config_mode()));
+    pmem_dump_file.write_line("misc_config beep_on_packets: " + to_string_dec_int(beep_on_packets()));
+
+    // receiver_model
+    pmem_dump_file.write_line("\n[Receiver Model]");
+    pmem_dump_file.write_line("target_frequency: " + to_string_dec_uint(receiver_model.target_frequency()));
+    pmem_dump_file.write_line("frequency_step: " + to_string_dec_uint(receiver_model.frequency_step()));
+    pmem_dump_file.write_line("lna: " + to_string_dec_int(receiver_model.lna()));
+    pmem_dump_file.write_line("vga: " + to_string_dec_int(receiver_model.vga()));
+    pmem_dump_file.write_line("rf_amp: " + to_string_dec_int(receiver_model.rf_amp()));
+    pmem_dump_file.write_line("baseband_bandwidth: " + to_string_dec_uint(receiver_model.baseband_bandwidth()));
+    pmem_dump_file.write_line("sampling_rate: " + to_string_dec_uint(receiver_model.sampling_rate()));
+    switch (receiver_model.modulation()) {
+        case ReceiverModel::Mode::AMAudio:
+            pmem_dump_file.write_line("modulation: Mode::AMAudio");
+            break;
+        case ReceiverModel::Mode::NarrowbandFMAudio:
+            pmem_dump_file.write_line("modulation: Mode::NarrowbandFMAudio");
+            break;
+        case ReceiverModel::Mode::WidebandFMAudio:
+            pmem_dump_file.write_line("modulation: Mode::WidebandFMAudio");
+            break;
+        case ReceiverModel::Mode::SpectrumAnalysis:
+            pmem_dump_file.write_line("modulation: Mode::SpectrumAnalysis");
+            break;
+        case ReceiverModel::Mode::Capture:
+            pmem_dump_file.write_line("modulation: Mode::Capture");
+            break;
+        case ReceiverModel::Mode::AMAudioFMApt:
+            pmem_dump_file.write_line("modulation: Mode::AMAudioFMApt");
+            break;
+        default:
+            pmem_dump_file.write_line("modulation: !!unknown mode!!");
+            break;
+    }
+    pmem_dump_file.write_line("headphone_volume.centibel: " + to_string_dec_int(receiver_model.headphone_volume().centibel()));
+    pmem_dump_file.write_line("normalized_headphone_volume: " + to_string_dec_uint(receiver_model.normalized_headphone_volume()));
+    pmem_dump_file.write_line("am_configuration: " + to_string_dec_uint(receiver_model.am_configuration()));
+    pmem_dump_file.write_line("nbfm_configuration: " + to_string_dec_uint(receiver_model.nbfm_configuration()));
+    pmem_dump_file.write_line("wfm_configuration: " + to_string_dec_uint(receiver_model.wfm_configuration()));
+
+    // transmitter_model
+    pmem_dump_file.write_line("\n[Transmitter Model]");
+    pmem_dump_file.write_line("target_frequency: " + to_string_dec_uint(transmitter_model.target_frequency()));
+    pmem_dump_file.write_line("rf_amp: " + to_string_dec_int(transmitter_model.rf_amp()));
+    pmem_dump_file.write_line("baseband_bandwidth: " + to_string_dec_uint(transmitter_model.baseband_bandwidth()));
+    pmem_dump_file.write_line("sampling_rate: " + to_string_dec_uint(transmitter_model.sampling_rate()));
+    pmem_dump_file.write_line("tx_gain: " + to_string_dec_int(transmitter_model.tx_gain()));
+    pmem_dump_file.write_line("channel_bandwidth: " + to_string_dec_uint(transmitter_model.channel_bandwidth()));
+    // on screen information
+    dump_output.set(filename.filename().string() + " DUMPED !");
+    dump_output.set_style(ui::Theme::getInstance()->fg_green);
+
+    return true;
+}
+
+DebugDumpView::DebugDumpView(NavigationView& nav)
+    : nav_{nav} {
+    add_children({&dump_output,
+                  &button_exit});
+
+    debug_dump_func();
+
+    button_exit.on_select = [this](Button&) {
+        nav_.pop();
+    };
+}
+
+void DebugDumpView::focus() {
+    button_exit.focus();
+}
+
+}  // namespace ui::external_app::debug_pmem

firmware/application/external/debug_pmem/ui_debug_pmem.hpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2018 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.
+ */
+
+#ifndef __UI_DEBUG_PMEM_APP_H__
+#define __UI_DEBUG_PMEM_APP_H__
+
+#include "portapack_persistent_memory.hpp"
+#include "ui_flash_utility.hpp"
+
+using namespace portapack;
+using namespace portapack::persistent_memory;
+
+namespace ui::external_app::debug_pmem {
+
+class DebugDumpView : public View {
+   public:
+    DebugDumpView(NavigationView& nav);
+
+    void focus() override;
+
+    std::string title() const override { return "DebugPMem"; };
+    bool debug_dump_func();
+
+   private:
+    NavigationView& nav_;
+
+    Text dump_output{
+        {0 * 8, 19 * 8, 30 * 8, 16},
+        ""};
+
+    Button button_exit{
+        {22 * 8, 34 * 8, 8 * 8, 32},
+        "Exit"};
+};
+
+}  // namespace ui::external_app::debug_pmem
+
+#endif /*__UI_DEBUG_PMEM_APP_H__*/

firmware/application/external/doom/ui_doom.cpp

@@ -9,6 +9,9 @@
 #include "ui_doom.hpp"
 #include "ui.hpp"
 
+namespace ui::external_app::doom {
+
+//clang-format off
 #define SCREEN_WIDTH 240
 #define SCREEN_HEIGHT 320
 #define RENDER_HEIGHT 280
@@ -46,30 +49,7 @@
 #define COLOR_WALL_LIGHT Green
 #define COLOR_WALL_DARK Maroon
 #define COLOR_FLOOR_DARK Black
-
-struct Coords {
-    double x, y;
-};
-
-struct Player {
-    Coords pos;
-    Coords dir;
-    Coords plane;
-    double velocity;
-    uint8_t health;
-    uint8_t keys;
-    uint8_t ammo;
-};
-
-struct Entity {
-    uint16_t uid;
-    Coords pos;
-    Coords death_pos;
-    uint8_t state;
-    uint8_t health;
-    uint8_t distance;
-    uint8_t timer;
-};
+//clang-format on
 
 // Stole this level map from Flipper Zero Doom, but he stole it from a guy who stole it and that guy probably stole it too. Argh!
 static const uint8_t level[LEVEL_SIZE] = {
@@ -131,7 +111,29 @@ static const uint8_t level[LEVEL_SIZE] = {
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
-namespace ui::external_app::doom {
+struct Coords {
+    double x, y;
+};
+
+struct Player {
+    Coords pos;
+    Coords dir;
+    Coords plane;
+    double velocity;
+    uint8_t health;
+    uint8_t keys;
+    uint8_t ammo;
+};
+
+struct Entity {
+    uint16_t uid;
+    Coords pos;
+    Coords death_pos;
+    uint8_t state;
+    uint8_t health;
+    uint8_t distance;
+    uint8_t timer;
+};
 
 static Ticker game_timer;
 static Player player;

firmware/application/external/external.cmake

@@ -192,9 +192,17 @@ set(EXTCPPSRC
 	external/doom/main.cpp
 	external/doom/ui_doom.cpp
 
-	#screening
-	# external/screening/main.cpp
-	# external/screening/ui_screening.cpp
+	#debug_pmem
+	external/debug_pmem/main.cpp
+	external/debug_pmem/ui_debug_pmem.cpp
+
+	#scanner
+	external/scanner/main.cpp
+	external/scanner/ui_scanner.cpp
+
+	#level
+	external/level/main.cpp
+	external/level/ui_level.cpp
 )
 
 set(EXTAPPLIST
@@ -244,5 +252,7 @@ set(EXTAPPLIST
 	stopwatch
 	breakout
 	doom
-	# screening
+	debug_pmem
+	scanner
+	level
 )

firmware/application/external/external.ld

@@ -69,8 +69,9 @@ MEMORY
     ram_external_app_wefax_rx   (rwx) : org = 0xADDC0000, len = 32k
     ram_external_app_breakout   (rwx) : org = 0xADDD0000, len = 32k
     ram_external_app_doom       (rwx) : org = 0xADDE0000, len = 32k
-    /*ram_external_app_screening  (rwx) : org = 0xADDF0000, len = 32k*/
-
+    ram_external_app_debug_pmem (rwx) : org = 0xADDF0000, len = 32k
+    ram_external_app_scanner    (rwx) : org = 0xADE00000, len = 32k
+    ram_external_app_level      (rwx) : org = 0xADE10000, len = 32k
 }
 
 SECTIONS
@@ -349,15 +350,22 @@ SECTIONS
         KEEP(*(.external_app.app_doom.application_information));
         *(*ui*external_app*doom*);
     } > ram_external_app_doom    
-
-/*
-    .external_app_screening : ALIGN(4) SUBALIGN(4)
+    
+    .external_app_debug_pmem : ALIGN(4) SUBALIGN(4)
     {
-        KEEP(*(.external_app.app_screening.application_information));
-        *(*ui*external_app*screening*);
-    } > ram_external_app_screening   
-
-*/
+        KEEP(*(.external_app.app_debug_pmem.application_information));
+        *(*ui*external_app*debug_pmem*);
+    } > ram_external_app_debug_pmem    
 
+    .external_app_scanner : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_scanner.application_information));
+        *(*ui*external_app*scanner*);
+    } > ram_external_app_scanner    
 
+    .external_app_level : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_level.application_information));
+        *(*ui*external_app*level*);
+    } > ram_external_app_level
 }

firmware/application/external/font_viewer/ui_font_viewer.cpp

@@ -67,6 +67,7 @@ void DebugFontsView::paint(Painter& painter) {
 
     line_pos = display_font(painter, 32, Theme::getInstance()->bg_darkest, "Fixed 8x16", true);
     display_font(painter, line_pos + 16, Theme::getInstance()->bg_darkest_small, "Fixed 5x8", false);
+    paint_zoomed_text(painter);
 }
 
 void DebugFontsView::update_address_text() {
@@ -74,16 +75,29 @@ void DebugFontsView::update_address_text() {
     text_address.set("0x" + to_string_hex(ascii_value, 2));
 }
 
+void DebugFontsView::paint_zoomed_text(Painter& painter) {
+    if (field_zoom_level.value() == 0) return;
+    uint8_t cursor_pos = field_cursor.value();
+    painter.draw_char({screen_width / 2, screen_height / 2},
+                      *Theme::getInstance()->bg_darkest,
+                      (char)(cursor_pos + 0x20), field_zoom_level.value());
+}
+
 DebugFontsView::DebugFontsView(NavigationView& nav)
     : nav_{nav} {
     add_children({&field_cursor,
-                  &text_address});
+                  &text_address,
+                  &field_zoom_level});
     set_focusable(true);
 
     field_cursor.on_change = [&](int32_t) {
         update_address_text();
         set_dirty();
     };
+
+    field_zoom_level.on_change = [&](int32_t) {
+        set_dirty();
+    };
 }
 
 void DebugFontsView::focus() {

firmware/application/external/font_viewer/ui_font_viewer.hpp

@@ -46,10 +46,17 @@ class DebugFontsView : public View {
    private:
     uint16_t display_font(Painter& painter, uint16_t y_offset, const Style* font_style, std::string_view font_name, bool is_big_font);
     void update_address_text();
+    void paint_zoomed_text(Painter& painter);
 
     NumberField field_cursor{
         {0 * 8, 0 * 8},
+        4,
+        {0, 1000},
         1,
+        ' '};
+    NumberField field_zoom_level{
+        {6 * 8, 0 * 8},
+        4,
         {0, 1000},
         1,
         ' '};

firmware/application/external/hopper/ui_hopper.cpp

@@ -227,6 +227,7 @@ void HopperView::save_list() {
         nav_,
         filename_buffer,
         64,
+        ENTER_KEYBOARD_MODE_ALPHA,
         [this](std::string& value) {
             auto path = hopper_dir / (value + ".PHOP");
 

firmware/application/external/lcr/ui_lcr.cpp

@@ -189,6 +189,7 @@ void LCRView::on_button_set_am(NavigationView& nav, int16_t button_id) {
         nav,
         litteral[button_id],
         7,
+        ENTER_KEYBOARD_MODE_ALPHA,
         [this, button_id](std::string& buffer) {
             texts[button_id].set(buffer);
         });
@@ -257,6 +258,7 @@ LCRView::LCRView(NavigationView& nav) {
             nav,
             rgsb,
             4,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& buffer) {
                 button_set_rgsb.set_text(buffer);
             });

firmware/application/external/level/main.cpp

@@ -0,0 +1,84 @@
+/*
+ * 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 "ui_level.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::level {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<LevelView>();
+}
+}  // namespace ui::external_app::level
+
+extern "C" {
+
+__attribute__((section(".external_app.app_level.application_information"), used)) application_information_t _application_information_level = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::level::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Level",
+    /*.bitmap_data = */
+    {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x04,
+        0x20,
+        0x12,
+        0x48,
+        0x8A,
+        0x51,
+        0xCA,
+        0x53,
+        0xCA,
+        0x53,
+        0x8A,
+        0x51,
+        0x12,
+        0x48,
+        0x84,
+        0x21,
+        0xC0,
+        0x03,
+        0x40,
+        0x02,
+        0x60,
+        0x06,
+        0x20,
+        0x04,
+        0x30,
+        0x0C,
+        0xF0,
+        0x0F},
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    // this has to be the biggest baseband used by the app. Level is using AM,WFM,NFM,AMFM,SPEC and NFM is the biggest
+    /*.m4_app_tag = portapack::spi_flash::image_tag_nfm */ {'P', 'N', 'F', 'M'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/level/ui_level.cpp

@@ -33,7 +33,7 @@ using namespace portapack;
 using namespace tonekey;
 using portapack::memory::map::backup_ram;
 
-namespace ui {
+namespace ui::external_app::level {
 
 // Function to map the value from one range to another
 int32_t LevelView::map(int32_t value, int32_t fromLow, int32_t fromHigh, int32_t toLow, int32_t toHigh) {
@@ -130,9 +130,16 @@ LevelView::LevelView(NavigationView& nav)
 
     freqman_set_modulation_option(field_mode);
     field_mode.on_change = [this](size_t, OptionsField::value_t v) {
-        if (v != -1) {
-            change_mode(v);
+        static freqman_index_t last_mode = WFM_MODULATION;
+        if (v > SPEC_MODULATION) {
+            if (last_mode == SPEC_MODULATION)
+                v = AM_MODULATION;
+            else
+                v = SPEC_MODULATION;
+            field_mode.set_selected_index(v);
         }
+        last_mode = v;
+        change_mode(v);
     };
     field_mode.set_by_value(radio_mode);  // Reflect the mode into the manual selector
     field_bw.set_selected_index(radio_bw);
@@ -277,15 +284,6 @@ size_t LevelView::change_mode(freqman_index_t new_mod) {
             field_bw.set_by_value(0);
             field_bw.on_change = [this](size_t index, OptionsField::value_t n) { radio_bw = index ; receiver_model.set_wfm_configuration(n); };
             break;
-        case AMFM_MODULATION:
-            audio_sampling_rate = audio::Rate::Hz_12000;
-            freqman_set_bandwidth_option(new_mod, field_bw);
-            baseband::run_image(portapack::spi_flash::image_tag_am_audio);
-            receiver_model.set_modulation(ReceiverModel::Mode::AMAudioFMApt);
-            receiver_model.set_amfm_configuration(5);  // Fix index 5 manually, not from freqman: set to  RX AM (USB+FM) mode to demod audio tone, and get Wefax_APT signal.
-            field_bw.set_by_value(0);
-            field_bw.on_change = [this](size_t, OptionsField::value_t n) { (void)n; };
-            break;
         case SPEC_MODULATION:
             audio_sampling_rate = audio::Rate::Hz_24000;
             freqman_set_bandwidth_option(new_mod, field_bw);
@@ -338,4 +336,4 @@ void LevelView::on_freqchg(int64_t freq) {
     button_frequency.set_text("<" + to_string_short_freq(freq) + " MHz>");
 }
 
-} /* namespace ui */
+}  // namespace ui::external_app::level

firmware/application/external/level/ui_level.hpp

@@ -39,7 +39,7 @@
 #include "ui_receiver.hpp"
 #include "ui_spectrum.hpp"
 
-namespace ui {
+namespace ui::external_app::level {
 
 class LevelView : public View {
    public:
@@ -211,6 +211,6 @@ class LevelView : public View {
         }};
 };
 
-} /* namespace ui */
+}  // namespace ui::external_app::level
 
 #endif

firmware/application/external/lge/lge_app.cpp

@@ -311,6 +311,7 @@ LGEView::LGEView(NavigationView& nav) {
             nav,
             nickname,
             15,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& buffer) {
                 button_text.set_text(buffer);
             });

firmware/application/external/metronome/ui_metronome.cpp

@@ -23,6 +23,7 @@
 #include "baseband_api.hpp"
 #include "audio.hpp"
 #include "portapack.hpp"
+#include "ui_textentry.hpp"
 
 using namespace portapack;
 
@@ -42,6 +43,7 @@ MetronomeView::MetronomeView(NavigationView& nav)
         &field_unaccent_beep_tune,
         &field_beep_flash_duration,
         &field_bpm,
+        &button_enter_tap_tempo,
         &progressbar,
     });
 
@@ -59,6 +61,14 @@ MetronomeView::MetronomeView(NavigationView& nav)
         }
     };
 
+    button_enter_tap_tempo.on_select = [this](Button&) {
+        auto tap_tempo_view = nav_.push<MetronomeTapTempoView>(field_bpm.value());
+
+        tap_tempo_view->on_apply = [this](uint16_t bpm) {
+            field_bpm.set_value(bpm);
+        };
+    };
+
     field_volume.set_value(0);  // seems that a change is required to force update, so setting to 0 first
     field_volume.set_value(99);
 
@@ -174,4 +184,116 @@ void MetronomeView::run() {
     }
 }
 
+MetronomeTapTempoView::MetronomeTapTempoView(NavigationView& nav, uint16_t bpm)
+    : nav_{nav},
+      bpm_{bpm} {
+    add_children({
+        &button_input,
+        &button_tap,
+        &button_cancel,
+        &button_apply,
+    });
+
+    bpm_when_entered_ = bpm;  // save for if user cancel
+
+    // im aware that we have duplicated painter which means in this app, weo have two painter instances
+    // here is the reason why this is necessary:
+    // We need to draw the bpm big font once when enter, which would be at bad timing in constructor,
+    // cuz it happened before the view is pushed to nav, which casued it actually didn't draw
+    // which leads me have to override the paint func from father and draw inside of it.
+    //
+    // BUT I can't completely package the draw logic inside of the paint func,
+    // cuz set_dirty has flaw and cause screen flicker during the char changes, if i just package there and use set_dirty()
+    Painter painter_instance_2;
+
+    button_input.on_select = [this](Button&) {
+        input_buffer = to_string_dec_uint(bpm_);
+        text_prompt(
+            nav_,
+            input_buffer,
+            3,
+            ENTER_KEYBOARD_MODE_DIGITS,
+            [this](std::string& buffer) {
+                if (buffer.empty()) {
+                    return;
+                }
+                bpm_ = atoi(buffer.c_str());
+
+                if (on_apply) {
+                    on_apply(bpm_);
+                }
+            });
+    };
+
+    button_tap.on_select = [&](Button&) {
+        on_tap(painter_instance_2);
+    };
+
+    button_apply.on_select = [this](Button&) {
+        // it's dynamically applied in tap handler
+        // the design allow user to hear changes before apply
+        nav_.pop();
+    };
+
+    button_cancel.on_select = [this](Button&) {
+        bpm_ = bpm_when_entered_;
+        if (on_apply) {
+            on_apply(bpm_);
+        }
+        nav_.pop();
+    };
+}
+
+void MetronomeTapTempoView::focus() {
+    button_tap.focus();
+}
+
+void MetronomeTapTempoView::paint(Painter& painter) {
+    View::paint(painter);
+    painter.draw_char({(0 * 16) * 4 + 2 * 16, 3 * 16}, *Theme::getInstance()->fg_light, '0' + bpm_ / 100, 4);
+    painter.draw_char({(1 * 16) * 4 + 2 * 16, 3 * 16}, *Theme::getInstance()->fg_light, '0' + (bpm_ / 10) % 10, 4);
+    painter.draw_char({(2 * 16) * 4 + 2 * 16, 3 * 16}, *Theme::getInstance()->fg_light, '0' + bpm_ % 10, 4);
+}
+
+/*
+NB: i don't really know if the cpu clock is 1000Hz AKA 1ms per tick for chTimeNow()
+    but it should be, refering to the stop watch app.
+    and also i compared with my real metronome and it's very close
+    so I assume it's 1ms per tick
+*/
+void MetronomeTapTempoView::on_tap(Painter& painter) {
+    /*                                      ^ NB: this painter accepted from painter_instance_2*/
+    systime_t current_time = chTimeNow();
+    if (last_tap_time > 0) {
+        uint32_t interval_ms = current_time - last_tap_time;
+
+        if (interval_ms > 100) {
+            uint16_t this_time_bpm = 60000 / interval_ms;
+
+            if (this_time_bpm > 0 && this_time_bpm < 400) {
+                bpms_deque.push_back(this_time_bpm);
+                if (bpms_deque.size() > 4) {  // one bar length cuz most music tempo is quarter note as 1 beat
+                    bpms_deque.pop_front();
+                }
+
+                // avg
+                uint32_t sum = 0;
+                for (auto& bpm : bpms_deque) {
+                    sum += bpm;
+                }
+                bpm_ = sum / bpms_deque.size();
+
+                if (on_apply) {
+                    on_apply(bpm_);
+                }
+
+                painter.draw_char({(0 * 16) * 4 + 2 * 16, 3 * 16}, *Theme::getInstance()->fg_light, '0' + bpm_ / 100, 4);
+                painter.draw_char({(1 * 16) * 4 + 2 * 16, 3 * 16}, *Theme::getInstance()->fg_light, '0' + (bpm_ / 10) % 10, 4);
+                painter.draw_char({(2 * 16) * 4 + 2 * 16, 3 * 16}, *Theme::getInstance()->fg_light, '0' + bpm_ % 10, 4);
+            }
+        }
+    }
+    last_tap_time = current_time;
+}
+
 }  // namespace ui::external_app::metronome

firmware/application/external/metronome/ui_metronome.hpp

@@ -27,6 +27,8 @@
 #include "audio.hpp"
 #include "ch.h"
 
+#include <deque>
+
 namespace ui::external_app::metronome {
 
 class MetronomeView : public View {
@@ -73,6 +75,11 @@ class MetronomeView : public View {
         1,
         ' '};
 
+    Button button_enter_tap_tempo{
+        {(sizeof("BPM:") + 6) * 8, 1 * 16, (sizeof("Tap Tempo") + 3) * 8, 16},
+        "Tap Tempo",
+    };
+
     NumberField field_rythm_unaccent_time{// e.g. 3 in 3/4 beat
                                           {(sizeof("Rhythm:") + 1) * 8, 4 * 16},
                                           2,
@@ -121,6 +128,45 @@ class MetronomeView : public View {
         {0 * 16, 8 * 16, screen_width, screen_height - 14 * 16}};
 };
 
+class MetronomeTapTempoView : public View {
+   public:
+    std::function<void(uint16_t)> on_apply{};
+
+    MetronomeTapTempoView(NavigationView& nav, uint16_t bpm);
+
+    std::string title() const override { return "Tap.T"; };
+    void focus() override;
+    void paint(Painter& painter) override;
+
+   private:
+    void on_tap(Painter& painter);
+
+    NavigationView& nav_;
+
+    uint16_t bpm_{0};
+    uint16_t bpm_when_entered_{0};          // this pass from MetronomeView and need to restore if user cancel
+    std::deque<uint16_t> bpms_deque = {0};  // take average for recent taps to debounce
+    uint32_t last_tap_time{0};
+
+    std::string input_buffer{""};  // needed by text_prompt
+
+    Button button_input{
+        {0, 0, screen_width, 2 * 16},
+        "Input BPM"};
+
+    Button button_tap{
+        {0, 8 * 16, screen_width, 7 * 16},
+        "Tap BPM"};
+
+    Button button_cancel{
+        {1, 17 * 16, screen_width / 2 - 4, 2 * 16},
+        "Cancel"};
+
+    Button button_apply{
+        {1 + screen_width / 2 + 1, 17 * 16, screen_width / 2 - 4, 2 * 16},
+        "Apply"};
+};
+
 }  // namespace ui::external_app::metronome
 
 #endif /*__UI_METRONOME_H__*/

firmware/application/external/morse_tx/ui_morse.cpp

@@ -99,7 +99,7 @@ static msg_t loopthread_fn(void* arg) {
 }
 
 void MorseView::on_set_text(NavigationView& nav) {
-    text_prompt(nav, buffer, 28);
+    text_prompt(nav, buffer, 28, ENTER_KEYBOARD_MODE_ALPHA);
 }
 
 void MorseView::focus() {

firmware/application/external/ook_editor/ui_ook_editor.cpp

@@ -210,6 +210,7 @@ OOKEditorAppView::OOKEditorAppView(NavigationView& nav)
             nav,
             outputFileBuffer,
             64,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [this](std::string& buffer) {
                 on_save_file(buffer);
             });
@@ -263,6 +264,7 @@ OOKEditorAppView::OOKEditorAppView(NavigationView& nav)
             nav,
             ook_data.payload,
             100,
+            ENTER_KEYBOARD_MODE_DIGITS,
             [this](std::string& s) {
                 text_payload.set(s);
                 draw_waveform();

firmware/application/external/ookbrute/ui_ookbrute.cpp

@@ -83,6 +83,7 @@ OOKBruteView::OOKBruteView(NavigationView& nav)
             nav_,
             text_input_buffer,
             8,  // currently longest is princeton
+            ENTER_KEYBOARD_MODE_DIGITS,
             [this](std::string& buffer) {
                 field_start.set_value(atoi(buffer.c_str()));
                 validate_start_stop();
@@ -100,6 +101,7 @@ OOKBruteView::OOKBruteView(NavigationView& nav)
             nav_,
             text_input_buffer,
             8,  // currently longest is princeton
+            ENTER_KEYBOARD_MODE_DIGITS,
             [this](std::string& buffer) {
                 field_stop.set_value(atoi(buffer.c_str()));
                 validate_start_stop();

firmware/application/external/playlist_editor/ui_playlist_editor.cpp

@@ -122,6 +122,7 @@ bool PlaylistEditorView::on_create_ppl() {
         nav_,
         current_ppl_name_buffer,
         100,
+        ENTER_KEYBOARD_MODE_ALPHA,
         [&](std::string& s) {
             current_ppl_name_buffer = s;
 
@@ -307,6 +308,7 @@ PlaylistItemEditView::PlaylistItemEditView(
             nav_,
             delay_str,
             100,
+            ENTER_KEYBOARD_MODE_ALPHA,
             [&](std::string& s) {
                 delay_ = atoi(s.c_str());
                 field_delay.set_value(delay_);

firmware/application/external/remote/ui_remote.cpp

@@ -330,7 +330,7 @@ RemoteAppView::RemoteAppView(
 
     field_title.on_select = [this, &nav](TextField&) {
         temp_buffer_ = model_.name;
-        text_prompt(nav_, temp_buffer_, text_edit_max, [this](std::string& new_name) {
+        text_prompt(nav_, temp_buffer_, text_edit_max, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& new_name) {
             model_.name = new_name;
             refresh_ui();
             set_needs_save();
@@ -339,7 +339,7 @@ RemoteAppView::RemoteAppView(
 
     field_filename.on_select = [this, &nav](TextField&) {
         temp_buffer_ = remote_path_.stem().string();
-        text_prompt(nav_, temp_buffer_, text_edit_max, [this](std::string& new_name) {
+        text_prompt(nav_, temp_buffer_, text_edit_max, ENTER_KEYBOARD_MODE_ALPHA, [this](std::string& new_name) {
             rename_remote(new_name);
             refresh_ui();
         });

firmware/application/external/scanner/main.cpp

@@ -0,0 +1,51 @@
+/*
+ * 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 "ui_scanner.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::scanner {
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<ScannerView>();
+}
+}  // namespace ui::external_app::scanner
+
+extern "C" {
+
+__attribute__((section(".external_app.app_scanner.application_information"), used)) application_information_t _application_information_scanner = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::scanner::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Scanner",
+    /*.bitmap_data = */ {0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x03, 0x01, 0x80, 0x01, 0xC3, 0x00, 0xE0, 0xFF, 0xEF, 0xFF, 0xC0, 0x00, 0x83, 0x01, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00},
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    // this has to be the biggest baseband used by the app. Scanner is using AM,WFM,NFM and NFM is the biggest
+    /*.m4_app_tag = portapack::spi_flash::image_tag_scanner */ {'P', 'N', 'F', 'M'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+}

firmware/application/external/scanner/ui_scanner.cpp

@@ -28,10 +28,11 @@
 #include "ui_freqman.hpp"
 #include "file_path.hpp"
 
+using namespace ui;
 using namespace portapack;
 namespace fs = std::filesystem;
 
-namespace ui {
+namespace ui::external_app::scanner {
 
 ScannerThread::ScannerThread(std::vector<rf::Frequency> frequency_list)
     : frequency_list_{std::move(frequency_list)} {
@@ -451,13 +452,14 @@ ScannerView::ScannerView(
 
     // Mode field was changed (AM/NFM/WFM)
     field_mode.on_change = [this](size_t, OptionsField::value_t v) {
-        static freqman_index_t last_mode = AM_MODULATION;
+        // initialize to a value under SPEC
+        static freqman_index_t last_mode = WFM_MODULATION;
         // unsupported SPEC mode fix
-        if (v == SPEC_MODULATION) {
-            if (last_mode == AM_MODULATION)
-                v = WFM_MODULATION;
-            else
+        if (v >= SPEC_MODULATION) {
+            if (last_mode == WFM_MODULATION)
                 v = AM_MODULATION;
+            else
+                v = WFM_MODULATION;
             field_mode.set_selected_index(v);
         }
         last_mode = v;
@@ -725,14 +727,6 @@ void ScannerView::change_mode(freqman_index_t new_mod) {
             field_bw.set_by_value(receiver_model.wfm_configuration());
             field_bw.on_change = [this](size_t, OptionsField::value_t n) { receiver_model.set_wfm_configuration(n); };
             break;
-        case AMFM_MODULATION:
-            freqman_set_bandwidth_option(new_mod, field_bw);
-            baseband::run_image(portapack::spi_flash::image_tag_am_audio);
-            receiver_model.set_modulation(ReceiverModel::Mode::AMAudioFMApt);
-            receiver_model.set_amfm_configuration(5);
-            field_bw.set_by_value(0);
-            field_bw.on_change = [this](size_t, OptionsField::value_t n) { (void)n; };
-            break;
         default:
             break;
     }
@@ -773,5 +767,4 @@ void ScannerView::restart_scan() {
 
     start_scan_thread();  // RESTART SCANNER THREAD in selected mode
 }
-
-} /* namespace ui */
+}  // namespace ui::external_app::scanner

firmware/application/external/scanner/ui_scanner.hpp

@@ -35,12 +35,14 @@
 #include "ui_mictx.hpp"
 #include "ui_receiver.hpp"
 
+using namespace ui;
+
+namespace ui::external_app::scanner {
+
 #define SCANNER_SLEEP_MS 50  // ms that Scanner Thread sleeps per loop
 #define STATISTICS_UPDATES_PER_SEC 10
 #define MAX_FREQ_LOCK 10  // # of 50ms cycles scanner locks into freq when signal detected, to verify signal is not spurious
 
-namespace ui {
-
 // TODO: There is too much duplicated data in these classes.
 // ScannerThread should just use more from the View.
 // Or perhaps ScannerThread should just be in the View.
@@ -314,5 +316,4 @@ class ScannerView : public View {
             this->on_statistics_update(static_cast<const ChannelStatisticsMessage*>(p)->statistics);
         }};
 };
-
-} /* namespace ui */
+}  // namespace ui::external_app::scanner

firmware/application/external/shoppingcart_lock/main.cpp

@@ -1,6 +1,8 @@
+// CVS Spam app by RocketGod (@rocketgod-git) https://betaskynet.com
+// Original .cu8 files by @jimilinuxguy https://github.com/jimilinuxguy/customer-assistance-buttons-sdr
+// If you can read this, you're a nerd. :P
+// Come join us at https://discord.gg/thepiratesreborn
 
-// RocketGod's Shopping Cart Lock app
-// https://betaskynet.com
 #include "ui.hpp"
 #include "shoppingcart_lock.hpp"
 #include "ui_navigation.hpp"
@@ -57,10 +59,10 @@ __attribute__((section(".external_app.app_shoppingcart_lock.application_informat
         0x00,
     },
     /*.icon_color = */ ui::Color::red().v,
-    /*.menu_location = */ app_location_t::TX,
+    /*.menu_location = */ app_location_t::UTILITIES,
     /*.desired_menu_position = */ -1,
 
-    /*.m4_app_tag = portapack::spi_flash::image_tag_afsk_rx */ {'P', 'A', 'T', 'X'},
-    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+    /*.m4_app_tag = portapack::spi_flash::image_tag_audio_tx */ {'P', 'A', 'T', 'X'},
+    /*.m4_app_offset = */ 0x00000000,
 };
 }

firmware/application/external/shoppingcart_lock/shoppingcart_lock.cpp

@@ -1,5 +1,8 @@
-// RocketGod's Shopping Cart Lock app
-// https://betaskynet.com
+// CVS Spam app by RocketGod (@rocketgod-git) https://betaskynet.com
+// Original .cu8 files by @jimilinuxguy https://github.com/jimilinuxguy/customer-assistance-buttons-sdr
+// If you can read this, you're a nerd. :P
+// Come join us at https://discord.gg/thepiratesreborn
+
 #include "shoppingcart_lock.hpp"
 
 using namespace portapack;
@@ -48,7 +51,6 @@ void ShoppingCartLock::stop() {
     audio::output::stop();
 
     log_event("... Resetting State Variables");
-    transmitter_model.disable();
     ready_signal = false;
     thread_sync_complete = false;
     looping = false;
@@ -110,18 +112,24 @@ std::string ShoppingCartLock::list_wav_files() {
 }
 
 void ShoppingCartLock::wait_for_thread() {
-    uint32_t timeout = 100;
+    uint32_t timeout = 1000;
     while (!ready_signal && timeout > 0) {
         chThdYield();
         timeout--;
     }
+    if (!ready_signal) {
+        log_event("!!! Timeout waiting for ReplayThread");
+    }
 }
 
 void ShoppingCartLock::restart_playback() {
     auto reader = std::make_unique<WAVFileReader>();
     std::string file_path = (wav_dir / current_file).string();
 
-    if (!reader->open(file_path)) return;
+    if (!reader->open(file_path)) {
+        log_event("!!! Failed to reopen " + current_file + " for restart");
+        return;
+    }
 
     replay_thread = std::make_unique<ReplayThread>(
         std::move(reader),
@@ -133,9 +141,8 @@ void ShoppingCartLock::restart_playback() {
             EventDispatcher::send_message(message);
         });
 
-    log_event(">> SENDING <<");
+    log_event(">> RESTARTING AUDIO <<");
     audio::output::start();
-    transmitter_model.enable();
 }
 
 void ShoppingCartLock::play_audio(const std::string& filename, bool loop) {
@@ -166,33 +173,24 @@ void ShoppingCartLock::play_audio(const std::string& filename, bool loop) {
 
     wait_for_thread();
 
-    log_event("... Configuring Baseband");
-
-    const uint32_t bb_sample_rate = 1536000;
-    const uint32_t decimation = bb_sample_rate / wav_sample_rate;
-
+    baseband::set_sample_rate(wav_sample_rate);
+    audio::set_rate(wav_sample_rate <= 12000 ? audio::Rate::Hz_12000 : wav_sample_rate <= 24000 ? audio::Rate::Hz_24000
+                                                                                                : audio::Rate::Hz_48000);
     baseband::set_audiotx_config(
-        bb_sample_rate / decimation,
+        wav_sample_rate,
+        0.0f,
         0.0f,
-        5.0f,
         wav_bits_per_sample,
         wav_bits_per_sample,
         0,
-        true,
+        false,
         false,
         false,
         false);
 
-    baseband::set_sample_rate(wav_sample_rate);
-
-    log_event("... Starting Audio Output");
     audio::output::start();
-    log_event("... Setting Max Volume");
-    audio::headphone::set_volume(audio::headphone::volume_range().max);
-
-    transmitter_model.enable();
-
-    log_event(">>> Playback Started <<<");
+    volume_t max_volume = audio::headphone::volume_range().max;
+    audio::headphone::set_volume(max_volume);
 }
 
 ShoppingCartLock::ShoppingCartLock(NavigationView& nav)
@@ -225,9 +223,6 @@ ShoppingCartLock::ShoppingCartLock(NavigationView& nav)
     log_event("[+] INITIALIZATION COMPLETE");
     log_event("[+] PORTAPACK ARMED");
     log_event("[*] STATUS: READY");
-    log_event("This app use speaker to");
-    log_event("produce LF signal, but");
-    log_event("also trigger radio TX");
 }
 
 ShoppingCartLock::~ShoppingCartLock() {
@@ -235,4 +230,4 @@ ShoppingCartLock::~ShoppingCartLock() {
     baseband::shutdown();
 }
 
-}  // namespace ui::external_app::shoppingcart_lock
+}  // namespace ui::external_app::shoppingcart_lock

firmware/application/external/shoppingcart_lock/shoppingcart_lock.hpp

@@ -1,5 +1,8 @@
-// RocketGod's Shopping Cart Lock app
-// https://betaskynet.com
+// CVS Spam app by RocketGod (@rocketgod-git) https://betaskynet.com
+// Original .cu8 files by @jimilinuxguy https://github.com/jimilinuxguy/customer-assistance-buttons-sdr
+// If you can read this, you're a nerd. :P
+// Come join us at https://discord.gg/thepiratesreborn
+
 #pragma once
 
 #include "ui_widget.hpp"
@@ -27,8 +30,8 @@ class ShoppingCartLock : public View {
     void focus() override;
 
    private:
-    static constexpr size_t BUFFER_SIZE = 8192;
-    static constexpr size_t NUM_BUFFERS = 8;
+    static constexpr size_t BUFFER_SIZE = 512;
+    static constexpr size_t NUM_BUFFERS = 2;
     const std::string shoppingcart_lock_file{"shopping_cart_lock.wav"};
     const std::string shoppingcart_unlock_file{"shopping_cart_unlock.wav"};
 

firmware/application/external/snake/Arial12x12.h

@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2024 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.
- */
-
-// dummy include file to avoid changing original source
-
-#ifndef __UI_Arial12x12_H__
-#define __UI_Arial12x12_H__
-
-#define Arial12x12 (0)
-
-#endif /*__UI_Arial12x12_H__*/

firmware/application/external/snake/SPI_TFT_ILI9341.h

@@ -1,68 +0,0 @@
-/*
- * ------------------------------------------------------------
- * |  Made by RocketGod                                       |
- * |  Find me at https://betaskynet.com                       |
- * |  Argh matey!                                             |
- * ------------------------------------------------------------
- */
-
-#ifndef __UI_SPI_TFT_ILI9341_H__
-#define __UI_SPI_TFT_ILI9341_H__
-
-ui::Painter painter;
-
-static int bg_color;
-
-enum {
-    White,
-    Blue,
-    Yellow,
-    Purple,
-    Green,
-    Red,
-    Maroon,
-    Orange,
-    Black,
-};
-
-static const Color pp_colors[] = {
-    Color::white(),
-    Color::blue(),
-    Color::yellow(),
-    Color::purple(),
-    Color::green(),
-    Color::red(),
-    Color::magenta(),
-    Color::orange(),
-    Color::black(),
-};
-
-static void claim(__FILE* x) {
-    (void)x;
-};
-
-static void cls() {
-    painter.fill_rectangle({0, 0, portapack::display.width(), portapack::display.height()}, Color::black());
-};
-
-static void background(int color) {
-    bg_color = color;
-};
-
-static void set_orientation(int x) {
-    (void)x;
-};
-
-static void set_font(unsigned char* x) {
-    (void)x;
-};
-
-static void fillrect(int x1, int y1, int x2, int y2, int color) {
-    painter.fill_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
-};
-
-static void rect(int x1, int y1, int x2, int y2, int color) {
-    painter.draw_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
-};
-
-#endif /*__UI_SPI_TFT_ILI9341_H__*/

firmware/application/external/snake/main.cpp

@@ -65,4 +65,4 @@ __attribute__((section(".external_app.app_snake.application_information"), used)
     {0, 0, 0, 0},
     0x00000000,
 };
-}
+}  // namespace ui::external_app::snake

firmware/application/external/snake/mbed.h

@@ -1,98 +0,0 @@
-#ifndef __UI_mbed_H__
-#define __UI_mbed_H__
-
-using Callback = void (*)(void);
-
-#define wait_us(x) (void)0
-#define wait(x) chThdSleepMilliseconds(x * 1000)
-#define PullUp 1
-
-#include "ui_navigation.hpp"
-
-enum {
-    dp0,
-    dp1,
-    dp2,
-    dp3,
-    dp4,
-    dp5,
-    dp6,
-    dp7,
-    dp8,
-    dp9,
-    dp10,
-    dp11,
-    dp12,
-    dp13,
-    dp14,
-    dp15,
-    dp16,
-    dp17,
-    dp18,
-    dp19,
-    dp20,
-    dp21,
-    dp22,
-    dp23,
-    dp24,
-    dp25,
-};
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-variable"
-static bool but_RIGHT;
-static bool but_LEFT;
-#pragma GCC diagnostic pop
-static bool but_SELECT;
-
-class Timer {
-   public:
-    Timer() { (void)0; };
-    void reset() { (void)0; };
-    void start() { (void)0; }
-    uint32_t read_ms() { return 1000; };
-
-   private:
-};
-
-static Callback game_update_callback;
-static uint32_t game_update_timeout;
-static uint32_t game_update_counter;
-
-static void check_game_timer() {
-    if (game_update_callback) {
-        if (++game_update_counter >= game_update_timeout) {
-            game_update_counter = 0;
-            game_update_callback();
-        }
-    }
-}
-
-class Ticker {
-   public:
-    Ticker() { (void)0; };
-    void attach(Callback func, double delay_sec) {
-        game_update_callback = func;
-        game_update_timeout = delay_sec * 60;
-    }
-    void detach() {
-        game_update_callback = nullptr;
-    }
-
-   private:
-};
-
-static Callback button_callback;
-
-class InterruptIn {
-   public:
-    InterruptIn(int reg) {
-        (void)reg;
-    };
-    void fall(Callback func) { button_callback = func; };
-    void mode(int v) { (void)v; };
-
-   private:
-};
-
-#endif /*__UI_mbed_H__*/

firmware/application/external/snake/snake.cpp

@@ -1,234 +0,0 @@
-/*
- * ------------------------------------------------------------
- * |  Made by RocketGod                                       |
- * |  Find me at https://betaskynet.com                       |
- * |  Argh matey!                                             |
- * ------------------------------------------------------------
- */
-
-#include "mbed.h"
-#include "SPI_TFT_ILI9341.h"
-#include "Arial12x12.h"
-#include "ui.hpp"
-#include "random.hpp"
-
-extern int game_state;
-
-#define SCREEN_WIDTH 240
-#define SCREEN_HEIGHT 320
-#define SNAKE_SIZE 10
-#define INFO_BAR_HEIGHT 25
-#define GAME_AREA_TOP (INFO_BAR_HEIGHT + 1)
-#define GAME_AREA_HEIGHT (SCREEN_HEIGHT - INFO_BAR_HEIGHT - 2)
-#define GRID_WIDTH ((SCREEN_WIDTH - 2) / SNAKE_SIZE)
-#define GRID_HEIGHT (GAME_AREA_HEIGHT / SNAKE_SIZE)
-#define STATE_MENU 0
-#define STATE_PLAYING 1
-#define STATE_GAME_OVER 2
-
-#define COLOR_BACKGROUND Black
-#define COLOR_SNAKE Green
-#define COLOR_FOOD Red
-#define COLOR_BORDER White
-
-Ticker game_timer;
-
-int snake_x[GRID_WIDTH * GRID_HEIGHT];
-int snake_y[GRID_WIDTH * GRID_HEIGHT];
-int snake_length = 1;
-int snake_dx = 1, snake_dy = 0;
-int food_x, food_y;
-int score = 0;
-int game_state = STATE_MENU;
-bool initialized = false;
-
-extern ui::Painter painter;
-
-void init_game();
-void update_game();
-void draw_screen();
-void draw_snake();
-void draw_full_snake();
-void erase_tail(int x, int y);
-void draw_food();
-void erase_food();
-void draw_score();
-void draw_borders();
-void spawn_food();
-bool check_collision();
-void show_menu();
-void show_game_over();
-
-void game_timer_check() {
-    if (game_state == STATE_PLAYING) {
-        update_game();
-    }
-}
-
-void init_game() {
-    claim(stdout);
-    set_orientation(2);
-    set_font((unsigned char*)Arial12x12);
-    snake_x[0] = GRID_WIDTH / 2;
-    snake_y[0] = GRID_HEIGHT / 2;
-    snake_length = 1;
-    snake_dx = 1;
-    snake_dy = 0;
-    score = 0;
-    spawn_food();
-    if (game_state == STATE_MENU) {
-        show_menu();
-    } else if (game_state == STATE_PLAYING) {
-        draw_screen();
-    }
-}
-
-void spawn_food() {
-    bool valid;
-    do {
-        food_x = rand() % GRID_WIDTH;
-        food_y = rand() % GRID_HEIGHT;
-        valid = true;
-        for (int i = 0; i < snake_length; i++) {
-            if (snake_x[i] == food_x && snake_y[i] == food_y) {
-                valid = false;
-                break;
-            }
-        }
-    } while (!valid);
-}
-
-void update_game() {
-    int new_x = snake_x[0] + snake_dx;
-    int new_y = snake_y[0] + snake_dy;
-    bool ate_food = (new_x == food_x && new_y == food_y);
-
-    int tail_x = snake_x[snake_length - 1];
-    int tail_y = snake_y[snake_length - 1];
-
-    for (int i = snake_length - 1; i > 0; i--) {
-        snake_x[i] = snake_x[i - 1];
-        snake_y[i] = snake_y[i - 1];
-    }
-
-    snake_x[0] = new_x;
-    snake_y[0] = new_y;
-
-    if (ate_food) {
-        snake_x[snake_length] = tail_x;
-        snake_y[snake_length] = tail_y;
-        snake_length++;
-        score += 10;
-        spawn_food();
-        draw_food();
-    } else {
-        erase_tail(tail_x, tail_y);
-    }
-
-    draw_snake();
-    draw_score();
-
-    if (check_collision()) {
-        draw_borders();
-        game_state = STATE_GAME_OVER;
-        show_game_over();
-        return;
-    }
-}
-
-bool check_collision() {
-    if (snake_x[0] < 0 || snake_x[0] >= GRID_WIDTH || snake_y[0] < 0 || snake_y[0] >= GRID_HEIGHT) {
-        return true;
-    }
-    for (int i = 1; i < snake_length; i++) {
-        if (snake_x[0] == snake_x[i] && snake_y[0] == snake_y[i]) {
-            return true;
-        }
-    }
-    return false;
-}
-
-void draw_screen() {
-    cls();
-    background(COLOR_BACKGROUND);
-    draw_borders();
-    draw_full_snake();
-    draw_food();
-    draw_score();
-}
-
-void draw_snake() {
-    fillrect(1 + snake_x[0] * SNAKE_SIZE, GAME_AREA_TOP + snake_y[0] * SNAKE_SIZE,
-             1 + snake_x[0] * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + snake_y[0] * SNAKE_SIZE + SNAKE_SIZE, COLOR_SNAKE);
-}
-
-void draw_full_snake() {
-    for (int i = 0; i < snake_length; i++) {
-        fillrect(1 + snake_x[i] * SNAKE_SIZE, GAME_AREA_TOP + snake_y[i] * SNAKE_SIZE,
-                 1 + snake_x[i] * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + snake_y[i] * SNAKE_SIZE + SNAKE_SIZE, COLOR_SNAKE);
-    }
-}
-
-void erase_tail(int x, int y) {
-    fillrect(1 + x * SNAKE_SIZE, GAME_AREA_TOP + y * SNAKE_SIZE,
-             1 + x * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + y * SNAKE_SIZE + SNAKE_SIZE, COLOR_BACKGROUND);
-}
-
-void draw_food() {
-    fillrect(1 + food_x * SNAKE_SIZE, GAME_AREA_TOP + food_y * SNAKE_SIZE,
-             1 + food_x * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + food_y * SNAKE_SIZE + SNAKE_SIZE, COLOR_FOOD);
-}
-
-void erase_food() {
-    fillrect(1 + food_x * SNAKE_SIZE, GAME_AREA_TOP + food_y * SNAKE_SIZE,
-             1 + food_x * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + food_y * SNAKE_SIZE + SNAKE_SIZE, COLOR_BACKGROUND);
-}
-
-void draw_score() {
-    auto style = *ui::Theme::getInstance()->fg_blue;
-    painter.draw_string({5, 5}, style, "Score: " + std::to_string(score));
-}
-
-void draw_borders() {
-    rect(0, GAME_AREA_TOP - 1, SCREEN_WIDTH, GAME_AREA_TOP, COLOR_BORDER);
-    rect(0, GAME_AREA_TOP, SCREEN_WIDTH, SCREEN_HEIGHT, COLOR_BORDER);
-}
-
-void show_menu() {
-    cls();
-    background(COLOR_BACKGROUND);
-    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
-    auto style_green = *ui::Theme::getInstance()->fg_green;
-    auto style_blue = *ui::Theme::getInstance()->fg_blue;
-    painter.draw_string({50, 40}, style_yellow, "* * * SNAKE * * *");
-    painter.draw_string({0, 120}, style_blue, "USE THE D-PAD TO MOVE");
-    painter.draw_string({0, 150}, style_blue, "EAT THE RED SQUARES TO GROW");
-    painter.draw_string({0, 180}, style_blue, "DON'T HIT THE WALLS OR SELF");
-    painter.draw_string({15, 240}, style_green, "** PRESS SELECT TO START **");
-}
-
-void show_game_over() {
-    cls();
-    background(COLOR_BACKGROUND);
-    auto style_red = *ui::Theme::getInstance()->fg_red;
-    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
-    auto style_green = *ui::Theme::getInstance()->fg_green;
-    painter.draw_string({75, 90}, style_red, "GAME OVER");
-    painter.draw_string({74, 150}, style_yellow, "SCORE: " + std::to_string(score));
-    painter.draw_string({20, 220}, style_green, "PRESS SELECT TO RESTART");
-    wait(1);
-}
-
-int main() {
-    if (!initialized) {
-        initialized = true;
-        game_timer.attach(&game_timer_check, 1.0 / 5.0);
-        init_game();
-    }
-    while (1) {
-        if (but_SELECT && (game_state == STATE_MENU || game_state == STATE_GAME_OVER)) {
-            game_state = STATE_PLAYING;
-            init_game();
-        }
-    }
-}

firmware/application/external/snake/ui_snake.cpp

@@ -10,7 +10,230 @@
 
 namespace ui::external_app::snake {
 
-#include "snake.cpp"
+Ticker game_timer;
+
+int snake_x[GRID_WIDTH * GRID_HEIGHT];
+int snake_y[GRID_WIDTH * GRID_HEIGHT];
+int snake_length = 1;
+int snake_dx = 1;
+int snake_dy = 0;
+int food_x, food_y;
+int score = 0;
+int game_state = STATE_MENU;
+bool initialized = false;
+
+const Color pp_colors[] = {
+    Color::white(),
+    Color::blue(),
+    Color::yellow(),
+    Color::purple(),
+    Color::green(),
+    Color::red(),
+    Color::magenta(),
+    Color::orange(),
+    Color::black(),
+};
+
+Painter painter;
+
+bool but_RIGHT = false;
+bool but_LEFT = false;
+bool but_SELECT = false;
+
+static Callback game_update_callback = nullptr;
+static uint32_t game_update_timeout = 0;
+static uint32_t game_update_counter = 0;
+
+void cls() {
+    painter.fill_rectangle({0, 0, portapack::display.width(), portapack::display.height()}, Color::black());
+}
+
+void background(int color) {
+    (void)color;
+}
+
+void fillrect(int x1, int y1, int x2, int y2, int color) {
+    painter.fill_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
+}
+
+void rect(int x1, int y1, int x2, int y2, int color) {
+    painter.draw_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
+}
+
+void check_game_timer() {
+    if (game_update_callback) {
+        if (++game_update_counter >= game_update_timeout) {
+            game_update_counter = 0;
+            game_update_callback();
+        }
+    }
+}
+
+void Ticker::attach(Callback func, double delay_sec) {
+    game_update_callback = func;
+    game_update_timeout = delay_sec * 60;
+}
+
+void Ticker::detach() {
+    game_update_callback = nullptr;
+}
+
+void game_timer_check() {
+    if (game_state == STATE_PLAYING) {
+        update_game();
+    }
+}
+
+void init_game() {
+    snake_x[0] = GRID_WIDTH / 2;
+    snake_y[0] = GRID_HEIGHT / 2;
+    snake_length = 1;
+    snake_dx = 1;
+    snake_dy = 0;
+    score = 0;
+    spawn_food();
+    if (game_state == STATE_MENU) {
+        show_menu();
+    } else if (game_state == STATE_PLAYING) {
+        draw_screen();
+    }
+}
+
+void spawn_food() {
+    bool valid;
+    do {
+        food_x = rand() % GRID_WIDTH;
+        food_y = rand() % GRID_HEIGHT;
+        valid = true;
+        for (int i = 0; i < snake_length; i++) {
+            if (snake_x[i] == food_x && snake_y[i] == food_y) {
+                valid = false;
+                break;
+            }
+        }
+    } while (!valid);
+}
+
+void update_game() {
+    int new_x = snake_x[0] + snake_dx;
+    int new_y = snake_y[0] + snake_dy;
+    bool ate_food = (new_x == food_x && new_y == food_y);
+
+    int tail_x = snake_x[snake_length - 1];
+    int tail_y = snake_y[snake_length - 1];
+
+    for (int i = snake_length - 1; i > 0; i--) {
+        snake_x[i] = snake_x[i - 1];
+        snake_y[i] = snake_y[i - 1];
+    }
+
+    snake_x[0] = new_x;
+    snake_y[0] = new_y;
+
+    if (ate_food) {
+        snake_x[snake_length] = tail_x;
+        snake_y[snake_length] = tail_y;
+        snake_length++;
+        score += 10;
+        spawn_food();
+        draw_food();
+    } else {
+        erase_tail(tail_x, tail_y);
+    }
+
+    draw_snake();
+    draw_score();
+
+    if (check_collision()) {
+        draw_borders();
+        game_state = STATE_GAME_OVER;
+        show_game_over();
+        return;
+    }
+}
+
+bool check_collision() {
+    if (snake_x[0] < 0 || snake_x[0] >= GRID_WIDTH || snake_y[0] < 0 || snake_y[0] >= GRID_HEIGHT) {
+        return true;
+    }
+    for (int i = 1; i < snake_length; i++) {
+        if (snake_x[0] == snake_x[i] && snake_y[0] == snake_y[i]) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void draw_screen() {
+    cls();
+    background(COLOR_BACKGROUND);
+    draw_borders();
+    draw_full_snake();
+    draw_food();
+    draw_score();
+}
+
+void draw_snake() {
+    fillrect(1 + snake_x[0] * SNAKE_SIZE, GAME_AREA_TOP + snake_y[0] * SNAKE_SIZE,
+             1 + snake_x[0] * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + snake_y[0] * SNAKE_SIZE + SNAKE_SIZE, COLOR_SNAKE);
+}
+
+void draw_full_snake() {
+    for (int i = 0; i < snake_length; i++) {
+        fillrect(1 + snake_x[i] * SNAKE_SIZE, GAME_AREA_TOP + snake_y[i] * SNAKE_SIZE,
+                 1 + snake_x[i] * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + snake_y[i] * SNAKE_SIZE + SNAKE_SIZE, COLOR_SNAKE);
+    }
+}
+
+void erase_tail(int x, int y) {
+    fillrect(1 + x * SNAKE_SIZE, GAME_AREA_TOP + y * SNAKE_SIZE,
+             1 + x * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + y * SNAKE_SIZE + SNAKE_SIZE, COLOR_BACKGROUND);
+}
+
+void draw_food() {
+    fillrect(1 + food_x * SNAKE_SIZE, GAME_AREA_TOP + food_y * SNAKE_SIZE,
+             1 + food_x * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + food_y * SNAKE_SIZE + SNAKE_SIZE, COLOR_FOOD);
+}
+
+void erase_food() {
+    fillrect(1 + food_x * SNAKE_SIZE, GAME_AREA_TOP + food_y * SNAKE_SIZE,
+             1 + food_x * SNAKE_SIZE + SNAKE_SIZE, GAME_AREA_TOP + food_y * SNAKE_SIZE + SNAKE_SIZE, COLOR_BACKGROUND);
+}
+
+void draw_score() {
+    auto style = *ui::Theme::getInstance()->fg_blue;
+    painter.draw_string({5, 5}, style, "Score: " + std::to_string(score));
+}
+
+void draw_borders() {
+    rect(0, GAME_AREA_TOP - 1, SCREEN_WIDTH, GAME_AREA_TOP, COLOR_BORDER);
+    rect(0, GAME_AREA_TOP, SCREEN_WIDTH, SCREEN_HEIGHT, COLOR_BORDER);
+}
+
+void show_menu() {
+    cls();
+    background(COLOR_BACKGROUND);
+    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
+    auto style_green = *ui::Theme::getInstance()->fg_green;
+    auto style_blue = *ui::Theme::getInstance()->fg_blue;
+    painter.draw_string({50, 40}, style_yellow, "* * * SNAKE * * *");
+    painter.draw_string({0, 120}, style_blue, "USE THE D-PAD TO MOVE");
+    painter.draw_string({0, 150}, style_blue, "EAT THE RED SQUARES TO GROW");
+    painter.draw_string({0, 180}, style_blue, "DON'T HIT THE WALLS OR SELF");
+    painter.draw_string({15, 240}, style_green, "** PRESS SELECT TO START **");
+}
+
+void show_game_over() {
+    cls();
+    background(COLOR_BACKGROUND);
+    auto style_red = *ui::Theme::getInstance()->fg_red;
+    auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
+    auto style_green = *ui::Theme::getInstance()->fg_green;
+    painter.draw_string({75, 90}, style_red, "GAME OVER");
+    painter.draw_string({74, 150}, style_yellow, "SCORE: " + std::to_string(score));
+    painter.draw_string({20, 220}, style_green, "PRESS SELECT TO RESTART");
+    wait(1);
+}
 
 SnakeView::SnakeView(NavigationView& nav)
     : nav_{nav} {

firmware/application/external/snake/ui_snake.hpp

@@ -9,23 +9,105 @@
 #ifndef __UI_SNAKE_H__
 #define __UI_SNAKE_H__
 
+#include "ui.hpp"
 #include "ui_navigation.hpp"
 #include "event_m0.hpp"
 #include "message.hpp"
 #include "irq_controls.hpp"
 #include "random.hpp"
 #include "lpc43xx_cpp.hpp"
-#include "limits.h"
 #include "ui_widget.hpp"
 
 namespace ui::external_app::snake {
 
+enum {
+    White,
+    Blue,
+    Yellow,
+    Purple,
+    Green,
+    Red,
+    Maroon,
+    Orange,
+    Black,
+};
+
+extern const Color pp_colors[];
+extern Painter painter;
+extern bool but_RIGHT;
+extern bool but_LEFT;
+extern bool but_SELECT;
+
+void cls();
+void background(int color);
+void fillrect(int x1, int y1, int x2, int y2, int color);
+void rect(int x1, int y1, int x2, int y2, int color);
+
+#define wait(x) chThdSleepMilliseconds(x * 1000)
+
+using Callback = void (*)(void);
+
+class Ticker {
+   public:
+    Ticker() = default;
+    void attach(Callback func, double delay_sec);
+    void detach();
+};
+
+#define SCREEN_WIDTH 240
+#define SCREEN_HEIGHT 320
+#define SNAKE_SIZE 10
+#define INFO_BAR_HEIGHT 25
+#define GAME_AREA_TOP (INFO_BAR_HEIGHT + 1)
+#define GAME_AREA_HEIGHT (SCREEN_HEIGHT - INFO_BAR_HEIGHT - 2)
+#define GRID_WIDTH ((SCREEN_WIDTH - 2) / SNAKE_SIZE)
+#define GRID_HEIGHT (GAME_AREA_HEIGHT / SNAKE_SIZE)
+#define STATE_MENU 0
+#define STATE_PLAYING 1
+#define STATE_GAME_OVER 2
+
+#define COLOR_BACKGROUND Black
+#define COLOR_SNAKE Green
+#define COLOR_FOOD Red
+#define COLOR_BORDER White
+
+extern Ticker game_timer;
+
+extern int snake_x[GRID_WIDTH * GRID_HEIGHT];
+extern int snake_y[GRID_WIDTH * GRID_HEIGHT];
+extern int snake_length;
+extern int snake_dx;
+extern int snake_dy;
+extern int food_x;
+extern int food_y;
+extern int score;
+extern int game_state;
+extern bool initialized;
+
+void game_timer_check();
+void init_game();
+void update_game();
+void draw_screen();
+void draw_snake();
+void draw_full_snake();
+void erase_tail(int x, int y);
+void draw_food();
+void erase_food();
+void draw_score();
+void draw_borders();
+void spawn_food();
+bool check_collision();
+void show_menu();
+void show_game_over();
+
 class SnakeView : public View {
    public:
     SnakeView(NavigationView& nav);
     void on_show() override;
-    std::string title() const override { return "Snake"; };
-    void focus() override { dummy.focus(); };
+
+    std::string title() const override { return "Snake"; }
+
+    void focus() override { dummy.focus(); }
     void paint(Painter& painter) override;
     void frame_sync();
     bool on_key(KeyEvent key) override;
@@ -33,9 +115,11 @@ class SnakeView : public View {
    private:
     bool initialized = false;
     NavigationView& nav_;
+
     Button dummy{
         {240, 0, 0, 0},
         ""};
+
     MessageHandlerRegistration message_handler_frame_sync{
         Message::ID::DisplayFrameSync,
         [this](const Message* const) {
@@ -45,4 +129,4 @@ class SnakeView : public View {
 
 }  // namespace ui::external_app::snake
 
-#endif /*__UI_SNAKE_H__*/
+#endif /* __UI_SNAKE_H__ */

firmware/application/external/spainter/ui_spectrum_painter_text.cpp

@@ -56,7 +56,7 @@ SpectrumInputTextView::~SpectrumInputTextView() {
 }
 
 void SpectrumInputTextView::on_set_text(NavigationView& nav) {
-    text_prompt(nav, buffer, 300);
+    text_prompt(nav, buffer, 300, ENTER_KEYBOARD_MODE_DIGITS);
 }
 
 void SpectrumInputTextView::focus() {

firmware/application/external/tetris/Arial12x12.h

@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2024 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.
- */
-
-// dummy include file to avoid changing original source
-
-#ifndef __UI_Arial12x12_H__
-#define __UI_Arial12x12_H__
-
-#define Arial12x12 (0)
-
-#endif /*__UI_Arial12x12_H__*/

firmware/application/external/tetris/SPI_TFT_ILI9341.h

@@ -1,110 +0,0 @@
-/*
- * Copyright (C) 2024 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.
- */
-
-// "HAL" display layer for Tetris code to run on PortaPack without its original ILI9341 functions
-
-#ifndef __UI_SPI_TFT_ILI9341_H__
-#define __UI_SPI_TFT_ILI9341_H__
-
-ui::Painter painter;
-
-static int x_pos{0};
-static int y_pos{0};
-static int fg_color;
-static int bg_color;
-
-enum {
-    White,
-    Blue,
-    Yellow,
-    Purple,
-    Green,
-    Red,
-    Maroon,
-    Orange,
-    Black,
-};
-
-// pp_colors must be in same order as enums above
-static const Color pp_colors[] = {
-    Color::white(),
-    Color::blue(),
-    Color::yellow(),
-    Color::purple(),
-    Color::green(),
-    Color::red(),
-    Color::magenta(),
-    Color::orange(),
-    Color::black(),
-};
-
-// NB: ELIMINATED SPI_TFT_ILI9341 DISPLAY CLASS DUE TO GLOBAL OBJECT INITIALIZATION ISSUE WITH EXTERNAL APPS
-
-static void claim(__FILE* x) {
-    (void)x;
-};
-
-static void cls() {
-    painter.fill_rectangle({0, 0, portapack::display.width(), portapack::display.height()}, Color::black());
-};
-
-static void background(int color) {
-    bg_color = color;
-};
-
-static void foreground(int color) {
-    fg_color = color;
-};
-
-static void locate(int x, int y) {
-    x_pos = x;
-    y_pos = y;
-};
-
-static void set_orientation(int x) {
-    (void)x;
-};
-
-static void set_font(unsigned char* x) {
-    (void)x;
-};
-
-static void fillrect(int x1, int y1, int x2, int y2, int color) {
-    painter.fill_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
-};
-
-static void rect(int x1, int y1, int x2, int y2, int color) {
-    painter.draw_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
-};
-
-static void printf(std::string str) {
-    auto style = (fg_color == White) ? *ui::Theme::getInstance()->bg_darkest : *ui::Theme::getInstance()->bg_lightest;
-    painter.draw_string({x_pos, y_pos - 1}, style, str);
-};
-
-static void printf(std::string str, int v) {
-    if (str.find_first_of("%") != std::string::npos) {
-        str.resize(str.find_first_of("%"));  // remove %d from end of string
-    }
-    printf(str + to_string_dec_uint(v));
-};
-
-#endif /*__UI_SPI_TFT_ILI9341_H__*/

firmware/application/external/tetris/mbed.h

@@ -1,220 +0,0 @@
-/*
- * Copyright (C) 2024 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.
- */
-
-// "HAL" layer for Tetris code to run on PortaPack without its original mbed OS
-// (the dream here was to avoid modifying the original code)
-
-#ifndef __UI_mbed_H__
-#define __UI_mbed_H__
-
-using Callback = void (*)(void);
-
-#define wait_us(x) (void)0
-#define wait(x) chThdSleepMilliseconds(x * 1000)
-#define PullUp 1
-
-enum {
-    dp0,
-    dp1,
-    dp2,
-    dp3,
-    dp4,
-    dp5,
-    dp6,
-    dp7,
-    dp8,
-    dp9,
-    dp10,
-    dp11,
-    dp12,
-    dp13,
-    dp14,
-    dp15,
-    dp16,
-    dp17,
-    dp18,
-    dp19,
-    dp20,
-    dp21,
-    dp22,
-    dp23,
-    dp24,
-    dp25,
-};
-
-static bool but_RIGHT;
-static bool but_LEFT;
-static bool but_UP;
-static bool but_DOWN;
-static bool but_SELECT;
-
-//
-// AnalogIn Class -- DID NOT WORK DUE TO GLOBAL OBJECT INITIALIZER ISSUE WITH EXTERNAL APPS -- hacked original code module instead
-//
-// dp9 = joystick rotate button --> select button
-// dp10 = joystick y --> up & down buttons
-// dp11 = joystick x --> left & right buttons
-// dp13 = random number generator
-//
-//
-// class AnalogIn {
-//    public:
-//     AnalogIn(uint32_t analog_input) {
-//         // FIXME - THIS CODE NEVER GETS EXECUTED!
-//         analog_input_ = analog_input;
-//     };
-//
-//     // Tetris code only uses this function for dp13 - supposed to be a random number
-//     uint16_t read_u16() {
-//         return std::rand();
-//     };
-//
-//     // Tetris code uses read() function for direction buttons only
-//     float read() {
-//         float retval = 0.5;
-//         switch (analog_input_) {
-//             case dp11:
-//                 if (but_LEFT)
-//                     retval = 0.0;
-//                 else if (but_RIGHT)
-//                     retval = 1.0;
-//                 break;
-//
-//             case dp10:
-//                 if (but_UP)
-//                     retval = 0.0;
-//                 else if (but_DOWN)
-//                     retval = 1.0;
-//                 break;
-//         }
-//         return retval;
-//     };
-//
-//     operator float() {
-//         return read();
-//     };
-//
-//    private:
-//     uint32_t analog_input_{INT_MAX};
-// };
-
-//
-// Timer Class
-// (Timer object was used for unneeded button debouncing, so just returning 1000ms to indicate we've waited long enough)
-//
-class Timer {
-   public:
-    // NOTE: INITIALIZER CODE WON'T RUN
-    Timer() { (void)0; };
-    void reset() { (void)0; };
-    void start() { (void)0; }
-    uint32_t read_ms() { return 1000; };
-
-   private:
-};
-
-//
-// Ticker Class
-// (Ticker is timed callback, used for checking "joystick" directional switches and when time to move piece down a row)
-//
-// NB: Only one callback is supported per Ticker class instantiation
-static Callback fall_timer_callback;
-static uint32_t fall_timer_timeout;
-static uint32_t fall_timer_counter;
-
-static Callback dir_button_callback;
-
-static void check_fall_timer() {
-    if (fall_timer_callback) {
-        if (++fall_timer_counter >= fall_timer_timeout) {
-            fall_timer_counter = 0;
-            fall_timer_callback();
-        }
-    }
-}
-
-class Ticker {
-   public:
-    // NOTE: INITIALIZER CODE WON'T RUN
-    Ticker() { (void)0; };
-
-    void attach(Callback func, double delay_sec) {
-        // 0.3 sec is requested only for button check -- kludge to use on_key callback for this one instead of timer
-        if (delay_sec == 0.3) {
-            dir_button_callback = func;
-        } else {
-            fall_timer_callback = func;
-            fall_timer_timeout = delay_sec * 60;  // timer interrupts at 60 Hz
-        }
-    }
-
-    void detach() {
-        // shouldn't detach both, but don't know how to tell which object is which
-        dir_button_callback = nullptr;
-        fall_timer_callback = nullptr;
-    }
-
-   private:
-};
-
-//
-// InterruptIn Class
-// (just used for the Select button)
-//
-static Callback sel_button_callback;
-
-static bool check_encoder(const EncoderEvent delta) {
-    (void)delta;
-    // TODO: consider adding ability to rotate Tetronimo via encoder too
-    return false;
-}
-
-static bool check_key(const KeyEvent key) {
-    auto switches_debounced = get_switches_state().to_ulong();
-    but_RIGHT = (switches_debounced & 0x01) != 0;
-    but_LEFT = (switches_debounced & 0x02) != 0;
-    but_DOWN = (switches_debounced & 0x04) != 0;
-    but_UP = (switches_debounced & 0x08) != 0;
-    but_SELECT = (switches_debounced & 0x10) != 0;
-
-    if (key == KeyEvent::Select) {
-        if (sel_button_callback)
-            sel_button_callback();
-    } else {
-        if (dir_button_callback)
-            dir_button_callback();
-    }
-    return true;
-}
-
-class InterruptIn {
-   public:
-    InterruptIn(int reg) {
-        // NOTE: INITIALIZER CODE WON'T RUN
-        (void)reg;
-    };
-    void fall(Callback func) { sel_button_callback = func; };
-    void mode(int v) { (void)v; };
-
-   private:
-};
-
-#endif /*__UI_mbed_H__*/

firmware/application/external/tetris/tetris.cpp

@@ -1,548 +0,0 @@
-// Projekat Tetris
-// by Vrnjak Lamija & Selimović Denis
-// Elektrotehnički fakultet Sarajevo
-
-// clang-format off
-
-//////// HACKED FOR PORTAPACK -- CHANGES HIGHLIGHTED
-int main();
-void pause_game();
-void Initialize(unsigned char c);
-void DeleteFigure();
-void DrawFigure();
-bool InCollisionDown(char delta);
-bool InCollisionLeft();
-bool InCollisionRight();
-//////// PORTAPACK
-
-#include "mbed.h"
-#include "SPI_TFT_ILI9341.h"
-#include "Arial12x12.h"
-
-#define dp23 P0_0
-
-//////// PORTAPACK - DISABLED MOST CLASSES DUE TO GLOBAL OBJECT INITIALIZER ISSUE WITH EXTERNAL APPS:
-//deklaracija display-a
-//SPI_TFT_ILI9341 display(dp2, dp1, dp6, dp24, dp23, dp25, "TFT");
-//
-//analogni ulazi za joystick
-// AnalogIn VRx(dp11);
-// AnalogIn VRy(dp10);
-//
-// AnalogIn random(dp13); //analogni ulaz za generisanje random vrijednosti
-//////// PORTAPACK
-
-//taster na joysticku za rotaciju
-InterruptIn taster(dp9);
-
-//ticker za spustanje figure
-//timer za debouncing tastera na joysticku
-Ticker game, joystick;
-Timer debounceTaster;
-
-unsigned char level = 0; //mora biti tipa usigned char jer inače se može desiti da level bude manji od 0, a i da ne trošimo memoriju
-const float delays[4] = {1.2, 0.7, 0.4, 0.25}; //svakih koliko se spusti jedan red, ovo provjeriti da li je presporo ili prebrzo, ovisi o levelu
-
-//////// PORTAPACK - DELETED UNNEEDED JOYSTICK HYSTERESIS VARIABLES
-//char leftBoundary = 1, rightBoundary = 5, downBoundary = 1, upBoundary = 5;// sada je ovo tipa char
-//////// PORTAPACK
-
-unsigned int score = 0; //stavio sam ovo unsigned int za veći opseg, mada je jako teško da se i int premaši, ali nmvz
-bool firstTime = true; //ako je prvi put, figura se crta u Tickeru
-bool gameStarted = false;
-unsigned char nextFigure = 1; //ovo je sad globalna varijabla, da bi mogli unaprijed generisati sljedeću figuru radi prikaza
-
-//white - no figure
-//I - BLUE
-//O - YELLOW
-//T - PURPLE
-//S - GREEN
-//Z - RED
-//J - MAROON
-//L - ORANGE
-const int colors[8] = {White, Blue, Yellow, Purple, Green, Red, Maroon, Orange};
-const short DIMENSION = 16;
-const short DIMENSION_NEXT = 12;
-short board[20][10] = {0}; //matrica boja, 0 - 7 indeksi boja
-
-short figuresX[7][4] = {{0,0,0,0}, {0,0,1,1}, {0,1,1,1}, {1,1,0,0}, {0,1,0,1}, {1,1,1,0}, {1,1,1,0}};
-short figuresY[7][4] = {{0,1,2,3}, {1,0,0,1}, {1,1,2,0}, {0,1,1,2}, {0,1,1,2}, {2,1,0,0}, {0,1,2,2}};
-
-unsigned int GenerateRandomSeed() {
-//////// PORTAPACK - USE RTC FOR SEED
-return LPC_RTC->CTIME0;
-//////// PORTAPACK
-}
-
-void Init() {
-   //ovo su zajedničke osobine za sve prikaze na display-u
-   //nikad se ne mijenjaju i pozvat ćemo je jednom prije petlje
-    claim(stdout);
-    set_orientation(2); // 2 ili 0, zavisi kako okrenemo display, provjerit ćemo na labu kako nam je najlakše povezat
-    set_font((unsigned char*) Arial12x12);
-}
-
-
-void ShowScore() {
-    //pomocna funkcija za prikazivanje score-a
-    fillrect(165, 20, 235, 50, White); //popunimo pravugaonik da obrišemo stari score
-    locate(200, 35); //valjda je na sredini pravougaonika
-    printf("%d", score);
-}
-
-void ShowNextFigure() {
-    //prikaz sljedeće figure koristeći pomoćnu varijablu nextFigure
-    fillrect(165, 70, 235, 120, White);
-    int upperLeftX = 176, upperLeftY = 83;
-    for(int i = 0; i < 4; i++) {
-        int x = upperLeftX + DIMENSION_NEXT * figuresY[nextFigure - 1][i], y = upperLeftY + DIMENSION_NEXT * figuresX[nextFigure - 1][i];
-        fillrect(x, y, x + DIMENSION_NEXT, y + DIMENSION_NEXT, colors[nextFigure]);
-        rect(x, y, x + DIMENSION_NEXT, y + DIMENSION_NEXT, Black);
-    }
-}
-
-//funkcija za crtanje cursora za odabir levela
-void DrawCursor(int color, unsigned char lev) {
-    fillrect(60, lev * 70 + 50, 72, lev * 70 + 50 + 12,  color);
-}
-
-// PORTAPACK - ADDED EXTRA LEVEL:
-void ShowLevelMenu() {
-    //ovdje inicijalizujemo display
-    cls(); // brišemo prethodno
-    background(Black);
-    foreground(White);
-    locate(80, 50);
-    printf("LEVEL 1");
-    locate(80, 120);
-    printf("LEVEL 2");
-    locate(80, 190);
-    printf("LEVEL 3");
-    locate(80, 260);
-    printf("LEVEL 4");
-    DrawCursor(White, level);
-}
-//////// PORTAPACK
-
-//////// PORTAPACK - USE BUTTONS VS JOYSTICK:
-void ReadJoystickForLevel(){
-    unsigned char old = level;
-    if(but_UP){
-        (level == 0) ? level = 3 : level--;
-    }
-    else if(but_DOWN){
-        //ne radi ona prethodna varijanta jer % vraća i negastivni rezultat
-        //to što ne koristimo unsigned tip ne pomaže jer će doći do overflow-a
-        level = (level + 1) % 4;
-    }
-    DrawCursor(Black, old); //na prethodni level popunimo bojom pozadine
-    DrawCursor(White, level); //na novi level popunimo bijelom bojom - pozadina je crna
-   //koristio sam fillrect, jer njega svakako moramo koristiti, jer možda budemo morali da brišemo fillcircle iz biblioteke
-}
-//////// PORTAPACK
-
-void EndPlay() {
-    joystick.detach();
-    score = 0;
-    firstTime = true;
-    gameStarted = false;
-    for(int i = 0; i < 20; i++) {
-        for(int j = 0; j < 10; j++) {
-            board[i][j] = 0;
-        }
-    }
-//////// PORTAPACK - FIX TO REINITIALIZE SCREEN
-//    ShowLevelMenu();
-//    joystick.attach(&ReadJoystickForLevel, 0.3);
-main();
-//////// PORTAPACK
-}
-
-void StartGame()
-{
-    cls(); // brišemo ShowLevelMenu
-    background(White);
-    foreground(Black);
-    fillrect(0, 0, 160, 320, White);
-    fillrect(160, 0, 240, 320, Black); //dio za prikazivanje rezultata će biti crni pravougaonik, a tabla je bijeli
-    ShowScore();
-}
-
-void copyCoordinates(short X[], short Y[], unsigned char index)
-{
-    //umjesto one prošle metode za kopiranje, ova prima index, čisto da nam olakša život
-    for(int i = 0; i < 4; i++) {
-        X[i] = figuresX[index][i];
-        Y[i] = figuresY[index][i];
-    }
-}
-
-bool BottomEdge(int x){
-    return x > 19;
-}
-
-bool LeftEdge(int y){
-    return y  < 0;
-}
-
-bool RightEdge(int y){
-    return y > 9;
-}
-
-bool OutOfBounds(int y, int x){
-    return y < 0 || y > 9 || x > 19;
-}
-
-void PutBorders(short x, short y) {
-    for(int i = x - 1; i <= x + 1; i++) {
-        for(int j = y - 1; j <= y + 1; j++) {
-            if(i < 0 || i > 9 || j < 0 || j > 19 || board[j][i] == 0) continue;
-            rect(i * DIMENSION, j * DIMENSION, (i + 1) * DIMENSION, (j + 1) * DIMENSION, Black);
-        }
-    }
-}
-
-//////// PORTAPACK - ELIMINATED CLASSES DUE TO GLOBAL OBJECT INITIALIZATION ISSUE WITH EXTERNAL APPS:
-//class Tetromino{
-//private:
-    short X[4];
-    short Y[4];
-    short boardX, boardY;
-    unsigned char colorIndex;//dodao sam colorIndex zasad, jer nema drugog načina da popunimo matricu sa indeksima boja
-    //ovo je najbezbolnija varijanta što se memorije tiče
-//public:
-//    Tetromino(){
-//        unsigned char r = rand() % 7 + 1;
-//        Initialize(r);
-//    }
-
-    void Tetromino(unsigned char c) {
-        Initialize(c);
-    }
-
-    void Initialize(unsigned char c) {
-        colorIndex = c;
-        boardX = 0;
-        boardY = 4; //3,4 ili 5 najbolje da vidimo kad imamo display
-        copyCoordinates(X, Y, c - 1);
-    }
-
-    void Rotate(){
-       short pivotX = X[1], pivotY = Y[1];
-        //prvi elemnti u matrici su pivoti oko koje rotiramo
-
-       short newX[4]; //pozicije blokova nakon rotiranja ako sve bude ok
-       short newY[4];
-
-       for(int i = 0; i < 4; i++){
-           short tmp = X[i], tmp2 = Y[i];
-           newX[i] = pivotX + pivotY - tmp2;
-           newY[i] = tmp + pivotX - pivotY;
-
-           if(OutOfBounds(boardY + newY[i], boardX + newX[i]) || board[boardX + newX[i]][boardY + newY[i]] != 0) return;
-       }
-       DeleteFigure();
-       for(int i = 0; i < 4; i++){
-           X[i] = newX[i];
-           Y[i] = newY[i];
-       }
-       DrawFigure();
-   }
-
-    void DrawFigure() {
-        for(int i = 0; i < 4; i++) {
-            //display je deklarisani display logy iz biblioteke one
-            //računamo gornji lijevi pixel po x i y
-            //donji desni dobijemo kad dodamo DIMENZIJU
-            //stavio sam 16 za početak, možemo se opet skontati na labu
-            //ovo pretpostavlja da nema margina, mogu se lagano dodati uz neku konstantu kao offset
-            int upperLeftX = (boardX + X[i]) * DIMENSION, upperLeftY = (boardY + Y[i]) * DIMENSION;
-            fillrect( upperLeftY, upperLeftX, upperLeftY + DIMENSION, upperLeftX + DIMENSION, colors[colorIndex]);
-            //ovo boji granice blokova u crno, možemo skloniti ako ti se ne sviđa
-            rect( upperLeftY, upperLeftX, upperLeftY + DIMENSION, upperLeftX + DIMENSION, Black);
-        }
-    }
-
-    void DeleteFigure() {
-        for(int i = 0; i < 4; i++) {
-            //ista logika kao u DrawFigure, samo popunjavamo sve blokove sa bijelim pravougaonicima
-            short upperLeftX = (boardX + X[i]) * DIMENSION, upperLeftY = (boardY + Y[i]) * DIMENSION;
-            fillrect( upperLeftY, upperLeftX, upperLeftY + DIMENSION, upperLeftX + DIMENSION, White);
-            PutBorders(upperLeftY, upperLeftX);
-        }
-    }
-
-    void OnAttached() {
-        //metoda se poziva kad figura prestanje da se krece
-        //popunimo matricu indeksom boje
-        for(int i = 0; i < 4; i++) {
-            board[boardX + X[i]][boardY + Y[i]] = colorIndex;
-            //btw board bi mogao biti niz tipa unsigned char, ali to ćemo vidjet kasnije
-        }
-    }
-
-   bool MoveDown(char delta = 1){
-       if(!InCollisionDown(delta)){
-            DeleteFigure();
-            boardX+=delta;
-            DrawFigure();
-            return true;
-       }
-
-       return false;
-   }
-
-   void MoveLeft(){
-       if(!InCollisionLeft()){
-           DeleteFigure();
-           boardY--;
-           DrawFigure();
-       }
-   }
-
-   void MoveRight(){
-       if(!InCollisionRight()){
-           DeleteFigure();
-           boardY++;
-           DrawFigure();
-       }
-   }
-
-   void SoftDrop() {
-       //ovo je funkcija za soft drop
-       //obrisemo figuru, postavimo novu poziciju dva reda ispod, nacrtamo figuru
-       DeleteFigure();
-       MoveDown(2);
-       DrawFigure();
-       //treba još vidjeti koje izmjene u tickeru trebaju
-       score += 2 * (level +1); //prema igrici koju smo igrali, dobije se 14 poena kad se uradi hard drop
-       ShowScore();
-   }
-
-
-   bool InCollisionDown(char delta = 1){
-       int newX, newY; //da bi bilo citljivije
-
-       for(int i = 0; i < 4; i++){
-        newX = boardX + X[i] + delta;
-        newY = boardY + Y[i];
-
-        if(BottomEdge(newX) || board[newX][newY] != 0){
-            return true;
-        }
-        //jedna figura je u koliziji ako
-        //pozicija na koju zelimo da pomjerimo bilo koji blok dotakne dno ili lijevu ili desnu ivicu ekrana
-        //ili ako je pozicija na koju zelimo da pomjerimo bilo koji od blokova vec zauzeta a da nije dio figure prije pomijeranja
-       }
-
-       return false;
-   }
-
-   bool InCollisionLeft(){
-       int newX, newY;
-
-       for(int i = 0; i < 4; i++){
-        newX = boardX + X[i];
-        newY = boardY + Y[i] - 1;
-
-        if(LeftEdge(newY) || board[newX][newY] != 0){
-            return true;
-        }
-       }
-
-       return false;
-   }
-
-
-   bool InCollisionRight(){
-       int newX, newY;
-
-       for(int i = 0; i < 4; i++){
-        newX = boardX + X[i];
-        newY = boardY + Y[i] + 1;
-
-        if(RightEdge(newY) || board[newX][newY] != 0){
-            return true;
-        }
-       }
-
-       return false;
-   }
-// };
-
-// Tetromino currentTetromino;
-
-//////// PORTAPACK - USE BUTTONS VS JOYSTICK, AND ADDED PAUSE FEATURE:
-void ReadJoystickForFigure() {
-    if(but_LEFT) {
-        MoveLeft();
-    }
-    else if(but_RIGHT) {
-        MoveRight();
-    }
-    else if(but_UP) {
-        pause_game();
-    }
-    else if(but_DOWN) {
-        SoftDrop();
-    }
-}
-//////// PORTAPACK
-
-void CheckLines(short &firstLine, short &numberOfLines)
-{
-    //vraća preko reference prvu liniju koja je popunjena do kraja, kao i takvih linija
-    firstLine = -1; //postavljen na -1 jer ako nema linija koje treba brisati ispod u UpdateBoard neće se ući u petlju
-    numberOfLines = 0;
-    for(int i = 19; i >= 0; i--) {
-        short temp = 0;
-        for(int j = 0; j < 10; j++) {
-            if(board[i][j] == 0) {
-                if(numberOfLines > 0) return;
-                break;
-            }//ako je makar jedna bijela, prekida se brojanje
-            temp++;
-        }
-        if(temp == 10) { //ako je temo došao do 10, niti jedna bijela - puna linija
-            numberOfLines++;
-            if(firstLine == -1) firstLine = i; //ovo mijenjamo samo prvi put
-        }
-    }
-}
-
-unsigned int UpdateScore (short numOfLines){
-    unsigned int newIncrement = 0;
-    switch(numOfLines) {
-        case 1 : newIncrement =  40; break;
-        case 2 : newIncrement =  100; break;
-        case 3 : newIncrement =  300; break;
-        case 4 : newIncrement =  1200; break;
-        default : newIncrement = 0; break; //update funkcije za score, još sam vratio ovo na 0
-    }
-    return newIncrement * (level + 1);
-}
-
-void UpdateBoard()
-{
-    short firstLine, numberOfLines;
-     //pozivamo funkciju
-    do {
-        CheckLines(firstLine, numberOfLines);
-        for(int i = firstLine; i >= numberOfLines; i--) {
-            for(int j = 0; j < 10; j++) {
-                board[i][j] = board[i - numberOfLines][j];
-                board[i - numberOfLines][j] = 0;
-                short tmp = i - numberOfLines;
-                fillrect( j * DIMENSION,i * DIMENSION, (j + 1) * DIMENSION , (i + 1) * DIMENSION , colors[board[i][j]]); // bojimo novi blok
-                fillrect( j * DIMENSION, tmp * DIMENSION,(j + 1) * DIMENSION, (tmp + 1) * DIMENSION , White);
-                if(board[i][j] != 0)
-                    rect( j * DIMENSION,i * DIMENSION, (j + 1) * DIMENSION , (i + 1) * DIMENSION , Black);
-            }
-        }
-        score += UpdateScore(numberOfLines);
-    }
-    while(numberOfLines != 0); //ovdje se mijenja globalna varijabla score
-}
-
-bool IsOver() {
-    for(int i = 0; i < 10; i++) {
-        if(board[0][i] != 0) return true;
-    }
-    return false;
-}
-
-void ShowGameOverScreen() {
-//////// PORTAPACK - SKIP CLS
-//    cls();
-//    background(Black);
-//    foreground(White);
-background(White);
-foreground(Black);
-//////// PORTAPACK
-    locate(60, 120);
-    printf("GAME OVER");
-    locate(40, 150);
-    printf("YOUR SCORE IS %d", score);
-    wait(5); //ovaj prikaz traje 3s (možemo mijenjati) a nakon toga se ponovo prikazuje meni sa levelima
-}
-
-void InitGame() {
-    if(firstTime) {
-        Tetromino(rand() % 7 + 1);
-        DrawFigure();
-        nextFigure = rand() % 7 + 1;
-        ShowNextFigure();
-        firstTime = false;
-    }
-}
-
-void PlayGame(){
-    InitGame();
-    if(!MoveDown()){
-        OnAttached();
-        UpdateBoard();
-        ShowScore();
-
-        Tetromino(nextFigure);
-        DrawFigure();
-        nextFigure = rand() % 7 + 1;
-        ShowNextFigure();
-        if(IsOver()) {
-            //ako je igra završena brišemo sve sa displey-a, prikazujemo poruku i score
-            //takođe moramo dettach-at ticker
-            game.detach();
-            ShowGameOverScreen(); //prikaz da je kraj igre, ima wait od 3s
-            EndPlay();
-        }
-    }
-
-}
-
-void OnTasterPressed(){
-    if(debounceTaster.read_ms() > 200) {
-        if(gameStarted){
-            Rotate();
-        }
-        else{
-            joystick.detach();
-            gameStarted = true;
-            StartGame(); //pocinje igra, prikazuje se tabla
-            joystick.attach(&ReadJoystickForFigure, 0.3);
-            game.attach(&PlayGame, delays[level]); //svakih nekoliko spusta figuru jedan red nize
-        }
-        debounceTaster.reset();
-    }
-}
-
-void SetTaster() {
-    taster.mode(PullUp); //mora se aktivirati pull up otpornik na tasteru joystick-a
-    taster.fall(&OnTasterPressed);
-    debounceTaster.reset();
-    debounceTaster.start();
-}
-
-int main() {
-    srand(GenerateRandomSeed());
-    Init();
-    ShowLevelMenu();
-    joystick.attach(&ReadJoystickForLevel, 0.3);
-    SetTaster();
-
-//////// PORTAPACK: CAN'T HANG HERE IN MAYHEM OR WE WON'T GET ANY CALLBACKS
-//    while(1);
-return 0;
-//////// PORTAPACK
-}
-
-//////// PORTAPACK - ADDED PAUSE FEATURE:
-void pause_game() {
-    game.detach();
-    joystick.detach();
-    locate(180, 200);
-    printf("PAUSED");
-    while ((get_switches_state().to_ulong() & 0x10) == 0);  // wait for SELECT button to resume
-    printf("      ");
-    joystick.attach(&ReadJoystickForFigure, 0.3);
-    game.attach(&PlayGame, delays[level]); //svakih nekoliko spusta figuru jedan red nize
-};
-//////// PORTAPACK

firmware/application/external/tetris/ui_tetris.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2024 Mark Thompson
+ * 2025 updates by RocketGod (https://betaskynet.com/)
  *
  * This file is part of PortaPack.
  *
@@ -23,23 +24,567 @@
 
 namespace ui::external_app::tetris {
 
-#pragma GCC diagnostic push
-// external code, so ignore warnings
-#pragma GCC diagnostic ignored "-Weffc++"
-#include "tetris.cpp"
-#pragma GCC diagnostic pop
+Ticker game;
+Ticker joystick;
+
+unsigned char level = 0;
+const float delays[4] = {1.2, 0.7, 0.4, 0.25};
+unsigned int score = 0;
+bool firstTime = true;
+bool gameStarted = false;
+unsigned char nextFigure = 1;
+short board[20][10] = {0};
+const int colors[8] = {White, Blue, Yellow, Purple, Green, Red, Maroon, Orange};
+const short DIMENSION = 16;
+const short DIMENSION_NEXT = 12;
+short figuresX[7][4] = {{0, 0, 0, 0}, {0, 0, 1, 1}, {0, 1, 1, 1}, {1, 1, 0, 0}, {0, 1, 0, 1}, {1, 1, 1, 0}, {1, 1, 1, 0}};
+short figuresY[7][4] = {{0, 1, 2, 3}, {1, 0, 0, 1}, {1, 1, 2, 0}, {0, 1, 1, 2}, {0, 1, 1, 2}, {2, 1, 0, 0}, {0, 1, 2, 2}};
+
+const Color pp_colors[] = {
+    Color::white(),
+    Color::blue(),
+    Color::yellow(),
+    Color::purple(),
+    Color::green(),
+    Color::red(),
+    Color::magenta(),
+    Color::orange(),
+    Color::black(),
+};
+
+Painter painter;
+
+bool but_RIGHT = false;
+bool but_LEFT = false;
+bool but_UP = false;
+bool but_DOWN = false;
+bool but_SELECT = false;
+
+static int x_pos{0};
+static int y_pos{0};
+
+static int rotation_state = 0;
+
+static int fg_color;
+static int bg_color;
+
+static Callback fall_timer_callback = nullptr;
+static uint32_t fall_timer_timeout = 0;
+static uint32_t fall_timer_counter = 0;
+static Callback dir_button_callback = nullptr;
+
+void cls() {
+    painter.fill_rectangle({0, 0, portapack::display.width(), portapack::display.height()}, Color::black());
+}
+
+void background(int color) {
+    bg_color = color;
+}
+
+void foreground(int color) {
+    fg_color = color;
+}
+
+void locate(int x, int y) {
+    x_pos = x;
+    y_pos = y;
+}
+
+void fillrect(int x1, int y1, int x2, int y2, int color) {
+    painter.fill_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
+}
+
+void rect(int x1, int y1, int x2, int y2, int color) {
+    painter.draw_rectangle({x1, y1, x2 - x1, y2 - y1}, pp_colors[color]);
+}
+
+void printf(std::string str) {
+    auto style = (fg_color == White) ? *ui::Theme::getInstance()->bg_darkest : *ui::Theme::getInstance()->fg_light;
+    painter.draw_string({x_pos, y_pos - 1}, style, str);
+}
+
+void printf(std::string str, int v) {
+    if (str.find_first_of("%") != std::string::npos) {
+        str.resize(str.find_first_of("%"));
+    }
+    printf(str + to_string_dec_uint(v));
+}
+
+void check_fall_timer() {
+    if (fall_timer_callback) {
+        if (++fall_timer_counter >= fall_timer_timeout) {
+            fall_timer_counter = 0;
+            fall_timer_callback();
+        }
+    }
+}
+
+void Ticker::attach(Callback func, double delay_sec) {
+    if (delay_sec == 0.3) {
+        dir_button_callback = func;
+    } else {
+        fall_timer_callback = func;
+        fall_timer_timeout = delay_sec * 60;
+    }
+}
+
+void Ticker::detach() {
+    dir_button_callback = nullptr;
+    fall_timer_callback = nullptr;
+}
+
+unsigned int GenerateRandomSeed() {
+    return LPC_RTC->CTIME0;
+}
+
+void Init() {
+}
+
+void ShowScore() {
+    fillrect(165, 10, 235, 60, Black);
+    rect(165, 10, 235, 60, White);
+    locate(200, 35);
+    printf("%d", score);
+}
+
+void ShowNextFigure() {
+    fillrect(165, 70, 235, 130, Black);
+    rect(165, 70, 235, 130, White);
+    int upperLeftX = 176, upperLeftY = 83;
+    for (int i = 0; i < 4; i++) {
+        int x = upperLeftX + DIMENSION_NEXT * figuresY[nextFigure - 1][i], y = upperLeftY + DIMENSION_NEXT * figuresX[nextFigure - 1][i];
+        fillrect(x, y, x + DIMENSION_NEXT, y + DIMENSION_NEXT, colors[nextFigure]);
+        rect(x, y, x + DIMENSION_NEXT, y + DIMENSION_NEXT, Black);
+    }
+}
+
+void DrawCursor(int color, unsigned char lev) {
+    fillrect(60, lev * 70 + 50, 72, lev * 70 + 50 + 12, color);
+}
+
+void ShowLevelMenu() {
+    cls();
+    background(Black);
+    foreground(White);
+    locate(80, 50);
+    printf("LEVEL 1");
+    locate(80, 120);
+    printf("LEVEL 2");
+    locate(80, 190);
+    printf("LEVEL 3");
+    locate(80, 260);
+    printf("LEVEL 4");
+    DrawCursor(White, level);
+}
+
+void ReadJoystickForLevel() {
+    unsigned char old = level;
+    if (but_UP) {
+        (level == 0) ? level = 3 : level--;
+    } else if (but_DOWN) {
+        level = (level + 1) % 4;
+    }
+    if (old != level) {
+        DrawCursor(Black, old);
+        DrawCursor(White, level);
+    }
+}
+
+void EndPlay() {
+    joystick.detach();
+    game.detach();
+    score = 0;
+    firstTime = true;
+    gameStarted = false;
+    for (int i = 0; i < 20; i++) {
+        for (int j = 0; j < 10; j++) {
+            board[i][j] = 0;
+        }
+    }
+    ShowLevelMenu();
+    joystick.attach(&ReadJoystickForLevel, 0.3);
+}
+
+void StartGame() {
+    cls();
+    background(Black);
+    foreground(White);
+    fillrect(0, 0, 162, 320, Black);
+    rect(162, 0, 164, 320, White);
+    fillrect(164, 0, 240, 320, Black);
+    ShowScore();
+    ShowNextFigure();
+}
+
+void copyCoordinates(short X[], short Y[], unsigned char index) {
+    for (int i = 0; i < 4; i++) {
+        X[i] = figuresX[index][i];
+        Y[i] = figuresY[index][i];
+    }
+}
+
+bool BottomEdge(int x) {
+    return x > 19;
+}
+
+bool LeftEdge(int y) {
+    return y < 0;
+}
+
+bool RightEdge(int y) {
+    return y > 9;
+}
+
+bool OutOfBounds(int y, int x) {
+    return y < 0 || y > 9 || x > 19;
+}
+
+void PutBorders(short x, short y) {
+    for (int i = x - 1; i <= x + 1; i++) {
+        for (int j = y - 1; j <= y + 1; j++) {
+            if (i < 0 || i > 9 || j < 0 || j > 19 || board[j][i] == 0) continue;
+            rect(i * DIMENSION, j * DIMENSION, (i + 1) * DIMENSION, (j + 1) * DIMENSION, Black);
+        }
+    }
+}
+
+short X[4];
+short Y[4];
+short boardX, boardY;
+unsigned char colorIndex;
+
+void Tetromino(unsigned char c) {
+    Initialize(c);
+}
+
+void Initialize(unsigned char c) {
+    colorIndex = c;
+    boardX = 0;
+    boardY = 4;
+    copyCoordinates(X, Y, c - 1);
+    rotation_state = 0;
+}
+
+void Rotate() {
+    short newX[4], newY[4];
+    int next_state = (rotation_state + 1) % 4;
+
+    if (colorIndex == 2) {
+        return;
+    }
+
+    const short kick_tests_I[4][5][2] = {
+        {{0, 0}, {-2, 0}, {1, 0}, {-2, -1}, {1, 2}},
+        {{0, 0}, {-1, 0}, {2, 0}, {-1, 2}, {2, -1}},
+        {{0, 0}, {2, 0}, {-1, 0}, {2, 1}, {-1, -2}},
+        {{0, 0}, {1, 0}, {-2, 0}, {1, -2}, {-2, 1}}};
+    const short kick_tests_other[4][5][2] = {
+        {{0, 0}, {-1, 0}, {-1, 1}, {0, -2}, {-1, -2}},
+        {{0, 0}, {1, 0}, {1, -1}, {0, 2}, {1, 2}},
+        {{0, 0}, {1, 0}, {1, 1}, {0, -2}, {1, -2}},
+        {{0, 0}, {-1, 0}, {-1, -1}, {0, 2}, {-1, 2}}};
+
+    bool is_I_tetromino = (colorIndex == 1);
+    const short(*kick_tests)[5][2] = is_I_tetromino ? kick_tests_I : kick_tests_other;
+
+    for (int test = 0; test < 5; test++) {
+        short kickX = kick_tests[rotation_state][test][0];
+        short kickY = kick_tests[rotation_state][test][1];
+
+        for (int i = 0; i < 4; i++) {
+            short tmpX = X[i] - X[1];
+            short tmpY = Y[i] - Y[1];
+            newX[i] = X[1] - tmpY;
+            newY[i] = Y[1] + tmpX;
+            int testX = boardX + newX[i] + kickX;
+            int testY = boardY + newY[i] + kickY;
+            if (OutOfBounds(testY, testX) || (testX >= 0 && board[testX][testY] != 0)) {
+                goto next_test;
+            }
+        }
+
+        DeleteFigure();
+        for (int i = 0; i < 4; i++) {
+            X[i] = newX[i];
+            Y[i] = newY[i];
+        }
+        boardX += kickX;
+        boardY += kickY;
+        rotation_state = next_state;
+        DrawFigure();
+        return;
+
+    next_test:
+        continue;
+    }
+}
+
+void DrawFigure() {
+    for (int i = 0; i < 4; i++) {
+        int upperLeftX = (boardX + X[i]) * DIMENSION, upperLeftY = (boardY + Y[i]) * DIMENSION;
+        fillrect(upperLeftY, upperLeftX, upperLeftY + DIMENSION, upperLeftX + DIMENSION, colors[colorIndex]);
+        rect(upperLeftY, upperLeftX, upperLeftY + DIMENSION, upperLeftX + DIMENSION, Black);
+    }
+}
+
+void DeleteFigure() {
+    for (int i = 0; i < 4; i++) {
+        short upperLeftX = (boardX + X[i]) * DIMENSION, upperLeftY = (boardY + Y[i]) * DIMENSION;
+        fillrect(upperLeftY, upperLeftX, upperLeftY + DIMENSION, upperLeftX + DIMENSION, Black);
+        PutBorders(upperLeftY, upperLeftX);
+    }
+}
+
+void OnAttached() {
+    for (int i = 0; i < 4; i++) {
+        board[boardX + X[i]][boardY + Y[i]] = colorIndex;
+    }
+}
+
+bool MoveDown(char delta) {
+    if (!InCollisionDown(delta)) {
+        DeleteFigure();
+        boardX += delta;
+        DrawFigure();
+        return true;
+    }
+    return false;
+}
+
+void MoveLeft() {
+    if (!InCollisionLeft()) {
+        DeleteFigure();
+        boardY--;
+        DrawFigure();
+    }
+}
+
+void MoveRight() {
+    if (!InCollisionRight()) {
+        DeleteFigure();
+        boardY++;
+        DrawFigure();
+    }
+}
+
+void SoftDrop() {
+    DeleteFigure();
+    MoveDown(2);
+    DrawFigure();
+    score += 2 * (level + 1);
+    ShowScore();
+}
+
+bool InCollisionDown(char delta) {
+    int newX, newY;
+    for (int i = 0; i < 4; i++) {
+        newX = boardX + X[i] + delta;
+        newY = boardY + Y[i];
+        if (BottomEdge(newX) || board[newX][newY] != 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool InCollisionLeft() {
+    int newX, newY;
+    for (int i = 0; i < 4; i++) {
+        newX = boardX + X[i];
+        newY = boardY + Y[i] - 1;
+        if (LeftEdge(newY) || board[newX][newY] != 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool InCollisionRight() {
+    int newX, newY;
+    for (int i = 0; i < 4; i++) {
+        newX = boardX + X[i];
+        newY = boardY + Y[i] + 1;
+        if (RightEdge(newY) || board[newX][newY] != 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void ReadJoystickForFigure() {
+    if (but_LEFT) {
+        MoveLeft();
+    } else if (but_RIGHT) {
+        MoveRight();
+    } else if (but_UP) {
+        pause_game();
+    } else if (but_DOWN) {
+        SoftDrop();
+    } else if (but_SELECT) {
+        Rotate();
+    }
+}
+
+void CheckLines(short& firstLine, short& numberOfLines) {
+    firstLine = -1;
+    numberOfLines = 0;
+    for (int i = 19; i >= 0; i--) {
+        short temp = 0;
+        for (int j = 0; j < 10; j++) {
+            if (board[i][j] == 0) {
+                if (numberOfLines > 0) return;
+                break;
+            }
+            temp++;
+        }
+        if (temp == 10) {
+            numberOfLines++;
+            if (firstLine == -1) firstLine = i;
+        }
+    }
+}
+
+unsigned int UpdateScore(short numOfLines) {
+    unsigned int newIncrement = 0;
+    switch (numOfLines) {
+        case 1:
+            newIncrement = 40;
+            break;
+        case 2:
+            newIncrement = 100;
+            break;
+        case 3:
+            newIncrement = 300;
+            break;
+        case 4:
+            newIncrement = 1200;
+            break;
+        default:
+            newIncrement = 0;
+            break;
+    }
+    return newIncrement * (level + 1);
+}
+
+void UpdateBoard() {
+    short firstLine, numberOfLines;
+    do {
+        CheckLines(firstLine, numberOfLines);
+        for (int i = firstLine; i >= numberOfLines; i--) {
+            for (int j = 0; j < 10; j++) {
+                board[i][j] = board[i - numberOfLines][j];
+                board[i - numberOfLines][j] = 0;
+            }
+        }
+        fillrect(0, 0, 162, 320, Black);
+        for (int i = 0; i < 20; i++) {
+            for (int j = 0; j < 10; j++) {
+                if (board[i][j] != 0) {
+                    fillrect(j * DIMENSION, i * DIMENSION, (j + 1) * DIMENSION, (i + 1) * DIMENSION, colors[board[i][j]]);
+                    rect(j * DIMENSION, i * DIMENSION, (j + 1) * DIMENSION, (i + 1) * DIMENSION, Black);
+                }
+            }
+        }
+        score += UpdateScore(numberOfLines);
+        DrawFigure();
+    } while (numberOfLines != 0);
+}
+
+bool IsOver() {
+    for (int i = 0; i < 10; i++) {
+        if (board[0][i] != 0) return true;
+    }
+    return false;
+}
+
+void ShowGameOverScreen() {
+    background(Black);
+    foreground(White);
+    locate(60, 120);
+    printf("GAME OVER");
+    locate(40, 150);
+    printf("YOUR SCORE IS %d", score);
+    wait(5);
+}
+
+void InitGame() {
+    if (firstTime) {
+        Tetromino(rand() % 7 + 1);
+        DrawFigure();
+        nextFigure = rand() % 7 + 1;
+        ShowNextFigure();
+        firstTime = false;
+    }
+}
+
+void PlayGame() {
+    InitGame();
+    if (!MoveDown(1)) {
+        OnAttached();
+        UpdateBoard();
+        ShowScore();
+        Tetromino(nextFigure);
+        DrawFigure();
+        nextFigure = rand() % 7 + 1;
+        ShowNextFigure();
+        if (IsOver()) {
+            game.detach();
+            ShowGameOverScreen();
+            EndPlay();
+        }
+    }
+}
+
+void OnTasterPressed() {
+    static uint32_t debounce_counter = 0;
+    const uint32_t debounce_threshold = 12;
+
+    if (debounce_counter == 0) {
+        if (!gameStarted) {
+            joystick.detach();
+            gameStarted = true;
+            StartGame();
+            joystick.attach(&ReadJoystickForFigure, 0.3);
+            game.attach(&PlayGame, delays[level]);
+        }
+        debounce_counter = debounce_threshold;
+    } else if (debounce_counter > 0) {
+        debounce_counter--;
+    }
+}
+
+void pause_game() {
+    game.detach();
+    joystick.detach();
+    locate(180, 200);
+    printf("PAUSED");
+    while ((get_switches_state().to_ulong() & 0x10) == 0)
+        ;
+    printf("      ");
+    joystick.attach(&ReadJoystickForFigure, 0.3);
+    game.attach(&PlayGame, delays[level]);
+}
+
+int main() {
+    std::srand(GenerateRandomSeed());
+    Init();
+    ShowLevelMenu();
+    joystick.attach(&ReadJoystickForLevel, 0.3);
+    return 0;
+}
 
 TetrisView::TetrisView(NavigationView& nav)
-    : nav_(nav) {
+    : nav_{nav} {
     add_children({&dummy});
 }
 
+void TetrisView::on_show() {
+}
+
 void TetrisView::paint(Painter& painter) {
     (void)painter;
-
     if (!initialized) {
         initialized = true;
-        std::srand(LPC_RTC->CTIME0);
         main();
     }
 }
@@ -50,11 +595,45 @@ void TetrisView::frame_sync() {
 }
 
 bool TetrisView::on_encoder(const EncoderEvent delta) {
-    return check_encoder(delta);
+    if (!gameStarted) {
+        unsigned char old = level;
+        if (delta > 0) {
+            level = (level + 1) % 4;
+        } else if (delta < 0) {
+            (level == 0) ? level = 3 : level--;
+        }
+        if (old != level) {
+            DrawCursor(Black, old);
+            DrawCursor(White, level);
+        }
+    } else if (gameStarted && delta != 0) {
+        Rotate();
+    }
+    set_dirty();
+    return true;
 }
 
 bool TetrisView::on_key(const KeyEvent key) {
-    return check_key(key);
+    auto switches_debounced = get_switches_state().to_ulong();
+    but_RIGHT = (switches_debounced & 0x01) != 0;
+    but_LEFT = (switches_debounced & 0x02) != 0;
+    but_DOWN = (switches_debounced & 0x04) != 0;
+    but_UP = (switches_debounced & 0x08) != 0;
+    but_SELECT = (switches_debounced & 0x10) != 0;
+
+    if (key == KeyEvent::Select) {
+        if (!gameStarted) {
+            OnTasterPressed();
+        } else {
+            Rotate();
+        }
+    } else if (gameStarted) {
+        ReadJoystickForFigure();
+    } else {
+        ReadJoystickForLevel();
+    }
+    set_dirty();
+    return true;
 }
 
-}  // namespace ui::external_app::tetris
+}  // namespace ui::external_app::tetris

firmware/application/external/tetris/ui_tetris.hpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2024 Mark Thompson
+ * 2025 updates by RocketGod (https://betaskynet.com/)
  *
  * This file is part of PortaPack.
  *
@@ -22,6 +23,7 @@
 #ifndef __UI_TETRIS_H__
 #define __UI_TETRIS_H__
 
+#include "ui.hpp"
 #include "ui_navigation.hpp"
 #include "event_m0.hpp"
 #include "message.hpp"
@@ -29,16 +31,113 @@
 #include "random.hpp"
 #include "lpc43xx_cpp.hpp"
 #include "limits.h"
+#include "ui_widget.hpp"
 
 namespace ui::external_app::tetris {
 
+enum {
+    White,
+    Blue,
+    Yellow,
+    Purple,
+    Green,
+    Red,
+    Maroon,
+    Orange,
+    Black,
+};
+
+extern const Color pp_colors[];
+extern Painter painter;
+extern bool but_RIGHT;
+extern bool but_LEFT;
+extern bool but_UP;
+extern bool but_DOWN;
+extern bool but_SELECT;
+
+void cls();
+void background(int color);
+void foreground(int color);
+void locate(int x, int y);
+void fillrect(int x1, int y1, int x2, int y2, int color);
+void rect(int x1, int y1, int x2, int y2, int color);
+void printf(std::string str);
+void printf(std::string str, int v);
+
+#define wait(x) chThdSleepMilliseconds(x * 1000)
+
+using Callback = void (*)(void);
+
+class Ticker {
+   public:
+    Ticker() = default;
+    void attach(Callback func, double delay_sec);
+    void detach();
+};
+
+extern Ticker game;
+extern Ticker joystick;
+
+extern unsigned char level;
+extern const float delays[4];
+extern unsigned int score;
+extern bool firstTime;
+extern bool gameStarted;
+extern unsigned char nextFigure;
+extern short board[20][10];
+extern const int colors[8];
+extern const short DIMENSION;
+extern const short DIMENSION_NEXT;
+extern short figuresX[7][4];
+extern short figuresY[7][4];
+
+unsigned int GenerateRandomSeed();
+void Init();
+void ShowScore();
+void ShowNextFigure();
+void DrawCursor(int color, unsigned char lev);
+void ShowLevelMenu();
+void ReadJoystickForLevel();
+void EndPlay();
+void StartGame();
+void copyCoordinates(short X[], short Y[], unsigned char index);
+bool BottomEdge(int x);
+bool LeftEdge(int y);
+bool RightEdge(int y);
+bool OutOfBounds(int y, int x);
+void PutBorders(short x, short y);
+void Tetromino(unsigned char c);
+void Initialize(unsigned char c);
+void Rotate();
+void DrawFigure();
+void DeleteFigure();
+void OnAttached();
+bool MoveDown(char delta);
+void MoveLeft();
+void MoveRight();
+void SoftDrop();
+bool InCollisionDown(char delta);
+bool InCollisionLeft();
+bool InCollisionRight();
+void ReadJoystickForFigure();
+void CheckLines(short& firstLine, short& numberOfLines);
+unsigned int UpdateScore(short numOfLines);
+void UpdateBoard();
+bool IsOver();
+void ShowGameOverScreen();
+void InitGame();
+void PlayGame();
+void OnTasterPressed();
+void pause_game();
+
 class TetrisView : public View {
    public:
     TetrisView(NavigationView& nav);
+    void on_show() override;
 
-    std::string title() const override { return "Tetris"; };
+    std::string title() const override { return "Tetris"; }
 
-    void focus() override { dummy.focus(); };
+    void focus() override { dummy.focus(); }
     void paint(Painter& painter) override;
     void frame_sync();
     bool on_encoder(const EncoderEvent event) override;
@@ -61,4 +160,4 @@ class TetrisView : public View {
 
 }  // namespace ui::external_app::tetris
 
-#endif /*__UI_TETRIS_H__*/
+#endif /* __UI_TETRIS_H__ */

firmware/application/receiver_model.cpp

@@ -39,14 +39,22 @@ using namespace portapack;
 
 namespace {
 
-static constexpr std::array<baseband::AMConfig, 6> am_configs{{
+static constexpr std::array<baseband::AMConfig, 12> am_configs{{
     // we config here all the non COMMON parameters to each AM modulation type in RX.
-    {taps_9k0_decim_2, taps_9k0_dsb_channel, AMConfigureMessage::Modulation::DSB, audio_12k_hpf_300hz_config},            // AM DSB-C  BW 9khz  (+-4k5)  commercial EU bandwidth .
-    {taps_6k0_decim_2, taps_6k0_dsb_channel, AMConfigureMessage::Modulation::DSB, audio_12k_hpf_300hz_config},            // AM DSB-C  BW 6khz  (+-3k0)  narrow AM , ham equipments.
-    {taps_6k0_decim_2, taps_2k8_usb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config},            // SSB USB   BW 2K8   (+ 2K8)  SSB ham equipments.
-    {taps_6k0_decim_2, taps_2k8_lsb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config},            // SSB LSB   BW 2K8   (- 2K8)  SSB ham equipments.
-    {taps_6k0_decim_2, taps_0k7_usb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config},            // SSB USB   BW 0K7   (+ 0K7)  To get audio tone from CW Morse, assuming tx shifted +700hz aprox
-    {taps_6k0_decim_2, taps_2k6_usb_wefax_channel, AMConfigureMessage::Modulation::SSB_FM, audio_12k_lpf_1500hz_config},  // SSB USB+FM  to demod. Subcarrier FM Audio Tones to get APT Weather Fax.
+    {taps_6k0_decim_1, taps_9k0_decim_2, taps_9k0_dsb_channel, AMConfigureMessage::Modulation::DSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_1},            // AM DSB-C  BW 9khz  (+-4k5)  commercial EU bandwidth .
+    {taps_6k0_decim_1, taps_6k0_decim_2, taps_6k0_dsb_channel, AMConfigureMessage::Modulation::DSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_1},            // AM DSB-C  BW 6khz  (+-3k0)  narrow AM , ham equipments.
+    {taps_6k0_decim_1, taps_6k0_decim_2, taps_2k8_usb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_1},            // SSB USB   BW 2K8   (+ 2K8)  SSB ham equipments.
+    {taps_6k0_decim_1, taps_6k0_decim_2, taps_2k8_lsb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_1},            // SSB LSB   BW 2K8   (- 2K8)  SSB ham equipments.
+    {taps_6k0_decim_1, taps_6k0_decim_2, taps_0k7_usb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_1},            // SSB USB   BW 0K7   (+ 0K7)  To get audio tone from CW Morse, assuming tx shifted +700hz aprox
+    {taps_6k0_decim_1, taps_6k0_decim_2, taps_2k6_usb_wefax_channel, AMConfigureMessage::Modulation::SSB_FM, audio_12k_lpf_1500hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_1},  // SSB USB+FM  to demod. Subcarrier FM Audio Tones to get APT Weather Fax.
+
+    // below options for Waterfall zoom x 2
+    {taps_6k0_narrow_decim_1, taps_9k0_decim_2, taps_9k0_dsb_channel, AMConfigureMessage::Modulation::DSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_2},            // AM DSB-C  BW 9khz  (+-4k5)  commercial EU bandwidth .
+    {taps_6k0_narrow_decim_1, taps_6k0_decim_2, taps_6k0_dsb_channel, AMConfigureMessage::Modulation::DSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_2},            // AM DSB-C  BW 6khz  (+-3k0)  narrow AM , ham equipments.
+    {taps_6k0_narrow_decim_1, taps_6k0_decim_2, taps_2k8_usb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_2},            // SSB USB   BW 2K8   (+ 2K8)  SSB ham equipments.
+    {taps_6k0_narrow_decim_1, taps_6k0_decim_2, taps_2k8_lsb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_2},            // SSB LSB   BW 2K8   (- 2K8)  SSB ham equipments.
+    {taps_6k0_narrow_decim_1, taps_6k0_decim_2, taps_0k7_usb_channel, AMConfigureMessage::Modulation::SSB, audio_12k_hpf_300hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_2},            // SSB USB   BW 0K7   (+ 0K7)  To get audio tone from CW Morse, assuming tx shifted +700hz aprox
+    {taps_6k0_narrow_decim_1, taps_6k0_decim_2, taps_2k6_usb_wefax_channel, AMConfigureMessage::Modulation::SSB_FM, audio_12k_lpf_1500hz_config, (int)AMConfigureMessage::Zoom_waterfall::ZOOM_x_2},  // SSB USB+FM  to demod. Subcarrier FM Audio Tones to get APT Weather Fax with waterfall zoom x 2 (we need taps_6k0_narrow_decim_1 to minimize aliasing)
 }};
 
 static constexpr std::array<baseband::NBFMConfig, 3> nbfm_configs{{

firmware/application/ui/ui_alphanum.cpp

@@ -32,7 +32,8 @@ namespace ui {
 AlphanumView::AlphanumView(
     NavigationView& nav,
     std::string& str,
-    size_t max_length)
+    size_t max_length,
+    uint8_t enter_mode)
     : TextEntryView(nav, str, max_length) {
     size_t n;
 
@@ -76,7 +77,7 @@ AlphanumView::AlphanumView(
         n++;
     }
 
-    set_mode(mode);
+    set_mode(enter_mode);
 
     button_mode.on_select = [this](Button&) {
         set_mode(mode + 1);

firmware/application/ui/ui_alphanum.hpp

@@ -37,7 +37,7 @@ namespace ui {
 
 class AlphanumView : public TextEntryView {
    public:
-    AlphanumView(NavigationView& nav, std::string& str, size_t max_length);
+    AlphanumView(NavigationView& nav, std::string& str, size_t max_length, uint8_t enter_mode);
 
     AlphanumView(const AlphanumView&) = delete;
     AlphanumView(AlphanumView&&) = delete;

firmware/application/ui/ui_textentry.cpp

@@ -31,8 +31,9 @@ void text_prompt(
     NavigationView& nav,
     std::string& str,
     size_t max_length,
+    uint8_t mode,
     std::function<void(std::string&)> on_done) {
-    text_prompt(nav, str, str.length(), max_length, on_done);
+    text_prompt(nav, str, str.length(), max_length, mode, on_done);
 }
 
 void text_prompt(
@@ -40,8 +41,9 @@ void text_prompt(
     std::string& str,
     uint32_t cursor_pos,
     size_t max_length,
+    uint8_t mode,
     std::function<void(std::string&)> on_done) {
-    auto te_view = nav.push<AlphanumView>(str, max_length);
+    auto te_view = nav.push<AlphanumView>(str, max_length, mode);
     te_view->set_cursor(cursor_pos);
     te_view->on_changed = [on_done](std::string& value) {
         if (on_done)

firmware/application/ui/ui_textentry.hpp

@@ -26,6 +26,11 @@
 #include "ui.hpp"
 #include "ui_navigation.hpp"
 
+#define ENTER_KEYBOARD_MODE_ALPHA 0
+#define ENTER_KEYBOARD_MODE_DIGITS 1
+#define ENTER_KEYBOARD_MODE_SYMBOLS 2
+#define ENTER_KEYBOARD_MODE_HEX 3
+
 namespace ui {
 
 class TextEntryView : public View {
@@ -62,6 +67,7 @@ void text_prompt(
     NavigationView& nav,
     std::string& str,
     size_t max_length,
+    uint8_t mode,
     std::function<void(std::string&)> on_done = nullptr);
 
 void text_prompt(
@@ -69,6 +75,7 @@ void text_prompt(
     std::string& str,
     uint32_t cursor_pos,
     size_t max_length,
+    uint8_t mode,  // enter mode: 123 abc etc
     std::function<void(std::string&)> on_done = nullptr);
 
 } /* namespace ui */

firmware/application/ui_navigation.cpp

@@ -24,8 +24,6 @@
 
 #include "ui_navigation.hpp"
 
-#include "bmp_modal_warning.hpp"
-#include "bmp_splash.hpp"
 #include "event_m0.hpp"
 #include "portapack_persistent_memory.hpp"
 #include "portapack_shared_memory.hpp"
@@ -44,7 +42,6 @@
 #include "ui_font_fixed_8x16.hpp"
 #include "ui_freqman.hpp"
 #include "ui_iq_trim.hpp"
-#include "ui_level.hpp"
 #include "ui_looking_glass_app.hpp"
 #include "ui_mictx.hpp"
 
@@ -52,7 +49,7 @@
 #include "ui_pocsag_tx.hpp"
 #include "ui_rds.hpp"
 #include "ui_recon.hpp"
-#include "ui_scanner.hpp"
+// #include "ui_scanner.hpp"
 #include "ui_sd_over_usb.hpp"
 #include "ui_search.hpp"
 #include "ui_settings.hpp"
@@ -133,22 +130,13 @@ const NavigationView::AppList NavigationView::appList = {
     {"ais", "AIS Boats", RX, Color::green(), &bitmap_icon_ais, new ViewFactory<AISAppView>()},
     {"aprsrx", "APRS", RX, Color::green(), &bitmap_icon_aprs, new ViewFactory<APRSRXView>()},
     {"audio", "Audio", RX, Color::green(), &bitmap_icon_speaker, new ViewFactory<AnalogAudioView>()},
-    //{"blecomm", "BLE Comm", RX, ui::Color::orange(), &bitmap_icon_btle, new ViewFactory<BLECommView>()},
     {"blerx", "BLE Rx", RX, Color::green(), &bitmap_icon_btle, new ViewFactory<BLERxView>()},
     {"ert", "ERT Meter", RX, Color::green(), &bitmap_icon_ert, new ViewFactory<ERTAppView>()},
-    {"level", "Level", RX, Color::green(), &bitmap_icon_options_radio, new ViewFactory<LevelView>()},
     {"pocsag", "POCSAG", RX, Color::green(), &bitmap_icon_pocsag, new ViewFactory<POCSAGAppView>()},
     {"radiosonde", "Radiosnde", RX, Color::green(), &bitmap_icon_sonde, new ViewFactory<SondeView>()},
-    {"scanner", "Scanner", RX, Color::green(), &bitmap_icon_scanner, new ViewFactory<ScannerView>()},
     {"search", "Search", RX, Color::yellow(), &bitmap_icon_search, new ViewFactory<SearchView>()},
     {"subghzd", "SubGhzD", RX, Color::yellow(), &bitmap_icon_remote, new ViewFactory<SubGhzDView>()},
     {"weather", "Weather", RX, Color::green(), &bitmap_icon_thermometer, new ViewFactory<WeatherView>()},
-    //{"fskrx", "FSK RX", RX, Color::yellow(), &bitmap_icon_remote, new ViewFactory<FskxRxMainView>()}, //for JT
-    //{"dmr", "DMR", RX, Color::dark_grey(), &bitmap_icon_dmr, new ViewFactory<NotImplementedView>()},
-    //{"sigfox", "SIGFOX", RX, Color::dark_grey(), &bitmap_icon_fox, new ViewFactory<NotImplementedView>()},
-    //{"lora", "LoRa", RX, Color::dark_grey(), &bitmap_icon_lora, new ViewFactory<NotImplementedView>()},
-    //{"sstv", "SSTV", RX, Color::dark_grey(), &bitmap_icon_sstv, new ViewFactory<NotImplementedView>()},
-    //{"tetra", "TETRA", RX, Color::dark_grey(), &bitmap_icon_tetra, new ViewFactory<NotImplementedView>()},
     /* TX ********************************************************************/
     {"aprstx", "APRS TX", TX, ui::Color::green(), &bitmap_icon_aprs, new ViewFactory<APRSTXView>()},
     {"bht", "BHT Xy/EP", TX, ui::Color::green(), &bitmap_icon_bht, new ViewFactory<BHTView>()},
@@ -158,7 +146,7 @@ const NavigationView::AppList NavigationView::appList = {
     {"rdstx", "RDS", TX, ui::Color::green(), &bitmap_icon_rds, new ViewFactory<RDSView>()},
     {"soundbrd", "Soundbrd", TX, ui::Color::green(), &bitmap_icon_soundboard, new ViewFactory<SoundBoardView>()},
     {"touchtune", "TouchTune", TX, ui::Color::green(), &bitmap_icon_touchtunes, new ViewFactory<TouchTunesView>()},
-    {"signalgen", "Signal Gen", TX, Color::green(), &bitmap_icon_cwgen, new ViewFactory<SigGenView>()},
+    {"signalgen", "SignalGen", TX, Color::green(), &bitmap_icon_cwgen, new ViewFactory<SigGenView>()},
     /* UTILITIES *************************************************************/
     {"filemanager", "File Manager", UTILITIES, Color::green(), &bitmap_icon_dir, new ViewFactory<FileManagerView>()},
     {"freqman", "Freq. Manager", UTILITIES, Color::green(), &bitmap_icon_freqman, new ViewFactory<FrequencyManagerView>()},
@@ -355,7 +343,7 @@ void SystemStatusView::on_battery_data(const BatteryStateMessage* msg) {
 
     // Check if charging state changed to charging
     static bool was_charging = false;
-    if (msg->on_charger && !was_charging) {
+    if (msg->on_charger && !was_charging && pmem::ui_battery_charge_hint()) {
         // Only show charging modal when transitioning to charging state
         nav_.display_modal(
             "CHARGING",
@@ -1049,7 +1037,12 @@ SplashScreenView::SplashScreenView(NavigationView& nav)
 void SplashScreenView::paint(Painter&) {
     if (!portapack::display.draw_bmp_from_sdcard_file({0, 0}, splash_dot_bmp))
         // ^ try draw bmp file from sdcard at (0,0), and the (0,0) already bypassed the status bar, so actual pos is (0, STATUS_BAR_HEIGHT)
-        portapack::display.draw_bmp_from_bmp_hex_arr({(240 - 230) / 2, (320 - 50) / 2 - 10}, splash_bmp, (const uint8_t[]){0x29, 0x18, 0x16});
+        portapack::display.draw_bitmap({screen_width / 2 - 120,
+                                        screen_height / 2},
+                                       bitmap_titlebar_image.size,
+                                       bitmap_titlebar_image.data,
+                                       Theme::getInstance()->bg_darkest->foreground,
+                                       Theme::getInstance()->bg_darkest->background, 3);
     // ^ draw BMP HEX arr in firmware, note that the BMP HEX arr only cover the image part (instead of fill the screen with background, this position is located it in the center)
 }
 
@@ -1144,7 +1137,12 @@ ModalMessageView::ModalMessageView(
 }
 
 void ModalMessageView::paint(Painter& painter) {
-    if (!compact) portapack::display.draw_bmp_from_bmp_hex_arr({100, 48}, modal_warning_bmp, (const uint8_t[]){0, 0, 0});
+    if (!compact) portapack::display.draw_bitmap({screen_width / 2 - 3 * 16 / 2,
+                                                  screen_height / 2 - 3 * 16 / 2 - 100},
+                                                 bitmap_icon_utilities.size,
+                                                 bitmap_icon_utilities.data,
+                                                 Theme::getInstance()->bg_darkest->foreground,
+                                                 Theme::getInstance()->bg_darkest->background, 3);
 
     // Break lines.
     auto lines = split_string(message_, '\n');

firmware/baseband/proc_am_audio.cpp

@@ -113,13 +113,8 @@ void NarrowbandAMAudio::configure(const AMConfigureMessage& message) {
     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;
 
-    // modulation_ssb = (message.modulation == AMConfigureMessage::Modulation::SSB);  // originally we had just 2 AM types of demod. (DSB , SSB)
     modulation_ssb = (int)message.modulation;  // now sending by message , 3 types of AM demod :   enum class Modulation : int32_t {DSB = 0, SSB = 1, SSB_FM = 2}
-    if (modulation_ssb == (int)(AMConfigureMessage::Modulation::SSB_FM)) {
-        channel_spectrum.set_decimation_factor(6.0f);  // zooming for better tuning {SSB_FM = 2}
-    } else {
-        channel_spectrum.set_decimation_factor(1.0f);  // no zooming .{DSB = 0, SSB = 1,}
-    }
+    channel_spectrum.set_decimation_factor(message.channel_spectrum_decimation_factor);
     audio_output.configure(message.audio_hpf_lpf_config);  // hpf in all AM demod modes (AM-6K/9K, USB/LSB,DSB), except Wefax (lpf there).
 
     configured = true;

firmware/common/dsp_fir_taps.hpp

@@ -512,6 +512,51 @@ constexpr fir_taps_real<32> taps_6k0_decim_1{
     }},
 };
 
+// IFIR prototype filter: fs=384000, pass=3000, stop=33000, decim=8, fout=48000
+// Narrower taps_6k0_decim_1IFIR version to avoid LCD waterfall  aliasing in AMFM Wefax in ZOOM X 2 (means spectrum decimation factor x2)
+// It has BW -3dB's of +-9Khz, Stop band from 33khz onwards -60 dB's , then we can use in all AM modes (DSB, SSB,CW )
+constexpr fir_taps_real<32> taps_6k0_narrow_decim_1{
+    .low_frequency_normalized = -3000.0f / 384000.0f,
+    .high_frequency_normalized = 3000.0f / 384000.0f,
+    .transition_normalized = 30000.0f / 384000.0f,
+    .taps = {{
+
+        58,
+        80,
+        138,
+        219,
+        326,
+        461,
+        622,
+        807,
+        1011,
+        1224,
+        1438,
+        1640,
+        1820,
+        1966,
+        2069,
+        2122,
+        2122,
+        2069,
+        1966,
+        1820,
+        1640,
+        1438,
+        1224,
+        1011,
+        807,
+        622,
+        461,
+        326,
+        219,
+        138,
+        80,
+        58,
+
+    }},
+};
+
 // IFIR prototype filter: fs=48000, pass=3000, stop=6700, decim=4, fout=12000
 constexpr fir_taps_real<32> taps_6k0_decim_2{
     .low_frequency_normalized = -3000.0f / 48000.0f,

firmware/common/lcd_ili9341.cpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2016 Furrtek
+ * copyleft 2025 Whiterose of the Dark Army
  *
  * This file is part of PortaPack.
  *
@@ -646,31 +647,58 @@ void ILI9341::draw_bitmap(
     const ui::Size size,
     const uint8_t* const pixels,
     const ui::Color foreground,
-    const ui::Color background) {
-    // Not a transparent background
-    if (ui::Color::magenta().v != background.v) {
-        lcd_start_ram_write(p, size);
+    const ui::Color background,
+    uint8_t zoom_level) {
+    if (zoom_level <= 1) {
+        // Not a transparent background
+        if (ui::Color::magenta().v != background.v) {
+            lcd_start_ram_write(p, size);
 
-        const size_t count = size.width() * size.height();
-        for (size_t i = 0; i < count; i++) {
-            const auto pixel = pixels[i >> 3] & (1U << (i & 0x7));
-            io.lcd_write_pixel(pixel ? foreground : background);
-        }
-    } else {
-        int x = p.x();
-        int y = p.y();
-        int maxX = x + size.width();
-        const size_t count = size.width() * size.height();
-        for (size_t i = 0; i < count; i++) {
-            const auto pixel = pixels[i >> 3] & (1U << (i & 0x7));
-            if (pixel) {
-                draw_pixel(ui::Point(x, y), foreground);
+            const size_t count = size.width() * size.height();
+            for (size_t i = 0; i < count; i++) {
+                const auto pixel = pixels[i >> 3] & (1U << (i & 0x7));
+                io.lcd_write_pixel(pixel ? foreground : background);
             }
-            // Move to the next pixel
-            x++;
-            if (x >= maxX) {
-                x = p.x();
-                y++;
+        } else {
+            // transparent bg
+            int x = p.x();
+            int y = p.y();
+            int maxX = x + size.width();
+            const size_t count = size.width() * size.height();
+            for (size_t i = 0; i < count; i++) {
+                const auto pixel = pixels[i >> 3] & (1U << (i & 0x7));
+                if (pixel) {
+                    draw_pixel(ui::Point(x, y), foreground);
+                }
+                // move to next px
+                x++;
+                if (x >= maxX) {
+                    x = p.x();
+                    y++;
+                }
+            }
+        }
+    } else {  // zoom
+
+        // dot to square
+        for (int y = 0; y < size.height(); y++) {
+            for (int x = 0; x < size.width(); x++) {
+                // pos
+                size_t bit_index = y * size.width() + x;
+                int byte_index = bit_index >> 3;
+                int bit_pos = bit_index & 0x7;
+
+                // val
+                const auto pixel = pixels[byte_index] & (1U << bit_pos);
+                /*                 ^ the byte_index-th bit AKA current bit
+                                                         ^ current px in current byte*/
+
+                if (pixel || background.v != ui::Color::magenta().v) {
+                    fill_rectangle(
+                        {p.x() + x * zoom_level, p.y() + y * zoom_level,
+                         zoom_level, zoom_level},
+                        pixel ? foreground : background);
+                }
             }
         }
     }
@@ -680,8 +708,9 @@ void ILI9341::draw_glyph(
     const ui::Point p,
     const ui::Glyph& glyph,
     const ui::Color foreground,
-    const ui::Color background) {
-    draw_bitmap(p, glyph.size(), glyph.pixels(), foreground, background);
+    const ui::Color background,
+    uint8_t zoom_level) {
+    draw_bitmap(p, glyph.size(), glyph.pixels(), foreground, background, zoom_level);
 }
 
 void ILI9341::scroll_set_area(

firmware/common/lcd_ili9341.hpp

@@ -86,13 +86,15 @@ class ILI9341 {
         const ui::Size size,
         const uint8_t* const data,
         const ui::Color foreground,
-        const ui::Color background);
+        const ui::Color background,
+        uint8_t zoom_level = 1);
 
     void draw_glyph(
         const ui::Point p,
         const ui::Glyph& glyph,
         const ui::Color foreground,
-        const ui::Color background);
+        const ui::Color background,
+        uint8_t zoom_level = 1);
 
     /*** Scrolling ***
      * Scrolling support is implemented in the ILI9341 driver. Basically a region

firmware/common/message.hpp

@@ -591,6 +591,10 @@ class AMConfigureMessage : public Message {
         SSB = 1,
         SSB_FM = 2,  // Added new for RX Wefax mode,  to demodulate APT signal ,FM modulated inside audio subcarrier tones, and then up broadcasted in SSB USB .
     };
+    enum class Zoom_waterfall : size_t {
+        ZOOM_x_1 = 1,
+        ZOOM_x_2 = 2,
+    };
 
     constexpr AMConfigureMessage(
         const fir_taps_real<24> decim_0_filter,
@@ -598,14 +602,17 @@ class AMConfigureMessage : public Message {
         const fir_taps_real<32> decim_2_filter,
         const fir_taps_complex<64> channel_filter,
         const Modulation modulation,
-        const iir_biquad_config_t audio_hpf_lpf_config)
+        const iir_biquad_config_t audio_hpf_lpf_config,
+        const size_t channel_spectrum_decimation_factor)
+
         : Message{ID::AMConfigure},
           decim_0_filter(decim_0_filter),
           decim_1_filter(decim_1_filter),
           decim_2_filter(decim_2_filter),
           channel_filter(channel_filter),
           modulation{modulation},
-          audio_hpf_lpf_config(audio_hpf_lpf_config) {
+          audio_hpf_lpf_config(audio_hpf_lpf_config),
+          channel_spectrum_decimation_factor(channel_spectrum_decimation_factor) {
     }
 
     const fir_taps_real<24> decim_0_filter;
@@ -614,6 +621,7 @@ class AMConfigureMessage : public Message {
     const fir_taps_complex<64> channel_filter;
     const Modulation modulation;
     const iir_biquad_config_t audio_hpf_lpf_config;
+    const size_t channel_spectrum_decimation_factor;
 };
 
 // TODO: Put this somewhere else, or at least the implementation part.

firmware/common/portapack_persistent_memory.cpp

@@ -137,9 +137,9 @@ struct ui_config2_t {
     bool button_repeat_delay : 1;
     bool button_repeat_speed : 1;
     bool button_long_press_delay : 1;
+    bool battery_charge_hint : 1;
 
     uint8_t theme_id;
-    uint8_t PLACEHOLDER_3;
 };
 static_assert(sizeof(ui_config2_t) == sizeof(uint32_t));
 
@@ -480,6 +480,10 @@ void persist() {
 
 } /* namespace cache */
 
+uint32_t get_data_structure_version() {
+    return data->structure_version;
+}
+
 uint32_t pmem_data_word(uint32_t index) {
     return backup_ram->pmem_data_word(index);
 }
@@ -562,6 +566,10 @@ void set_afsk_space(const int32_t new_value) {
     data->afsk_space_freq = afsk_freq_range.clip(new_value);
 }
 
+uint32_t get_modem_def_index() {
+    return data->modem_def_index;
+}
+
 int32_t modem_baudrate() {
     modem_baudrate_range.reset_if_outside(data->modem_baudrate, modem_baudrate_reset_value);
     return data->modem_baudrate;
@@ -571,13 +579,11 @@ void set_modem_baudrate(const int32_t new_value) {
     data->modem_baudrate = modem_baudrate_range.clip(new_value);
 }
 
-/*
 int32_t modem_bw() {
-    modem_bw_range.reset_if_outside(data->modem_bw, modem_bw_reset_value);
     return data->modem_bw;
 }
 
-void set_modem_bw(const int32_t new_value) {
+/*void set_modem_bw(const int32_t new_value) {
     data->modem_bw = modem_bw_range.clip(new_value);
 }
 */
@@ -672,10 +678,18 @@ void set_gui_return_icon(bool v) {
     data->ui_config.show_gui_return_icon = v ? 1 : 0;
 }
 
+bool load_app_settings() {
+    return data->ui_config.load_app_settings;
+}
+
 void set_load_app_settings(bool v) {
     data->ui_config.load_app_settings = v ? 1 : 0;
 }
 
+bool save_app_settings() {
+    return data->ui_config.save_app_settings;
+}
+
 void set_save_app_settings(bool v) {
     data->ui_config.save_app_settings = v ? 1 : 0;
 }
@@ -809,6 +823,9 @@ void set_recon_config_bit(uint8_t rc_bit, bool v) {
     auto bit_mask = 1LL << rc_bit;
     data->recon_config = v ? (data->recon_config | bit_mask) : (data->recon_config & ~bit_mask);
 }
+uint64_t get_recon_config() {
+    return data->recon_config;
+}
 bool recon_autosave_freqs() {
     return check_recon_config_bit(RC_AUTOSAVE_FREQS);
 }
@@ -964,6 +981,9 @@ bool ui_button_repeat_speed() {
 bool ui_button_long_press_delay() {
     return data->ui_config2.button_long_press_delay;
 }
+bool ui_battery_charge_hint() {
+    return data->ui_config2.battery_charge_hint;
+}
 
 void set_ui_hide_speaker(bool v) {
     data->ui_config2.hide_speaker = v;
@@ -1018,6 +1038,9 @@ void set_ui_button_repeat_speed(bool v) {
 void set_ui_button_long_press_delay(bool v) {
     data->ui_config2.button_long_press_delay = v;
 }
+void set_ui_battery_charge_hint(bool v) {
+    data->ui_config2.battery_charge_hint = v;
+}
 
 /* Converter */
 bool config_converter() {
@@ -1199,173 +1222,5 @@ size_t data_size() {
     return sizeof(data_t);
 }
 
-// Dump pmem, receiver and transmitter models internals in human readable format
-
-bool debug_dump() {
-    ui::Painter painter{};
-    std::string debug_dir = "DEBUG";
-    std::filesystem::path filename{};
-    File pmem_dump_file{};
-    // create new dump file name and DEBUG directory
-    ensure_directory(debug_dir);
-    filename = next_filename_matching_pattern(debug_dir + "/DEBUG_DUMP_????.TXT");
-    if (filename.empty()) {
-        painter.draw_string({0, 320 - 16}, *ui::Theme::getInstance()->fg_red, "COULD NOT GET DUMP NAME !");
-        return false;
-    }
-    // dump data fo filename
-    auto error = pmem_dump_file.create(filename);
-    if (error) {
-        painter.draw_string({0, 320 - 16}, *ui::Theme::getInstance()->fg_red, "ERROR DUMPING " + filename.filename().string() + " !");
-        return false;
-    }
-    pmem_dump_file.write_line("FW version: " VERSION_STRING);
-    pmem_dump_file.write_line("Ext APPS version req'd: 0x" + to_string_hex(VERSION_MD5));
-    pmem_dump_file.write_line("GCC version: " + to_string_dec_int(__GNUC__) + "." + to_string_dec_int(__GNUC_MINOR__) + "." + to_string_dec_int(__GNUC_PATCHLEVEL__));
-
-    // firmware checksum
-    pmem_dump_file.write_line("Firmware calculated checksum: 0x" + to_string_hex(simple_checksum(FLASH_STARTING_ADDRESS, FLASH_ROM_SIZE), 8));
-
-    // write persistent memory
-    pmem_dump_file.write_line("\n[Persistent Memory]");
-
-    // full variables
-    pmem_dump_file.write_line("structure_version: 0x" + to_string_hex(data->structure_version, 8));
-    pmem_dump_file.write_line("target_frequency: " + to_string_dec_int(data->target_frequency));
-    pmem_dump_file.write_line("correction_ppb: " + to_string_dec_int(data->correction_ppb));
-    pmem_dump_file.write_line("modem_def_index: " + to_string_dec_uint(data->modem_def_index));
-    pmem_dump_file.write_line("serial_format.data_bit: " + to_string_dec_uint(data->serial_format.data_bits));
-    pmem_dump_file.write_line("serial_format.parity: " + to_string_dec_uint(data->serial_format.parity));
-    pmem_dump_file.write_line("serial_format.stop_bits: " + to_string_dec_uint(data->serial_format.stop_bits));
-    pmem_dump_file.write_line("serial_format.bit_order: " + to_string_dec_uint(data->serial_format.bit_order));
-    pmem_dump_file.write_line("modem_bw: " + to_string_dec_int(data->modem_bw));
-    pmem_dump_file.write_line("afsk_mark_freq: " + to_string_dec_int(data->afsk_mark_freq));
-    pmem_dump_file.write_line("afsk_space_freq: " + to_string_dec_int(data->afsk_space_freq));
-    pmem_dump_file.write_line("modem_baudrate: " + to_string_dec_int(data->modem_baudrate));
-    pmem_dump_file.write_line("modem_repeat: " + to_string_dec_int(data->modem_repeat));
-    pmem_dump_file.write_line("pocsag_last_address: " + to_string_dec_uint(data->pocsag_last_address));
-    pmem_dump_file.write_line("pocsag_ignore_address: " + to_string_dec_uint(data->pocsag_ignore_address));
-    pmem_dump_file.write_line("tone_mix: " + to_string_dec_uint(data->tone_mix));
-    pmem_dump_file.write_line("hardware_config: " + to_string_dec_uint(data->hardware_config));
-    pmem_dump_file.write_line("recon_config: 0x" + to_string_hex(data->recon_config, 16));
-    pmem_dump_file.write_line("recon_repeat_nb: " + to_string_dec_int(data->recon_repeat_nb));
-    pmem_dump_file.write_line("recon_repeat_gain: " + to_string_dec_int(data->recon_repeat_gain));
-    pmem_dump_file.write_line("recon_repeat_delay: " + to_string_dec_int(data->recon_repeat_delay));
-    pmem_dump_file.write_line("converter: " + to_string_dec_int(data->converter));
-    pmem_dump_file.write_line("updown_converter: " + to_string_dec_int(data->updown_converter));
-    pmem_dump_file.write_line("updown_frequency_rx_correction: " + to_string_dec_int(data->updown_frequency_rx_correction));
-    pmem_dump_file.write_line("updown_frequency_tx_correction: " + to_string_dec_int(data->updown_frequency_tx_correction));
-    pmem_dump_file.write_line("lcd_inverted_mode: " + to_string_dec_uint(data->lcd_inverted_mode));
-    // pmem_dump_file.write_line("UNUSED_5: " + to_string_dec_int(data->UNUSED_5));
-    // pmem_dump_file.write_line("UNUSED_6: " + to_string_dec_int(data->UNUSED_6));
-    // pmem_dump_file.write_line("UNUSED_7: " + to_string_dec_int(data->UNUSED_7));
-    pmem_dump_file.write_line("converter_frequency_offset: " + to_string_dec_int(data->converter_frequency_offset));
-    pmem_dump_file.write_line("frequency_rx_correction: " + to_string_dec_uint(data->frequency_rx_correction));
-    pmem_dump_file.write_line("frequency_tx_correction: " + to_string_dec_uint(data->frequency_tx_correction));
-    pmem_dump_file.write_line("encoder_dial_sensitivity: " + to_string_dec_uint(data->encoder_dial_sensitivity));
-    pmem_dump_file.write_line("encoder_rate_multiplier: " + to_string_dec_uint(data->encoder_rate_multiplier));
-    pmem_dump_file.write_line("encoder_dial_direction: " + to_string_dec_uint(data->encoder_dial_direction));  // 0 = normal, 1 = reverse
-    pmem_dump_file.write_line("headphone_volume_cb: " + to_string_dec_int(data->headphone_volume_cb));
-    pmem_dump_file.write_line("config_mode_storage: 0x" + to_string_hex(data->config_mode_storage, 8));
-    pmem_dump_file.write_line("dst_config: 0x" + to_string_hex((uint32_t)data->dst_config.v, 8));
-    pmem_dump_file.write_line("fake_brightness_level: " + to_string_dec_uint(data->fake_brightness_level));
-    pmem_dump_file.write_line("menu_color: 0x" + to_string_hex(data->menu_color.v, 4));
-    pmem_dump_file.write_line("touchscreen_threshold: " + to_string_dec_uint(data->touchscreen_threshold));
-
-    // ui_config bits
-    const auto backlight_timer = portapack::persistent_memory::config_backlight_timer();
-    pmem_dump_file.write_line("ui_config clkout_freq: " + to_string_dec_uint(clkout_freq()));
-    pmem_dump_file.write_line("ui_config backlight_timer.timeout_enabled: " + to_string_dec_uint(backlight_timer.timeout_enabled()));
-    pmem_dump_file.write_line("ui_config backlight_timer.timeout_seconds: " + to_string_dec_uint(backlight_timer.timeout_seconds()));
-    pmem_dump_file.write_line("ui_config show_gui_return_icon: " + to_string_dec_uint(data->ui_config.show_gui_return_icon));
-    pmem_dump_file.write_line("ui_config load_app_settings: " + to_string_dec_uint(data->ui_config.load_app_settings));
-    pmem_dump_file.write_line("ui_config save_app_settings: " + to_string_dec_uint(data->ui_config.save_app_settings));
-    pmem_dump_file.write_line("ui_config disable_touchscreen: " + to_string_dec_uint(data->ui_config.disable_touchscreen));
-    pmem_dump_file.write_line("ui_config hide_clock: " + to_string_dec_uint(data->ui_config.hide_clock));
-    pmem_dump_file.write_line("ui_config clock_with_date: " + to_string_dec_uint(data->ui_config.clock_show_date));
-    pmem_dump_file.write_line("ui_config clkout_enabled: " + to_string_dec_uint(data->ui_config.clkout_enabled));
-    pmem_dump_file.write_line("ui_config apply_fake_brightness: " + to_string_dec_uint(data->ui_config.apply_fake_brightness));
-    pmem_dump_file.write_line("ui_config stealth_mode: " + to_string_dec_uint(data->ui_config.stealth_mode));
-    pmem_dump_file.write_line("ui_config config_login: " + to_string_dec_uint(data->ui_config.config_login));
-    pmem_dump_file.write_line("ui_config config_splash: " + to_string_dec_uint(data->ui_config.config_splash));
-
-    // ui_config2 bits
-    pmem_dump_file.write_line("ui_config2 hide_speaker: " + to_string_dec_uint(data->ui_config2.hide_speaker));
-    pmem_dump_file.write_line("ui_config2 hide_converter: " + to_string_dec_uint(data->ui_config2.hide_converter));
-    pmem_dump_file.write_line("ui_config2 hide_stealth: " + to_string_dec_uint(data->ui_config2.hide_stealth));
-    pmem_dump_file.write_line("ui_config2 hide_camera: " + to_string_dec_uint(data->ui_config2.hide_camera));
-    pmem_dump_file.write_line("ui_config2 hide_sleep: " + to_string_dec_uint(data->ui_config2.hide_sleep));
-    pmem_dump_file.write_line("ui_config2 hide_bias_tee: " + to_string_dec_uint(data->ui_config2.hide_bias_tee));
-    pmem_dump_file.write_line("ui_config2 hide_clock: " + to_string_dec_uint(data->ui_config2.hide_clock));
-    pmem_dump_file.write_line("ui_config2 hide_sd_card: " + to_string_dec_uint(data->ui_config2.hide_sd_card));
-    pmem_dump_file.write_line("ui_config2 hide_mute: " + to_string_dec_uint(data->ui_config2.hide_mute));
-    pmem_dump_file.write_line("ui_config2 hide_fake_brightness: " + to_string_dec_uint(data->ui_config2.hide_fake_brightness));
-    pmem_dump_file.write_line("ui_config2 hide_battery_icon: " + to_string_dec_uint(data->ui_config2.hide_battery_icon));
-    pmem_dump_file.write_line("ui_config2 hide_numeric_battery: " + to_string_dec_uint(data->ui_config2.hide_numeric_battery));
-    pmem_dump_file.write_line("ui_config2 theme_id: " + to_string_dec_uint(data->ui_config2.theme_id));
-    pmem_dump_file.write_line("ui_config2 override_batt_calc: " + to_string_dec_uint(data->ui_config2.override_batt_calc));
-    pmem_dump_file.write_line("ui_config2 button_repeat_delay: " + to_string_dec_uint(data->ui_config2.button_repeat_delay));
-    pmem_dump_file.write_line("ui_config2 button_repeat_speed: " + to_string_dec_uint(data->ui_config2.button_repeat_speed));
-    pmem_dump_file.write_line("ui_config2 button_long_press_delay: " + to_string_dec_uint(data->ui_config2.button_long_press_delay));
-
-    // misc_config bits
-    pmem_dump_file.write_line("misc_config config_audio_mute: " + to_string_dec_int(config_audio_mute()));
-    pmem_dump_file.write_line("misc_config config_speaker_disable: " + to_string_dec_int(config_speaker_disable()));
-    pmem_dump_file.write_line("misc_config config_disable_external_tcxo: " + to_string_dec_uint(config_disable_external_tcxo()));
-    pmem_dump_file.write_line("misc_config config_sdcard_high_speed_io: " + to_string_dec_uint(config_sdcard_high_speed_io()));
-    pmem_dump_file.write_line("misc_config config_disable_config_mode: " + to_string_dec_uint(config_disable_config_mode()));
-    pmem_dump_file.write_line("misc_config beep_on_packets: " + to_string_dec_int(beep_on_packets()));
-
-    // receiver_model
-    pmem_dump_file.write_line("\n[Receiver Model]");
-    pmem_dump_file.write_line("target_frequency: " + to_string_dec_uint(receiver_model.target_frequency()));
-    pmem_dump_file.write_line("frequency_step: " + to_string_dec_uint(receiver_model.frequency_step()));
-    pmem_dump_file.write_line("lna: " + to_string_dec_int(receiver_model.lna()));
-    pmem_dump_file.write_line("vga: " + to_string_dec_int(receiver_model.vga()));
-    pmem_dump_file.write_line("rf_amp: " + to_string_dec_int(receiver_model.rf_amp()));
-    pmem_dump_file.write_line("baseband_bandwidth: " + to_string_dec_uint(receiver_model.baseband_bandwidth()));
-    pmem_dump_file.write_line("sampling_rate: " + to_string_dec_uint(receiver_model.sampling_rate()));
-    switch (receiver_model.modulation()) {
-        case ReceiverModel::Mode::AMAudio:
-            pmem_dump_file.write_line("modulation: Mode::AMAudio");
-            break;
-        case ReceiverModel::Mode::NarrowbandFMAudio:
-            pmem_dump_file.write_line("modulation: Mode::NarrowbandFMAudio");
-            break;
-        case ReceiverModel::Mode::WidebandFMAudio:
-            pmem_dump_file.write_line("modulation: Mode::WidebandFMAudio");
-            break;
-        case ReceiverModel::Mode::SpectrumAnalysis:
-            pmem_dump_file.write_line("modulation: Mode::SpectrumAnalysis");
-            break;
-        case ReceiverModel::Mode::Capture:
-            pmem_dump_file.write_line("modulation: Mode::Capture");
-            break;
-        case ReceiverModel::Mode::AMAudioFMApt:
-            pmem_dump_file.write_line("modulation: Mode::AMAudioFMApt");
-            break;
-        default:
-            pmem_dump_file.write_line("modulation: !!unknown mode!!");
-            break;
-    }
-    pmem_dump_file.write_line("headphone_volume.centibel: " + to_string_dec_int(receiver_model.headphone_volume().centibel()));
-    pmem_dump_file.write_line("normalized_headphone_volume: " + to_string_dec_uint(receiver_model.normalized_headphone_volume()));
-    pmem_dump_file.write_line("am_configuration: " + to_string_dec_uint(receiver_model.am_configuration()));
-    pmem_dump_file.write_line("nbfm_configuration: " + to_string_dec_uint(receiver_model.nbfm_configuration()));
-    pmem_dump_file.write_line("wfm_configuration: " + to_string_dec_uint(receiver_model.wfm_configuration()));
-
-    // transmitter_model
-    pmem_dump_file.write_line("\n[Transmitter Model]");
-    pmem_dump_file.write_line("target_frequency: " + to_string_dec_uint(transmitter_model.target_frequency()));
-    pmem_dump_file.write_line("rf_amp: " + to_string_dec_int(transmitter_model.rf_amp()));
-    pmem_dump_file.write_line("baseband_bandwidth: " + to_string_dec_uint(transmitter_model.baseband_bandwidth()));
-    pmem_dump_file.write_line("sampling_rate: " + to_string_dec_uint(transmitter_model.sampling_rate()));
-    pmem_dump_file.write_line("tx_gain: " + to_string_dec_int(transmitter_model.tx_gain()));
-    pmem_dump_file.write_line("channel_bandwidth: " + to_string_dec_uint(transmitter_model.channel_bandwidth()));
-    // on screen information
-    painter.draw_string({0, 320 - 16}, *ui::Theme::getInstance()->fg_green, filename.filename().string() + " DUMPED !");
-    return true;
-}
-
 } /* namespace persistent_memory */
 } /* namespace portapack */

firmware/common/portapack_persistent_memory.hpp

@@ -183,9 +183,13 @@ void set_afsk_mark(const int32_t new_value);
 int32_t afsk_space_freq();
 void set_afsk_space(const int32_t new_value);
 
+uint32_t get_modem_def_index();
+
 int32_t modem_baudrate();
 void set_modem_baudrate(const int32_t new_value);
 
+int32_t modem_bw();
+
 uint8_t modem_repeat();
 void set_modem_repeat(const uint32_t new_value);
 
@@ -214,7 +218,9 @@ backlight_config_t config_backlight_timer();
 bool disable_touchscreen();
 
 void set_gui_return_icon(bool v);
+bool load_app_settings();
 void set_load_app_settings(bool v);
+bool save_app_settings();
 void set_save_app_settings(bool v);
 void set_config_disable_external_tcxo(bool v);
 void set_config_sdcard_high_speed_io(bool v, bool save);
@@ -290,6 +296,7 @@ Color menu_color();
 void set_menu_color(Color v);
 
 /* Recon app */
+uint64_t get_recon_config();
 bool recon_autosave_freqs();
 bool recon_autostart_recon();
 bool recon_continuous();
@@ -343,6 +350,8 @@ bool ui_override_batt_calc();
 bool ui_button_repeat_delay();
 bool ui_button_repeat_speed();
 bool ui_button_long_press_delay();
+bool ui_battery_charge_hint();
+
 void set_ui_hide_speaker(bool v);
 void set_ui_hide_mute(bool v);
 void set_ui_hide_converter(bool v);
@@ -360,20 +369,20 @@ void set_ui_override_batt_calc(bool v);
 void set_ui_button_repeat_delay(bool v);
 void set_ui_button_repeat_speed(bool v);
 void set_ui_button_long_press_delay(bool v);
+void set_ui_battery_charge_hint(bool v);
 
 // sd persisting settings
 bool should_use_sdcard_for_pmem();
 int save_persistent_settings_to_file();
 int load_persistent_settings_from_file();
 
+uint32_t get_data_structure_version();
 uint32_t pmem_data_word(uint32_t index);
 uint32_t pmem_stored_checksum(void);
 uint32_t pmem_calculated_checksum(void);
 
 size_t data_size();
 
-bool debug_dump();
-
 } /* namespace persistent_memory */
 
 } /* namespace portapack */

firmware/common/ui_painter.cpp

@@ -36,34 +36,12 @@ Style Style::invert() const {
         .foreground = background};
 }
 
-int Painter::draw_char(Point p, const Style& style, char c, uint8_t zoom_factor) {
+int Painter::draw_char(Point p, const Style& style, char c, uint8_t zoom_level) {
     const auto glyph = style.font.glyph(c);
 
-    if (zoom_factor <= 1) {
-        display.draw_glyph(p, glyph, style.foreground, style.background);
-    } else {
-        // dot to square
-        const uint8_t* pixels = glyph.pixels();
-        for (int y = 0; y < glyph.h(); y++) {      // each line
-            for (int x = 0; x < glyph.w(); x++) {  // each clum
-                // pos
-                int byte_index = (y * glyph.w() + x) / 8;
-                int bit_pos = (y * glyph.w() + x) % 8;
+    display.draw_glyph(p, glyph, style.foreground, style.background, zoom_level);
 
-                // fill
-                Color pixel_color = ((pixels[byte_index] & (1 << bit_pos)) != 0) ? style.foreground : style.background;
-                /*                                       ^ true: fg, false: bg
-                                      ^ the byte_index-th bit AKA current bit
-                                                            ^ current px in current byte  */
-                display.fill_rectangle(
-                    {p.x() + x * zoom_factor, p.y() + y * zoom_factor,
-                     zoom_factor, zoom_factor},
-                    pixel_color);
-            }
-        }
-    }
-
-    return glyph.advance().x() * zoom_factor;
+    return glyph.advance().x() * zoom_level;
 }
 
 int Painter::draw_string(Point p, const Style& style, std::string_view text) {

firmware/common/ui_widget.cpp

@@ -1136,7 +1136,7 @@ void ButtonWithEncoder::paint(Painter& painter) {
 
     const Style paint_style = {style().font, bg, fg};
 
-    painter.draw_rectangle({r.location(), {r.size().width(), 1}}, Theme::getInstance()->fg_light->foreground);
+    painter.draw_rectangle({r.location(), {r.size().width(), 1}}, Theme::getInstance()->bg_light->background);
     painter.draw_rectangle({r.location().x(), r.location().y() + r.size().height() - 1, r.size().width(), 1}, Theme::getInstance()->bg_dark->background);
     painter.draw_rectangle({r.location().x() + r.size().width() - 1, r.location().y(), 1, r.size().height()}, Theme::getInstance()->bg_dark->background);
 

firmware/tools/bitmap_tools/.gitignore

@@ -0,0 +1 @@
+bitmap.hpp

firmware/tools/bitmap_tools/make_bitmap2.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2016 Furrtek
+#
+# 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.
+#
+
+import sys
+import struct
+from PIL import Image
+from os import listdir
+from os import path
+from os import makedirs
+
+usage_message = f"""
+1BPP PortaPack bitmap.hpp generator
+
+Usage: {sys.argv[0]} <directory>
+"""
+
+if len(sys.argv) < 2:
+	print(usage_message)
+	sys.exit(-1)
+
+graphics_path = path.join(sys.argv[1], '')
+hex_output_dir = path.join(graphics_path, 'hex_files')
+
+# Create hex output directory if it doesn't exist
+if not path.exists(hex_output_dir):
+	makedirs(hex_output_dir)
+
+def convert_png(file):
+	c = 0
+	data = 0
+
+	rgb_im = Image.open(file).convert('RGBA')
+
+	if rgb_im.size[0] % 8 or rgb_im.size[1] % 8:
+		print((file + ": Size is not a multiple of 8. Image is not included in bitmap.hpp."))
+		sys.exit(-1)
+
+	name = path.basename(file).split(".")[0].lower();
+    
+    # Prepare data for both hpp and hex file
+	hpp_lines = []
+	hex_data = bytearray()
+    
+	for i in range(rgb_im.size[1]):
+		for j in range(rgb_im.size[0]):
+			r, g, b, a = rgb_im.getpixel((j, i))
+            
+			data >>= 1
+            
+			if r > 127 and g > 127 and b > 127 and a > 127:
+				data += 128
+            
+			if j % 8 == 7:
+				hpp_lines.append("    0x%0.2X,\n" % data)
+				hex_data.append(data)
+				data = 0
+
+    # Write to hpp file
+	f.write("static constexpr uint8_t bitmap_" + name + "_data[] = {\n")
+	f.writelines(hpp_lines)
+	f.write("};\n")
+	f.write("static constexpr Bitmap bitmap_"  + name + " {\n")
+	f.write("    {" + str(rgb_im.size[0]) + ", " + str(rgb_im.size[1]) + "},\n    bitmap_" + name + "_data};\n\n")
+    
+    # Write to hex file
+	hex_filename = path.join(hex_output_dir, name + ".hex")
+	with open(hex_filename, 'wb') as hex_file:
+		hex_file.write(hex_data)
+    
+	return
+
+count = 0
+
+f = open('bitmap.hpp', 'w')
+f.write("/*\n"
+	" * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.\n"
+	" * Copyright (C) 2016 Furrtek\n"
+	" *\n"
+	" * This file is part of PortaPack.\n"
+	" *\n"
+	" * This program is free software; you can redistribute it and/or modify\n"
+	" * it under the terms of the GNU General Public License as published by\n"
+	" * the Free Software Foundation; either version 2, or (at your option)\n"
+	" * any later version.\n"
+	" *\n"
+	" * This program is distributed in the hope that it will be useful,\n"
+	" * but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+	" * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
+	" * GNU General Public License for more details.\n"
+	" *\n"
+	" * You should have received a copy of the GNU General Public License\n"
+	" * along with this program; see the file COPYING.  If not, write to\n"
+	" * the Free Software Foundation, Inc., 51 Franklin Street,\n"
+	" * Boston, MA 02110-1301, USA.\n"
+	" */\n\n"
+	"// This file was generated by make_bitmap.py\n\n"
+	"#ifndef __BITMAP_HPP__\n"
+	"#define __BITMAP_HPP__\n\n"
+	"#include \"ui.hpp\"\n\n"
+	"namespace ui {\n\n")
+
+for file in listdir(graphics_path):
+    if file.endswith(".png") and path.isfile(graphics_path + file):
+        convert_png(graphics_path + file)
+        count += 1
+
+f.write("} /* namespace ui */\n\n")
+f.write("#endif/*__BITMAP_HPP__*/\n")
+
+print(("Converted " + str(count) + " files"))

firmware/tools/check_external_app_linker_script_correct.py

@@ -120,10 +120,10 @@ def main():
         if validate_memory_regions(regions):
             print("external app addr seems correct, pass")
         else:
-            print("\nWARENING: It seems you are having incorrect external app addresses.")
+            print("\nWARNING: It seems you are having incorrect external app addresses.")
             
     except Exception as e:
         print(f"err: {e}")
 
 if __name__ == "__main__":
-    main()
+    main()