Pacman update (#2837)

* freqman add touch support. solves #1919

* menuview touch support

firmware/application/apps/ui_freqman.hpp

@@ -65,7 +65,7 @@ class FreqManBaseView : public View {
 
     OptionsField options_category{
         {3 * 8, 2},
-        20 /* length */,
+        19 /* length */,
         {}};
 
     FreqManUIList freqlist_view{

firmware/application/apps/ui_settings.hpp

@@ -1008,7 +1008,7 @@ class SetBatteryView : public View {
         "Save"};
 
     Button button_reset{
-        {UI_POS_X_CENTER(12) - UI_POS_WIDTH(8), UI_POS_Y_BOTTOM(7), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
+        {UI_POS_X_CENTER(12) - UI_POS_WIDTH(8), UI_POS_Y(13), UI_POS_WIDTH(12), UI_POS_HEIGHT(2)},
         "Reset",
     };
 };

firmware/application/apps/ui_standalone_view.cpp

@@ -287,7 +287,7 @@ bool StandaloneView::on_touch(const TouchEvent event) {
     if (get_application_information()->header_version > 1) {
         get_application_information()->OnTouchEvent(event.point.x(), event.point.y(), (uint32_t)event.type);
     }
-    return false;
+    return true;
 }
 
 bool StandaloneView::on_keyboard(const KeyboardEvent event) {

firmware/application/apps/ui_touch_calibration.hpp

@@ -81,13 +81,13 @@ class TouchCalibrationView : public View {
         Color::black()};
 
     Image image_calibrate_1{
-        {240 - 32 - 16, (320 - 16) / 2 - 16, 32, 32},
+        {screen_width - 32 - 16, (screen_height - 16) / 2 - 16, 32, 32},
         &bitmap_target_calibrate,
         Color::white(),
         Color::black()};
 
     Image image_calibrate_2{
-        {240 / 2 - 16, (320 - 16) - 32 - 16, 32, 32},
+        {screen_width / 2 - 16, (screen_height - 16) - 32 - 16, 32, 32},
         &bitmap_target_calibrate,
         Color::white(),
         Color::black()};
@@ -99,13 +99,13 @@ class TouchCalibrationView : public View {
         Color::black()};
 
     Image image_verify_1{
-        {240 - 32 - 16, (320 - 16) / 2 - 16, 32, 32},
+        {screen_width - 32 - 16, (screen_height - 16) / 2 - 16, 32, 32},
         &bitmap_target_verify,
         Color::white(),
         Color::black()};
 
     Image image_verify_2{
-        {240 / 2 - 16, (320 - 16) - 32 - 16, 32, 32},
+        {screen_width / 2 - 16, (screen_height - 16) - 32 - 16, 32, 32},
         &bitmap_target_verify,
         Color::white(),
         Color::black()};
@@ -131,11 +131,11 @@ class TouchCalibrationView : public View {
         "Calibration failed. Retry?"};
 
     Button button_cancel{
-        {40, 200, 64, 24},
+        {40, 200, UI_POS_WIDTH(8), 24},
         "Cancel"};
 
     Button button_ok{
-        {136, 200, 64, 24},
+        {136, 200, UI_POS_WIDTH(8), 24},
         "OK"};
 
     void on_frame_sync();

firmware/application/apps/ui_weatherstation.cpp

@@ -197,6 +197,10 @@ WeatherView::~WeatherView() {
     baseband::shutdown();
 }
 
+uint16_t WeatherView::bcd_decode_short(uint32_t data) {
+    return (data & 0xF) * 10 + ((data >> 4) & 0xF);
+}
+
 const char* WeatherView::getWeatherSensorTypeName(FPROTO_WEATHER_SENSOR type) {
     switch (type) {
         case FPW_NexusTH:
@@ -225,6 +229,8 @@ const char* WeatherView::getWeatherSensorTypeName(FPROTO_WEATHER_SENSOR type) {
             return "LaCrosse TX141THBv2";
         case FPW_OREGON2:
             return "Oregon2";
+        case FPW_OREGON2B:
+            return "Oregon2B";
         case FPW_OREGON3:
             return "Oregon3";
         case FPW_OREGONv1:
@@ -299,7 +305,9 @@ WeatherRecentEntry WeatherView::process_data(const WeatherDataMessage* data) {
     WeatherRecentEntry ret = {};
     ret.sensorType = data->sensorType;
     int16_t i16 = 0;
+    int32_t i32 = 0;
     uint16_t u16 = 0;
+
     uint64_t u64 = 0;
     uint8_t u8 = 0;
     uint8_t channel_3021[] = {3, 0, 2, 1};
@@ -442,12 +450,34 @@ WeatherRecentEntry WeatherView::process_data(const WeatherDataMessage* data) {
             ret.humidity = (data->decode_data >> 8) & 0xFF;
             break;
         case FPW_OREGON2:
-            i16 = ((data->decode_data >> 4) & 0xF) * 10 + (((data->decode_data >> 4) >> 4) & 0xF);
-            i16 *= 10;
-            i16 += (data->decode_data >> 12) & 0xF;
-            if (data->decode_data & 0xF) i16 = -i16;
-            ret.temp = (float)i16 / 10.0;
-            // todo fix missing parts.
+            i32 = bcd_decode_short(data->decode_data >> 4);
+            i32 *= 10;
+            i32 += (data->decode_data >> 12) & 0xf;
+            if (data->decode_data & 0xF) i32 = -i32;
+            ret.temp = (float)i32 / 10.0;
+            ret.battery_low = ((data->decode_data >> 32) & 0x4) ? 1 : 0;
+            u8 = (data->decode_data >> 44) & 0xF;
+            ret.channel = 1;
+            while (u8 > 1) {
+                ret.channel++;
+                u8 >>= 1;
+            }
+            break;
+        case FPW_OREGON2B:
+            ret.humidity = bcd_decode_short(data->decode_data);
+            u64 = data->decode_data >> 8;
+            i32 = bcd_decode_short(u64 >> 4);
+            i32 *= 10;
+            i32 += (u64 >> 12) & 0xf;
+            if (u64 & 0xF) i32 = -i32;
+            ret.temp = (float)i32 / 10.0;
+            ret.battery_low = ((data->decode_data >> 32) & 0x4) ? 1 : 0;
+            u8 = (data->decode_data >> 44) & 0xF;
+            ret.channel = 1;
+            while (u8 > 1) {
+                ret.channel++;
+                u8 >>= 1;
+            }
             break;
         case FPW_OREGON3:
             // todo check

firmware/application/apps/ui_weatherstation.hpp

@@ -114,6 +114,7 @@ class WeatherView : public View {
 
    private:
     void on_tick_second();
+    uint16_t bcd_decode_short(uint32_t data);
     void on_data(const WeatherDataMessage* data);
     WeatherRecentEntry process_data(const WeatherDataMessage* data);
     NavigationView& nav_;

firmware/application/event_m0.cpp

@@ -124,12 +124,12 @@ void EventDispatcher::request_stop() {
 
 void EventDispatcher::set_display_sleep(const bool sleep) {
     // TODO: Distribute display sleep message more broadly, shut down data generation
-    // on baseband side, since all that data is being discarded during sleep.
+    // on baseband side, since all that data is being discarded during sleep.  -- DON'T TODO it, sincethe stealth mode want to send with screen off!
     if (sleep) {
         portapack::backlight()->off();
-        portapack::display.sleep();
+        portapack::display.sleep(false);  // when called the hw_sleep = true, the irq wont fire, so the EVT_MASK_LCD_FRAME_SYNC won't set.
     } else {
-        portapack::display.wake();
+        portapack::display.wake(true);  // not important, command not affect if already hw waken up
         // Don't turn on backlight here.
         // Let frame sync handler turn on backlight after repaint.
     }
@@ -180,12 +180,10 @@ void EventDispatcher::dispatch(const eventmask_t events) {
     /*if( events & EVT_MASK_LCD_FRAME_SYNC ) {
                 blink_timer();
         }*/
-
+    if (events & EVT_MASK_LCD_FRAME_SYNC) {
+        handle_lcd_frame_sync(!EventDispatcher::display_sleep);
+    }
     if (!EventDispatcher::display_sleep) {
-        if (events & EVT_MASK_LCD_FRAME_SYNC) {
-            handle_lcd_frame_sync();
-        }
-
         if (events & EVT_MASK_ENCODER) {
             handle_encoder();
         }
@@ -328,17 +326,16 @@ ui::Widget* EventDispatcher::getFocusedWidget() {
     return context.focus_manager().focus_widget();
 }
 
-void EventDispatcher::handle_lcd_frame_sync() {
+void EventDispatcher::handle_lcd_frame_sync(bool screen_on) {
     bool waiting_for_frame = this->waiting_for_frame;
 
-    DisplayFrameSyncMessage message;
+    DisplayFrameSyncMessage message;  // send framesync msg all the time, bc some apps relay on it
     message_map.send(&message);
-
-    static_cast<ui::SystemView*>(top_widget)->paint_overlay();
-    painter.paint_widget_tree(top_widget);
-
-    portapack::backlight()->on();
-
+    if (screen_on) {  // only draw when screen is on
+        static_cast<ui::SystemView*>(top_widget)->paint_overlay();
+        painter.paint_widget_tree(top_widget);
+        portapack::backlight()->on();
+    }
     if (waiting_for_frame)
         this->waiting_for_frame = false;
 }

firmware/application/event_m0.hpp

@@ -133,7 +133,7 @@ class EventDispatcher {
     void on_keyboard_event(ui::KeyboardEvent event);
 
     // void blink_timer();
-    void handle_lcd_frame_sync();
+    void handle_lcd_frame_sync(bool screen_on);
     void handle_switches();
     void handle_encoder();
     void handle_touch();

firmware/application/external/battleship/ui_battleship.cpp

@@ -24,25 +24,25 @@ constexpr uint32_t BLUE_TEAM_ADDRESS = BATTLESHIP_BASE_ADDRESS + 2;
 
 BattleshipView::BattleshipView(NavigationView& nav)
     : nav_{nav} {
+    CELL_SIZE = screen_width / GRID_SIZE;
     baseband::run_image(portapack::spi_flash::image_tag_pocsag2);
 
     add_children({&text_title, &text_subtitle,
-                  &rect_radio_settings, &label_radio, &button_frequency,
+                  //&rect_radio_settings, &rect_audio_settings, &rect_team_selection,
+                  &label_radio, &button_frequency,
                   &label_rf_amp, &checkbox_rf_amp,
                   &label_lna, &field_lna,
                   &label_vga, &field_vga,
                   &label_tx_gain, &field_tx_gain,
-                  &rect_audio_settings, &label_audio,
+                  &label_audio,
                   &checkbox_sound, &label_volume, &field_volume,
-                  &rect_team_selection, &label_team,
+                  &label_team,
                   &button_red_team, &button_blue_team,
-                  &rssi, &text_status, &text_score,
+                  &rssi,
                   &button_rotate, &button_place, &button_fire, &button_menu});
 
     // Hide in-game elements
     rssi.hidden(true);
-    text_status.hidden(true);
-    text_score.hidden(true);
     button_rotate.hidden(true);
     button_place.hidden(true);
     button_fire.hidden(true);
@@ -151,8 +151,8 @@ BattleshipView::BattleshipView(NavigationView& nav)
     field_tx_gain.set_parent_rect({185, 118, 32, 16});
     checkbox_sound.set_parent_rect({17, 187, 80, 24});
     field_volume.set_parent_rect({165, 187, 32, 16});
-    button_red_team.set_parent_rect({25, 242, 85, 45});
-    button_blue_team.set_parent_rect({130, 242, 85, 45});
+    // button_red_team.set_parent_rect({25, 242, 85, 45});
+    // button_blue_team.set_parent_rect({130, 242, 85, 45});
 
     // Make menu elements focusable
     button_frequency.set_focusable(true);
@@ -191,11 +191,42 @@ void BattleshipView::init_game() {
             enemy_grid[y][x] = CellState::EMPTY;
         }
     }
-
     setup_ships();
     update_score();
 }
 
+void BattleshipView::show_hide_menu(bool menu_vis) {
+    text_title.hidden(!menu_vis);
+    text_subtitle.hidden(!menu_vis);
+    // rect_radio_settings.hidden(!menu_vis);    rect_audio_settings.hidden(!menu_vis);    rect_team_selection.hidden(!menu_vis);
+    label_radio.hidden(!menu_vis);
+    button_frequency.hidden(!menu_vis);
+    label_rf_amp.hidden(!menu_vis);
+    checkbox_rf_amp.hidden(!menu_vis);
+    label_lna.hidden(!menu_vis);
+    field_lna.hidden(!menu_vis);
+    label_vga.hidden(!menu_vis);
+    field_vga.hidden(!menu_vis);
+    label_tx_gain.hidden(!menu_vis);
+    field_tx_gain.hidden(!menu_vis);
+    label_audio.hidden(!menu_vis);
+    checkbox_sound.hidden(!menu_vis);
+    label_volume.hidden(!menu_vis);
+    field_volume.hidden(!menu_vis);
+    label_team.hidden(!menu_vis);
+    button_red_team.hidden(!menu_vis);
+    button_blue_team.hidden(!menu_vis);
+    rssi.hidden(menu_vis);
+    button_rotate.hidden(menu_vis);
+    button_place.hidden(menu_vis);
+    button_menu.hidden(menu_vis);
+
+    // button_rotate.set_focusable(false); //no need, since can't focus on hidden
+    // button_place.set_focusable(false);
+    // button_menu.set_focusable(false);
+    set_dirty();
+}
+
 void BattleshipView::reset_game() {
     transmitter_model.disable();
     receiver_model.disable();
@@ -221,50 +252,7 @@ void BattleshipView::reset_game() {
     update_score();
 
     // Toggle visibility
-    bool menu_vis = true;
-    bool game_vis = false;
-
-    text_title.hidden(!menu_vis);
-    text_subtitle.hidden(!menu_vis);
-    rect_radio_settings.hidden(!menu_vis);
-    label_radio.hidden(!menu_vis);
-    button_frequency.hidden(!menu_vis);
-    label_rf_amp.hidden(!menu_vis);
-    checkbox_rf_amp.hidden(!menu_vis);
-    label_lna.hidden(!menu_vis);
-    field_lna.hidden(!menu_vis);
-    label_vga.hidden(!menu_vis);
-    field_vga.hidden(!menu_vis);
-    label_tx_gain.hidden(!menu_vis);
-    field_tx_gain.hidden(!menu_vis);
-    rect_audio_settings.hidden(!menu_vis);
-    label_audio.hidden(!menu_vis);
-    checkbox_sound.hidden(!menu_vis);
-    label_volume.hidden(!menu_vis);
-    field_volume.hidden(!menu_vis);
-    rect_team_selection.hidden(!menu_vis);
-    label_team.hidden(!menu_vis);
-    button_red_team.hidden(!menu_vis);
-    button_blue_team.hidden(!menu_vis);
-
-    rssi.hidden(!game_vis);
-    text_status.hidden(!game_vis);
-    text_score.hidden(!game_vis);
-    button_rotate.hidden(!game_vis);
-    button_place.hidden(!game_vis);
-    button_fire.hidden(!game_vis);
-    button_menu.hidden(!game_vis);
-
-    // Restore focusability
-    button_frequency.set_focusable(menu_vis);
-    checkbox_rf_amp.set_focusable(menu_vis);
-    field_lna.set_focusable(menu_vis);
-    field_vga.set_focusable(menu_vis);
-    field_tx_gain.set_focusable(menu_vis);
-    checkbox_sound.set_focusable(menu_vis);
-    field_volume.set_focusable(menu_vis);
-    button_red_team.set_focusable(menu_vis);
-    button_blue_team.set_focusable(menu_vis);
+    show_hide_menu(true);
 
     button_frequency.focus();
     set_dirty();
@@ -283,45 +271,10 @@ void BattleshipView::start_team(bool red) {
     game_state = GameState::PLACING_SHIPS;
 
     // Toggle visibility
-    bool menu_vis = false;
-    bool game_vis = true;
-
-    text_title.hidden(!menu_vis);
-    text_subtitle.hidden(!menu_vis);
-    rect_radio_settings.hidden(!menu_vis);
-    label_radio.hidden(!menu_vis);
-    button_frequency.hidden(!menu_vis);
-    label_rf_amp.hidden(!menu_vis);
-    checkbox_rf_amp.hidden(!menu_vis);
-    label_lna.hidden(!menu_vis);
-    field_lna.hidden(!menu_vis);
-    label_vga.hidden(!menu_vis);
-    field_vga.hidden(!menu_vis);
-    label_tx_gain.hidden(!menu_vis);
-    field_tx_gain.hidden(!menu_vis);
-    rect_audio_settings.hidden(!menu_vis);
-    label_audio.hidden(!menu_vis);
-    checkbox_sound.hidden(!menu_vis);
-    label_volume.hidden(!menu_vis);
-    field_volume.hidden(!menu_vis);
-    rect_team_selection.hidden(!menu_vis);
-    label_team.hidden(!menu_vis);
-    button_red_team.hidden(!menu_vis);
-    button_blue_team.hidden(!menu_vis);
-
-    rssi.hidden(!game_vis);
-    text_status.hidden(true);
-    text_score.hidden(true);
-    button_rotate.hidden(false);
-    button_place.hidden(false);
-    button_menu.hidden(false);
+    show_hide_menu(false);
 
     current_status = "Place carrier (5)";
 
-    button_rotate.set_focusable(false);
-    button_place.set_focusable(false);
-    button_menu.set_focusable(false);
-
     focus();
     is_transmitting = true;
     configure_radio_rx();
@@ -382,7 +335,7 @@ void BattleshipView::configure_radio_rx() {
 }
 
 void BattleshipView::paint(Painter& painter) {
-    painter.fill_rectangle({0, 0, 240, 320}, Color::black());
+    painter.fill_rectangle({0, 0, UI_POS_MAXWIDTH, UI_POS_MAXHEIGHT}, Color::black());
 
     if (game_state == GameState::MENU) {
         draw_menu_screen(painter);
@@ -426,24 +379,21 @@ void BattleshipView::paint(Painter& painter) {
     }
 
     Color team_color = is_red_team ? Color::red() : Color::blue();
-    painter.fill_rectangle({0, 5, 240, 16}, team_color);
+    painter.fill_rectangle({0, 5, screen_width, 16}, team_color);
 
     auto style_white = Style{
         .font = ui::font::fixed_8x16,
         .background = team_color,
         .foreground = Color::white()};
-    painter.draw_string({85, 5}, style_white, is_red_team ? "RED TEAM" : "BLUE TEAM");
+    painter.draw_string({UI_POS_X_CENTER(9), 5}, style_white, is_red_team ? "RED TEAM" : "BLUE TEAM");
 
     auto style_status = Style{
         .font = ui::font::fixed_8x16,
         .background = Color::black(),
         .foreground = Color::white()};
-    painter.fill_rectangle({0, 21, 240, 16}, Color::black());
-    painter.draw_string({10, 21}, style_status, current_status);
-
-    if (game_state != GameState::MENU) {
-        painter.draw_string({170, 21}, style_status, current_score);
-    }
+    painter.fill_rectangle({0, 21, screen_width, 16}, Color::black());
+    painter.draw_string({5, 21}, style_status, current_status);
+    painter.draw_string({170, 21}, style_status, current_score);
 
     if (game_state == GameState::PLACING_SHIPS) {
         draw_grid(painter, GRID_OFFSET_X, GRID_OFFSET_Y + 5, my_grid, true);
@@ -452,35 +402,35 @@ void BattleshipView::paint(Painter& painter) {
         }
     } else if (game_state == GameState::MY_TURN) {
         draw_grid(painter, GRID_OFFSET_X, GRID_OFFSET_Y + 5, enemy_grid, false, true);
-        painter.draw_string({10, GRID_OFFSET_Y + GRID_SIZE * CELL_SIZE + 10}, style_status,
-                            "Enemy ships: " + to_string_dec_uint(enemy_ships_remaining));
+        painter.draw_string({0, GRID_OFFSET_Y + GRID_SIZE * CELL_SIZE + 10}, style_status,
+                            "Enemy: " + to_string_dec_uint(enemy_ships_remaining));
     } else if (game_state == GameState::OPPONENT_TURN || game_state == GameState::WAITING_FOR_OPPONENT) {
         draw_grid(painter, GRID_OFFSET_X, GRID_OFFSET_Y + 5, my_grid, true);
-        painter.draw_string({10, GRID_OFFSET_Y + GRID_SIZE * CELL_SIZE + 10}, style_status,
-                            "Your ships: " + to_string_dec_uint(ships_remaining));
+        painter.draw_string({0, GRID_OFFSET_Y + GRID_SIZE * CELL_SIZE + 10}, style_status,
+                            "You: " + to_string_dec_uint(ships_remaining));
     } else if (game_state == GameState::GAME_OVER) {
-        painter.draw_string({50, 150}, style_status, "Game Over!");
+        painter.draw_string({UI_POS_X_CENTER(11), 150}, style_status, "Game Over!");
         painter.draw_string({30, 170}, style_status, current_status);
     }
 }
 
 void BattleshipView::draw_menu_screen(Painter& painter) {
-    painter.draw_hline({12, 38}, 216, Color::dark_cyan());
+    painter.draw_hline({12, 20 + 16}, screen_width - 24, Color::dark_cyan());
 
-    painter.fill_rectangle({13, 41, 214, 116}, Color::dark_grey());
-    painter.draw_hline({12, 40}, 216, Color::cyan());
-    painter.draw_hline({12, 157}, 216, Color::cyan());
+    painter.fill_rectangle({13, 59, screen_width - 26, 116}, Color::dark_grey());
+    painter.draw_hline({12, 58}, screen_width - 24, Color::cyan());
+    painter.draw_hline({12, 157}, screen_width - 24, Color::cyan());
 
-    painter.fill_rectangle({13, 165, 214, 43}, Color::dark_grey());
-    painter.draw_hline({12, 164}, 216, Color::cyan());
-    painter.draw_hline({12, 208}, 216, Color::cyan());
+    painter.fill_rectangle({13, 165, screen_width - 24, 57}, Color::dark_grey());
+    painter.draw_hline({12, 164}, screen_width - 24, Color::cyan());
+    painter.draw_hline({12, 223}, screen_width - 24, Color::cyan());
 
-    painter.fill_rectangle({13, 218, 214, 73}, Color::dark_grey());
-    painter.draw_hline({12, 217}, 216, Color::cyan());
-    painter.draw_hline({12, 291}, 216, Color::cyan());
+    painter.fill_rectangle({13, 232, screen_width - 26, 67}, Color::dark_grey());
+    painter.draw_hline({12, 232}, screen_width - 24, Color::cyan());
+    painter.draw_hline({12, 300}, screen_width - 24, Color::cyan());
 
     // Radio status indicator
-    Point indicator_pos{220, 53};
+    Point indicator_pos{UI_POS_MAXWIDTH - 20, 59};
     if (is_transmitting) {
         painter.fill_rectangle({indicator_pos, {6, 6}}, Color::red());
         painter.draw_rectangle({indicator_pos.x() - 1, indicator_pos.y() - 1, 8, 8}, Color::light_grey());
@@ -490,7 +440,7 @@ void BattleshipView::draw_menu_screen(Painter& painter) {
     }
 }
 
-void BattleshipView::draw_grid(Painter& painter, uint8_t grid_x, uint8_t grid_y, const std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE>& grid, bool show_ships, bool is_offense_grid) {
+void BattleshipView::draw_grid(Painter& painter, uint16_t grid_x, uint16_t grid_y, const std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE>& grid, bool show_ships, bool is_offense_grid) {
     painter.fill_rectangle({grid_x, grid_y, GRID_SIZE * CELL_SIZE, GRID_SIZE * CELL_SIZE},
                            Color::dark_blue());
 
@@ -501,26 +451,24 @@ void BattleshipView::draw_grid(Painter& painter, uint8_t grid_x, uint8_t grid_y,
                            GRID_SIZE * CELL_SIZE, Color::grey());
     }
 
-    for (uint8_t y = 0; y < GRID_SIZE; y++) {
-        for (uint8_t x = 0; x < GRID_SIZE; x++) {
-            draw_cell(painter, grid_x + x * CELL_SIZE + 1, grid_y + y * CELL_SIZE + 1,
-                      grid[y][x], show_ships, is_offense_grid,
-                      is_cursor_at(x, y, is_offense_grid));
+    for (uint16_t y = 0; y < GRID_SIZE; y++) {
+        for (uint16_t x = 0; x < GRID_SIZE; x++) {
+            draw_cell(painter, grid_x + x * CELL_SIZE + 1, grid_y + y * CELL_SIZE + 1, grid[y][x], show_ships, is_offense_grid, is_cursor_at(x, y, is_offense_grid));
         }
     }
 }
 
-void BattleshipView::draw_cell(Painter& painter, uint8_t cell_x, uint8_t cell_y, CellState state, bool show_ships, bool is_offense_grid, bool is_cursor) {
+void BattleshipView::draw_cell(Painter& painter, uint16_t cell_x, uint16_t cell_y, CellState state, bool show_ships, bool is_offense_grid, bool is_cursor) {
     Color cell_color = Color::dark_blue();
     bool should_fill = false;
 
     if (game_state == GameState::PLACING_SHIPS && !is_offense_grid && current_ship_index < 5) {
         uint8_t ship_size = my_ships[current_ship_index].size();
         for (uint8_t i = 0; i < ship_size; i++) {
-            uint8_t preview_x = placing_horizontal ? cursor_x + i : cursor_x;
-            uint8_t preview_y = placing_horizontal ? cursor_y : cursor_y + i;
-            uint8_t grid_x = (cell_x - 1) / CELL_SIZE;
-            uint8_t grid_y = (cell_y - GRID_OFFSET_Y - 6) / CELL_SIZE;
+            uint16_t preview_x = placing_horizontal ? cursor_x + i : cursor_x;
+            uint16_t preview_y = placing_horizontal ? cursor_y : cursor_y + i;
+            uint16_t grid_x = (cell_x - 1) / CELL_SIZE;
+            uint16_t grid_y = (cell_y - GRID_OFFSET_Y - 6) / CELL_SIZE;
             if (grid_x == preview_x && grid_y == preview_y && preview_x < GRID_SIZE && preview_y < GRID_SIZE) {
                 return;
             }
@@ -597,8 +545,8 @@ void BattleshipView::draw_ship_preview(Painter& painter) {
         uint8_t y = placing_horizontal ? cursor_y : cursor_y + i;
 
         if (x < GRID_SIZE && y < GRID_SIZE) {
-            uint8_t cell_x = GRID_OFFSET_X + x * CELL_SIZE + 1;
-            uint8_t cell_y = GRID_OFFSET_Y + 5 + y * CELL_SIZE + 1;
+            uint16_t cell_x = GRID_OFFSET_X + x * CELL_SIZE + 1;
+            uint16_t cell_y = GRID_OFFSET_Y + 5 + y * CELL_SIZE + 1;
 
             Color preview_color = can_place ? Color::green() : Color::red();
 

firmware/application/external/battleship/ui_battleship.hpp

@@ -23,12 +23,9 @@
 
 #include <array>
 
-namespace ui::external_app::battleship {
+#define GRID_SIZE 10
 
-constexpr uint8_t GRID_SIZE = 10;
-constexpr uint8_t CELL_SIZE = 24;
-constexpr uint8_t GRID_OFFSET_X = 0;
-constexpr uint8_t GRID_OFFSET_Y = 32;
+namespace ui::external_app::battleship {
 
 enum class ShipType : uint8_t {
     CARRIER = 5,
@@ -103,6 +100,10 @@ class BattleshipView : public View {
    private:
     NavigationView& nav_;
 
+    uint16_t CELL_SIZE = 24;
+    uint16_t GRID_OFFSET_X = 0;
+    uint16_t GRID_OFFSET_Y = 32;
+
     RxRadioState rx_radio_state_{
         433920000 /* frequency */,
         1750000 /* bandwidth */,
@@ -163,11 +164,11 @@ class BattleshipView : public View {
     uint32_t last_address{0};
 
     // UI Elements - Menu/Settings Screen
-    Text text_title{{60, 2, 120, 24}, "BATTLESHIP"};
-    Text text_subtitle{{40, 20, 160, 16}, "Naval Combat Game"};
+    Text text_title{{UI_POS_X_CENTER(11), 2, UI_POS_WIDTH(11), 16}, "BATTLESHIP"};
+    Text text_subtitle{{UI_POS_X_CENTER(18), 24, UI_POS_WIDTH(18), 16}, "Naval Combat Game"};
 
-    Rectangle rect_radio_settings{{12, 40, 216, 118}, Color::dark_grey()};
-    Text label_radio{{17, 45, 100, 16}, "RADIO SETUP"};
+    // Rectangle rect_radio_settings{{12, 40, 216, 118}, Color::dark_grey()};
+    Text label_radio{{UI_POS_X_CENTER(12), 45, UI_POS_WIDTH(12), 16}, "RADIO SETUP"};
     ButtonWithEncoder button_frequency{{17, 65, 11 * 8, 20}, ""};
 
     // Radio controls
@@ -183,25 +184,24 @@ class BattleshipView : public View {
     Text label_tx_gain{{155, 118, 25, 16}, "TX:"};
     NumberField field_tx_gain{{185, 118}, 2, {0, 47}, 8, ' '};
 
-    Rectangle rect_audio_settings{{12, 164, 216, 45}, Color::dark_grey()};
-    Text label_audio{{17, 169, 80, 16}, "AUDIO"};
-    Checkbox checkbox_sound{{17, 187}, 8, "Sound On", true};
+    // Rectangle rect_audio_settings{{12, 164, 216, 45}, Color::dark_grey()};
+    Text label_audio{{UI_POS_X_CENTER(6), 155, UI_POS_WIDTH(6), 16}, "AUDIO"};
+    Checkbox checkbox_sound{{17, 177}, 8, "Sound On", true};
     Text label_volume{{110, 187, 50, 16}, "Volume:"};
-    AudioVolumeField field_volume{{165, 187}};
+    AudioVolumeField field_volume{{165, 177}};
 
-    Rectangle rect_team_selection{{12, 217, 216, 75}, Color::dark_grey()};
-    Text label_team{{17, 222, 110, 16}, "SELECT TEAM"};
-    Button button_red_team{{25, 242, 85, 45}, "RED\nTEAM"};
-    Button button_blue_team{{130, 242, 85, 45}, "BLUE\nTEAM"};
+    // Rectangle rect_team_selection{{12, 217, 216, 75}, Color::dark_grey()};
+    Text label_team{{17, 220, 8 * 12, 16}, "SELECT TEAM"};
+    Button button_red_team{{UI_POS_X_CENTER(10) - UI_POS_WIDTH(7), 237, UI_POS_WIDTH(10), 45}, "RED\nTEAM"};
+    Button button_blue_team{{UI_POS_X_CENTER(10) + UI_POS_WIDTH(7), 237, UI_POS_WIDTH(10), 45}, "BLUE\nTEAM"};
 
     // In-game UI elements
-    RSSI rssi{{21 * 8, 0, 6 * 8, 4}};
-    Text text_status{{10, 16, 220, 16}, ""};
+    RSSI rssi{{UI_POS_X_RIGHT(6), 0, 6 * 8, 4}};
     Text text_score{{170, 16, 60, 16}, ""};
-    Button button_rotate{{10, 265, 65, 32}, "Rotate"};
-    Button button_place{{82, 265, 65, 32}, "Place"};
-    Button button_fire{{82, 265, 65, 32}, "Fire!"};
-    Button button_menu{{155, 265, 65, 32}, "Menu"};
+    Button button_rotate{{5, UI_POS_Y_BOTTOM(3), 65, 32}, "Rotate"};
+    Button button_place{{UI_POS_X_CENTER(6), UI_POS_Y_BOTTOM(3), 65, 32}, "Place"};
+    Button button_fire{{UI_POS_X_RIGHT(17), UI_POS_Y_BOTTOM(3), 65, 32}, "Fire!"};
+    Button button_menu{{UI_POS_X_RIGHT(8), UI_POS_Y_BOTTOM(3), 65, 32}, "Menu"};
 
     // Methods
     void init_game();
@@ -209,8 +209,8 @@ class BattleshipView : public View {
     void start_team(bool red);
     void setup_ships();
     void draw_menu_screen(Painter& painter);
-    void draw_grid(Painter& painter, uint8_t grid_x, uint8_t grid_y, const std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE>& grid, bool show_ships, bool is_offense_grid = false);
-    void draw_cell(Painter& painter, uint8_t cell_x, uint8_t cell_y, CellState state, bool show_ships, bool is_offense_grid, bool is_cursor);
+    void draw_grid(Painter& painter, uint16_t grid_x, uint16_t grid_y, const std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE>& grid, bool show_ships, bool is_offense_grid = false);
+    void draw_cell(Painter& painter, uint16_t cell_x, uint16_t cell_y, CellState state, bool show_ships, bool is_offense_grid, bool is_cursor);
     void draw_ship_preview(Painter& painter);
     void place_ship();
     bool can_place_ship(uint8_t x, uint8_t y, uint8_t size, bool horizontal);
@@ -218,6 +218,7 @@ class BattleshipView : public View {
     void process_shot(uint8_t x, uint8_t y);
     void update_score();
     bool is_cursor_at(uint8_t x, uint8_t y, bool is_offense_grid);
+    void show_hide_menu(bool menu_vis);
 
     void send_message(const GameMessage& msg);
     void process_message(const std::string& message);

firmware/application/external/blackjack/ui_blackjack.cpp

@@ -41,6 +41,19 @@ void game_timer_check() {
 
 BlackjackView::BlackjackView(NavigationView& nav)
     : nav_{nav}, game_timer{} {
+    // Initialize screen dimensions dynamically
+    screen_w = ui::screen_width;
+    screen_h = ui::screen_height;
+
+    // Scale card size based on screen
+    if (screen_w <= 240) {
+        card_width = 50;
+        card_height = 65;
+    } else if (screen_w >= 400) {
+        card_width = 70;
+        card_height = 90;
+    }
+
     add_children({&dummy});
     current_instance = this;
     game_timer.attach(&game_timer_check, 1.0 / 60.0);
@@ -70,7 +83,7 @@ void BlackjackView::frame_sync() {
 }
 
 void BlackjackView::clear_screen() {
-    painter.fill_rectangle({0, 0, screen_width, screen_height}, Color::black());
+    painter.fill_rectangle({0, 0, screen_w, screen_h}, Color::black());
 }
 
 void BlackjackView::init_deck() {
@@ -267,22 +280,24 @@ void BlackjackView::draw_menu_static() {
 
     painter.draw_string({UI_POS_X_CENTER(10), 20}, style_title, "BLACKJACK");
 
-    // Draw rules
-    painter.draw_string({UI_POS_X_CENTER(12), 55}, style_rules, "-- RULES --");
-    painter.draw_string({UI_POS_X_CENTER(16), 75}, style_text, "Get close to 21");
-    painter.draw_string({UI_POS_X_CENTER(19), 90}, style_text, "without going over");
-    painter.draw_string({UI_POS_X_CENTER(18), 110}, style_text, "Dealer hits on 16");
-    painter.draw_string({UI_POS_X_CENTER(19), 125}, style_text, "Dealer stays on 17");
-    painter.draw_string({UI_POS_X_CENTER(19), 145}, style_text, "Blackjack pays 1:1");
+    // Draw rules - adjust Y positions for smaller screens
+    int rules_y = (screen_h > 300) ? 55 : 45;
+    painter.draw_string({UI_POS_X_CENTER(12), rules_y}, style_rules, "-- RULES --");
+    painter.draw_string({UI_POS_X_CENTER(16), rules_y + 20}, style_text, "Get close to 21");
+    painter.draw_string({UI_POS_X_CENTER(19), rules_y + 35}, style_text, "without going over");
+    painter.draw_string({UI_POS_X_CENTER(18), rules_y + 55}, style_text, "Dealer hits on 16");
+    painter.draw_string({UI_POS_X_CENTER(19), rules_y + 70}, style_text, "Dealer stays on 17");
+    painter.draw_string({UI_POS_X_CENTER(19), rules_y + 90}, style_text, "Blackjack pays 1:1");
 
     // Controls
-    painter.draw_string({UI_POS_X_CENTER(15), 175}, style_rules, "-- CONTROLS --");
-    painter.draw_string({UI_POS_X_CENTER(18), 195}, style_text, "SELECT: Start/Hit");
-    painter.draw_string({UI_POS_X_CENTER(12), 210}, style_text, "LEFT: Stats");
-    painter.draw_string({UI_POS_X_CENTER(17), 225}, style_text, "RIGHT: Exit/Stay");
+    int controls_y = (screen_h > 300) ? 175 : 155;
+    painter.draw_string({UI_POS_X_CENTER(15), controls_y}, style_rules, "-- CONTROLS --");
+    painter.draw_string({UI_POS_X_CENTER(18), controls_y + 20}, style_text, "SELECT: Start/Hit");
+    painter.draw_string({UI_POS_X_CENTER(12), controls_y + 35}, style_text, "LEFT: Stats");
+    painter.draw_string({UI_POS_X_CENTER(17), controls_y + 50}, style_text, "RIGHT: Exit/Stay");
 
-    // Draw high score
-    painter.draw_string({UI_POS_X_CENTER(17), 250}, style_text, "High Score: $" + std::to_string(high_score));
+    // Draw high score at bottom
+    painter.draw_string({UI_POS_X_CENTER(17), screen_h - 70}, style_text, "High Score: $" + std::to_string(high_score));
 }
 
 void BlackjackView::draw_menu() {
@@ -293,10 +308,10 @@ void BlackjackView::draw_menu() {
 
         if (blink_state) {
             auto style = *ui::Theme::getInstance()->fg_yellow;
-            painter.draw_string({UI_POS_X_CENTER(17), 280}, style, "* PRESS SELECT *");
+            painter.draw_string({UI_POS_X_CENTER(17), screen_h - 40}, style, "* PRESS SELECT *");
         } else {
             // Clear just the text area
-            painter.fill_rectangle({UI_POS_X_CENTER(17), 278, 130, 20}, Color::black());
+            painter.fill_rectangle({UI_POS_X_CENTER(17), screen_h - 42, 130, 20}, Color::black());
         }
     }
 }
@@ -310,27 +325,29 @@ void BlackjackView::draw_stats() {
 
     painter.draw_string({UI_POS_X_CENTER(11), 30}, style_title, "STATISTICS");
 
-    painter.draw_string({30, 80}, style_text, "Wins:");
+    int stats_x = (screen_w > 300) ? 50 : 30;
+
+    painter.draw_string({stats_x, 80}, style_text, "Wins:");
     painter.draw_string({UI_POS_X_CENTER(5), 80}, style_value, std::to_string(wins));
 
-    painter.draw_string({30, 100}, style_text, "Losses:");
+    painter.draw_string({stats_x, 100}, style_text, "Losses:");
     painter.draw_string({UI_POS_X_CENTER(5), 100}, style_value, std::to_string(losses));
 
     // Win percentage
     uint32_t total = wins + losses;
     if (total > 0) {
         uint32_t win_pct = (wins * 100) / total;
-        painter.draw_string({30, 120}, style_text, "Win %:");
+        painter.draw_string({stats_x, 120}, style_text, "Win %:");
         painter.draw_string({UI_POS_X_CENTER(5), 120}, style_value, std::to_string(win_pct) + "%");
     }
 
-    painter.draw_string({30, 160}, style_text, "High Score:");
+    painter.draw_string({stats_x, 160}, style_text, "High Score:");
     painter.draw_string({UI_POS_X_CENTER(5), 160}, style_value, "$" + std::to_string(high_score));
 
-    painter.draw_string({30, 180}, style_text, "Cash:");
+    painter.draw_string({stats_x, 180}, style_text, "Cash:");
     painter.draw_string({UI_POS_X_CENTER(5), 180}, style_value, "$" + std::to_string(cash));
 
-    painter.draw_string({40, 250}, style_text, "SELECT: Back");
+    painter.draw_string({UI_POS_X_CENTER(12), screen_h - 70}, style_text, "SELECT: Back");
 }
 
 void BlackjackView::draw_betting() {
@@ -343,7 +360,7 @@ void BlackjackView::draw_betting() {
         auto style_title = *ui::Theme::getInstance()->fg_green;
         auto style_text = *ui::Theme::getInstance()->fg_light;
 
-        painter.draw_string({70, 40}, style_title, "PLACE BET");
+        painter.draw_string({UI_POS_X_CENTER(10), 40}, style_title, "PLACE BET");
         painter.draw_string({30, 80}, style_text, "Cash: $" + std::to_string(cash));
 
         painter.draw_string({30, 140}, style_text, "ENCODER: +/- $10");
@@ -373,7 +390,7 @@ void BlackjackView::draw_game() {
 
         auto style = *ui::Theme::getInstance()->fg_green;
         painter.draw_string({10, 10}, style, "Cash: $" + std::to_string(cash));
-        painter.draw_string({140, 10}, style, "Bet: $" + std::to_string(bet));
+        painter.draw_string({screen_w - 80, 10}, style, "Bet: $" + std::to_string(bet));
 
         // Draw dealer hand with value next to label
         auto style_value = *ui::Theme::getInstance()->fg_yellow;
@@ -385,16 +402,18 @@ void BlackjackView::draw_game() {
         draw_hand(10, 65, dealer_cards, dealer_card_count, true);
 
         // Draw player hand with value next to label
-        painter.draw_string({10, 165}, *ui::Theme::getInstance()->fg_light, "You:");
+        int player_y = (screen_h > 300) ? 165 : 145;
+        painter.draw_string({10, player_y}, *ui::Theme::getInstance()->fg_light, "You:");
         int player_value = calculate_hand_value(player_cards, player_card_count);
-        painter.draw_string({50, 165}, style_value, "(" + std::to_string(player_value) + ")");
-        draw_hand(10, 185, player_cards, player_card_count, false);
+        painter.draw_string({50, player_y}, style_value, "(" + std::to_string(player_value) + ")");
+        draw_hand(10, player_y + 20, player_cards, player_card_count, false);
 
         // Draw controls or result
+        int controls_y = screen_h - 50;
         if (game_state == GameState::PLAYING) {
             auto style_text = *ui::Theme::getInstance()->fg_light;
-            painter.draw_string({30, 290}, style_text, "SELECT: Hit");
-            painter.draw_string({130, 290}, style_text, "RIGHT: Stay");
+            painter.draw_string({30, controls_y}, style_text, "SELECT: Hit");
+            painter.draw_string({screen_w - 100, controls_y}, style_text, "RIGHT: Stay");
         } else if (game_state == GameState::GAME_OVER) {
             const Style* style_result = ui::Theme::getInstance()->fg_yellow;
             std::string result;
@@ -416,14 +435,14 @@ void BlackjackView::draw_game() {
             }
 
             // Draw result
-            painter.draw_string({UI_POS_X_CENTER(result.length()), 270}, *style_result, result);
+            painter.draw_string({UI_POS_X_CENTER(result.length()), controls_y - 20}, *style_result, result);
 
-            // Draw compact bet selector in top right area
+            // Draw compact bet selector
             auto style_bet = *ui::Theme::getInstance()->fg_cyan;
-            painter.draw_string({140, 25}, style_bet, "Next: $" + std::to_string(bet));
+            painter.draw_string({screen_w - 100, 25}, style_bet, "Next: $" + std::to_string(bet));
 
             // Show controls
-            painter.draw_string({10, 290}, *ui::Theme::getInstance()->fg_light, "SELECT: Deal  ENC: +/-");
+            painter.draw_string({10, controls_y}, *ui::Theme::getInstance()->fg_light, "SELECT: Deal  ENC: +/-");
         }
 
         last_player_count = player_card_count;
@@ -432,109 +451,106 @@ void BlackjackView::draw_game() {
         last_bet = bet;
     } else if (game_state == GameState::GAME_OVER && bet != last_bet) {
         // Only update the bet display when it changes
-        painter.fill_rectangle({140, 25, 90, 16}, Color::black());
-        painter.draw_string({140, 25}, *ui::Theme::getInstance()->fg_cyan, "Next: $" + std::to_string(bet));
+        painter.fill_rectangle({screen_w - 100, 25, 90, 16}, Color::black());
+        painter.draw_string({screen_w - 100, 25}, *ui::Theme::getInstance()->fg_cyan, "Next: $" + std::to_string(bet));
         last_bet = bet;
     }
 }
 
 void BlackjackView::draw_suit_symbol(int x, int y, uint8_t suit, Color color, bool large) {
     if (large) {
-        // Large suit symbols for center of card
+        // Scale large symbols based on card size
+        int scale = card_width / 60;
+
         switch (suit) {
             case 0:  // Spades
-                // Top curve
-                painter.fill_rectangle({x + 9, y + 4, 2, 2}, color);
-                painter.fill_rectangle({x + 8, y + 5, 4, 2}, color);
-                painter.fill_rectangle({x + 7, y + 6, 6, 2}, color);
-                painter.fill_rectangle({x + 6, y + 7, 8, 2}, color);
-                painter.fill_rectangle({x + 5, y + 8, 10, 2}, color);
-                painter.fill_rectangle({x + 4, y + 9, 12, 2}, color);
-                painter.fill_rectangle({x + 3, y + 10, 14, 2}, color);
-                painter.fill_rectangle({x + 2, y + 11, 16, 2}, color);
-                painter.fill_rectangle({x + 1, y + 12, 18, 2}, color);
-                painter.fill_rectangle({x + 0, y + 13, 20, 3}, color);
-                painter.fill_rectangle({x + 1, y + 16, 18, 2}, color);
-                painter.fill_rectangle({x + 2, y + 17, 16, 1}, color);
-                painter.fill_rectangle({x + 3, y + 18, 14, 1}, color);
+                // Draw using scaled rectangles
+                painter.fill_rectangle({x + 9 * scale, y + 4 * scale, 2 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 8 * scale, y + 5 * scale, 4 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 7 * scale, y + 6 * scale, 6 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 6 * scale, y + 7 * scale, 8 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 5 * scale, y + 8 * scale, 10 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 4 * scale, y + 9 * scale, 12 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 3 * scale, y + 10 * scale, 14 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 2 * scale, y + 11 * scale, 16 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 1 * scale, y + 12 * scale, 18 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 0 * scale, y + 13 * scale, 20 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 1 * scale, y + 16 * scale, 18 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 2 * scale, y + 17 * scale, 16 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 3 * scale, y + 18 * scale, 14 * scale, 1 * scale}, color);
                 // Stem
-                painter.fill_rectangle({x + 9, y + 19, 2, 4}, color);
-                painter.fill_rectangle({x + 8, y + 22, 4, 1}, color);
-                painter.fill_rectangle({x + 7, y + 23, 6, 1}, color);
-                painter.fill_rectangle({x + 6, y + 24, 8, 1}, color);
+                painter.fill_rectangle({x + 9 * scale, y + 19 * scale, 2 * scale, 4 * scale}, color);
+                painter.fill_rectangle({x + 8 * scale, y + 22 * scale, 4 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 7 * scale, y + 23 * scale, 6 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 6 * scale, y + 24 * scale, 8 * scale, 1 * scale}, color);
                 break;
 
             case 1:  // Hearts
-                // Left bump
-                painter.fill_rectangle({x + 3, y + 5, 4, 2}, color);
-                painter.fill_rectangle({x + 2, y + 6, 6, 2}, color);
-                painter.fill_rectangle({x + 1, y + 7, 8, 3}, color);
-                painter.fill_rectangle({x + 0, y + 9, 9, 3}, color);
-                // Right bump
-                painter.fill_rectangle({x + 13, y + 5, 4, 2}, color);
-                painter.fill_rectangle({x + 12, y + 6, 6, 2}, color);
-                painter.fill_rectangle({x + 11, y + 7, 8, 3}, color);
-                painter.fill_rectangle({x + 11, y + 9, 9, 3}, color);
-                // Body
-                painter.fill_rectangle({x + 1, y + 11, 18, 3}, color);
-                painter.fill_rectangle({x + 2, y + 14, 16, 2}, color);
-                painter.fill_rectangle({x + 3, y + 16, 14, 2}, color);
-                painter.fill_rectangle({x + 4, y + 18, 12, 1}, color);
-                painter.fill_rectangle({x + 5, y + 19, 10, 1}, color);
-                painter.fill_rectangle({x + 6, y + 20, 8, 1}, color);
-                painter.fill_rectangle({x + 7, y + 21, 6, 1}, color);
-                painter.fill_rectangle({x + 8, y + 22, 4, 1}, color);
-                painter.fill_rectangle({x + 9, y + 23, 2, 1}, color);
+                // Draw using scaled rectangles
+                painter.fill_rectangle({x + 3 * scale, y + 5 * scale, 4 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 2 * scale, y + 6 * scale, 6 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 1 * scale, y + 7 * scale, 8 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 0 * scale, y + 9 * scale, 9 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 13 * scale, y + 5 * scale, 4 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 12 * scale, y + 6 * scale, 6 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 11 * scale, y + 7 * scale, 8 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 11 * scale, y + 9 * scale, 9 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 1 * scale, y + 11 * scale, 18 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 2 * scale, y + 14 * scale, 16 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 3 * scale, y + 16 * scale, 14 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 4 * scale, y + 18 * scale, 12 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 5 * scale, y + 19 * scale, 10 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 6 * scale, y + 20 * scale, 8 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 7 * scale, y + 21 * scale, 6 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 8 * scale, y + 22 * scale, 4 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 9 * scale, y + 23 * scale, 2 * scale, 1 * scale}, color);
                 break;
 
             case 2:  // Diamonds
-                painter.fill_rectangle({x + 10, y + 3, 1, 1}, color);
-                painter.fill_rectangle({x + 9, y + 4, 3, 1}, color);
-                painter.fill_rectangle({x + 8, y + 5, 5, 1}, color);
-                painter.fill_rectangle({x + 7, y + 6, 7, 1}, color);
-                painter.fill_rectangle({x + 6, y + 7, 9, 1}, color);
-                painter.fill_rectangle({x + 5, y + 8, 11, 1}, color);
-                painter.fill_rectangle({x + 4, y + 9, 13, 1}, color);
-                painter.fill_rectangle({x + 3, y + 10, 15, 1}, color);
-                painter.fill_rectangle({x + 2, y + 11, 17, 1}, color);
-                painter.fill_rectangle({x + 1, y + 12, 19, 1}, color);
-                painter.fill_rectangle({x + 0, y + 13, 21, 1}, color);
-                painter.fill_rectangle({x + 1, y + 14, 19, 1}, color);
-                painter.fill_rectangle({x + 2, y + 15, 17, 1}, color);
-                painter.fill_rectangle({x + 3, y + 16, 15, 1}, color);
-                painter.fill_rectangle({x + 4, y + 17, 13, 1}, color);
-                painter.fill_rectangle({x + 5, y + 18, 11, 1}, color);
-                painter.fill_rectangle({x + 6, y + 19, 9, 1}, color);
-                painter.fill_rectangle({x + 7, y + 20, 7, 1}, color);
-                painter.fill_rectangle({x + 8, y + 21, 5, 1}, color);
-                painter.fill_rectangle({x + 9, y + 22, 3, 1}, color);
-                painter.fill_rectangle({x + 10, y + 23, 1, 1}, color);
+                // Draw using scaled rectangles
+                painter.fill_rectangle({x + 10 * scale, y + 3 * scale, 1 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 9 * scale, y + 4 * scale, 3 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 8 * scale, y + 5 * scale, 5 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 7 * scale, y + 6 * scale, 7 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 6 * scale, y + 7 * scale, 9 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 5 * scale, y + 8 * scale, 11 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 4 * scale, y + 9 * scale, 13 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 3 * scale, y + 10 * scale, 15 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 2 * scale, y + 11 * scale, 17 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 1 * scale, y + 12 * scale, 19 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 0 * scale, y + 13 * scale, 21 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 1 * scale, y + 14 * scale, 19 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 2 * scale, y + 15 * scale, 17 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 3 * scale, y + 16 * scale, 15 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 4 * scale, y + 17 * scale, 13 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 5 * scale, y + 18 * scale, 11 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 6 * scale, y + 19 * scale, 9 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 7 * scale, y + 20 * scale, 7 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 8 * scale, y + 21 * scale, 5 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 9 * scale, y + 22 * scale, 3 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 10 * scale, y + 23 * scale, 1 * scale, 1 * scale}, color);
                 break;
 
             case 3:  // Clubs
-                // Center circle
-                painter.fill_rectangle({x + 8, y + 8, 5, 1}, color);
-                painter.fill_rectangle({x + 7, y + 9, 7, 3}, color);
-                painter.fill_rectangle({x + 8, y + 12, 5, 1}, color);
-                // Left circle
-                painter.fill_rectangle({x + 3, y + 11, 4, 1}, color);
-                painter.fill_rectangle({x + 2, y + 12, 6, 3}, color);
-                painter.fill_rectangle({x + 3, y + 15, 4, 1}, color);
-                // Right circle
-                painter.fill_rectangle({x + 14, y + 11, 4, 1}, color);
-                painter.fill_rectangle({x + 13, y + 12, 6, 3}, color);
-                painter.fill_rectangle({x + 14, y + 15, 4, 1}, color);
-                // Connect circles
-                painter.fill_rectangle({x + 6, y + 13, 9, 2}, color);
-                // Stem
-                painter.fill_rectangle({x + 9, y + 16, 3, 4}, color);
-                painter.fill_rectangle({x + 8, y + 19, 5, 1}, color);
-                painter.fill_rectangle({x + 7, y + 20, 7, 1}, color);
-                painter.fill_rectangle({x + 6, y + 21, 9, 1}, color);
+                // Draw using scaled rectangles
+                painter.fill_rectangle({x + 8 * scale, y + 8 * scale, 5 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 7 * scale, y + 9 * scale, 7 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 8 * scale, y + 12 * scale, 5 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 3 * scale, y + 11 * scale, 4 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 2 * scale, y + 12 * scale, 6 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 3 * scale, y + 15 * scale, 4 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 14 * scale, y + 11 * scale, 4 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 13 * scale, y + 12 * scale, 6 * scale, 3 * scale}, color);
+                painter.fill_rectangle({x + 14 * scale, y + 15 * scale, 4 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 6 * scale, y + 13 * scale, 9 * scale, 2 * scale}, color);
+                painter.fill_rectangle({x + 9 * scale, y + 16 * scale, 3 * scale, 4 * scale}, color);
+                painter.fill_rectangle({x + 8 * scale, y + 19 * scale, 5 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 7 * scale, y + 20 * scale, 7 * scale, 1 * scale}, color);
+                painter.fill_rectangle({x + 6 * scale, y + 21 * scale, 9 * scale, 1 * scale}, color);
                 break;
         }
     } else {
-        // Small suit symbols
+        // Small suit symbols remain the same
         switch (suit) {
             case 0:  // Spades - small
                 painter.fill_rectangle({x + 2, y + 1, 3, 3}, color);
@@ -569,18 +585,15 @@ void BlackjackView::draw_suit_symbol(int x, int y, uint8_t suit, Color color, bo
 }
 
 void BlackjackView::draw_card(int x, int y, uint8_t card, bool hidden) {
-    const int width = 60;
-    const int height = 80;
-
     // Draw card background
-    painter.fill_rectangle({x, y, width, height}, Color::white());
-    painter.draw_rectangle({x, y, width, height}, Color::black());
-    painter.draw_rectangle({x + 1, y + 1, width - 2, height - 2}, Color::grey());  // Inner border
+    painter.fill_rectangle({x, y, card_width, card_height}, Color::white());
+    painter.draw_rectangle({x, y, card_width, card_height}, Color::black());
+    painter.draw_rectangle({x + 1, y + 1, card_width - 2, card_height - 2}, Color::grey());
 
     if (hidden) {
         // Draw card back pattern - diagonal lines
-        for (int i = 4; i < width - 4; i += 6) {
-            for (int j = 4; j < height - 4; j += 6) {
+        for (int i = 4; i < card_width - 4; i += 6) {
+            for (int j = 4; j < card_height - 4; j += 6) {
                 painter.fill_rectangle({x + i, y + j, 3, 3}, Color::blue());
                 painter.fill_rectangle({x + i + 3, y + j + 3, 3, 3}, Color::red());
             }
@@ -606,22 +619,23 @@ void BlackjackView::draw_card(int x, int y, uint8_t card, bool hidden) {
         draw_suit_symbol(suit_x, y + 4, suit, suit_color, false);
 
         // Draw value in bottom-right corner
-        int bottom_x = (value_str == "10") ? x + width - 24 : x + width - 16;
-        painter.draw_string({bottom_x, y + height - 18}, card_style, value_str);
+        int bottom_x = (value_str == "10") ? x + card_width - 24 : x + card_width - 16;
+        painter.draw_string({bottom_x, y + card_height - 18}, card_style, value_str);
 
         // Draw small suit symbol in bottom-right
-        draw_suit_symbol(x + width - 10, y + height - 16, suit, suit_color, false);
+        draw_suit_symbol(x + card_width - 10, y + card_height - 16, suit, suit_color, false);
 
         // Draw large suit symbol in center
-        draw_suit_symbol(x + 20, y + 28, suit, suit_color, true);
+        int center_x = x + (card_width - 20) / 2;
+        int center_y = y + (card_height - 25) / 2;
+        draw_suit_symbol(center_x, center_y, suit, suit_color, true);
     }
 }
 
 void BlackjackView::draw_hand(int x, int y, uint8_t* cards, uint8_t count, bool is_dealer) {
     // Calculate total width needed
-    const int card_width = 60;
-    const int overlap = 40;                       // Amount of overlap when cards need to fit
-    const int max_width = screen_width - 10 - x;  // Available width on screen
+    const int overlap = card_width * 2 / 3;   // Amount of overlap when cards need to fit
+    const int max_width = screen_w - 10 - x;  // Available width on screen
 
     int spacing;
     if (count == 1) {
@@ -651,7 +665,7 @@ bool BlackjackView::on_key(const KeyEvent key) {
         switch (game_state) {
             case GameState::MENU:
                 if (cash < 10) {
-                    cash = 100;  // Reset if broke - maybe should provide https://gamblersanonymous.org/ link if they also lost their wife and house
+                    cash = 100;  // Reset if broke
                     wins = 0;
                     losses = 0;
                 }
@@ -724,4 +738,4 @@ bool BlackjackView::on_encoder(const EncoderEvent delta) {
     return false;
 }
 
-}  // namespace ui::external_app::blackjack
+}  // namespace ui::external_app::blackjack

firmware/application/external/blackjack/ui_blackjack.hpp

@@ -77,6 +77,12 @@ class BlackjackView : public View {
     NavigationView& nav_;
     bool initialized = false;
 
+    // Screen dimensions (set dynamically)
+    int screen_w = 0;
+    int screen_h = 0;
+    int card_width = 60;
+    int card_height = 80;
+
     // Game variables
     static constexpr uint8_t MAX_CARDS_IN_HAND = 11;  // Maximum possible cards before bust
     uint8_t deck[52];
@@ -141,7 +147,7 @@ class BlackjackView : public View {
          {"highscore"sv, &high_score}}};
 
     Button dummy{
-        {screen_width, 0, 0, 0},
+        {0, 0, 0, 0},
         ""};
 
     MessageHandlerRegistration message_handler_frame_sync{
@@ -153,4 +159,4 @@ class BlackjackView : public View {
 
 }  // namespace ui::external_app::blackjack
 
-#endif /* __UI_BLACKJACK_H__ */
+#endif /* __UI_BLACKJACK_H__ */

firmware/application/external/dinogame/ui_dinogame.cpp

@@ -43,7 +43,7 @@ const Color pp_colors[] = {
 
 // Drawing functions
 void cls() {
-    painter.fill_rectangle({0, 0, portapack::display.width(), portapack::display.height()}, Color::black());
+    painter.fill_rectangle({0, 0, ui::screen_width, ui::screen_height}, Color::black());
 }
 
 void fillrect(int x1, int y1, int x2, int y2, int color) {
@@ -100,6 +100,15 @@ DinoGameView::DinoGameView(NavigationView& nav)
     : nav_{nav}, bird_info{}, game_timer{} {
     add_children({&dummy, &button_difficulty});
     current_instance = this;
+
+    // Initialize dimensions first
+    init_dimensions();
+
+    // Now reposition button with proper centering
+    int button_y = SCREEN_HEIGHT - 100;
+    int button_x = (SCREEN_WIDTH - 100) / 2;
+    button_difficulty.set_parent_rect({button_x, button_y, 100, 20});
+
     game_timer.attach(&game_timer_check, 1.0 / 60.0);
 
     button_difficulty.on_select = [this](Button&) {
@@ -126,6 +135,33 @@ void DinoGameView::frame_sync() {
     set_dirty();
 }
 
+void DinoGameView::init_dimensions() {
+    SCREEN_WIDTH = ui::screen_width;
+    SCREEN_HEIGHT = ui::screen_height;
+
+    // Scale game area based on screen size
+    GAME_AREA_HEIGHT = (SCREEN_HEIGHT * 160) / 320;  // Scale proportionally
+    GAME_AREA_TOP = SCREEN_HEIGHT / 4;
+
+    // Calculate positions
+    DINO_Y = GAME_AREA_TOP + GAME_AREA_HEIGHT - GROUND_HEIGHT - DINO_HEIGHT;
+    DINO_DUCK_Y = GAME_AREA_TOP + GAME_AREA_HEIGHT - GROUND_HEIGHT - DINO_DUCK_HEIGHT;
+    BIRD_Y_UP = GAME_AREA_TOP + 20;
+    BIRD_Y_DOWN = GAME_AREA_TOP + (GAME_AREA_HEIGHT * 60) / 160;
+
+    // Scale jump height
+    JUMP_MAX_HEIGHT = (GAME_AREA_HEIGHT * 70) / 160;
+
+    // Scale distances based on screen width
+    MIN_OBSTACLE_DISTANCE = (SCREEN_WIDTH * 300) / 240;
+    MAX_OBSTACLE_DISTANCE = (SCREEN_WIDTH * 600) / 240;
+
+    // Scale horizontal position
+    DINO_X = SCREEN_WIDTH / 8;
+
+    last_dino_y = DINO_Y;
+}
+
 void DinoGameView::init_game() {
     game_state = GameState::MENU;
     menu_initialized = false;
@@ -142,7 +178,7 @@ void DinoGameView::new_game() {
     duck_timer = 0;
     displayedGameOver = false;
     bird_info.inGame = false;
-    bird_info.x_offset = 320;
+    bird_info.x_offset = SCREEN_WIDTH;
     bird_info.y_offset = 0;
     bird_info.y_velocity = 0;
     jumping = false;
@@ -181,9 +217,9 @@ void DinoGameView::show_menu() {
         painter.draw_string({UI_POS_X_CENTER(10), 60}, style_title, "DINO GAME");
 
         // Draw instructions
-        painter.draw_string({UI_POS_X_CENTER(19), 130}, style, "SELECT: Jump/Start");
-        painter.draw_string({UI_POS_X_CENTER(11), 150}, style, "DOWN: Duck");
-        painter.draw_string({UI_POS_X_CENTER(17), 170}, style, "Avoid obstacles!");
+        painter.draw_string({UI_POS_X_CENTER(19), 120}, style, "SELECT: Jump/Start");
+        painter.draw_string({UI_POS_X_CENTER(11), 140}, style, "DOWN: Duck");
+        painter.draw_string({UI_POS_X_CENTER(17), 160}, style, "Avoid obstacles!");
 
         // Draw high score
         draw_high_score();
@@ -194,14 +230,21 @@ void DinoGameView::show_menu() {
     // Show difficulty button
     button_difficulty.hidden(false);
 
-    // Animate the menu dino
-    bool menu_run_frame = (blink_counter / 15) % 2;
+    // Animate the menu dino - use frame counter for smooth animation
+    bool menu_run_frame = (blink_counter / 10) % 2;
 
-    // Clear previous dino position
-    fillrect(103, 90, 103 + DINO_WIDTH, 90 + DINO_HEIGHT, Black);
+    int menu_dino_x = UI_POS_X_CENTER(DINO_WIDTH);
+    int menu_dino_y = 90;
+
+    // Clear previous dino position - clear a bit extra to handle any artifacts
+    static bool last_menu_frame = false;
+    if (last_menu_frame != menu_run_frame || blink_counter == 0) {
+        fillrect(menu_dino_x - 5, menu_dino_y - 5, menu_dino_x + DINO_WIDTH + 5, menu_dino_y + DINO_HEIGHT + 5, Black);
+        last_menu_frame = menu_run_frame;
+    }
 
     // Draw animated dino
-    draw_dino_at(103, 90, false, menu_run_frame);
+    draw_dino_at(menu_dino_x, menu_dino_y, false, menu_run_frame);
 
     // Blinking start prompt
     auto style_prompt = *ui::Theme::getInstance()->fg_light;
@@ -209,9 +252,10 @@ void DinoGameView::show_menu() {
         blink_counter = 0;
         blink_state = !blink_state;
 
-        painter.fill_rectangle({UI_POS_X_CENTER(17), 258, 130, 20}, Color::black());
+        int prompt_y = SCREEN_HEIGHT - 60;
+        painter.fill_rectangle({UI_POS_X_CENTER(17), prompt_y - 2, 130, 20}, Color::black());
         if (blink_state) {
-            painter.draw_string({UI_POS_X_CENTER(17), 260}, style_prompt, "* PRESS SELECT *");
+            painter.draw_string({UI_POS_X_CENTER(17), prompt_y}, style_prompt, "* PRESS SELECT *");
         }
     }
 }
@@ -220,33 +264,30 @@ void DinoGameView::show_game_over() {
     if (!displayedGameOver) {
         displayedGameOver = true;
 
-        // Clear the last normal dino position
-        if (last_ducking) {
-            fillrect(DINO_X, last_dino_y, DINO_X + DINO_DUCK_WIDTH, last_dino_y + DINO_DUCK_HEIGHT, Black);
-        } else {
-            fillrect(DINO_X, last_dino_y, DINO_X + DINO_WIDTH, last_dino_y + DINO_HEIGHT, Black);
-        }
+        // Clear the entire play area to ensure clean display
+        fillrect(0, GAME_AREA_TOP, SCREEN_WIDTH, GAME_AREA_HEIGHT + 20, Black);
 
-        // Draw the game over dino sprite
-        draw_dino_sprite(DINO_X, DINO_Y, dino_gameover);
+        // Draw the game over dino sprite in the center
+        int gameover_dino_x = UI_POS_X_CENTER(DINO_WIDTH);
+        int gameover_dino_y = GAME_AREA_TOP + 40;
+        draw_dino_sprite(gameover_dino_x, gameover_dino_y, dino_gameover);
 
         auto style = *ui::Theme::getInstance()->fg_light;
         auto style_score = *ui::Theme::getInstance()->fg_medium;
 
         // Game over text
-        painter.draw_string({UI_POS_X_CENTER(10), 70}, style, "GAME OVER");
+        painter.draw_string({UI_POS_X_CENTER(10), GAME_AREA_TOP + 90}, style, "GAME OVER");
 
         // Show final score
         std::string score_text = "SCORE: " + score_to_string(score);
-        int score_x = (screen_width - score_text.length() * 8) / 2;
-        painter.draw_string({score_x, 90}, style_score, score_text);
+        painter.draw_string({UI_POS_X_CENTER(score_text.length()), GAME_AREA_TOP + 110}, style_score, score_text);
 
-        painter.draw_string({UI_POS_X_CENTER(16), 110}, style, "SELECT TO RETRY");
+        painter.draw_string({UI_POS_X_CENTER(16), GAME_AREA_TOP + 130}, style, "SELECT TO RETRY");
 
         // Update high score
         if (score > highScore) {
             highScore = score;
-            painter.draw_string({UI_POS_X_CENTER(16), 130}, style, "NEW HIGH SCORE!");
+            painter.draw_string({UI_POS_X_CENTER(16), GAME_AREA_TOP + 150}, style, "NEW HIGH SCORE!");
         }
     }
 }
@@ -263,7 +304,7 @@ void DinoGameView::game_loop() {
     // Update ground animation
     ground_offset = (ground_offset + GAME_SPEED_BASE + speed_modifier) % 20;
 
-    // Clear only the game area (not the whole screen to reduce flicker)
+    // Draw ground
     draw_ground();
 
     // Update and draw obstacles
@@ -295,38 +336,38 @@ void DinoGameView::game_loop() {
     // Update run animation
     if (get_steps() % (10 - speed_modifier) == 0) runstate = !runstate;
 
-    // Draw dino with minimal redraw
+    // Draw dino with proper clearing
     int current_dino_y = jumping ? (DINO_Y - jumpHeight) : (ducking ? DINO_DUCK_Y : DINO_Y);
 
-    // Clear old dino position more precisely
+    // Only clear and redraw if something changed
     if (current_dino_y != last_dino_y || runstate != last_runstate || ducking != last_ducking) {
-        // Clear based on last state
+        // Clear old position with extra margin to prevent artifacts
         if (last_ducking) {
-            fillrect(DINO_X, last_dino_y, DINO_X + DINO_DUCK_WIDTH, last_dino_y + DINO_DUCK_HEIGHT, Black);
+            fillrect(DINO_X - 2, last_dino_y - 2, DINO_X + DINO_DUCK_WIDTH + 2, last_dino_y + DINO_DUCK_HEIGHT + 2, Black);
         } else {
-            fillrect(DINO_X, last_dino_y, DINO_X + DINO_WIDTH, last_dino_y + DINO_HEIGHT, Black);
+            fillrect(DINO_X - 2, last_dino_y - 2, DINO_X + DINO_WIDTH + 2, last_dino_y + DINO_HEIGHT + 2, Black);
         }
-    }
 
-    // Draw dino at new position
-    if (jumping) {
-        draw_dino_sprite(DINO_X, current_dino_y, dino_default);
-    } else if (ducking) {
-        if (runstate)
-            draw_dino_sprite(DINO_X, current_dino_y, dino_ducking_leftstep);
-        else
-            draw_dino_sprite(DINO_X, current_dino_y, dino_ducking_rightstep);
-    } else {
-        if (runstate)
-            draw_dino_sprite(DINO_X, current_dino_y, dino_leftstep);
-        else
-            draw_dino_sprite(DINO_X, current_dino_y, dino_rightstep);
-    }
+        // Draw dino at new position
+        if (jumping) {
+            draw_dino_sprite(DINO_X, current_dino_y, dino_default);
+        } else if (ducking) {
+            if (runstate)
+                draw_dino_sprite(DINO_X, current_dino_y, dino_ducking_leftstep);
+            else
+                draw_dino_sprite(DINO_X, current_dino_y, dino_ducking_rightstep);
+        } else {
+            if (runstate)
+                draw_dino_sprite(DINO_X, current_dino_y, dino_leftstep);
+            else
+                draw_dino_sprite(DINO_X, current_dino_y, dino_rightstep);
+        }
 
-    // Update last state
-    last_dino_y = current_dino_y;
-    last_ducking = ducking;
-    last_runstate = runstate;
+        // Update last state
+        last_dino_y = current_dino_y;
+        last_ducking = ducking;
+        last_runstate = runstate;
+    }
 
     // Check collisions
     check_collision();
@@ -346,14 +387,14 @@ void DinoGameView::draw_ground() {
     int ground_y = GAME_AREA_TOP + GAME_AREA_HEIGHT - GROUND_HEIGHT;
 
     // Clear ground area
-    fillrect(0, ground_y, 320, ground_y + GROUND_HEIGHT, Black);
+    fillrect(0, ground_y, SCREEN_WIDTH, ground_y + GROUND_HEIGHT, Black);
 
     // Draw ground line
-    painter.draw_hline({0, ground_y}, 320, Color::white());
-    painter.draw_hline({0, ground_y + 1}, 320, Color::dark_grey());
+    painter.draw_hline({0, ground_y}, SCREEN_WIDTH, Color::white());
+    painter.draw_hline({0, ground_y + 1}, SCREEN_WIDTH, Color::dark_grey());
 
     // Draw ground texture
-    for (int x = -ground_offset; x < 320; x += 20) {
+    for (int x = -ground_offset; x < SCREEN_WIDTH; x += 20) {
         painter.draw_hline({x, ground_y + 3}, 10, Color::dark_grey());
         painter.draw_hline({x + 5, ground_y + 5}, 5, Color::dark_grey());
     }
@@ -364,7 +405,7 @@ void DinoGameView::update_obstacles() {
     for (int i = 0; i < MAX_OBSTACLES; i++) {
         if (obstacles[i].active) {
             // Clear old position
-            if (obstacles[i].last_x != obstacles[i].x && obstacles[i].last_x < 320) {
+            if (obstacles[i].last_x != obstacles[i].x && obstacles[i].last_x < SCREEN_WIDTH) {
                 clear_obstacle_area(obstacles[i].last_x, obstacles[i].width + 10, obstacles[i].height + 10);
             }
 
@@ -394,8 +435,8 @@ void DinoGameView::update_obstacles() {
         for (int i = 0; i < MAX_OBSTACLES; i++) {
             if (!obstacles[i].active) {
                 obstacles[i].active = true;
-                obstacles[i].x = 320;
-                obstacles[i].last_x = 320;
+                obstacles[i].x = SCREEN_WIDTH;
+                obstacles[i].last_x = SCREEN_WIDTH;
                 obstacles[i].type = rand() % 4;
 
                 // Set obstacle dimensions based on type
@@ -495,7 +536,7 @@ void DinoGameView::manage_bird() {
         // Only spawn bird if no obstacles are too close
         bool obstacle_nearby = false;
         for (int i = 0; i < MAX_OBSTACLES; i++) {
-            if (obstacles[i].active && obstacles[i].x > 200) {
+            if (obstacles[i].active && obstacles[i].x > SCREEN_WIDTH * 0.8) {
                 obstacle_nearby = true;
                 break;
             }
@@ -504,7 +545,7 @@ void DinoGameView::manage_bird() {
         // Randomly spawn bird if no nearby obstacles
         if (!obstacle_nearby && rand() % 400 == 0 && get_steps() > 100) {
             bird_info.inGame = true;
-            bird_info.x_offset = 320;
+            bird_info.x_offset = SCREEN_WIDTH;
             bird_info.y_offset = 0;
             bird_info.y_velocity = easy_mode ? 0 : (rand() % 3) - 1;  // No vertical movement in easy mode
             bird_info.y_position = BirdPosition::DOWN;                // Always spawn at standing height in easy mode
@@ -514,16 +555,16 @@ void DinoGameView::manage_bird() {
         int base_y = (bird_info.y_position == BirdPosition::UP) ? BIRD_Y_UP : BIRD_Y_DOWN;
         int current_y = base_y + bird_info.y_offset;
 
-        // Clear previous bird position
-        if (last_bird_x < 320 && last_bird_x >= -BIRD_WIDTH) {
-            int clear_start_x = last_bird_x;
-            int clear_end_x = last_bird_x + BIRD_WIDTH;
+        // Clear previous bird position with extra margin
+        if (last_bird_x < SCREEN_WIDTH && last_bird_x >= -BIRD_WIDTH) {
+            int clear_start_x = last_bird_x - 2;
+            int clear_end_x = last_bird_x + BIRD_WIDTH + 2;
 
             if (clear_start_x < 0) clear_start_x = 0;
-            if (clear_end_x > 320) clear_end_x = 320;
+            if (clear_end_x > SCREEN_WIDTH) clear_end_x = SCREEN_WIDTH;
 
             if (clear_end_x > clear_start_x) {
-                fillrect(clear_start_x, last_bird_y, clear_end_x, last_bird_y + BIRD_HEIGHT, Black);
+                fillrect(clear_start_x, last_bird_y - 2, clear_end_x, last_bird_y + BIRD_HEIGHT + 2, Black);
             }
         }
 
@@ -549,7 +590,6 @@ void DinoGameView::manage_bird() {
             }
         } else {
             // In easy mode, keep bird at perfect ducking height
-            // Bird should hit standing dino but miss ducking dino
             current_y = DINO_Y - 10;  // Position bird just above ducking height
         }
 
@@ -557,7 +597,7 @@ void DinoGameView::manage_bird() {
         if (get_steps() % 15 == 0) bird_info.flop = !bird_info.flop;
 
         // Draw bird only if any part is visible
-        if (bird_info.x_offset > -BIRD_WIDTH && bird_info.x_offset < 320) {
+        if (bird_info.x_offset > -BIRD_WIDTH && bird_info.x_offset < SCREEN_WIDTH) {
             if (bird_info.flop) {
                 draw_bird_sprite(bird_info.x_offset, current_y, pterodactyl_upflop);
             } else {
@@ -590,6 +630,7 @@ void DinoGameView::draw_dino_sprite(int x, int y, const uint16_t* sprite) {
         width = DINO_WIDTH;
     }
 
+    // Draw sprite efficiently with run-length optimization
     for (int dy = 0; dy < height; dy++) {
         int run_start = -1;
         uint16_t run_color = 0;
@@ -623,16 +664,21 @@ void DinoGameView::draw_dino_sprite(int x, int y, const uint16_t* sprite) {
 }
 
 void DinoGameView::draw_bird_sprite(int x, int y, const uint16_t* sprite) {
+    // Draw sprite efficiently with clipping
     for (int dy = 0; dy < BIRD_HEIGHT; dy++) {
         int run_start = -1;
         uint16_t run_color = 0;
 
         for (int dx = 0; dx < BIRD_WIDTH; dx++) {
             // Skip pixels that would be off-screen
-            if (x + dx < 0 || x + dx >= 320) {
+            if (x + dx < 0 || x + dx >= SCREEN_WIDTH) {
                 // End any current run
-                if (run_start != -1) {
-                    painter.fill_rectangle({x + run_start, y + dy, dx - run_start, 1}, Color(run_color));
+                if (run_start != -1 && x + run_start < SCREEN_WIDTH) {
+                    int run_width = dx - run_start;
+                    if (x + run_start + run_width > SCREEN_WIDTH) {
+                        run_width = SCREEN_WIDTH - (x + run_start);
+                    }
+                    painter.fill_rectangle({x + run_start, y + dy, run_width, 1}, Color(run_color));
                     run_start = -1;
                 }
                 continue;
@@ -660,10 +706,10 @@ void DinoGameView::draw_bird_sprite(int x, int y, const uint16_t* sprite) {
             }
         }
 
-        if (run_start != -1 && x + run_start < 320) {
+        if (run_start != -1 && x + run_start < SCREEN_WIDTH) {
             int width = BIRD_WIDTH - run_start;
-            if (x + run_start + width > 320) {
-                width = 320 - (x + run_start);
+            if (x + run_start + width > SCREEN_WIDTH) {
+                width = SCREEN_WIDTH - (x + run_start);
             }
             if (width > 0) {
                 painter.fill_rectangle({x + run_start, y + dy, width, 1}, Color(run_color));
@@ -683,7 +729,7 @@ void DinoGameView::draw_dino_at(int x, int y, bool is_ducking, bool run_frame) {
         if (run_frame) {
             draw_dino_sprite(x, y, dino_leftstep);
         } else {
-            draw_dino_sprite(x, y, dino_default);
+            draw_dino_sprite(x, y, dino_rightstep);
         }
     }
 }
@@ -743,8 +789,8 @@ void DinoGameView::draw_current_score() {
 
 void DinoGameView::draw_high_score() {
     auto style = *ui::Theme::getInstance()->fg_light;
-    painter.fill_rectangle({UI_POS_X_RIGHT(9), 28, UI_POS_WIDTH(9), 18}, Color::black());
-    painter.draw_string({UI_POS_X_RIGHT(9), 30}, style, "HI " + score_to_string(highScore));
+    painter.fill_rectangle({UI_POS_X_RIGHT(90), 28, 90, 18}, Color::black());
+    painter.draw_string({UI_POS_X_RIGHT(90), 30}, style, "HI " + score_to_string(highScore));
 }
 
 void DinoGameView::jump() {
@@ -805,4 +851,4 @@ bool DinoGameView::on_encoder(const EncoderEvent delta) {
     return true;
 }
 
-}  // namespace ui::external_app::dinogame
+}  // namespace ui::external_app::dinogame

firmware/application/external/dinogame/ui_dinogame.hpp

@@ -41,29 +41,6 @@ enum {
     Black,
 };
 
-// Game constants
-#define DINO_WIDTH 34
-#define DINO_HEIGHT 36
-#define DINO_DUCK_WIDTH 45
-#define DINO_DUCK_HEIGHT 22
-#define BIRD_WIDTH 34
-#define BIRD_HEIGHT 27
-#define GROUND_HEIGHT 10
-#define GAME_AREA_TOP 78
-#define GAME_AREA_HEIGHT 160
-#define DINO_X 30
-#define DINO_Y (GAME_AREA_TOP + GAME_AREA_HEIGHT - GROUND_HEIGHT - DINO_HEIGHT)
-#define DINO_DUCK_Y (GAME_AREA_TOP + GAME_AREA_HEIGHT - GROUND_HEIGHT - DINO_DUCK_HEIGHT)
-#define BIRD_Y_UP (GAME_AREA_TOP + 20)
-#define BIRD_Y_DOWN (GAME_AREA_TOP + 60)
-#define JUMP_MAX_HEIGHT 70
-#define JUMP_SPEED 3
-#define GAME_SPEED_BASE 3
-#define SPRITE_COLOR 0x528A
-#define TRANSPARENT_COLOR 0xFFFF
-#define MIN_OBSTACLE_DISTANCE 300
-#define MAX_OBSTACLE_DISTANCE 600
-
 // Game states
 enum class GameState {
     MENU,
@@ -159,6 +136,33 @@ class DinoGameView : public View {
     bool initialized = false;
     NavigationView& nav_;
 
+    // Dynamic screen dimensions
+    int SCREEN_WIDTH = 240;
+    int SCREEN_HEIGHT = 320;
+    int DINO_WIDTH = 34;
+    int DINO_HEIGHT = 36;
+    int DINO_DUCK_WIDTH = 45;
+    int DINO_DUCK_HEIGHT = 22;
+    int BIRD_WIDTH = 34;
+    int BIRD_HEIGHT = 27;
+    int GROUND_HEIGHT = 10;
+    int GAME_AREA_TOP = 78;
+    int GAME_AREA_HEIGHT = 160;
+    int DINO_X = 30;
+    int DINO_Y = 0;       // Will be calculated
+    int DINO_DUCK_Y = 0;  // Will be calculated
+    int BIRD_Y_UP = 0;    // Will be calculated
+    int BIRD_Y_DOWN = 0;  // Will be calculated
+    int JUMP_MAX_HEIGHT = 70;
+    int JUMP_SPEED = 3;
+    int GAME_SPEED_BASE = 3;
+    int MIN_OBSTACLE_DISTANCE = 300;
+    int MAX_OBSTACLE_DISTANCE = 600;
+
+    // Sprite constants
+    static constexpr uint16_t SPRITE_COLOR = 0x528A;
+    static constexpr uint16_t TRANSPARENT_COLOR = 0xFFFF;
+
     // Game variables
     static constexpr uint8_t MAX_OBSTACLES = 1;
     SimpleObstacle obstacles[MAX_OBSTACLES];
@@ -185,7 +189,7 @@ class DinoGameView : public View {
     int32_t obstacle_spawn_timer = 0;
 
     // Position tracking for minimal redraw
-    int16_t last_dino_y = DINO_Y;
+    int16_t last_dino_y = 0;
     int16_t last_bird_x = -1;
     int16_t last_bird_y = -1;
     uint8_t duck_timer = 0;
@@ -202,6 +206,7 @@ class DinoGameView : public View {
     Ticker game_timer;
 
     // Private methods
+    void init_dimensions();
     void init_game();
     void new_game();
     void update_obstacles();
@@ -229,7 +234,7 @@ class DinoGameView : public View {
     bool easy_mode = false;
 
     Button button_difficulty{
-        {UI_POS_X_CENTER(13), 195, 13 * 8, 20},
+        {70, 195, 100, 20},
         "Mode: HARD"};
 
     app_settings::SettingsManager settings_{
@@ -239,7 +244,7 @@ class DinoGameView : public View {
          {"easy_mode"sv, &easy_mode}}};
 
     Button dummy{
-        {screen_width, 0, 0, 0},
+        {240, 0, 0, 0},
         ""};
 
     MessageHandlerRegistration message_handler_frame_sync{
@@ -251,4 +256,4 @@ class DinoGameView : public View {
 
 }  // namespace ui::external_app::dinogame
 
-#endif /* __UI_DINOGAME_H__ */
+#endif /* __UI_DINOGAME_H__ */

firmware/application/external/doom/ui_doom.cpp

@@ -17,6 +17,7 @@ int SCREEN_HEIGHT = 0;
 int RENDER_HEIGHT = 0;
 int HALF_WIDTH = 0;
 int HALF_HEIGHT = 0;
+int HUD_HEIGHT = 40;
 #define LEVEL_WIDTH_BASE 6
 #define LEVEL_WIDTH (1 << LEVEL_WIDTH_BASE)
 #define LEVEL_HEIGHT 57
@@ -24,7 +25,7 @@ int HALF_HEIGHT = 0;
 #define MAX_RENDER_DEPTH 12
 #define MIN_ENTITIES 15
 #define MAX_ENTITIES 25
-#define RES_DIVIDER 2
+int RES_DIVIDER = 2;
 #define DISTANCE_MULTIPLIER 20
 #define ROT_SPEED 0.25
 #define MOV_SPEED 1.0
@@ -32,10 +33,10 @@ int HALF_HEIGHT = 0;
 #define MAX_ENTITY_DISTANCE 200
 #define ITEM_COLLIDER_DIST 6
 #include "mathdef.hpp"
-#define GUN_WIDTH 30
-#define GUN_HEIGHT 40
-#define GUN_TARGET_POS 24
-#define GUN_SHOT_POS (GUN_TARGET_POS + 6)
+int GUN_WIDTH = 30;
+int GUN_HEIGHT = 40;
+int GUN_TARGET_POS = 24;
+int GUN_SHOT_POS = 30;
 #define ENEMY_SIZE 16
 #define ENEMY_SPEED 0.03
 #define ENEMY_MELEE_DIST 20
@@ -145,7 +146,7 @@ static bool up, down, left, right, fired;
 static double jogging, view_height;
 static bool needs_redraw = false;
 static bool needs_gun_redraw = false;
-static uint8_t gun_pos = GUN_TARGET_POS;
+static uint8_t gun_pos = 24;
 static bool gun_fired = false;
 static int prev_gun_x = 0;
 static int prev_gun_y = 0;
@@ -850,13 +851,23 @@ void render_entities(Painter& painter) {
     }
 }
 
-void render_map(Painter& painter, bool full_clear, int16_t x_start = 0, int16_t x_end = SCREEN_WIDTH) {
+void render_map(Painter& painter, bool full_clear, int16_t x_start = 0, int16_t x_end = -1) {
+    if (x_end == -1) x_end = SCREEN_WIDTH;
+
+    // Add safety bounds
+    x_start = fmax(0, x_start);
+    x_end = fmin(SCREEN_WIDTH, x_end);
+
+    // Dynamically adjust RES_DIVIDER based on screen size
+    int dynamic_res = (SCREEN_WIDTH > 400) ? 4 : (SCREEN_WIDTH > 300) ? 3
+                                                                      : RES_DIVIDER;
+
     if (full_clear) {
         painter.fill_rectangle({0, 0, SCREEN_WIDTH, RENDER_HEIGHT / 2}, Color(64, 64, 128));
         painter.fill_rectangle({0, RENDER_HEIGHT / 2, SCREEN_WIDTH, RENDER_HEIGHT / 2}, Color(32, 32, 32));
     }
 
-    for (uint8_t x = x_start; x < x_end; x += RES_DIVIDER) {
+    for (uint16_t x = x_start; x < x_end; x += dynamic_res) {
         double camera_x = 2 * (double)x / SCREEN_WIDTH - 1;
         double ray_x = player.dir.x + player.plane.x * camera_x;
         double ray_y = player.dir.y + player.plane.y * camera_x;
@@ -985,15 +996,15 @@ void render_map(Painter& painter, bool full_clear, int16_t x_start = 0, int16_t
                 wall_color = Color(brightness / 5, (brightness - noise) * 0.8, brightness / 5);
             }
 
-            painter.fill_rectangle({x, start_y, RES_DIVIDER, end_y - start_y}, wall_color);
+            painter.fill_rectangle({x, start_y, dynamic_res, end_y - start_y}, wall_color);
         }
 
         if (!full_clear && hit) {
             if (start_y > 0) {
-                painter.fill_rectangle({x, 0, RES_DIVIDER, start_y}, Color(64, 64, 128));
+                painter.fill_rectangle({x, 0, dynamic_res, start_y}, Color(64, 64, 128));
             }
             if (end_y < RENDER_HEIGHT) {
-                painter.fill_rectangle({x, end_y, RES_DIVIDER, RENDER_HEIGHT - end_y}, Color(32, 32, 32));
+                painter.fill_rectangle({x, end_y, dynamic_res, RENDER_HEIGHT - end_y}, Color(32, 32, 32));
             }
         }
     }
@@ -1001,11 +1012,28 @@ void render_map(Painter& painter, bool full_clear, int16_t x_start = 0, int16_t
 
 DoomView::DoomView(NavigationView& nav)
     : nav_{nav} {
-    SCREEN_WIDTH = screen_width;
-    SCREEN_HEIGHT = screen_height;
-    RENDER_HEIGHT = screen_height - 40;
-    HALF_WIDTH = screen_width / 2;
+    SCREEN_WIDTH = ui::screen_width;
+    SCREEN_HEIGHT = ui::screen_height;
+    HUD_HEIGHT = 40;
+    RENDER_HEIGHT = SCREEN_HEIGHT - HUD_HEIGHT;
+    HALF_WIDTH = SCREEN_WIDTH / 2;
     HALF_HEIGHT = RENDER_HEIGHT / 2;
+
+    // More aggressive resolution reduction for larger screens
+    if (SCREEN_WIDTH > 400) {
+        RES_DIVIDER = 4;
+    } else if (SCREEN_WIDTH > 300) {
+        RES_DIVIDER = 3;
+    } else {
+        RES_DIVIDER = 2;
+    }
+
+    // Cap gun size to prevent overflow
+    GUN_WIDTH = fmin(60, SCREEN_WIDTH / 8);
+    GUN_HEIGHT = fmin(50, SCREEN_HEIGHT / 8);
+    GUN_TARGET_POS = fmin(40, RENDER_HEIGHT / 13);
+    GUN_SHOT_POS = GUN_TARGET_POS + 6;
+
     add_children({&dummy});
     game_timer.attach(&game_timer_check, 1.0 / 60.0);
 }
@@ -1034,26 +1062,32 @@ void DoomView::paint(Painter& painter) {
 
     if (scene == 0) {
         auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
-        painter.draw_string({50, 40}, style_yellow, "* * * DOOM * * *");
+        painter.draw_string({UI_POS_X_CENTER(15), 40}, style_yellow, "* * * DOOM * * *");
         auto style_green = *ui::Theme::getInstance()->fg_green;
-        painter.draw_string({15, 240}, style_green, "** PRESS SELECT TO START **");
+        painter.draw_string({UI_POS_X_CENTER(26), SCREEN_HEIGHT - 80}, style_green, "** PRESS SELECT TO START **");
     } else if (scene == 1) {
         if (needs_redraw || (needs_gun_redraw && jogging > 0)) {
             bool full_clear = (player.velocity == 0 || !prev_velocity_moving);
             render_map(painter, full_clear);
             render_entities(painter);
             render_gun(painter, gun_pos, jogging);
+
+            // Draw HUD
             painter.fill_rectangle({0, RENDER_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT - RENDER_HEIGHT}, pp_colors[COLOR_BACKGROUND]);
             auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
             auto style_red = *ui::Theme::getInstance()->fg_red;
             auto style_blue = *ui::Theme::getInstance()->fg_blue;
-            painter.draw_string({5, RENDER_HEIGHT + 5}, style_yellow, "Health: " + std::to_string(player.health));
-            painter.draw_string({100, RENDER_HEIGHT + 5}, style_red, "Kills: " + std::to_string(kills));
-            painter.draw_string({170, RENDER_HEIGHT + 5}, style_blue, "Ammo: " + std::to_string(player.ammo));
+
+            int hud_y = RENDER_HEIGHT + 5;
+            painter.draw_string({5, hud_y}, style_yellow, "Health: " + std::to_string(player.health));
+            painter.draw_string({UI_POS_X_CENTER(15), hud_y}, style_red, "Kills: " + std::to_string(kills));
+            painter.draw_string({UI_POS_X_RIGHT(80), hud_y}, style_blue, "Ammo: " + std::to_string(player.ammo));
+
             prev_velocity_moving = (player.velocity != 0);
             needs_redraw = false;
             needs_gun_redraw = false;
         } else if (needs_gun_redraw) {
+            // Partial redraw for gun only
             int current_x = HALF_WIDTH - GUN_WIDTH / 2 + sin(LPC_RTC->CTIME0 * JOGGING_SPEED) * 10 * jogging;
             int current_y = RENDER_HEIGHT - gun_pos - 29 + fabs(cos(LPC_RTC->CTIME0 * JOGGING_SPEED)) * 8 * jogging;
             int flash_height = (gun_pos > GUN_TARGET_POS) ? (gun_pos - GUN_TARGET_POS) * 2 + 10 : 0;
@@ -1069,13 +1103,18 @@ void DoomView::paint(Painter& painter) {
             render_map(painter, false, min_x, max_x);
             render_entities(painter);
             render_gun(painter, gun_pos, jogging);
+
+            // Redraw HUD
             painter.fill_rectangle({0, RENDER_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT - RENDER_HEIGHT}, pp_colors[COLOR_BACKGROUND]);
             auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
             auto style_red = *ui::Theme::getInstance()->fg_red;
             auto style_blue = *ui::Theme::getInstance()->fg_blue;
-            painter.draw_string({5, RENDER_HEIGHT + 5}, style_yellow, "Health: " + std::to_string(player.health));
-            painter.draw_string({100, RENDER_HEIGHT + 5}, style_red, "Kills: " + std::to_string(kills));
-            painter.draw_string({170, RENDER_HEIGHT + 5}, style_blue, "Ammo: " + std::to_string(player.ammo));
+
+            int hud_y = RENDER_HEIGHT + 5;
+            painter.draw_string({5, hud_y}, style_yellow, "Health: " + std::to_string(player.health));
+            painter.draw_string({UI_POS_X_CENTER(15), hud_y}, style_red, "Kills: " + std::to_string(kills));
+            painter.draw_string({UI_POS_X_RIGHT(80), hud_y}, style_blue, "Ammo: " + std::to_string(player.ammo));
+
             needs_gun_redraw = false;
         }
     }

firmware/application/external/doom/ui_doom.hpp

@@ -70,7 +70,7 @@ class DoomView : public View {
 
    private:
     NavigationView& nav_;
-    Button dummy{{screen_width, 0, 0, 0}, ""};
+    Button dummy{{0, 0, 0, 0}, ""};
     bool initialized{false};
     bool prev_velocity_moving{false};
     MessageHandlerRegistration message_handler_frame_sync{

firmware/application/external/external.cmake

@@ -254,6 +254,10 @@ set(EXTCPPSRC
 	external/bht_tx/main.cpp
 	external/bht_tx/ui_bht_tx.cpp
 	external/bht_tx/bht.cpp
+
+	#morse_practice
+	external/morse_practice/main.cpp
+	external/morse_practice/ui_morse_practice.cpp
 )
 
 set(EXTAPPLIST
@@ -318,4 +322,5 @@ set(EXTAPPLIST
 	soundboard
 	game2048
 	bht_tx
+	morse_practice
 )

firmware/application/external/external.ld

@@ -83,7 +83,8 @@ MEMORY
     ram_external_app_epirb_rx   (rwx) : org = 0xADEA0000, len = 32k
     ram_external_app_soundboard   (rwx) : org = 0xADEB0000, len = 32k
     ram_external_app_game2048     (rwx) : org = 0xADEC0000, len = 32k
-    ram_external_app_bht_tx     (rwx) : org = 0xADED0000, len = 32k
+    ram_external_app_bht_tx          (rwx) : org = 0xADED0000, len = 32k
+    ram_external_app_morse_practice  (rwx) : org = 0xADEE0000, len = 32k
 
 
 }
@@ -458,5 +459,12 @@ SECTIONS
     } > ram_external_app_bht_tx
 
 
+    .external_app_morse_practice : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_morse_practice.application_information));
+        *(*ui*external_app*morse_practice*);
+    } > ram_external_app_morse_practice
+
+
 }
 

firmware/application/external/morse_practice/main.cpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2025 Pezsma
+ *
+ * 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_morse_practice.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::morse_practice {
+
+void initialize_app(NavigationView& nav) {
+    nav.push<MorsePracticeView>();
+}
+
+}  // namespace ui::external_app::morse_practice
+
+extern "C" {
+
+// Az alkalmazás információ C-linkage-ként, hogy a firmware hívhassa
+__attribute__((section(".external_app.app_morse_practice.application_information"), used))
+application_information_t _application_information_morse_practice = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::morse_practice::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "Morse P",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0xFE,
+        0x7F,
+        0xFF,
+        0xFF,
+        0xBB,
+        0xD0,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x0B,
+        0xE1,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xEB,
+        0xD0,
+        0xFF,
+        0xFF,
+        0xFE,
+        0x7F,
+        0x70,
+        0x00,
+        0x30,
+        0x00,
+        0x10,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::yellow().v,
+    /*.menu_location = */ app_location_t::GAMES,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_none */ {'P', 'A', 'B', 'P'},
+    /*.m4_app_offset = */ 0x00000000,  // will be filled at compile time
+};
+
+}  // extern "C"

firmware/application/external/morse_practice/morsedecoder.hpp

@@ -0,0 +1,348 @@
+#ifndef __MORSEDECODER_HPP__
+#define __MORSEDECODER_HPP__
+
+/*
+ * Copyright (C) 2025 Pezsma
+ *
+ * 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 <cstdint>
+#include <string>
+
+#define MORSEDEC_ERROR "<ERR>"
+
+namespace ui::external_app::morse_practice {
+
+class MorseRingBuffer {
+   public:
+    MorseRingBuffer()
+        : head_(0), tail_(0), count_(0) {}
+
+    void push_back(const uint32_t& value) {
+        data_[head_] = value;
+        head_ = (head_ + 1) % 40;
+        if (count_ < 40) {
+            count_++;
+        } else {
+            // overwrite oldest element
+            tail_ = (tail_ + 1) % 40;
+        }
+    }
+
+    void pop_front() {
+        if (count_ > 0) {
+            tail_ = (tail_ + 1) % 40;
+            count_--;
+        }
+    }
+
+    size_t size() const { return count_; }
+    bool empty() const { return count_ == 0; }
+    const uint32_t& front() const { return data_[tail_]; }
+    // Access by index (0 = oldest)
+    uint32_t operator[](size_t idx) const {
+        return data_[(tail_ + idx) % 40];
+    }
+    // Convert to vector-like access for sorting etc.
+    void copy_to_array(uint32_t* out) const {
+        for (size_t i = 0; i < count_; ++i)
+            out[i] = (*this)[i];
+    }
+
+   private:
+    uint32_t data_[40];
+    size_t head_;
+    size_t tail_;
+    size_t count_;
+};
+
+class MorseDecoder {
+   public:
+    struct DecodeResult {
+        std::string text = "";
+        double confidence = 0.0;
+
+        bool isValid() const {
+            return !text.empty();
+        }
+    };
+
+    struct MorseEntry {
+        std::string code;
+        std::string letter;
+    };
+
+    MorseDecoder() {}
+    DecodeResult handleInput(int32_t duration_ms) {
+        DecodeResult result = {"", 0.0};
+        if (duration_ms > 0) {
+            pulse_history_.push_back(duration_ms);
+            double dah_prob = getDahProbability(duration_ms);
+            current_sequence_ += (dah_prob > 0.5) ? '-' : '.';
+            last_confidence_ = (dah_prob > 0.5) ? dah_prob : (1.0 - dah_prob);
+            last_sequence_ = current_sequence_;
+        } else {
+            uint32_t gap_duration = -duration_ms;
+            pulse_gaps_.push_back(gap_duration);
+
+            if (gap_duration >= getInterCharThreshold() && !current_sequence_.empty()) {
+                result.text = lookupMorse(current_sequence_);
+                result.confidence = (result.text != MORSEDEC_ERROR) ? last_confidence_ : 0.0;
+                if (gap_duration >= getInterWordThreshold()) {
+                    result.text += " ";
+                }
+                current_sequence_ = "";
+            }
+        }
+
+        updateLearning();
+
+        return result;
+    }
+
+    inline double getInterElementThreshold() { return time_unit_ms_ * 2.0; }
+    inline double getInterCharThreshold() { return time_unit_ms_ * 4.0; }
+    inline double getInterWordThreshold() { return time_unit_ms_ * 7.0; }
+
+    inline double getCurrentTimeUnit() { return time_unit_ms_; }
+    inline std::string getLastSequence() { return last_sequence_; }
+
+   private:
+    std::string current_sequence_ = "";
+    std::string last_sequence_ = "";
+    double time_unit_ms_ = 160.0;
+    double last_confidence_ = 0.0;
+    MorseRingBuffer pulse_history_{};
+    MorseRingBuffer pulse_gaps_{};
+
+    std::string lookupMorse(const std::string& seq) {
+        for (size_t i = 0; i < morse_table_size_; i++) {
+            if (seq == morse_table_[i].code)
+                return morse_table_[i].letter;
+        }
+        return MORSEDEC_ERROR;  // not found
+    }
+
+    double getDahProbability(uint32_t duration_ms) {
+        double start_interp = 1.5 * time_unit_ms_;
+        double end_interp = 2.5 * time_unit_ms_;
+
+        if (duration_ms <= start_interp) return 0.0;
+        if (duration_ms >= end_interp) return 1.0;
+        return ((double)(duration_ms)-start_interp) / (end_interp - start_interp);
+    }
+
+    size_t findDecisionBoundary(uint32_t* sorted_data, size_t sorted_data_size) {
+        if (sorted_data_size < 4) return 0;
+
+        size_t best_split_index = 0;
+        uint32_t max_diff = 0;
+
+        for (size_t i = 1; i < sorted_data_size; ++i) {
+            uint32_t diff = sorted_data[i] - sorted_data[i - 1];
+            if (diff > sorted_data[i - 1] * 0.5 && diff > max_diff) {
+                max_diff = diff;
+                best_split_index = i;
+            }
+        }
+        return best_split_index;
+    }
+
+    bool calculatePulseUnit(double& unit, double& confidence) {
+        if (pulse_history_.size() < 10) return false;
+        uint32_t sorted_pulses[pulse_history_.size()];
+        pulse_history_.copy_to_array(sorted_pulses);
+        sort_uint32(sorted_pulses, pulse_history_.size());
+
+        size_t split_index = findDecisionBoundary(sorted_pulses, pulse_history_.size());
+        if (split_index == 0 || split_index < 3 || (pulse_history_.size() - split_index) < 2) {
+            return false;
+        }
+        double dit_sum = sum_uint32_range(sorted_pulses, 0, split_index);
+        double dah_sum = sum_uint32_range(sorted_pulses, split_index, pulse_history_.size());
+
+        double avg_dit = dit_sum / split_index;
+        double avg_dah = dah_sum / (pulse_history_.size() - split_index);
+        if (avg_dah <= avg_dit) return false;
+
+        double ratio = avg_dah / avg_dit;
+        if (ratio > 1.5 && ratio < 5.0) {
+            unit = avg_dit;
+            double tmpabs = ratio - 3.0;
+            if (tmpabs < 0) tmpabs *= -1;
+            tmpabs /= 3.0;
+            tmpabs = 1.0 - tmpabs;
+            if (tmpabs < 0) tmpabs = 0;
+            confidence = tmpabs;  // 0..1
+            return true;
+        }
+
+        return false;
+    }
+
+    bool calculateGapUnit(double& unit, double& confidence) {
+        if (pulse_gaps_.size() < 10) return false;
+        double threshold = getInterElementThreshold();
+        double valid_gaps[pulse_gaps_.size()];
+        size_t valid_count = 0;
+        for (size_t i = 0; i < pulse_gaps_.size(); i++) {
+            double gap = pulse_gaps_[i];
+            if (gap <= threshold) {
+                valid_gaps[valid_count++] = gap;
+            }
+        }
+        if (valid_count < 2) {
+            return false;
+        }
+        double sum = sum_double_range(valid_gaps, 0, valid_count);
+        size_t count_to_average = valid_count;
+
+        if (count_to_average > 0) {
+            unit = sum / count_to_average;
+            confidence = 0.8;
+            return true;
+        }
+
+        return false;
+    }
+
+    double sum_uint32_range(const uint32_t* data, size_t start, size_t end) {
+        double sum = 0.0;
+        for (size_t i = start; i < end; i++) {
+            sum += data[i];
+        }
+        return sum;
+    }
+    double sum_double_range(const double* data, size_t start, size_t end) {
+        double sum = 0.0;
+        for (size_t i = start; i < end; i++) {
+            sum += data[i];
+        }
+        return sum;
+    }
+
+    void sort_uint32(uint32_t* data, size_t size) {
+        if (size < 2)
+            return;
+
+        for (size_t i = 1; i < size; i++) {
+            uint32_t key = data[i];
+            size_t j = i;
+
+            while (j > 0 && data[j - 1] > key) {
+                data[j] = data[j - 1];
+                j--;
+            }
+
+            data[j] = key;
+        }
+    }
+
+    double clamp_double(double value, double min_val, double max_val) {
+        if (value < min_val)
+            return min_val;
+        else if (value > max_val)
+            return max_val;
+        else
+            return value;
+    }
+
+    void updateLearning() {
+        double pulse_unit = -1.0, pulse_confidence = 0.0;
+        double gap_unit = -1.0, gap_confidence = 0.0;
+
+        bool pulse_success = calculatePulseUnit(pulse_unit, pulse_confidence);
+        bool gap_success = calculateGapUnit(gap_unit, gap_confidence);
+
+        double new_time_unit = -1.0;
+        if (pulse_success && pulse_confidence > 0.5) {
+            new_time_unit = pulse_unit;
+        } else if (pulse_success && gap_success) {
+            gap_confidence = 0.2;
+            double total_confidence = pulse_confidence + gap_confidence;
+            new_time_unit = (pulse_unit * pulse_confidence + gap_unit * gap_confidence) / total_confidence;
+        } else if (gap_success) {
+            new_time_unit = gap_unit;
+        } else {
+            return;
+        }
+
+        double max_change = time_unit_ms_ * 0.25;
+        new_time_unit = clamp_double(new_time_unit, time_unit_ms_ - max_change, time_unit_ms_ + max_change);
+        double DEFAULT_TIME_UNIT = 160.0;
+        double BASE_LEARNING_RATE = 0.05;
+        double MAX_LEARNING_RATE = 0.25;
+        double tudeltaabs = new_time_unit - DEFAULT_TIME_UNIT;
+        if (tudeltaabs < 0) tudeltaabs *= -1;
+        double deviation_from_default = tudeltaabs / DEFAULT_TIME_UNIT;
+        double tpp = deviation_from_default * 2.0;
+        if (tpp > 1) tpp = 1;
+        double learning_factor = BASE_LEARNING_RATE + (MAX_LEARNING_RATE - BASE_LEARNING_RATE) * tpp;
+
+        time_unit_ms_ = (time_unit_ms_ * (1.0 - learning_factor)) + (new_time_unit * learning_factor);
+    }
+
+    size_t morse_table_size_ = 41;
+    MorseEntry morse_table_[41] = {
+        {".-", "A"},
+        {"-...", "B"},
+        {"-.-.", "C"},
+        {"-..", "D"},
+        {".", "E"},
+        {"..-.", "F"},
+        {"--.", "G"},
+        {"....", "H"},
+        {"..", "I"},
+        {".---", "J"},
+        {"-.-", "K"},
+        {".-..", "L"},
+        {"--", "M"},
+        {"-.", "N"},
+        {"---", "O"},
+        {".--.", "P"},
+        {"--.-", "Q"},
+        {".-.", "R"},
+        {"...", "S"},
+        {"-", "T"},
+        {"..-", "U"},
+        {"...-", "V"},
+        {".--", "W"},
+        {"-..-", "X"},
+        {"-.--", "Y"},
+        {"--..", "Z"},
+        {".----", "1"},
+        {"..---", "2"},
+        {"...--", "3"},
+        {"....-", "4"},
+        {".....", "5"},
+        {"-....", "6"},
+        {"--...", "7"},
+        {"---..", "8"},
+        {"----.", "9"},
+        {"-----", "0"},
+        {".-.-.-", "."},
+        {"..--..", "?"},
+        {"-.-.--", "!"},
+        {"--..--", ","},
+        {"-...-", "="}};
+};
+
+}  // namespace ui::external_app::morse_practice
+
+#endif  // __MORSEDECODER_HPP__

firmware/application/external/morse_practice/ui_morse_practice.cpp

@@ -0,0 +1,144 @@
+#include "ui_morse_practice.hpp"
+
+using namespace portapack;
+
+namespace ui::external_app::morse_practice {
+
+MorsePracticeView::MorsePracticeView(ui::NavigationView& nav)
+    : nav_(nav) {
+    baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+    add_children({&btn_tt,
+                  &txt_last,
+                  &btn_clear,
+                  &console_text,
+                  &field_volume});
+    audio::set_rate(audio::Rate::Hz_24000);
+
+    btn_tt.on_select = [this](Button&) {
+        if (button_touch) {
+            button_touch = false;
+            return;
+        }
+        button_was_selected = true;
+        onPress();
+    };
+    btn_tt.on_touch_press = [this](Button&) {
+        button_touch = true;
+        button_was_selected = false;
+        onPress();
+    };
+    btn_tt.on_touch_release = [this](Button&) {
+        button_touch = true;
+        button_was_selected = false;
+        onRelease();
+    };
+    btn_clear.on_select = [this](Button&) {
+        console_text.clear(true);
+        txt_last.set("");
+    };
+    audio::output::start();
+    auto vol = field_volume.value();
+    field_volume.set_value(0);
+    field_volume.set_value(vol);
+}
+
+MorsePracticeView::~MorsePracticeView() {
+    receiver_model.disable();
+    baseband::shutdown();
+    audio::output::stop();
+}
+
+void MorsePracticeView::on_show() {
+    console_text.write("Morse Practice ready\n");
+    start_time = 0;
+    end_time = 0;
+}
+
+void MorsePracticeView::focus() {
+    btn_tt.focus();
+}
+
+void MorsePracticeView::onPress() {
+    start_time = chTimeNow();
+    if (end_time != 0) {
+        int64_t gap_delta = (chTimeNow() - end_time);
+        auto result = morse_decoder_.handleInput(-gap_delta);
+        if (result.isValid()) {
+            writeCharToConsole(result.text, result.confidence);
+        }
+    }
+    end_time = 0;
+    decode_timeout_calc = false;
+    baseband::request_audio_beep(1000, 24000, 2000);
+}
+
+void MorsePracticeView::onRelease() {
+    end_time = chTimeNow();
+    if (start_time != 0) {
+        int32_t press_delta = (end_time - start_time);
+        auto result = morse_decoder_.handleInput(press_delta);
+        if (result.isValid()) {
+            writeCharToConsole(result.text, result.confidence);
+        }
+    }
+    start_time = 0;
+    decode_timeout_calc = true;
+    baseband::request_beep_stop();
+}
+
+void MorsePracticeView::writeCharToConsole(const std::string& ch, double confidence) {
+    if (ch.empty()) {
+        return;
+    }
+
+    txt_last.set(morse_decoder_.getLastSequence().c_str());
+
+    last_color_id = color_id;
+    std::string color = "";
+
+    if (ch == " ") {
+        color_id = 0;
+    } else if (ch == MORSEDEC_ERROR) {
+        color_id = 0;
+    } else {
+        if (confidence < 0.8)
+            color_id = 1;
+        else if (confidence < 0.9)
+            color_id = 2;
+        else
+            color_id = 3;
+    }
+    color = arr_color[color_id];
+    last_color_id = color_id;
+    console_text.write(color + ch);
+}
+
+inline bool MorsePracticeView::tx_button_held() {
+    const auto switches_state = get_switches_state();
+    return switches_state[(size_t)ui::KeyEvent::Select];
+}
+
+void MorsePracticeView::on_framesync() {
+    if (button_was_selected && !button_touch && !tx_button_held()) {
+        button_was_selected = false;
+        onRelease();
+    }
+
+    if (end_time != 0 && decode_timeout_calc) {
+        int64_t gap_delta = (chTimeNow() - end_time);
+
+        if (gap_delta >= morse_decoder_.getInterCharThreshold()) {
+            auto result = morse_decoder_.handleInput(-(int32_t)gap_delta);
+            if (result.isValid()) {
+                writeCharToConsole(result.text, result.confidence);
+            }
+        }
+        if (gap_delta >= morse_decoder_.getInterWordThreshold()) {
+            writeCharToConsole(" ", 1.0);
+            end_time = 0;
+            decode_timeout_calc = false;
+        }
+    }
+}
+
+}  // namespace ui::external_app::morse_practice

firmware/application/external/morse_practice/ui_morse_practice.hpp

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2025 Pezsma
+ *
+ * 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 __MORSE_PRACTICE_H__
+#define __MORSE_PRACTICE_H__
+
+#include "ui.hpp"
+#include "ui_widget.hpp"
+#include "ui_navigation.hpp"
+#include "ui_language.hpp"
+#include "ui_painter.hpp"
+#include "ui_receiver.hpp"
+#include "string_format.hpp"
+#include "morsedecoder.hpp"
+#include "irq_controls.hpp"
+#include "radio_state.hpp"
+#include "portapack.hpp"
+#include "message.hpp"
+#include "volume.hpp"
+#include "audio.hpp"
+#include "baseband_api.hpp"
+#include "external_app.hpp"
+#include <ch.h>
+
+namespace ui::external_app::morse_practice {
+
+class MorsePracticeView : public ui::View {
+   public:
+    MorsePracticeView(ui::NavigationView& nav);
+    ~MorsePracticeView();
+
+    std::string title() { return "Morse P"; }
+    void focus() override;
+    void on_show() override;
+
+   private:
+    void onPress();
+    void onRelease();
+    void on_framesync();
+    void writeCharToConsole(const std::string& ch, double confidence);
+    bool tx_button_held();
+
+    ui::NavigationView& nav_;
+    MorseDecoder morse_decoder_{};
+
+    int64_t start_time = 0;
+    int64_t end_time = 0;
+
+    ui::Button btn_tt{{UI_POS_X_CENTER(12), UI_POS_Y(3), UI_POS_WIDTH(12), UI_POS_HEIGHT(3)}, "KEY"};
+    ui::Text txt_last{{UI_POS_X(0), UI_POS_Y(6), UI_POS_MAXWIDTH, UI_POS_HEIGHT(1)}, ""};
+    ui::Button btn_clear{{UI_POS_X(0), UI_POS_Y_BOTTOM(2), UI_POS_WIDTH(6), UI_POS_HEIGHT(1)}, "CLR"};
+    ui::Console console_text{{UI_POS_X(0), UI_POS_Y(7), UI_POS_MAXWIDTH, UI_POS_HEIGHT_REMAINING(10)}};
+    AudioVolumeField field_volume{{UI_POS_X_RIGHT(2), UI_POS_X(0)}};
+
+    uint8_t last_color_id = 255;
+    uint8_t color_id = 255;
+    std::string arr_color[4] = {STR_COLOR_WHITE, STR_COLOR_RED, STR_COLOR_YELLOW, STR_COLOR_GREEN};
+
+    bool button_touch = false;
+    bool button_was_selected = false;
+    bool decode_timeout_calc = false;
+
+    MessageHandlerRegistration message_handler_framesync{
+        Message::ID::DisplayFrameSync,
+        [this](const Message* const p) {
+            (void)p;
+            this->on_framesync();
+        }};
+};
+
+}  // namespace ui::external_app::morse_practice
+
+#endif  // __MORSE_PRACTICE_H__

firmware/application/external/morse_tx/ui_morse.cpp

@@ -45,12 +45,9 @@ static msg_t ookthread_fn(void* arg) {
     uint8_t* message_symbols = shared_memory.bb_data.tones_data.message;
     uint8_t symbol;
     MorseView* arg_c = (MorseView*)arg;
-
     chRegSetThreadName("ookthread");
-
     for (uint32_t i = 0; i < arg_c->symbol_count; i++) {
         if (chThdShouldTerminate()) break;
-
         symbol = message_symbols[i];
 
         v = (symbol < 2) ? 1 : 0;  // TX on for dot or dash, off for pause
@@ -61,9 +58,7 @@ static msg_t ookthread_fn(void* arg) {
         } else {
             gpio_og_tx.write(v);  // in hackrf <=r6, "1" means tx , "0" no tx.
         }
-
         arg_c->on_tx_progress(i, false);
-
         chThdSleepMilliseconds(delay * arg_c->time_unit_ms);
     }
 
@@ -82,19 +77,14 @@ static msg_t ookthread_fn(void* arg) {
 static msg_t loopthread_fn(void* arg) {
     MorseView* arg_c = (MorseView*)arg;
     uint32_t wait = arg_c->loop;
-
     chRegSetThreadName("loopthread");
-
     for (uint32_t i = 0; i < wait; i++) {
         if (chThdShouldTerminate()) break;
-
         arg_c->on_loop_progress(i, false);
         chThdSleepMilliseconds(1000);
     }
-
-    arg_c->on_loop_progress(0, true);
+    if (!chThdShouldTerminate()) arg_c->on_loop_progress(0, true);
     chThdExit(0);
-
     return 0;
 }
 
@@ -132,6 +122,15 @@ void MorseView::focus() {
 }
 
 MorseView::~MorseView() {
+    if (ookthread) {
+        chThdTerminate(ookthread);
+        ookthread = nullptr;
+    }
+    if (loopthread) {
+        chThdTerminate(loopthread);
+        chThdWait(loopthread);
+        loopthread = nullptr;
+    }
     transmitter_model.disable();
     baseband::shutdown();
 }
@@ -181,6 +180,9 @@ void MorseView::update_tx_duration() {
 
 void MorseView::on_tx_progress(const uint32_t progress, const bool done) {
     if (done) {
+        if (ookthread) {
+            ookthread = nullptr;
+        }
         transmitter_model.disable();
         progressbar.set_value(0);
 
@@ -190,10 +192,10 @@ void MorseView::on_tx_progress(const uint32_t progress, const bool done) {
             progressbar.set_value(0);
 
             if (loopthread) {
-                chThdRelease(loopthread);
+                chThdTerminate(loopthread);
+                chThdWait(loopthread);
                 loopthread = nullptr;
             }
-
             loopthread = chThdCreateFromHeap(NULL, 1024, NORMALPRIO, loopthread_fn, this);
         } else {
             tx_view.set_transmitting(false);
@@ -219,7 +221,6 @@ void MorseView::set_foxhunt(size_t i) {
 MorseView::MorseView(
     NavigationView& nav)
     : nav_(nav) {
-    // baseband::run_image(portapack::spi_flash::image_tag_tones);
     baseband::run_prepared_image(portapack::memory::map::m4_code.base());
 
     add_children({&labels,

firmware/application/external/spaceinv/ui_spaceinv.cpp

@@ -10,22 +10,27 @@
 
 namespace ui::external_app::spaceinv {
 
-// Game constants
-#define PLAYER_WIDTH 26
-#define PLAYER_HEIGHT 16
-#define PLAYER_Y 280
-#define BULLET_WIDTH 3
-#define BULLET_HEIGHT 10
-#define BULLET_SPEED 8
-#define MAX_BULLETS 3
-#define INVADER_WIDTH 20
-#define INVADER_HEIGHT 16
-#define INVADER_ROWS 5  // Classic 5 rows
-#define INVADER_COLS 6  // Reduced for more movement space on narrow PP screen
-#define INVADER_GAP_X 10
-#define INVADER_GAP_Y 8  // Gap between invaders
-#define MAX_ENEMY_BULLETS 3
-#define ENEMY_BULLET_SPEED 3
+// Dynamic game constants
+static int SCREEN_WIDTH = 240;
+static int SCREEN_HEIGHT = 320;
+static int PLAYER_WIDTH = 26;
+static int PLAYER_HEIGHT = 16;
+static int PLAYER_Y = 280;
+static int BULLET_WIDTH = 3;
+static int BULLET_HEIGHT = 10;
+static int BULLET_SPEED = 8;
+static int MAX_BULLETS = 3;
+static int INVADER_WIDTH = 20;
+static int INVADER_HEIGHT = 16;
+static int INVADER_ROWS = 5;
+static int INVADER_COLS = 6;
+static int INVADER_GAP_X = 10;
+static int INVADER_GAP_Y = 8;
+static int MAX_ENEMY_BULLETS = 3;
+static int ENEMY_BULLET_SPEED = 3;
+static int INFO_BAR_HEIGHT = 50;
+static int INVADER_MOVE_AMOUNT = 8;
+static int INVADER_DROP_AMOUNT = 15;
 
 // Game state
 static int game_state = 0;  // 0=menu, 1=playing, 2=game over, 3=wave_complete
@@ -38,18 +43,18 @@ static uint32_t speed_bonus = 0;
 static uint32_t wave_complete_timer = 0;
 
 // Cannon Bullets
-static int bullet_x[MAX_BULLETS] = {0, 0, 0};
-static int bullet_y[MAX_BULLETS] = {0, 0, 0};
-static bool bullet_active[MAX_BULLETS] = {false, false, false};
+static int bullet_x[3] = {0, 0, 0};
+static int bullet_y[3] = {0, 0, 0};
+static bool bullet_active[3] = {false, false, false};
 
 // Enemy bullets
-static int enemy_bullet_x[MAX_ENEMY_BULLETS] = {0, 0, 0};
-static int enemy_bullet_y[MAX_ENEMY_BULLETS] = {0, 0, 0};
-static bool enemy_bullet_active[MAX_ENEMY_BULLETS] = {false, false, false};
+static int enemy_bullet_x[3] = {0, 0, 0};
+static int enemy_bullet_y[3] = {0, 0, 0};
+static bool enemy_bullet_active[3] = {false, false, false};
 static uint32_t enemy_fire_counter = 0;
 
 // Invaders
-static bool invaders[INVADER_ROWS][INVADER_COLS];
+static bool invaders[5][11];  // Max possible columns
 static int invaders_x = 40;
 static int invaders_y = 60;
 static int invader_direction = 1;
@@ -94,15 +99,47 @@ void Ticker::detach() {
     game_update_callback = nullptr;
 }
 
+static void init_dimensions() {
+    SCREEN_WIDTH = ui::screen_width;
+    SCREEN_HEIGHT = ui::screen_height;
+
+    // Scale player based on screen size
+    PLAYER_WIDTH = SCREEN_WIDTH / 9;
+    PLAYER_HEIGHT = SCREEN_HEIGHT / 20;
+    PLAYER_Y = SCREEN_HEIGHT - 40;
+
+    // Keep invader size fixed for proper pixel art
+    INVADER_WIDTH = 20;
+    INVADER_HEIGHT = 16;
+
+    // Calculate columns based on available width
+    int available_width = SCREEN_WIDTH - 40;  // 20px margins on each side
+    INVADER_COLS = available_width / (INVADER_WIDTH + INVADER_GAP_X);
+    if (INVADER_COLS > 11) INVADER_COLS = 11;
+    if (INVADER_COLS < 6) INVADER_COLS = 6;
+
+    // Center the invader formation
+    int formation_width = INVADER_COLS * INVADER_WIDTH + (INVADER_COLS - 1) * INVADER_GAP_X;
+    invaders_x = (SCREEN_WIDTH - formation_width) / 2;
+    invaders_y = INFO_BAR_HEIGHT + 10;
+
+    // Scale movement
+    INVADER_MOVE_AMOUNT = SCREEN_WIDTH / 30;
+    INVADER_DROP_AMOUNT = SCREEN_HEIGHT / 21;
+}
+
 static void init_invaders() {
-    // Initialize invader array
+    // Initialize invader array based on dynamic columns
     for (int row = 0; row < INVADER_ROWS; row++) {
         for (int col = 0; col < INVADER_COLS; col++) {
             invaders[row][col] = true;
         }
     }
-    invaders_x = 40;
-    invaders_y = 60;
+
+    // Reset position to center
+    int formation_width = INVADER_COLS * INVADER_WIDTH + (INVADER_COLS - 1) * INVADER_GAP_X;
+    invaders_x = (SCREEN_WIDTH - formation_width) / 2;
+    invaders_y = INFO_BAR_HEIGHT + 10;
     invader_direction = 1;
     invader_move_counter = 0;
 
@@ -125,138 +162,114 @@ static void save_high_score() {
 }
 
 static void init_menu() {
-    painter.fill_rectangle({0, 0, 240, 320}, Color::black());
+    painter.fill_rectangle({0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}, Color::black());
 
     auto style_green = *ui::Theme::getInstance()->fg_green;
     auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
     auto style_cyan = *ui::Theme::getInstance()->fg_cyan;
+    auto style_red = *ui::Theme::getInstance()->fg_red;
 
-    int16_t screen_width = 240;
-    int16_t title_x = (screen_width - 15 * 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 = 12 * 8;
-    prompt_x = (screen_width - prompt_width) / 2;
+    // Title section
+    painter.draw_string({UI_POS_X_CENTER(15), 30}, style_green, "SPACE INVADERS");
+    painter.draw_string({UI_POS_X_CENTER(24), 55}, style_yellow, "========================");
 
-    painter.fill_rectangle({0, 30, screen_width, 30}, Color::black());
-    painter.draw_string({title_x, 42}, style_green, "SPACE INVADERS");
+    // Instructions box
+    int box_width = 22 * 8;
+    int box_x = UI_POS_X_CENTER(22);
+    painter.fill_rectangle({box_x - 5, 85, box_width + 10, 80}, Color::black());
+    painter.draw_rectangle({box_x - 5, 85, box_width + 10, 80}, Color::white());
 
-    painter.draw_string({divider_x, 70}, style_yellow, "========================");
+    painter.draw_string({box_x, 95}, style_cyan, " ROTARY: MOVE SHIP");
+    painter.draw_string({box_x, 115}, style_cyan, " SELECT: FIRE");
+    painter.draw_string({box_x, 135}, style_cyan, " DEFEND EARTH!");
 
-    painter.fill_rectangle({instruction_x - 5, 100, instruction_width + 10, 80}, Color::black());
-    painter.draw_rectangle({instruction_x - 5, 100, instruction_width + 10, 80}, Color::white());
+    // Point values
+    painter.draw_string({UI_POS_X_CENTER(16), 175}, style_red, "TOP ROW = 30 PTS");
+    painter.draw_string({UI_POS_X_CENTER(16), 190}, style_yellow, "MID ROW = 20 PTS");
+    painter.draw_string({UI_POS_X_CENTER(16), 205}, style_green, "BOT ROW = 10 PTS");
 
-    painter.draw_string({instruction_x, 110}, style_cyan, " ROTARY: MOVE SHIP");
-    painter.draw_string({instruction_x, 130}, style_cyan, " SELECT: FIRE");
-    painter.draw_string({instruction_x, 150}, style_cyan, " DEFEND EARTH!");
-
-    // Draw point values
-    auto style_purple = *ui::Theme::getInstance()->fg_magenta;
-    painter.draw_string({50, 190}, style_purple, "TOP ROW = 30 PTS");
-    painter.draw_string({50, 205}, style_yellow, "MID ROW = 20 PTS");
-    painter.draw_string({50, 220}, style_green, "BOT ROW = 10 PTS");
-
-    // Draw high score
+    // High score
     if (current_instance) {
         auto style_white = *ui::Theme::getInstance()->fg_light;
         std::string high_score_text = "HIGH SCORE: " + std::to_string(current_instance->highScore);
-        int16_t high_score_x = (screen_width - high_score_text.length() * 8) / 2;
-        painter.draw_string({high_score_x, 240}, style_white, high_score_text);
+        painter.draw_string({UI_POS_X_CENTER(high_score_text.length()), 225}, style_white, high_score_text);
     }
 
+    // Set prompt position (will be used for blinking text)
+    prompt_x = UI_POS_X_CENTER(12);
+
     menu_initialized = true;
 }
 
 static void init_game_over() {
-    painter.fill_rectangle({0, 0, 240, 320}, Color::black());
+    painter.fill_rectangle({0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}, Color::black());
 
     auto style_red = *ui::Theme::getInstance()->fg_red;
     auto style_yellow = *ui::Theme::getInstance()->fg_yellow;
     auto style_cyan = *ui::Theme::getInstance()->fg_cyan;
     auto style_white = *ui::Theme::getInstance()->fg_light;
 
-    int16_t screen_width = 240;
-
     // Game Over title
-    int16_t title_x = (screen_width - 9 * 8) / 2;
-    painter.draw_string({title_x, 42}, style_red, "GAME OVER");
-
-    // Divider
-    int16_t divider_width = 24 * 8;
-    int16_t divider_x = (screen_width - divider_width) / 2;
-    painter.draw_string({divider_x, 70}, style_yellow, "========================");
+    painter.draw_string({UI_POS_X_CENTER(9), 40}, style_red, "GAME OVER");
+    painter.draw_string({UI_POS_X_CENTER(24), 65}, style_yellow, "========================");
 
     // Score box
-    int16_t box_width = 22 * 8;
-    int16_t box_x = (screen_width - box_width) / 2;
-    painter.fill_rectangle({box_x - 5, 100, box_width + 10, 80}, Color::black());
-    painter.draw_rectangle({box_x - 5, 100, box_width + 10, 80}, Color::white());
+    int box_width = 22 * 8;
+    int box_x = UI_POS_X_CENTER(22);
+    painter.fill_rectangle({box_x - 5, 90, box_width + 10, 80}, Color::black());
+    painter.draw_rectangle({box_x - 5, 90, box_width + 10, 80}, Color::white());
 
     // Display scores
     std::string score_text = "SCORE: " + std::to_string(score);
-    int16_t score_x = (screen_width - score_text.length() * 8) / 2;
-    painter.draw_string({score_x, 120}, style_cyan, score_text);
+    painter.draw_string({UI_POS_X_CENTER(score_text.length()), 110}, style_cyan, score_text);
 
     std::string wave_text = "WAVE: " + std::to_string(wave);
-    int16_t wave_x = (screen_width - wave_text.length() * 8) / 2;
-    painter.draw_string({wave_x, 140}, style_cyan, wave_text);
+    painter.draw_string({UI_POS_X_CENTER(wave_text.length()), 130}, style_cyan, wave_text);
 
     // High score section
     if (current_instance) {
         if (score > current_instance->highScore) {
             // New high score!
-            std::string new_high = "NEW HIGH SCORE!";
-            int16_t new_high_x = (screen_width - new_high.length() * 8) / 2;
-            painter.draw_string({new_high_x, 200}, style_yellow, new_high);
+            painter.draw_string({UI_POS_X_CENTER(15), 190}, style_yellow, "NEW HIGH SCORE!");
 
             std::string high_score_text = std::to_string(score);
-            int16_t high_score_x = (screen_width - high_score_text.length() * 8) / 2;
-            painter.draw_string({high_score_x, 220}, style_yellow, high_score_text);
+            painter.draw_string({UI_POS_X_CENTER(high_score_text.length()), 210}, style_yellow, high_score_text);
         } else {
             // Show existing high score
-            std::string high_label = "HIGH SCORE:";
-            int16_t label_x = (screen_width - high_label.length() * 8) / 2;
-            painter.draw_string({label_x, 200}, style_white, high_label);
+            painter.draw_string({UI_POS_X_CENTER(11), 190}, style_white, "HIGH SCORE:");
 
             std::string high_score_text = std::to_string(current_instance->highScore);
-            int16_t high_score_x = (screen_width - high_score_text.length() * 8) / 2;
-            painter.draw_string({high_score_x, 220}, style_white, high_score_text);
+            painter.draw_string({UI_POS_X_CENTER(high_score_text.length()), 210}, style_white, high_score_text);
         }
     }
 
+    // Set prompt position for blinking text
+    prompt_x = UI_POS_X_CENTER(12);
     game_over_initialized = true;
 }
 
 static void draw_player() {
     // Clear the entire player area
-    painter.fill_rectangle({0, PLAYER_Y - 4, 240, PLAYER_HEIGHT + 8}, Color::black());
+    painter.fill_rectangle({0, PLAYER_Y - 4, SCREEN_WIDTH, PLAYER_HEIGHT + 8}, Color::black());
 
     // Draw the classic Space Invaders cannon
     Color green = Color::green();
 
+    // Scale the drawing based on player size
+    int unit_x = PLAYER_WIDTH / 26;
+    int unit_y = PLAYER_HEIGHT / 16;
+
     // Top part - the cannon barrel
-    painter.draw_hline({player_x + 12, PLAYER_Y}, 2, green);
-    painter.draw_hline({player_x + 12, PLAYER_Y + 1}, 2, green);
+    painter.fill_rectangle({player_x + 12 * unit_x, PLAYER_Y, 2 * unit_x, 2 * unit_y}, green);
 
     // Upper body
-    painter.draw_hline({player_x + 11, PLAYER_Y + 2}, 4, green);
-    painter.draw_hline({player_x + 11, PLAYER_Y + 3}, 4, green);
-    painter.draw_hline({player_x + 10, PLAYER_Y + 4}, 6, green);
-    painter.draw_hline({player_x + 10, PLAYER_Y + 5}, 6, green);
+    painter.fill_rectangle({player_x + 11 * unit_x, PLAYER_Y + 2 * unit_y, 4 * unit_x, 2 * unit_y}, green);
+    painter.fill_rectangle({player_x + 10 * unit_x, PLAYER_Y + 4 * unit_y, 6 * unit_x, 2 * unit_y}, green);
 
     // Main body
-    painter.draw_hline({player_x + 2, PLAYER_Y + 6}, 22, green);
-    painter.draw_hline({player_x + 2, PLAYER_Y + 7}, 22, green);
-    painter.draw_hline({player_x + 1, PLAYER_Y + 8}, 24, green);
-    painter.draw_hline({player_x + 1, PLAYER_Y + 9}, 24, green);
-    painter.draw_hline({player_x, PLAYER_Y + 10}, 26, green);
-    painter.draw_hline({player_x, PLAYER_Y + 11}, 26, green);
-    painter.draw_hline({player_x, PLAYER_Y + 12}, 26, green);
-    painter.draw_hline({player_x, PLAYER_Y + 13}, 26, green);
-    painter.draw_hline({player_x, PLAYER_Y + 14}, 26, green);
-    painter.draw_hline({player_x, PLAYER_Y + 15}, 26, green);
+    painter.fill_rectangle({player_x + 2 * unit_x, PLAYER_Y + 6 * unit_y, 22 * unit_x, 10 * unit_y}, green);
+    painter.fill_rectangle({player_x + unit_x, PLAYER_Y + 8 * unit_y, 24 * unit_x, 8 * unit_y}, green);
+    painter.fill_rectangle({player_x, PLAYER_Y + 10 * unit_y, 26 * unit_x, 6 * unit_y}, green);
 }
 
 static void draw_invader(int row, int col) {
@@ -452,14 +465,14 @@ static void fire_enemy_bullet() {
 static void update_enemy_bullets() {
     for (int i = 0; i < MAX_ENEMY_BULLETS; i++) {
         if (enemy_bullet_active[i]) {
-            // Clear old position - but protect the border line
-            if (enemy_bullet_y[i] != 49) {  // Don't clear if we're exactly on the border line
+            // Clear old position
+            if (enemy_bullet_y[i] != INFO_BAR_HEIGHT - 1) {
                 painter.fill_rectangle({enemy_bullet_x[i], enemy_bullet_y[i], BULLET_WIDTH, BULLET_HEIGHT}, Color::black());
             }
 
             enemy_bullet_y[i] += ENEMY_BULLET_SPEED;
 
-            if (enemy_bullet_y[i] > 320) {
+            if (enemy_bullet_y[i] > SCREEN_HEIGHT) {
                 enemy_bullet_active[i] = false;
             } else {
                 // Draw at new position
@@ -498,7 +511,7 @@ static void update_invaders() {
         // Clear old positions
         clear_all_invaders();
 
-        // Check bounds - find the actual leftmost and rightmost invaders
+        // Check bounds
         int leftmost = INVADER_COLS;
         int rightmost = -1;
 
@@ -513,25 +526,25 @@ static void update_invaders() {
 
         bool hit_edge = false;
         if (invader_direction > 0) {
-            // Moving right - check rightmost invader
+            // Moving right - check rightmost invader with margin
             int right_edge = invaders_x + rightmost * (INVADER_WIDTH + INVADER_GAP_X) + INVADER_WIDTH;
-            if (right_edge >= 240) {
+            if (right_edge >= SCREEN_WIDTH - 5) {  // 5px margin
                 hit_edge = true;
             }
         } else {
-            // Moving left - check leftmost invader
+            // Moving left - check leftmost invader with margin
             int left_edge = invaders_x + leftmost * (INVADER_WIDTH + INVADER_GAP_X);
-            if (left_edge <= 0) {
+            if (left_edge <= 5) {  // 5px margin
                 hit_edge = true;
             }
         }
 
         // Move invaders
         if (hit_edge) {
-            invaders_y += 15;  // Move down
+            invaders_y += INVADER_DROP_AMOUNT;
             invader_direction = -invader_direction;
         } else {
-            invaders_x += invader_direction * 8;  // Horizontal movement
+            invaders_x += invader_direction * INVADER_MOVE_AMOUNT;
         }
 
         // Toggle animation frame
@@ -541,7 +554,7 @@ static void update_invaders() {
         draw_all_invaders();
     }
 
-    // Enemy firing logic - only in hard mode or always with lower frequency
+    // Enemy firing logic
     if (!current_instance || !current_instance->easy_mode) {
         if (++enemy_fire_counter >= 120) {  // Fire every 2 seconds at 60fps
             enemy_fire_counter = 0;
@@ -568,7 +581,7 @@ static void update_bullets() {
 
             bullet_y[i] -= BULLET_SPEED;
 
-            if (bullet_y[i] < 50) {
+            if (bullet_y[i] < INFO_BAR_HEIGHT) {
                 bullet_active[i] = false;
             } else {
                 painter.fill_rectangle({bullet_x[i], bullet_y[i], BULLET_WIDTH, BULLET_HEIGHT}, Color::white());
@@ -600,7 +613,7 @@ static void check_collisions() {
                     invaders[row][col] = false;
                     painter.fill_rectangle({inv_x, inv_y, INVADER_WIDTH, INVADER_HEIGHT}, Color::black());
 
-                    // Score based on row: top=30, middle=20, bottom=10
+                    // Score based on row
                     if (row == 0) {
                         score += 30;
                     } else if (row == 1 || row == 2) {
@@ -635,23 +648,20 @@ static void check_wave_complete() {
         speed_bonus = (wave - 1) * 3;            // Each wave is slightly faster
         if (speed_bonus > 15) speed_bonus = 15;  // Cap the speed increase
 
-        // Clear any enemy bullets before transitioning
+        // Clear any enemy bullets
         clear_all_enemy_bullets();
 
-        // Set state to wave complete and start timer
+        // Set state to wave complete
         game_state = 3;
-        wave_complete_timer = 60;  // 1 second at 60fps
+        wave_complete_timer = 60;  // 1 second
 
-        // Clear screen and show wave message - but preserve the border line
-        painter.fill_rectangle({0, 51, 240, 269}, Color::black());  // Start at 51 to preserve line at 49
-
-        // Redraw the border line to ensure it's intact - stupid bullet clearing wants to damage it
-        painter.draw_hline({0, 49}, 240, Color::white());
+        // Clear screen and show wave message
+        painter.fill_rectangle({0, INFO_BAR_HEIGHT + 1, SCREEN_WIDTH, SCREEN_HEIGHT - INFO_BAR_HEIGHT - 1}, Color::black());
+        painter.draw_hline({0, INFO_BAR_HEIGHT - 1}, SCREEN_WIDTH, Color::white());
 
         auto style = *ui::Theme::getInstance()->fg_green;
         std::string wave_text = "WAVE " + std::to_string(wave);
-        int wave_x = (240 - wave_text.length() * 8) / 2;
-        painter.draw_string({wave_x, 150}, style, wave_text);
+        painter.draw_string({UI_POS_X_CENTER(wave_text.length()), SCREEN_HEIGHT / 2}, style, wave_text);
 
         return;
     }
@@ -661,8 +671,8 @@ static void check_wave_complete() {
         for (int col = 0; col < INVADER_COLS; col++) {
             if (invaders[row][col]) {
                 int y = invaders_y + row * (INVADER_HEIGHT + INVADER_GAP_Y);
-                if (y + INVADER_HEIGHT >= PLAYER_Y) {  // Actual collision with player
-                    game_state = 2;                    // Game over
+                if (y + INVADER_HEIGHT >= PLAYER_Y) {
+                    game_state = 2;  // Game over
                     save_high_score();
                     return;
                 }
@@ -683,10 +693,12 @@ void game_timer_check() {
             blink_state = !blink_state;
 
             auto style = *ui::Theme::getInstance()->fg_red;
+            int blink_y = 250;  // Position below the high score
+
             if (blink_state) {
-                painter.draw_string({prompt_x, 260}, style, "PRESS SELECT");
+                painter.draw_string({prompt_x, blink_y}, style, "PRESS SELECT");
             } else {
-                painter.fill_rectangle({prompt_x, 260, 16 * 8, 20}, Color::black());
+                painter.fill_rectangle({prompt_x, blink_y, 12 * 8, 20}, Color::black());
             }
         }
     } else if (game_state == 1) {
@@ -704,16 +716,14 @@ void game_timer_check() {
             auto style = *ui::Theme::getInstance()->fg_green;
             painter.fill_rectangle({5, 10, 100, 20}, Color::black());
             painter.draw_string({5, 10}, style, "Score: " + std::to_string(score));
-
-            // Redraw border line after score update (in case it was damaged) - stupid bullet clearing wants to damage it
-            painter.draw_hline({0, 49}, 240, Color::white());
+            painter.draw_hline({0, INFO_BAR_HEIGHT - 1}, SCREEN_WIDTH, Color::white());
         }
 
-        // Periodically redraw the border line to fix any damage because it's a pain in the ass
+        // Periodically redraw the border line
         static uint32_t border_redraw_counter = 0;
-        if (++border_redraw_counter >= 60) {  // Once per second - might make less if causing flickering
+        if (++border_redraw_counter >= 60) {
             border_redraw_counter = 0;
-            painter.draw_hline({0, 49}, 240, Color::white());
+            painter.draw_hline({0, INFO_BAR_HEIGHT - 1}, SCREEN_WIDTH, Color::white());
         }
     } else if (game_state == 2) {
         // Game over state
@@ -726,30 +736,29 @@ void game_timer_check() {
             blink_state = !blink_state;
 
             auto style = *ui::Theme::getInstance()->fg_red;
+            int blink_y = 250;  // Position below high score section
+
             if (blink_state) {
-                painter.draw_string({prompt_x, 260}, style, "PRESS SELECT");
+                painter.draw_string({prompt_x, blink_y}, style, "PRESS SELECT");
             } else {
-                painter.fill_rectangle({prompt_x, 260, 16 * 8, 20}, Color::black());
+                painter.fill_rectangle({prompt_x, blink_y, 12 * 8, 20}, Color::black());
             }
         }
     } else if (game_state == 3) {
         // Wave complete state - wait for timer
         if (--wave_complete_timer <= 0) {
-            // Timer expired, start next wave
             game_state = 1;
 
-            // Clear and redraw game area - preserve border line
-            painter.fill_rectangle({0, 51, 240, 269}, Color::black());  // Start at 51 to preserve line
+            // Clear and redraw game area
+            painter.fill_rectangle({0, INFO_BAR_HEIGHT + 1, SCREEN_WIDTH, SCREEN_HEIGHT - INFO_BAR_HEIGHT - 1}, Color::black());
 
             // Restore UI
             auto style = *ui::Theme::getInstance()->fg_green;
             painter.draw_string({5, 10}, style, "Score: " + std::to_string(score));
             painter.draw_string({5, 30}, style, "Lives: " + std::to_string(lives));
+            painter.draw_hline({0, INFO_BAR_HEIGHT - 1}, SCREEN_WIDTH, Color::white());
 
-            // Redraw the border line in case it was damaged again
-            painter.draw_hline({0, 49}, 240, Color::white());
-
-            // Initialize new wave of invaders
+            // Initialize new wave
             init_invaders();
             draw_all_invaders();
             draw_player();
@@ -760,7 +769,16 @@ void game_timer_check() {
 SpaceInvadersView::SpaceInvadersView(NavigationView& nav)
     : nav_{nav} {
     add_children({&dummy, &button_difficulty});
+
+    // Initialize dimensions first
     current_instance = this;
+    init_dimensions();
+
+    // Now reposition button with proper centering
+    int button_y = SCREEN_HEIGHT - 45;        // 45px from bottom
+    int button_x = (SCREEN_WIDTH - 100) / 2;  // Center horizontally
+    button_difficulty.set_parent_rect({button_x, button_y, 100, 20});
+
     game_timer.attach(&game_timer_check, 1.0 / 60.0);
 
     // Update button text based on loaded setting
@@ -769,12 +787,10 @@ SpaceInvadersView::SpaceInvadersView(NavigationView& nav)
     button_difficulty.on_select = [this](Button&) {
         easy_mode = !easy_mode;
         button_difficulty.set_text(easy_mode ? "Mode: EASY" : "Mode: HARD");
-        // Settings will be saved when the view is destroyed
     };
 }
 
 SpaceInvadersView::~SpaceInvadersView() {
-    // Settings are automatically saved when destroyed
     current_instance = nullptr;
 }
 
@@ -791,7 +807,7 @@ void SpaceInvadersView::paint(Painter& painter) {
         game_over_initialized = false;
         blink_state = true;
         blink_counter = 0;
-        player_x = 107;
+        player_x = SCREEN_WIDTH / 2 - PLAYER_WIDTH / 2;
         score = 0;
         lives = 3;
         wave = 1;
@@ -821,12 +837,13 @@ void SpaceInvadersView::frame_sync() {
 
 bool SpaceInvadersView::on_encoder(const EncoderEvent delta) {
     if (game_state == 1) {
+        int move_speed = SCREEN_WIDTH / 48;  // Scale movement speed
         if (delta > 0) {
-            player_x += 5;
-            if (player_x > 214) player_x = 214;
+            player_x += move_speed;
+            if (player_x > SCREEN_WIDTH - PLAYER_WIDTH) player_x = SCREEN_WIDTH - PLAYER_WIDTH;
             draw_player();
         } else if (delta < 0) {
-            player_x -= 5;
+            player_x -= move_speed;
             if (player_x < 0) player_x = 0;
             draw_player();
         }
@@ -850,8 +867,8 @@ bool SpaceInvadersView::on_key(const KeyEvent key) {
             enemy_fire_counter = 0;
             init_invaders();
 
-            painter.fill_rectangle({0, 0, 240, 320}, Color::black());
-            painter.draw_hline({0, 49}, 240, Color::white());
+            painter.fill_rectangle({0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}, Color::black());
+            painter.draw_hline({0, INFO_BAR_HEIGHT - 1}, SCREEN_WIDTH, Color::white());
 
             auto style = *ui::Theme::getInstance()->fg_green;
             painter.draw_string({5, 10}, style, "Score: 0");
@@ -876,4 +893,4 @@ bool SpaceInvadersView::on_key(const KeyEvent key) {
     return true;
 }
 
-}  // namespace ui::external_app::spaceinv
+}  // namespace ui::external_app::spaceinv

firmware/application/external/spaceinv/ui_spaceinv.hpp

@@ -54,7 +54,7 @@ class SpaceInvadersView : public View {
     NavigationView& nav_;
 
     Button button_difficulty{
-        {70, 285, 100, 20},
+        {70, 275, 100, 20},
         "Mode: HARD"};
 
     app_settings::SettingsManager settings_{
@@ -76,4 +76,4 @@ class SpaceInvadersView : public View {
 
 }  // namespace ui::external_app::spaceinv
 
-#endif /* __UI_SPACEINV_H__ */
+#endif /* __UI_SPACEINV_H__ */

firmware/application/external/tetris/ui_tetris.cpp

@@ -35,11 +35,17 @@ 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 DIMENSION = 16;
+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}};
 
+// Dynamic screen values
+int SCREEN_WIDTH = 240;
+int SCREEN_HEIGHT = 320;
+int BOARD_RIGHT = 162;
+int INFO_LEFT = 165;
+
 const Color pp_colors[] = {
     Color::white(),
     Color::blue(),
@@ -138,19 +144,44 @@ unsigned int GenerateRandomSeed() {
 }
 
 void Init() {
+    // Initialize dynamic screen dimensions
+    SCREEN_WIDTH = ui::screen_width;
+    SCREEN_HEIGHT = ui::screen_height;
+
+    // For original screen size, use original dimensions
+    if (SCREEN_WIDTH == 240 && SCREEN_HEIGHT == 320) {
+        DIMENSION = 16;
+        DIMENSION_NEXT = 12;
+        BOARD_RIGHT = 162;
+        INFO_LEFT = 165;
+    } else {
+        // Calculate dimensions for other screen sizes
+        int available_width = (SCREEN_WIDTH * 3 / 4);
+        int available_height = SCREEN_HEIGHT - 10;
+
+        int max_dimension_width = available_width / 10;
+        int max_dimension_height = available_height / 20;
+        DIMENSION = std::min(max_dimension_width, max_dimension_height);
+
+        if (DIMENSION < 8) DIMENSION = 8;
+
+        DIMENSION_NEXT = DIMENSION * 3 / 4;
+        BOARD_RIGHT = 10 * DIMENSION + 2;
+        INFO_LEFT = BOARD_RIGHT + 3;
+    }
 }
 
 void ShowScore() {
-    fillrect(165, 10, 235, 60, Black);
-    rect(165, 10, 235, 60, White);
-    locate(200, 35);
+    fillrect(INFO_LEFT, 10, SCREEN_WIDTH - 5, 60, Black);
+    rect(INFO_LEFT, 10, SCREEN_WIDTH - 5, 60, White);
+    locate((INFO_LEFT + SCREEN_WIDTH - 5) / 2 - 10, 35);
     printf("%d", score);
 }
 
 void ShowNextFigure() {
-    fillrect(165, 70, 235, 130, Black);
-    rect(165, 70, 235, 130, White);
-    int upperLeftX = 176, upperLeftY = 83;
+    fillrect(INFO_LEFT, 70, SCREEN_WIDTH - 5, 130, Black);
+    rect(INFO_LEFT, 70, SCREEN_WIDTH - 5, 130, White);
+    int upperLeftX = INFO_LEFT + 11, 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]);
@@ -159,20 +190,20 @@ void ShowNextFigure() {
 }
 
 void DrawCursor(int color, unsigned char lev) {
-    fillrect(60, lev * 70 + 50, 72, lev * 70 + 50 + 12, color);
+    fillrect(UI_POS_X_CENTER(10) - 20, lev * 70 + 50, UI_POS_X_CENTER(10) - 8, lev * 70 + 50 + 12, color);
 }
 
 void ShowLevelMenu() {
     cls();
     background(Black);
     foreground(White);
-    locate(80, 50);
+    locate(UI_POS_X_CENTER(8), 50);
     printf("LEVEL 1");
-    locate(80, 120);
+    locate(UI_POS_X_CENTER(8), 120);
     printf("LEVEL 2");
-    locate(80, 190);
+    locate(UI_POS_X_CENTER(8), 190);
     printf("LEVEL 3");
-    locate(80, 260);
+    locate(UI_POS_X_CENTER(8), 260);
     printf("LEVEL 4");
     DrawCursor(White, level);
 }
@@ -209,9 +240,9 @@ void StartGame() {
     cls();
     background(Black);
     foreground(White);
-    fillrect(0, 0, 162, screen_height, Black);
-    rect(162, 0, 164, screen_height, White);
-    fillrect(164, 0, screen_width, screen_height, Black);
+    fillrect(0, 0, BOARD_RIGHT, SCREEN_HEIGHT, Black);
+    rect(BOARD_RIGHT, 0, BOARD_RIGHT + 2, SCREEN_HEIGHT, White);
+    fillrect(BOARD_RIGHT + 2, 0, SCREEN_WIDTH, SCREEN_HEIGHT, Black);
     ShowScore();
     ShowNextFigure();
 }
@@ -483,7 +514,7 @@ void UpdateBoard() {
                 board[i - numberOfLines][j] = 0;
             }
         }
-        fillrect(0, 0, 162, screen_height, Black);
+        fillrect(0, 0, BOARD_RIGHT, SCREEN_HEIGHT, Black);
         for (int i = 0; i < 20; i++) {
             for (int j = 0; j < 10; j++) {
                 if (board[i][j] != 0) {
@@ -509,9 +540,9 @@ bool IsOver() {
 void ShowGameOverScreen() {
     background(Black);
     foreground(White);
-    locate(60, 120);
+    locate(UI_POS_X_CENTER(10), 120);
     printf("GAME OVER");
-    locate(40, 150);
+    locate(UI_POS_X_CENTER(21), 150);
     printf("YOUR SCORE IS %d", score);
     wait(5);
 }
@@ -565,11 +596,11 @@ void OnTasterPressed() {
 void pause_game() {
     game.detach();
     joystick.detach();
-    locate(180, 200);
+    locate((INFO_LEFT + SCREEN_WIDTH) / 2 - 25, 200);
     printf("PAUSED");
     while ((get_switches_state().to_ulong() & 0x10) == 0)
         ;
-    printf("      ");
+    fillrect(INFO_LEFT, 195, SCREEN_WIDTH, 210, Black);
     joystick.attach(&ReadJoystickForFigure, 0.3);
     game.attach(&PlayGame, delays[level]);
 }

firmware/application/external/tetris/ui_tetris.hpp

@@ -86,11 +86,17 @@ 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 DIMENSION;
+extern short DIMENSION_NEXT;
 extern short figuresX[7][4];
 extern short figuresY[7][4];
 
+// Dynamic screen values
+extern int SCREEN_WIDTH;
+extern int SCREEN_HEIGHT;
+extern int BOARD_RIGHT;
+extern int INFO_LEFT;
+
 unsigned int GenerateRandomSeed();
 void Init();
 void ShowScore();
@@ -148,7 +154,7 @@ class TetrisView : public View {
     NavigationView& nav_;
 
     Button dummy{
-        {screen_width, 0, 0, 0},
+        {240, 0, 0, 0},
         ""};
 
     MessageHandlerRegistration message_handler_frame_sync{

firmware/application/ui/ui_freqlist.cpp

@@ -93,6 +93,33 @@ void FreqManUIList::on_blur() {
     set_dirty();
 }
 
+bool FreqManUIList::on_touch(const TouchEvent event) {
+    if (!db_ || db_->empty())
+        return false;
+    if (event.type == TouchEvent::Type::Start) {
+        focus();
+        set_dirty();
+        int16_t rel_y = event.point.y() - screen_rect().top();
+        size_t new_selected = rel_y / char_height;
+        if (new_selected + start_index_ >= db_->entry_count()) {
+            return true;  // clicked, where there is no entry, skip it
+        }
+        // selected_index_ is the current
+        if (selected_index_ == new_selected) {
+            // already selected, trigger on_select
+            if (on_select) {
+                // on_select(new_selected); //causes strange behavior, not so confident to use it
+            }
+            return true;
+        } else {
+            // just change selection
+            selected_index_ = new_selected;
+        }
+        return true;
+    }
+    return true;
+}
+
 bool FreqManUIList::on_keyboard(const KeyboardEvent key) {
     if (!db_ || db_->empty())
         return false;

firmware/application/ui/ui_freqlist.hpp

@@ -50,6 +50,7 @@ class FreqManUIList : public Widget {
     bool on_key(const KeyEvent key) override;
     bool on_encoder(EncoderEvent delta) override;
     bool on_keyboard(const KeyboardEvent event) override;
+    bool on_touch(const TouchEvent event) override;
 
     void set_parent_rect(Rect new_parent_rect) override;
 

firmware/application/ui/ui_menu.cpp

@@ -243,6 +243,18 @@ void MenuView::on_blur() {
         item_view(highlighted_item - offset)->unhighlight();
 }
 
+bool MenuView::on_touch(const TouchEvent event) {
+    size_t i = 0;
+    for (const auto child : children_) {
+        if (i >= menu_item_views.size()) break;
+        if (child->screen_rect().contains(event.point)) {
+            return set_highlighted(i + offset);
+        }
+        i++;
+    }
+    return false;
+}
+
 bool MenuView::on_key(const KeyEvent key) {
     switch (key) {
         case KeyEvent::Up:

firmware/application/ui/ui_menu.hpp

@@ -99,6 +99,7 @@ class MenuView : public View {
     bool on_key(const KeyEvent event) override;
     bool on_encoder(const EncoderEvent event) override;
     bool on_keyboard(const KeyboardEvent event) override;
+    bool on_touch(const TouchEvent event) override;
 
    private:
     void update_items();

firmware/application/ui_external_items_menu_loader.cpp

@@ -132,20 +132,36 @@ namespace ui {
 
                 gridItem.on_select = [&nav, appInfo, i]() {
                     auto dev2 = (i2cdev::I2cDev_PPmod*)i2cdev::I2CDevManager::get_dev_by_model(I2C_DEVMDL::I2CDECMDL_PPMOD);
+                    dev2->lockDevice();
                     if (dev2) {
-                        auto app_image = reinterpret_cast<uint8_t*>(portapack::memory::map::m4_code.end() - appInfo->binary_size);
+                        // auto app_image = reinterpret_cast<uint8_t*>(portapack::memory::map::m4_code.end() - appInfo->binary_size);
+                        auto app_image = reinterpret_cast<uint8_t*>(portapack::memory::map::local_sram_0.base());
+                        uint8_t errorcnt = 0;
                         for (size_t j = 0; j < appInfo->binary_size; j += 128) {
-                            auto segment = dev2->downloadStandaloneApp(i, j);
-                            if (segment.size() != 128) {
-                                continue;
+                            errorcnt = 0;
+                            do {
+                                auto segment = dev2->downloadStandaloneApp(i, j);
+                                if (segment.size() != 128) {
+                                    errorcnt++;
+                                    if (errorcnt > 5) {
+                                        break;
+                                    }
+                                } else {
+                                    std::copy(segment.begin(), segment.end(), app_image + j);
+                                    break;
+                                }
+                            } while (1);  // when ok, break. when errorcnt > 5, break
+                            if (errorcnt > 5) {
+                                nav.display_modal("Error", "Unable to download app.");
+                                dev2->unlockDevice();
+                                return;
                             }
-
-                            std::copy(segment.begin(), segment.end(), app_image + j);
                         }
 
                         if (!run_module_app(nav, app_image, appInfo->binary_size)) {
                             nav.display_modal("Error", "Unable to run downloaded app.");
                         }
+                        dev2->unlockDevice();
                     } else
                         nav.display_modal("Error", "Unable to download app.");
                 };
@@ -346,7 +362,6 @@ namespace ui {
     if (openError)
         return false;
 
-    // TODO: move this to m4 memory space
     auto app_image = reinterpret_cast<uint8_t*>(portapack::memory::map::local_sram_0.base());
 
     // read file in 512 byte chunks

firmware/application/usb_serial_shell_filesystem.cpp

@@ -59,13 +59,23 @@ static bool report_on_error(BaseSequentialStream* chp, File::Result<uint64_t> er
     return false;
 }
 
+std::string full_fn_from_args(int argc, char* argv[]) {
+    std::string full_fn;
+    for (int i = 0; i < argc; i++) {
+        if (i != 0)
+            full_fn += " ";
+        full_fn += argv[i];
+    }
+    return full_fn;
+}
+
 void cmd_sd_list_dir(BaseSequentialStream* chp, int argc, char* argv[]) {
-    if (argc != 1) {
+    if (argc < 1) {
         chprintf(chp, "usage: ls /\r\n");
         return;
     }
 
-    auto path = path_from_string8(argv[0]);
+    auto path = path_from_string8((char*)full_fn_from_args(argc, argv).c_str());
 
     for (const auto& entry : std::filesystem::directory_iterator(path, "*")) {
         if (std::filesystem::is_directory(entry.status())) {
@@ -79,12 +89,12 @@ void cmd_sd_list_dir(BaseSequentialStream* chp, int argc, char* argv[]) {
 }
 
 void cmd_sd_unlink(BaseSequentialStream* chp, int argc, char* argv[]) {
-    if (argc != 1) {
+    if (argc < 1) {
         chprintf(chp, "usage: unlink <path>\r\n");
         return;
     }
 
-    auto path = path_from_string8(argv[0]);
+    auto path = path_from_string8((char*)full_fn_from_args(argc, argv).c_str());
     auto error = delete_file(path);
     if (report_on_error(chp, error)) return;
 
@@ -92,12 +102,12 @@ void cmd_sd_unlink(BaseSequentialStream* chp, int argc, char* argv[]) {
 }
 
 void cmd_sd_mkdir(BaseSequentialStream* chp, int argc, char* argv[]) {
-    if (argc != 1) {
+    if (argc < 1) {
         chprintf(chp, "usage: mkdir <path>\r\n");
         return;
     }
 
-    auto path = path_from_string8(argv[0]);
+    auto path = path_from_string8((char*)full_fn_from_args(argc, argv).c_str());
 
     if (std::filesystem::is_directory(path)) {
         chprintf(chp, "directory already exists.\r\n");
@@ -111,11 +121,11 @@ void cmd_sd_mkdir(BaseSequentialStream* chp, int argc, char* argv[]) {
 }
 
 void cmd_sd_filesize(BaseSequentialStream* chp, int argc, char* argv[]) {
-    if (argc != 1) {
+    if (argc < 1) {
         chprintf(chp, "usage: filesize <path>\r\n");
         return;
     }
-    auto path = path_from_string8(argv[0]);
+    auto path = path_from_string8((char*)full_fn_from_args(argc, argv).c_str());
     FILINFO res;
     auto stat = f_stat(path.tchar(), &res);
     if (report_on_error(chp, stat)) return;
@@ -125,7 +135,7 @@ void cmd_sd_filesize(BaseSequentialStream* chp, int argc, char* argv[]) {
 }
 
 void cmd_sd_open(BaseSequentialStream* chp, int argc, char* argv[]) {
-    if (argc != 1) {
+    if (argc < 1) {
         chprintf(chp, "usage: fopen <path>\r\n");
         return;
     }
@@ -135,7 +145,7 @@ void cmd_sd_open(BaseSequentialStream* chp, int argc, char* argv[]) {
         return;
     }
 
-    auto path = path_from_string8(argv[0]);
+    auto path = path_from_string8((char*)full_fn_from_args(argc, argv).c_str());
     shell_file = new File();
     auto error = shell_file->open(path, false, true);
     if (report_on_error(chp, error)) return;
@@ -375,12 +385,12 @@ void cmd_sd_write_binary(BaseSequentialStream* chp, int argc, char* argv[]) {
 }
 
 void cmd_sd_crc32(BaseSequentialStream* chp, int argc, char* argv[]) {
-    if (argc != 1) {
+    if (argc < 1) {
         chprintf(chp, "usage: crc32 <path>\r\n");
         return;
     }
 
-    auto path = path_from_string8(argv[0]);
+    auto path = path_from_string8((char*)full_fn_from_args(argc, argv).c_str());
     File* crc_file = new File();
     auto error = crc_file->open(path, true, false);
     if (report_on_error(chp, error)) return;

firmware/baseband/fprotos/w-oregon2.hpp

@@ -132,15 +132,14 @@ class FProtoWeatherOregon2 : public FProtoWeatherBase {
                 // waiting for variable (sensor-specific data)
                 if (decode_count_bit == (uint32_t)var_bits + OREGON2_CHECKSUM_BITS) {
                     var_data = decode_data & 0xFFFFFFFF;
-
                     // reverse nibbles in var data
                     var_data = (var_data & 0x55555555) << 1 |
                                (var_data & 0xAAAAAAAA) >> 1;
                     var_data = (var_data & 0x33333333) << 2 |
                                (var_data & 0xCCCCCCCC) >> 2;
-                    decode_data = var_data;
+                    decode_data = var_data >> OREGON2_CHECKSUM_BITS;
+                    decode_data |= (data << 32);  // unique to portapack, i sent the upper part too, so we have all the data in one place
                     // ws_oregon2_decode_var_data(OREGON2_SENSOR_ID(data), var_data >> OREGON2_CHECKSUM_BITS); //a bit stepback, but will work
-
                     parser_step = Oregon2DecoderStepReset;
                     if (callback) callback(this);
                 }
@@ -195,8 +194,10 @@ class FProtoWeatherOregon2 : public FProtoWeatherBase {
             case ID_RTHN129_3:
             case ID_RTHN129_4:
             case ID_RTHN129_5:
+                sensorType = FPW_OREGON2;
                 return 16;
             case ID_THGR122N:
+                sensorType = FPW_OREGON2B;
                 return 24;
             default:
                 return 0;

firmware/baseband/fprotos/w-oregon3.hpp

@@ -96,7 +96,7 @@ class FProtoWeatherOregon3 : public FProtoWeatherBase {
                                (var_data & 0xAAAAAAAAAAAAAAAA) >> 1;
                     var_data = (var_data & 0x3333333333333333) << 2 |
                                (var_data & 0xCCCCCCCCCCCCCCCC) >> 2;
-                    decode_data = var_data;
+                    decode_data = var_data >> OREGON3_CHECKSUM_BITS;
                     // ws_oregon3_decode_var_data(OREGON3_SENSOR_ID(data), var_data >> OREGON3_CHECKSUM_BITS);
                     parser_step = Oregon3DecoderStepReset;
                     if (callback) callback(this);

firmware/baseband/fprotos/weatherprotos.hpp

@@ -71,6 +71,7 @@ class WeatherProtos : public FProtoListGeneral {
         protos[FPW_Bresser3CH] = new FProtoWeatheBresser3CH();
         protos[FPW_Bresser3CH_V1] = nullptr;  // done by FProtoWeatheBresser3CH
         protos[FPW_Vauno_EN8822] = new FProtoWeatherVaunoEN8822();
+        protos[FPW_OREGON2B] = nullptr;  // done by FProtoWeatherOregon2
 
         // set callback for them
         for (uint8_t i = 0; i < FPW_COUNT; ++i) {

firmware/baseband/fprotos/weathertypes.hpp

@@ -42,6 +42,7 @@ enum FPROTO_WEATHER_SENSOR {
     FPW_Bresser3CH = 24,
     FPW_Bresser3CH_V1 = 25,
     FPW_Vauno_EN8822 = 26,
+    FPW_OREGON2B = 27,
     FPW_COUNT  // this must be the last
 };
 

firmware/chibios/os/hal/src/i2c.c

@@ -69,7 +69,7 @@
  * @init
  */
 void i2cInit(void) {
-  i2c_lld_init();
+    i2c_lld_init();
 }
 
 /**
@@ -79,21 +79,20 @@ void i2cInit(void) {
  *
  * @init
  */
-void i2cObjectInit(I2CDriver *i2cp) {
-
-  i2cp->state  = I2C_STOP;
-  i2cp->config = NULL;
+void i2cObjectInit(I2CDriver* i2cp) {
+    i2cp->state = I2C_STOP;
+    i2cp->config = NULL;
 
 #if I2C_USE_MUTUAL_EXCLUSION
 #if CH_USE_MUTEXES
-  chMtxInit(&i2cp->mutex);
+    chMtxInit(&i2cp->mutex);
 #else
-  chSemInit(&i2cp->semaphore, 1);
+    chSemInit(&i2cp->semaphore, 1);
 #endif /* CH_USE_MUTEXES */
 #endif /* I2C_USE_MUTUAL_EXCLUSION */
 
 #if defined(I2C_DRIVER_EXT_INIT_HOOK)
-  I2C_DRIVER_EXT_INIT_HOOK(i2cp);
+    I2C_DRIVER_EXT_INIT_HOOK(i2cp);
 #endif
 }
 
@@ -105,19 +104,18 @@ void i2cObjectInit(I2CDriver *i2cp) {
  *
  * @api
  */
-void i2cStart(I2CDriver *i2cp, const I2CConfig *config) {
+void i2cStart(I2CDriver* i2cp, const I2CConfig* config) {
+    chDbgCheck((i2cp != NULL) && (config != NULL), "i2cStart");
+    chDbgAssert((i2cp->state == I2C_STOP) || (i2cp->state == I2C_READY) ||
+                    (i2cp->state == I2C_LOCKED),
+                "i2cStart(), #1",
+                "invalid state");
 
-  chDbgCheck((i2cp != NULL) && (config != NULL), "i2cStart");
-  chDbgAssert((i2cp->state == I2C_STOP) || (i2cp->state == I2C_READY) ||
-              (i2cp->state == I2C_LOCKED),
-              "i2cStart(), #1",
-              "invalid state");
-
-  chSysLock();
-  i2cp->config = config;
-  i2c_lld_start(i2cp);
-  i2cp->state = I2C_READY;
-  chSysUnlock();
+    chSysLock();
+    i2cp->config = config;
+    i2c_lld_start(i2cp);
+    i2cp->state = I2C_READY;
+    chSysUnlock();
 }
 
 /**
@@ -127,18 +125,17 @@ void i2cStart(I2CDriver *i2cp, const I2CConfig *config) {
  *
  * @api
  */
-void i2cStop(I2CDriver *i2cp) {
+void i2cStop(I2CDriver* i2cp) {
+    chDbgCheck(i2cp != NULL, "i2cStop");
+    chDbgAssert((i2cp->state == I2C_STOP) || (i2cp->state == I2C_READY) ||
+                    (i2cp->state == I2C_LOCKED),
+                "i2cStop(), #1",
+                "invalid state");
 
-  chDbgCheck(i2cp != NULL, "i2cStop");
-  chDbgAssert((i2cp->state == I2C_STOP) || (i2cp->state == I2C_READY) ||
-              (i2cp->state == I2C_LOCKED),
-              "i2cStop(), #1",
-              "invalid state");
-
-  chSysLock();
-  i2c_lld_stop(i2cp);
-  i2cp->state = I2C_STOP;
-  chSysUnlock();
+    chSysLock();
+    i2c_lld_stop(i2cp);
+    i2cp->state = I2C_STOP;
+    chSysUnlock();
 }
 
 /**
@@ -149,11 +146,10 @@ void i2cStop(I2CDriver *i2cp) {
  *
  * @api
  */
-i2cflags_t i2cGetErrors(I2CDriver *i2cp) {
+i2cflags_t i2cGetErrors(I2CDriver* i2cp) {
+    chDbgCheck(i2cp != NULL, "i2cGetErrors");
 
-  chDbgCheck(i2cp != NULL, "i2cGetErrors");
-
-  return i2c_lld_get_errors(i2cp);
+    return i2c_lld_get_errors(i2cp);
 }
 
 /**
@@ -182,35 +178,37 @@ i2cflags_t i2cGetErrors(I2CDriver *i2cp) {
  *
  * @api
  */
-msg_t i2cMasterTransmitTimeout(I2CDriver *i2cp,
+msg_t i2cMasterTransmitTimeout(I2CDriver* i2cp,
                                i2caddr_t addr,
-                               const uint8_t *txbuf,
+                               const uint8_t* txbuf,
                                size_t txbytes,
-                               uint8_t *rxbuf,
+                               uint8_t* rxbuf,
                                size_t rxbytes,
                                systime_t timeout) {
-  msg_t rdymsg;
+    msg_t rdymsg;
 
-  chDbgCheck((i2cp != NULL) && (addr != 0) &&
-             (txbytes > 0) && (txbuf != NULL) &&
-             ((rxbytes == 0) || ((rxbytes > 0) && (rxbuf != NULL))) &&
-             (timeout != TIME_IMMEDIATE),
-             "i2cMasterTransmitTimeout");
+    chDbgCheck((i2cp != NULL) && (addr != 0) &&
+                   (txbytes > 0) && (txbuf != NULL) &&
+                   ((rxbytes == 0) || ((rxbytes > 0) && (rxbuf != NULL))) &&
+                   (timeout != TIME_IMMEDIATE),
+               "i2cMasterTransmitTimeout");
 
-  chDbgAssert(i2cp->state == I2C_READY,
-              "i2cMasterTransmitTimeout(), #1", "not ready");
+    // chDbgAssert(i2cp->state == I2C_READY, "i2cMasterTransmitTimeout(), #1", "not ready");
+    if (i2cp->state != I2C_READY) {
+        return RDY_TIMEOUT;
+    }
 
-  chSysLock();
-  i2cp->errors = I2CD_NO_ERROR;
-  i2cp->state = I2C_ACTIVE_TX;
-  rdymsg = i2c_lld_master_transmit_timeout(i2cp, addr, txbuf, txbytes,
-                                           rxbuf, rxbytes, timeout);
-  if (rdymsg == RDY_TIMEOUT)
-    i2cp->state = I2C_LOCKED;
-  else
-    i2cp->state = I2C_READY;
-  chSysUnlock();
-  return rdymsg;
+    chSysLock();
+    i2cp->errors = I2CD_NO_ERROR;
+    i2cp->state = I2C_ACTIVE_TX;
+    rdymsg = i2c_lld_master_transmit_timeout(i2cp, addr, txbuf, txbytes,
+                                             rxbuf, rxbytes, timeout);
+    if (rdymsg == RDY_TIMEOUT)
+        i2cp->state = I2C_LOCKED;
+    else
+        i2cp->state = I2C_READY;
+    chSysUnlock();
+    return rdymsg;
 }
 
 /**
@@ -233,32 +231,33 @@ msg_t i2cMasterTransmitTimeout(I2CDriver *i2cp,
  *
  * @api
  */
-msg_t i2cMasterReceiveTimeout(I2CDriver *i2cp,
+msg_t i2cMasterReceiveTimeout(I2CDriver* i2cp,
                               i2caddr_t addr,
-                              uint8_t *rxbuf,
+                              uint8_t* rxbuf,
                               size_t rxbytes,
-                              systime_t timeout){
+                              systime_t timeout) {
+    msg_t rdymsg;
 
-  msg_t rdymsg;
+    chDbgCheck((i2cp != NULL) && (addr != 0) &&
+                   (rxbytes > 0) && (rxbuf != NULL) &&
+                   (timeout != TIME_IMMEDIATE),
+               "i2cMasterReceiveTimeout");
 
-  chDbgCheck((i2cp != NULL) && (addr != 0) &&
-             (rxbytes > 0) && (rxbuf != NULL) &&
-             (timeout != TIME_IMMEDIATE),
-             "i2cMasterReceiveTimeout");
+    // chDbgAssert(i2cp->state == I2C_READY, "i2cMasterReceive(), #1", "not ready");
+    if (i2cp->state != I2C_READY) {
+        return RDY_TIMEOUT;
+    }
 
-  chDbgAssert(i2cp->state == I2C_READY,
-              "i2cMasterReceive(), #1", "not ready");
-
-  chSysLock();
-  i2cp->errors = I2CD_NO_ERROR;
-  i2cp->state = I2C_ACTIVE_RX;
-  rdymsg = i2c_lld_master_receive_timeout(i2cp, addr, rxbuf, rxbytes, timeout);
-  if (rdymsg == RDY_TIMEOUT)
-    i2cp->state = I2C_LOCKED;
-  else
-    i2cp->state = I2C_READY;
-  chSysUnlock();
-  return rdymsg;
+    chSysLock();
+    i2cp->errors = I2CD_NO_ERROR;
+    i2cp->state = I2C_ACTIVE_RX;
+    rdymsg = i2c_lld_master_receive_timeout(i2cp, addr, rxbuf, rxbytes, timeout);
+    if (rdymsg == RDY_TIMEOUT)
+        i2cp->state = I2C_LOCKED;
+    else
+        i2cp->state = I2C_READY;
+    chSysUnlock();
+    return rdymsg;
 }
 
 #if I2C_USE_MUTUAL_EXCLUSION || defined(__DOXYGEN__)
@@ -273,14 +272,13 @@ msg_t i2cMasterReceiveTimeout(I2CDriver *i2cp,
  *
  * @api
  */
-void i2cAcquireBus(I2CDriver *i2cp) {
-
-  chDbgCheck(i2cp != NULL, "i2cAcquireBus");
+void i2cAcquireBus(I2CDriver* i2cp) {
+    chDbgCheck(i2cp != NULL, "i2cAcquireBus");
 
 #if CH_USE_MUTEXES
-  chMtxLock(&i2cp->mutex);
+    chMtxLock(&i2cp->mutex);
 #elif CH_USE_SEMAPHORES
-  chSemWait(&i2cp->semaphore);
+    chSemWait(&i2cp->semaphore);
 #endif
 }
 
@@ -293,14 +291,13 @@ void i2cAcquireBus(I2CDriver *i2cp) {
  *
  * @api
  */
-void i2cReleaseBus(I2CDriver *i2cp) {
-
-  chDbgCheck(i2cp != NULL, "i2cReleaseBus");
+void i2cReleaseBus(I2CDriver* i2cp) {
+    chDbgCheck(i2cp != NULL, "i2cReleaseBus");
 
 #if CH_USE_MUTEXES
-  chMtxUnlock();
+    chMtxUnlock();
 #elif CH_USE_SEMAPHORES
-  chSemSignal(&i2cp->semaphore);
+    chSemSignal(&i2cp->semaphore);
 #endif
 }
 #endif /* I2C_USE_MUTUAL_EXCLUSION */

firmware/common/battery.hpp

@@ -29,6 +29,7 @@ namespace battery {
 #define BATTERY_MIN_VOLTAGE 3000.0
 #define BATTERY_MAX_VOLTAGE 4170.0
 #define BATTERY_DESIGN_CAP 2500
+#define BATTERY_DESIGN_CAP_PRF 3000
 
 // this will just hold the config and a calculation. also some defines above for the battery management. could be movet to the classes, but it is a bit more readeable i think.
 class BatteryManagement {

firmware/common/i2cdev_max17055.cpp

@@ -235,18 +235,19 @@ bool I2cDev_MAX17055::soft_reset() {
 }
 
 bool I2cDev_MAX17055::initialize_custom_parameters() {
-    if (!write_register(0xD0, 0x03E8)) return false;  // Unknown register, possibly related to battery profile
-    if (!write_register(0xDB, 0x0000)) return false;  // ModelCfg
-    if (!write_register(0x05, 0x0000)) return false;  // RepCap
-    if (!write_register(0x18, 0x1388)) return false;  // DesignCap
-    if (!write_register(0x45, 0x009C)) return false;  // dQAcc
-    if (!write_register(0x1E, 0x03C0)) return false;  // IChgTerm
-    if (!write_register(0x3A, 0x9661)) return false;  // VEmpty
-    if (!write_register(0x60, 0x0090)) return false;  // Unknown register
-    if (!write_register(0x46, 0x0561)) return false;  // dPAcc
-    if (!write_register(0xDB, 0x8000)) return false;  // ModelCfg
+    if (!write_register(0xD0, 0x03E8)) return false;                                                                                                  // Unknown register, possibly related to battery profile
+    if (!write_register(0xDB, 0x0000)) return false;                                                                                                  // ModelCfg
+    if (!write_register(0x05, 0x0000)) return false;                                                                                                  // RepCap
+    uint32_t designcap = portapack::device_type == portapack::DEV_PORTARF ? __MAX17055_Design_Capacity_PRF__ * 2 : __MAX17055_Design_Capacity__ * 2;  // the original design has a 2x multiplier here, so i keep it
+    if (!write_register(0x18, designcap)) return false;                                                                                               // DesignCap
+    if (!write_register(0x45, designcap / 32)) return false;                                                                                          // dQAcc  =  DesignCap / 32
 
-    if (!write_register(0x40, 0x0001)) return false;  // Set user mem to 1
+    if (!write_register(0x1E, 0x03C0)) return false;                                  // IChgTerm
+    if (!write_register(0x3A, 0x9661)) return false;                                  // VEmpty
+    if (!write_register(0x60, 0x0090)) return false;                                  // Unknown register
+    if (!write_register(0x46, ((designcap / 32) * 44138) * designcap)) return false;  // dPAcc
+    if (!write_register(0xDB, 0x8000)) return false;                                  // ModelCfg  --we should wait till it loads here. While (ReadRegister(0xDB)&0x8000) Wait(10)；//do not continue until ModelCFG.Refresh == 0
+    if (!write_register(0x40, 0x0001)) return false;                                  // Set user mem to 1
     return true;
 }
 

firmware/common/i2cdev_max17055.hpp

@@ -51,6 +51,10 @@
 #define __MAX17055_Design_Capacity__ BATTERY_DESIGN_CAP  // Battery Capacity
 #endif
 
+#ifndef __MAX17055_Design_Capacity_PRF__
+#define __MAX17055_Design_Capacity_PRF__ BATTERY_DESIGN_CAP_PRF  // Battery Capacity for PortaRF
+#endif
+
 // Define Gauge Resistor
 #ifndef __MAX17055_Resistor__
 #define __MAX17055_Resistor__ 0.01  // Shunt Resistor

firmware/common/i2cdev_ppmod.cpp

@@ -46,6 +46,7 @@ bool I2cDev_PPmod::init(uint8_t addr_) {
 }
 
 void I2cDev_PPmod::update() {
+    if (isLocked()) return;  // device is busy
     // mask = get_features_mask(); //saved on init. replug device if something changed. //needs to revise when modules come out.
     if (mask & (uint64_t)SupportedFeatures::FEAT_GPS && self_timer % SENSORUPDATETIME == 0) {
         auto data = get_gps_data();
@@ -101,11 +102,13 @@ void I2cDev_PPmod::update() {
 }
 
 bool I2cDev_PPmod::get_shell_get_buffer_data(uint8_t* buff, size_t len) {
+    if (isLocked()) return false;  // device is busy
     Command cmd = Command::COMMAND_SHELL_MODTOPP_DATA;
     return i2c_read((uint8_t*)&cmd, 2, buff, len);
 }
 
 std::optional<orientation_t> I2cDev_PPmod::get_orientation_data() {
+    if (isLocked()) return std::nullopt;  // device is busy
     Command cmd = Command::COMMAND_GETFEAT_DATA_ORIENTATION;
     orientation_t data;
     bool success = i2c_read((uint8_t*)&cmd, 2, (uint8_t*)&data, sizeof(orientation_t));
@@ -116,6 +119,7 @@ std::optional<orientation_t> I2cDev_PPmod::get_orientation_data() {
 }
 
 std::optional<gpssmall_t> I2cDev_PPmod::get_gps_data() {
+    if (isLocked()) return std::nullopt;  // device is busy
     Command cmd = Command::COMMAND_GETFEAT_DATA_GPS;
     gpssmall_t data;
     bool success = i2c_read((uint8_t*)&cmd, 2, (uint8_t*)&data, sizeof(gpssmall_t));
@@ -126,6 +130,7 @@ std::optional<gpssmall_t> I2cDev_PPmod::get_gps_data() {
 }
 
 std::optional<environment_t> I2cDev_PPmod::get_environment_data() {
+    if (isLocked()) return std::nullopt;  // device is busy
     Command cmd = Command::COMMAND_GETFEAT_DATA_ENVIRONMENT;
     environment_t data;
     bool success = i2c_read((uint8_t*)&cmd, 2, (uint8_t*)&data, sizeof(environment_t));
@@ -136,6 +141,7 @@ std::optional<environment_t> I2cDev_PPmod::get_environment_data() {
 }
 
 std::optional<uint16_t> I2cDev_PPmod::get_light_data() {
+    if (isLocked()) return std::nullopt;  // device is busy
     Command cmd = Command::COMMAND_GETFEAT_DATA_LIGHT;
     uint16_t data;
     bool success = i2c_read((uint8_t*)&cmd, 2, (uint8_t*)&data, sizeof(uint16_t));
@@ -146,6 +152,7 @@ std::optional<uint16_t> I2cDev_PPmod::get_light_data() {
 }
 
 uint16_t I2cDev_PPmod::get_shell_buffer_bytes() {
+    if (isLocked()) return 0;  // device is busy
     Command cmd = Command::COMMAND_SHELL_MODTOPP_DATA_SIZE;
     uint16_t data;
     bool success = i2c_read((uint8_t*)&cmd, 2, (uint8_t*)&data, sizeof(uint16_t));
@@ -156,6 +163,7 @@ uint16_t I2cDev_PPmod::get_shell_buffer_bytes() {
 }
 
 uint64_t I2cDev_PPmod::get_features_mask() {
+    if (isLocked()) return 0;  // device is busy
     uint64_t mask_ = 0;
     Command cmd = Command::COMMAND_GETFEATURE_MASK;
     bool success = i2c_read((uint8_t*)&cmd, 2, (uint8_t*)&mask_, sizeof(mask_));
@@ -170,6 +178,7 @@ uint64_t I2cDev_PPmod::get_features_mask() {
 }
 
 std::optional<I2cDev_PPmod::device_info> I2cDev_PPmod::readDeviceInfo() {
+    if (isLocked()) return std::nullopt;  // device is busy
     Command cmd = Command::COMMAND_INFO;
     I2cDev_PPmod::device_info info;
 

firmware/common/i2cdevmanager.cpp

@@ -108,6 +108,19 @@ FROM HERE YOU SHOULDN'T WRITE ANYTHING IF YOU JUST IMPLEMENT A NEW DRIVER
 
 */
 
+void I2cDev::unlockDevice() {
+    mtx = 0;
+}
+
+// when device is locked, all not important queries will return 0 or nullopt, so no communication broken.
+bool I2cDev::lockDevice() {
+    if (mtx == 0) {
+        mtx = 1;
+        return true;
+    }
+    return false;
+}
+
 void I2cDev::set_update_interval(uint8_t interval) {
     query_interval = interval;
 }

firmware/common/i2cdevmanager.hpp

@@ -41,8 +41,8 @@ namespace i2cdev {
 class I2cDev {
    public:
     virtual ~I2cDev(){};
-    virtual bool init(uint8_t addr);  // returns true if it is that that device we are looking for.
-    virtual void update() = 0;        // override this, and you'll be able to query your device and broadcast the result to the system
+    virtual bool init(uint8_t addr) = 0;  // returns true if it is that that device we are looking for.
+    virtual void update() = 0;            // override this, and you'll be able to query your device and broadcast the result to the system
 
     void set_update_interval(uint8_t interval);  // sets the device's update interval in sec. if you change it, don't forget to change back to it's original value after you finished!
     uint8_t get_update_interval();               // gets the device's update interval in sec
@@ -59,6 +59,10 @@ class I2cDev {
     int16_t readS16_LE_1(uint8_t reg);
     uint32_t read24_1(uint8_t reg);
 
+    bool lockDevice();    // locks the device's "mutex". returns true on success. guard important communication with this
+    void unlockDevice();  // unlocks the device's "mutex"
+    inline bool isLocked() { return mtx != 0; }
+
     bool need_del = false;                // device can self destruct, and re-init when new scan discovers it
     I2C_DEVMDL model = I2CDEVMDL_NOTSET;  // overwrite it in the init()!!!
     uint8_t query_interval = 5;           // in seconds. can be overriden in init() if necessary
@@ -68,6 +72,7 @@ class I2cDev {
 
     uint8_t addr = 0;    // some devices can have different addresses, so we store what was it wound with
     uint8_t errcnt = 0;  // error count during communication. if it reaches a threshold set need_del to remove itself from the device list
+    uint8_t mtx = 0;     // internal lock, so important client code can be skipped when lock is on. check PPMod for an example
 };
 
 // store for the devices. may not have a driver if not supported

firmware/common/lcd_ili9341.cpp

@@ -77,13 +77,17 @@ void lcd_display_off() {
     io.lcd_data_write_command_and_data(0x28, {});
 }
 
-void lcd_sleep() {
+void lcd_sleep(bool hw_sleep = true) {
     lcd_display_off();
-    lcd_sleep_in();
+    if (hw_sleep) {
+        lcd_sleep_in();
+    }
 }
 
-void lcd_wake() {
-    lcd_sleep_out();
+void lcd_wake(bool hw_sleep = true) {
+    if (hw_sleep) {
+        lcd_sleep_out();
+    }
     lcd_display_on();
 }
 
@@ -394,12 +398,12 @@ void ILI9341::shutdown() {
     lcd_reset();
 }
 
-void ILI9341::sleep() {
-    lcd_sleep();
+void ILI9341::sleep(bool hw_sleep) {
+    lcd_sleep(hw_sleep);
 }
 
-void ILI9341::wake() {
-    lcd_wake();
+void ILI9341::wake(bool hw_sleep) {
+    lcd_wake(hw_sleep);
 }
 
 void ILI9341::fill_rectangle(ui::Rect r, const ui::Color c) {

firmware/common/lcd_ili9341.hpp

@@ -48,8 +48,8 @@ class ILI9341 {
     void init();
     void shutdown();
 
-    void sleep();
-    void wake();
+    void sleep(bool hw_sleep = true);
+    void wake(bool hw_sleep = true);
 
     void fill_rectangle(ui::Rect r, const ui::Color c);
     void fill_rectangle_unrolled8(ui::Rect r, const ui::Color c);

firmware/common/ui_widget.cpp

@@ -2167,12 +2167,14 @@ void BatteryIcon::paint(Painter& painter) {
     int8_t ptd = (int8_t)((static_cast<float>(percent_) / 100.0f) * (float)ppx + 0.5);  // pixels to draw
     int8_t pp = ppx - ptd;                                                              // pixels to start from
 
-    if (percent_ >= 70)
-        battColor = Theme::getInstance()->fg_green->foreground;
-    else if (percent_ >= 40)
-        battColor = Theme::getInstance()->fg_orange->foreground;
-    else
-        battColor = Theme::getInstance()->fg_red->foreground;
+    if (!charge_) {
+        if (percent_ >= 70)
+            battColor = Theme::getInstance()->fg_green->foreground;
+        else if (percent_ >= 40)
+            battColor = Theme::getInstance()->fg_orange->foreground;
+        else
+            battColor = Theme::getInstance()->fg_red->foreground;
+    }
     // fill the bars
     for (int y = pp; y < ppx; y++) {
         painter.draw_hline({rect.left() + 2, rect.top() + 3 + y}, rect.width() - 4, battColor);

firmware/standalone/pacman/main.cpp

@@ -23,11 +23,24 @@
 #include "pacman.hpp"
 #include <memory>
 
+void notouch(int, int, uint32_t) {
+    // do nothing
+}
+void nothing() {
+    // do nothing
+}
+bool noencoder(int32_t) {
+    return false;
+}
+bool nokeyboard(uint8_t) {
+    return false;
+}
+
 const standalone_application_api_t* _api;
 
 extern "C" {
 __attribute__((section(".standalone_application_information"), used)) standalone_application_information_t _standalone_application_information = {
-    /*.header_version = */ 1,
+    /*.header_version = */ 2,
 
     /*.app_name = */ "Pac-Man",
     /*.bitmap_data = */ {
@@ -70,18 +83,17 @@ __attribute__((section(".standalone_application_information"), used)) standalone
     /*.initialize_app = */ initialize,
     /*.on_event = */ on_event,
     /*.shutdown = */ shutdown,
-    /*PaintViewMirror */ NULL,
-    /*OnTouchEvent */ NULL,
-    /*OnFocus */ NULL,
-    /*OnKeyEvent */ NULL,
-    /*OnEncoder */ NULL,
-    /*OnKeyboard */ NULL};
+    /*PaintViewMirror */ nothing,
+    /*OnTouchEvent */ notouch,
+    /*OnFocus */ nothing,
+    /*OnKeyEvent */ on_key_event,
+    /*OnEncoder */ noencoder,
+    /*OnKeyboard */ nokeyboard};
 }
 
 /* Implementing abort() eliminates requirement for _getpid(), _kill(), _exit(). */
 extern "C" void abort() {
-    while (true)
-        ;
+    while (true);
 }
 
 // replace memory allocations to use heap from chibios

firmware/standalone/pacman/pacman.cpp

@@ -39,8 +39,36 @@ void initialize(const standalone_application_api_t& api) {
     _api = &api;
 }
 
+bool on_key_event(uint8_t key_val) {
+    ui::KeyEvent key = (ui::KeyEvent)key_val;
+    if (key == ui::KeyEvent::Right) {
+        but_RIGHT = true;
+        but_LEFT = false;
+        but_DOWN = false;
+        but_UP = false;
+    } else if (key == ui::KeyEvent::Left) {
+        but_LEFT = true;
+        but_RIGHT = false;
+        but_DOWN = false;
+        but_UP = false;
+    } else if (key == ui::KeyEvent::Down) {
+        but_DOWN = true;
+        but_RIGHT = false;
+        but_LEFT = false;
+        but_UP = false;
+    } else if (key == ui::KeyEvent::Up) {
+        but_UP = true;
+        but_RIGHT = false;
+        but_LEFT = false;
+        but_DOWN = false;
+    } else if (key == ui::KeyEvent::Select) {
+        but_A = true;
+    }
+    return true;
+}
+
 void on_event(const uint32_t& events) {
-    static bool wait_for_button_release{false};
+    // static bool wait_for_button_release{false};
 
     if (!_playfield) {
         _playfield = std::make_unique<Playfield>();
@@ -48,29 +76,30 @@ void on_event(const uint32_t& events) {
     }
 
     if (events & 1) {
-        auto switches_raw = _api->swizzled_switches() & ((1 << (int)Switch::Right) | (1 << (int)Switch::Left) | (1 << (int)Switch::Down) | (1 << (int)Switch::Up) | (1 << (int)Switch::Sel) | (1 << (int)Switch::Dfu));
-        auto switches_debounced = _api->get_switches_state();
+        /*
+            auto switches_raw = _api->swizzled_switches() & ((1 << (int)Switch::Right) | (1 << (int)Switch::Left) | (1 << (int)Switch::Down) | (1 << (int)Switch::Up) | (1 << (int)Switch::Sel) | (1 << (int)Switch::Dfu));
+            auto switches_debounced = _api->get_switches_state();
 
-        // For the Select (Start/Pause) button, wait for release to avoid repeat
-        uint8_t buttons_to_wait_for = (1 << (int)Switch::Sel);
-        if (wait_for_button_release) {
-            if ((switches_debounced & buttons_to_wait_for) == 0)
-                wait_for_button_release = false;
-            switches_debounced &= ~buttons_to_wait_for;
-        } else {
-            if (switches_debounced & buttons_to_wait_for)
-                wait_for_button_release = true;
-        }
+            // For the Select (Start/Pause) button, wait for release to avoid repeat
+            uint8_t buttons_to_wait_for = (1 << (int)Switch::Sel);
+            if (wait_for_button_release) {
+                if ((switches_debounced & buttons_to_wait_for) == 0)
+                    wait_for_button_release = false;
+                switches_debounced &= ~buttons_to_wait_for;
+            } else {
+                if (switches_debounced & buttons_to_wait_for)
+                    wait_for_button_release = true;
+            }
 
-        // For the directional buttons, use the raw inputs for fastest response time
-        but_RIGHT = (switches_raw & (1 << (int)Switch::Right)) != 0;
-        but_LEFT = (switches_raw & (1 << (int)Switch::Left)) != 0;
-        but_DOWN = (switches_raw & (1 << (int)Switch::Down)) != 0;
-        but_UP = (switches_raw & (1 << (int)Switch::Up)) != 0;
-
-        // For the pause button, use the debounced input to avoid glitches, and OR in the value to make sure that we don't clear it before it's seen
-        but_A |= (switches_debounced & (1 << (int)Switch::Sel)) != 0;
+            // For the directional buttons, use the raw inputs for fastest response time
+            but_RIGHT = (switches_raw & (1 << (int)Switch::Right)) != 0;
+            but_LEFT = (switches_raw & (1 << (int)Switch::Left)) != 0;
+            but_DOWN = (switches_raw & (1 << (int)Switch::Down)) != 0;
+            but_UP = (switches_raw & (1 << (int)Switch::Up)) != 0;
 
+            // For the pause button, use the debounced input to avoid glitches, and OR in the value to make sure that we don't clear it before it's seen
+            but_A |= (switches_debounced & (1 << (int)Switch::Sel)) != 0;
+        */
         _playfield->Step();
     }
 }

firmware/standalone/pacman/pacman.hpp

@@ -26,6 +26,7 @@
 
 void initialize(const standalone_application_api_t& api);
 void on_event(const uint32_t& events);
+bool on_key_event(uint8_t key_val);
 void shutdown();
 
 extern const standalone_application_api_t* _api;

firmware/standalone/pacman/playfield.hpp

@@ -133,39 +133,111 @@ const byte _initSprites[] =
 // Ghost colors
 const byte _palette2[] =
     {
-        0, 11, 1, 15,   // BINKY red
-        0, 11, 3, 15,   // PINKY pink
-        0, 11, 5, 15,   // INKY cyan
-        0, 11, 7, 15,   // CLYDE brown
-        0, 11, 9, 9,    // PACMAN yellow
-        0, 11, 15, 15,  // FRIGHTENED
-        0, 11, 0, 15,   // DEADEYES
+        0,
+        11,
+        1,
+        15,  // BINKY red
+        0,
+        11,
+        3,
+        15,  // PINKY pink
+        0,
+        11,
+        5,
+        15,  // INKY cyan
+        0,
+        11,
+        7,
+        15,  // CLYDE brown
+        0,
+        11,
+        9,
+        9,  // PACMAN yellow
+        0,
+        11,
+        15,
+        15,  // FRIGHTENED
+        0,
+        11,
+        0,
+        15,  // DEADEYES
 
-        0, 1, 15, 2,   // cherry
-        0, 1, 15, 12,  // strawberry
-        0, 7, 2, 12,   // peach
-        0, 9, 15, 0,   // bell
+        0,
+        1,
+        15,
+        2,  // cherry
+        0,
+        1,
+        15,
+        12,  // strawberry
+        0,
+        7,
+        2,
+        12,  // peach
+        0,
+        9,
+        15,
+        0,  // bell
 
-        0, 15, 1, 2,   // apple
-        0, 12, 15, 5,  // grape
-        0, 11, 9, 1,   // galaxian
-        0, 5, 15, 15,  // key
+        0,
+        15,
+        1,
+        2,  // apple
+        0,
+        12,
+        15,
+        5,  // grape
+        0,
+        11,
+        9,
+        1,  // galaxian
+        0,
+        5,
+        15,
+        15,  // key
 
 };
 
 const byte _paletteIcon2[] =
     {
-        0, 9, 9, 9,  // PACMAN
+        0,
+        9,
+        9,
+        9,  // PACMAN
 
-        0, 2, 15, 1,   // cherry
-        0, 12, 15, 1,  // strawberry
-        0, 12, 2, 7,   // peach
-        0, 0, 15, 9,   // bell
+        0,
+        2,
+        15,
+        1,  // cherry
+        0,
+        12,
+        15,
+        1,  // strawberry
+        0,
+        12,
+        2,
+        7,  // peach
+        0,
+        0,
+        15,
+        9,  // bell
 
-        0, 2, 15, 1,   // apple
-        0, 12, 15, 5,  // grape
-        0, 1, 9, 11,   // galaxian
-        0, 5, 15, 15,  // key
+        0,
+        2,
+        15,
+        1,  // apple
+        0,
+        12,
+        15,
+        5,  // grape
+        0,
+        1,
+        9,
+        11,  // galaxian
+        0,
+        5,
+        15,
+        15,  // key
 };
 
 #define PACMANICON 1
@@ -571,7 +643,7 @@ class Playfield {
       }
 #endif
 
-        x += (240 - 224) / 2;
+        x += (*(_api->screen_width) - 224) / 2;
         y += (320 - 288) / 2 + 8;
 
         // Should be a direct Graphics call

flashing/flash_portapack_mayhem.bat

@@ -23,6 +23,10 @@ if not exist portapack-mayhem-firmware.bin (
 
 "utils/hackrf_update.exe" portapack-mayhem-firmware.bin
 echo.
-echo If your device never boot after flashing, please refer to https://github.com/portapack-mayhem/mayhem-firmware/wiki/Won't-boot
+echo If your device never boot after flashing, please refer to won't boot article"
+echo.
+echo "click-to-open url: https://github.com/portapack-mayhem/mayhem-firmware/wiki/Won%%27t-boot"
+echo "or
+echo "copy-and-paste url: https://github.com/portapack-mayhem/mayhem-firmware/wiki/Won't-boot"
 echo.
 pause