feat: refine remote states and PRTS LCD refresh

- add remote NOT_READY/READY/PROTECT state flow and matching LED/status display

- speed up TFT hardware SPI DMA flush path and larger LVGL partial refresh buffer

- reduce page/menu redraw artifacts and center the PRTS status title

Core/Src/spi.c

@@ -49,7 +49,7 @@ void MX_SPI1_Init(void)
   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
   hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
   hspi1.Init.NSS = SPI_NSS_SOFT;
-  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
+  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
@@ -149,14 +149,14 @@ void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
     GPIO_InitStruct.Pin = GPIO_PIN_7;
     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     GPIO_InitStruct.Pull = GPIO_NOPULL;
-    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
 
     GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4;
     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     GPIO_InitStruct.Pull = GPIO_NOPULL;
-    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 

TronOneH7_Scaffold.ioc

@@ -654,12 +654,12 @@ PB13.Mode=Full_Duplex_Master
 PB13.Signal=SPI2_SCK
 PB15.Signal=S_TIM12_CH2
 PB3(JTDO/TRACESWO).GPIOParameters=GPIO_Speed
-PB3(JTDO/TRACESWO).GPIO_Speed=GPIO_SPEED_FREQ_HIGH
+PB3(JTDO/TRACESWO).GPIO_Speed=GPIO_SPEED_FREQ_VERY_HIGH
 PB3(JTDO/TRACESWO).Locked=true
 PB3(JTDO/TRACESWO).Mode=Full_Duplex_Master
 PB3(JTDO/TRACESWO).Signal=SPI1_SCK
 PB4(NJTRST).GPIOParameters=GPIO_Speed
-PB4(NJTRST).GPIO_Speed=GPIO_SPEED_FREQ_HIGH
+PB4(NJTRST).GPIO_Speed=GPIO_SPEED_FREQ_VERY_HIGH
 PB4(NJTRST).Locked=true
 PB4(NJTRST).Mode=Full_Duplex_Master
 PB4(NJTRST).Signal=SPI1_MISO
@@ -741,7 +741,7 @@ PD6.Locked=true
 PD6.Mode=Asynchronous
 PD6.Signal=USART2_RX
 PD7.GPIOParameters=GPIO_Speed
-PD7.GPIO_Speed=GPIO_SPEED_FREQ_HIGH
+PD7.GPIO_Speed=GPIO_SPEED_FREQ_VERY_HIGH
 PD7.Locked=true
 PD7.Mode=Full_Duplex_Master
 PD7.Signal=SPI1_MOSI
@@ -920,9 +920,9 @@ SH.S_TIM3_CH4.ConfNb=1
 SH.SharedStack_PC12.0=SPI3_MOSI
 SH.SharedStack_PC12.1=UART5_TX,Asynchronous
 SH.SharedStack_PC12.ConfNb=2
-SPI1.BaudRatePrescaler=SPI_BAUDRATEPRESCALER_4
+SPI1.BaudRatePrescaler=SPI_BAUDRATEPRESCALER_2
 SPI1.CLKPolarity=SPI_POLARITY_LOW
-SPI1.CalculateBaudRate=30 MBits/s
+SPI1.CalculateBaudRate=60 MBits/s
 SPI1.DataSize=SPI_DATASIZE_8BIT
 SPI1.Direction=SPI_DIRECTION_2LINES
 SPI1.IPParameters=VirtualType,Mode,Direction,CalculateBaudRate,DataSize,BaudRatePrescaler,CLKPolarity

User_Code/application/indicator_app/ws2812status.c

@@ -54,20 +54,16 @@ void robotSelfCheck(void)
 void ws2812Task(void *argument)
 {
     (void) argument;
-    RC_ctrl_t rc_data;
     while (1)
     {
         RobotMode_t display_mode = RobotMode;
         if (display_mode != SYS_ERROR_OCCURRED && !RemoteControlIsOnline())
             display_mode = REMOTE_NOT_CONNECTED;
 
-        if (RemoteControlReadSnapshot(&rc_data) && switch_is_down(rc_data.sw_d))
-            display_mode = NORMAL_MODE;
-
         switch (display_mode)
         {
             case NORMAL_MODE:
-                BlinkBlue();
+                BlinkGreen();
                 break;
             case SYS_ERROR_OCCURRED:
                 BlinkRed();
@@ -75,7 +71,13 @@ void ws2812Task(void *argument)
             case REMOTE_NOT_CONNECTED:
                 BlinkRed();
                 break;
-            case REMOTE_CONNECTED:
+            case REMOTE_NOT_READY:
+                BlinkWhite();
+                break;
+            case REMOTE_READY:
+                BlinkPurple();
+                break;
+            case REMOTE_PROTECT:
                 BlinkYellow();
                 break;
             case AUTO_SHOOTING_MODE:

User_Code/module/paramdef/robot_def.h

@@ -1,21 +1,18 @@
-// #pragma once // 可以用#pragma once代替#ifndef ROBOT_DEF_H(header guard)
 #ifndef ROBOT_DEF_H
 #define ROBOT_DEF_H
 
 typedef enum
 {
-    NORMAL_MODE = 0, // 正常模式，对应数值0
+    NORMAL_MODE = 0,
-    SYS_ERROR_OCCURRED = 1, // 系统错误，对应数值1
+    SYS_ERROR_OCCURRED = 1,
-    REMOTE_NOT_CONNECTED = 2, // 遥控器未连接，对应数值2
+    REMOTE_NOT_CONNECTED = 2,
-    REMOTE_CONNECTED = 3, // 遥控器已连接，对应数值3
+    REMOTE_NOT_READY = 3,
-    AUTO_SHOOTING_MODE = 4, // 成功进入自动瞄准模式，对应数值4
+    REMOTE_READY = 4,
-    IMU_CALIBERATION_MODE = 5 // IMU校准模式，对应数值5
+    REMOTE_PROTECT = 5,
-    // 添加其他模式
+    AUTO_SHOOTING_MODE = 6,
-} RobotMode_t; //机器人控制模式
+    IMU_CALIBERATION_MODE = 7
+} RobotMode_t;
 
 extern volatile RobotMode_t RobotMode;
 
-
-// #pragma pack() // 开启字节对齐,结束前面的#pragma pack(1)
-
 #endif

User_Code/module/periph/remote_control/rc.c

@@ -102,6 +102,49 @@ static uint8_t SBusEndByteIsValid(uint8_t value)
     return value == SBUS_END || value == 0x04u || value == 0x14u || value == 0x24u || value == 0x34u;
 }
 
+static uint8_t RemoteControlAllSwitchesDown(const RC_ctrl_t *rc)
+{
+    return rc != NULL && switch_is_down(rc->sw_a) && switch_is_down(rc->sw_b) && switch_is_down(rc->sw_c) &&
+           switch_is_down(rc->sw_d);
+}
+
+static void RemoteControlSetMode(RobotMode_t mode)
+{
+    if (RobotMode != SYS_ERROR_OCCURRED)
+        RobotMode = mode;
+}
+
+static void RemoteControlUpdateMode(const RC_ctrl_t *rc)
+{
+    if (rc == NULL || RobotMode == SYS_ERROR_OCCURRED)
+        return;
+
+    switch (RobotMode)
+    {
+        case REMOTE_NOT_CONNECTED:
+            RemoteControlSetMode(REMOTE_NOT_READY);
+            break;
+        case REMOTE_NOT_READY:
+            if (RemoteControlAllSwitchesDown(rc))
+                RemoteControlSetMode(REMOTE_READY);
+            break;
+        case REMOTE_READY:
+            if (switch_is_up(rc->sw_d))
+                RemoteControlSetMode(NORMAL_MODE);
+            break;
+        case NORMAL_MODE:
+            if (switch_is_down(rc->sw_d))
+                RemoteControlSetMode(REMOTE_PROTECT);
+            break;
+        case REMOTE_PROTECT:
+            if (switch_is_up(rc->sw_d))
+                RemoteControlSetMode(NORMAL_MODE);
+            break;
+        default:
+            break;
+    }
+}
+
 
 #ifdef REMOTE_DJI_DT7
 /**
@@ -364,8 +407,7 @@ static void RemoteControlPublishOffline(uint8_t force)
     {
         rc_data_valid = 0;
         memset(rc_ctrl, 0, sizeof(rc_ctrl));
-        if (RobotMode != SYS_ERROR_OCCURRED)
+        RemoteControlSetMode(REMOTE_NOT_CONNECTED);
-            RobotMode = REMOTE_NOT_CONNECTED;
     }
 
     __set_PRIMASK(primask);
@@ -396,8 +438,7 @@ static void RemoteControlRxCallback(USART_Instance *instance, const uint8_t *rec
     rc_valid_frame_count++;
     rc_data_valid = 1;
     DaemonReload(rc_daemon_instance);
-    if (RobotMode == REMOTE_NOT_CONNECTED)
+    RemoteControlUpdateMode(&rc_ctrl[TEMP]);
-        RobotMode = REMOTE_CONNECTED;
 }
 
 /**

User_Code/module/periph/tft/tft.c

@@ -28,6 +28,9 @@ typedef enum
 
 static bool tft_initialized = false;
 static bool tft_transfer_ok = true;
+static volatile bool tft_dma_active = false;
+static TFT_TransferDoneCallback tft_dma_callback = NULL;
+static void *tft_dma_context = NULL;
 
 static const uint8_t tft_font5x7[][TFT_FONT_H] = {
     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* space */
@@ -107,6 +110,31 @@ static void tft_backlight_on(void)
     HAL_GPIO_WritePin(TFT_BLK_GPIO_Port, TFT_BLK_Pin, GPIO_PIN_SET);
 }
 
+static void tft_dma_finish(bool ok)
+{
+    TFT_TransferDoneCallback callback = tft_dma_callback;
+    void *context = tft_dma_context;
+
+    if (!tft_dma_active)
+    {
+        return;
+    }
+
+    tft_dma_active = false;
+    tft_dma_callback = NULL;
+    tft_dma_context = NULL;
+    if (!ok)
+    {
+        tft_transfer_ok = false;
+    }
+    tft_cs_high();
+
+    if (callback != NULL)
+    {
+        callback(context, ok);
+    }
+}
+
 static void tft_bus_init(void)
 {
 #if TFT_USE_SOFT_SPI
@@ -278,6 +306,51 @@ void TFT_WriteColorData(const uint8_t *data, uint32_t len)
     tft_cs_high();
 }
 
+bool TFT_WriteColorDataDMA(const uint8_t *data,
+                           uint32_t len,
+                           TFT_TransferDoneCallback callback,
+                           void *context)
+{
+    if (data == NULL || len == 0U || len > UINT16_MAX || tft_dma_active || TFT_SPI_UNIT.hdmatx == NULL)
+    {
+        return false;
+    }
+
+    tft_cs_low();
+    tft_dc_data();
+    tft_dma_callback = callback;
+    tft_dma_context = context;
+    tft_dma_active = true;
+
+    if (HAL_SPI_Transmit_DMA(&TFT_SPI_UNIT, (uint8_t *) data, (uint16_t) len) != HAL_OK)
+    {
+        tft_dma_active = false;
+        tft_dma_callback = NULL;
+        tft_dma_context = NULL;
+        tft_transfer_ok = false;
+        tft_cs_high();
+        return false;
+    }
+
+    return true;
+}
+
+void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
+{
+    if (hspi == &TFT_SPI_UNIT)
+    {
+        tft_dma_finish(true);
+    }
+}
+
+void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi)
+{
+    if (hspi == &TFT_SPI_UNIT)
+    {
+        tft_dma_finish(false);
+    }
+}
+
 bool TFT_IsReady(void)
 {
     return tft_initialized && tft_transfer_ok;
@@ -599,8 +672,12 @@ const char *TFT_RobotModeText(RobotMode_t mode)
             return "ERROR";
         case REMOTE_NOT_CONNECTED:
             return "REMOTE OFF";
-        case REMOTE_CONNECTED:
+        case REMOTE_NOT_READY:
-            return "REMOTE ON";
+            return "NOT READY";
+        case REMOTE_READY:
+            return "READY";
+        case REMOTE_PROTECT:
+            return "PROTECT";
         case AUTO_SHOOTING_MODE:
             return "AUTO SHOOT";
         case IMU_CALIBERATION_MODE:
@@ -619,7 +696,11 @@ static uint16_t tft_mode_color(RobotMode_t mode)
         case SYS_ERROR_OCCURRED:
         case REMOTE_NOT_CONNECTED:
             return TFT_COLOR_RED;
-        case REMOTE_CONNECTED:
+        case REMOTE_NOT_READY:
+            return TFT_COLOR_WHITE;
+        case REMOTE_READY:
+            return TFT_COLOR_MAGENTA;
+        case REMOTE_PROTECT:
             return TFT_COLOR_YELLOW;
         case AUTO_SHOOTING_MODE:
             return TFT_COLOR_CYAN;

User_Code/module/periph/tft/tft.h

@@ -11,6 +11,8 @@
 extern "C" {
 #endif
 
+typedef void (*TFT_TransferDoneCallback)(void *context, bool ok);
+
 #define TFT_USE_HORIZONTAL   2U
 #define TFT_USE_SOFT_SPI     0U
 #define TFT_HW_SPI_BYTE_MODE 0U
@@ -91,6 +93,10 @@ void TFT_DrawString(uint16_t x, uint16_t y, const char *text, uint16_t fc, uint1
 void TFT_ShowStatus(float temperature_c, RobotMode_t mode);
 bool TFT_IsReady(void);
 void TFT_WriteColorData(const uint8_t *data, uint32_t len);
+bool TFT_WriteColorDataDMA(const uint8_t *data,
+                           uint32_t len,
+                           TFT_TransferDoneCallback callback,
+                           void *context);
 const char *TFT_RobotModeText(RobotMode_t mode);
 
 void LCD_Init(void);

User_Code/module/software/prts/lvgl/lv_conf.h

@@ -69,7 +69,7 @@
 
 #if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN
     /** Size of memory available for `lv_malloc()` in bytes (>= 2kB) */
-    #define LV_MEM_SIZE (80 * 1024U)          /**< [bytes] */
+    #define LV_MEM_SIZE (76 * 1024U)          /**< [bytes] */
 
     /** Size of the memory expand for `lv_malloc()` in bytes */
     #define LV_MEM_POOL_EXPAND_SIZE 0

User_Code/module/software/prts/port/prts_lvgl_port.c

@@ -7,18 +7,43 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#define PRTS_LVGL_BUF_LINES  64U
+#define PRTS_LVGL_BUF_LINES  80U
 #define PRTS_DMA_BUFFER_ATTR __attribute__((section(".dma_buffer"), aligned(32)))
 
 static lv_display_t *prts_display = NULL;
 static uint8_t prts_lvgl_buf[TFT_LCD_W * PRTS_LVGL_BUF_LINES * 2U] PRTS_DMA_BUFFER_ATTR;
 static volatile uint32_t prts_lvgl_frame_count = 0U;
+static volatile bool prts_lvgl_pending_last_flush = false;
 
 static uint32_t prts_lvgl_tick_get(void)
 {
     return HAL_GetTick();
 }
 
+static void prts_lvgl_finish_flush(lv_display_t *disp, bool is_last)
+{
+    if (is_last)
+    {
+        prts_lvgl_frame_count++;
+    }
+    lv_display_flush_ready(disp);
+}
+
+static void prts_lvgl_dma_done(void *context, bool ok)
+{
+    lv_display_t *disp = (lv_display_t *) context;
+
+    if (!ok)
+    {
+        prts_lvgl_pending_last_flush = false;
+        lv_display_flush_ready(disp);
+        return;
+    }
+
+    prts_lvgl_finish_flush(disp, prts_lvgl_pending_last_flush);
+    prts_lvgl_pending_last_flush = false;
+}
+
 static void prts_lvgl_flush(lv_display_t *disp, const lv_area_t *area, uint8_t *px_map)
 {
     int32_t area_width;
@@ -28,14 +53,12 @@ static void prts_lvgl_flush(lv_display_t *disp, const lv_area_t *area, uint8_t *
     int32_t x2;
     int32_t y2;
     uint32_t pixel_count;
+    bool is_last_flush;
 
+    is_last_flush = lv_display_flush_is_last(disp);
     if (area->x2 < 0 || area->y2 < 0 || area->x1 >= (int32_t) TFT_LCD_W || area->y1 >= (int32_t) TFT_LCD_H)
     {
-        if (lv_display_flush_is_last(disp))
+        prts_lvgl_finish_flush(disp, is_last_flush);
-        {
-            prts_lvgl_frame_count++;
-        }
-        lv_display_flush_ready(disp);
         return;
     }
 
@@ -43,11 +66,7 @@ static void prts_lvgl_flush(lv_display_t *disp, const lv_area_t *area, uint8_t *
     area_height = lv_area_get_height(area);
     if (area_width <= 0 || area_height <= 0)
     {
-        if (lv_display_flush_is_last(disp))
+        prts_lvgl_finish_flush(disp, is_last_flush);
-        {
-            prts_lvgl_frame_count++;
-        }
-        lv_display_flush_ready(disp);
         return;
     }
 
@@ -62,6 +81,12 @@ static void prts_lvgl_flush(lv_display_t *disp, const lv_area_t *area, uint8_t *
     if (x1 == area->x1 && y1 == area->y1 && x2 == area->x2 && y2 == area->y2)
     {
         LCD_Address_Set((uint16_t) x1, (uint16_t) y1, (uint16_t) x2, (uint16_t) y2);
+        prts_lvgl_pending_last_flush = is_last_flush;
+        if (TFT_WriteColorDataDMA(px_map, pixel_count * 2U, prts_lvgl_dma_done, disp))
+        {
+            return;
+        }
+        prts_lvgl_pending_last_flush = false;
         TFT_WriteColorData(px_map, pixel_count * 2U);
     }
     else
@@ -81,11 +106,7 @@ static void prts_lvgl_flush(lv_display_t *disp, const lv_area_t *area, uint8_t *
         }
     }
 
-    if (lv_display_flush_is_last(disp))
+    prts_lvgl_finish_flush(disp, is_last_flush);
-    {
-        prts_lvgl_frame_count++;
-    }
-    lv_display_flush_ready(disp);
 }
 
 uint32_t PRTS_LVGLPortGetFrameCount(void)

User_Code/module/software/prts/prts.c

@@ -21,9 +21,12 @@
 #define PRTS_CARD_H               140
 #define PRTS_CARD_GAP             15
 #define PRTS_CARD_PAD_HOR         75
-#define PRTS_DOT_SIZE_NORMAL      8
+#define PRTS_DOT_SIZE_NORMAL      10
-#define PRTS_DOT_SIZE_ACTIVE      12
+#define PRTS_DOT_SIZE_ACTIVE      10
 #define PRTS_MENU_CARD_COUNT      3U
+#define PRTS_STATUS_BRAND_X       18
+#define PRTS_STATUS_BRAND_W       54
+#define PRTS_STATUS_TITLE_W       130
 
 #define PRTS_VALUE_PANEL_WIDTH    228
 #define PRTS_VALUE_PANEL_HEIGHT   34
@@ -33,7 +36,7 @@
 #define PRTS_JOY_DEBOUNCE_MS      25U
 #define PRTS_JOY_LONG_PRESS_MS    700U
 #define PRTS_MONITOR_UPDATE_MS    150U
-#define PRTS_SCREEN_ANIM_MS       140U
+#define PRTS_SCREEN_ANIM_MS       0U
 
 typedef enum
 {
@@ -174,8 +177,12 @@ static const char *prts_robot_mode_text(RobotMode_t mode)
             return "ERROR";
         case REMOTE_NOT_CONNECTED:
             return "REMOTE OFF";
-        case REMOTE_CONNECTED:
+        case REMOTE_NOT_READY:
-            return "REMOTE ON";
+            return "NOT READY";
+        case REMOTE_READY:
+            return "READY";
+        case REMOTE_PROTECT:
+            return "PROTECT";
         case AUTO_SHOOTING_MODE:
             return "AUTO SHOOT";
         case IMU_CALIBERATION_MODE:
@@ -194,7 +201,11 @@ static lv_color_t prts_robot_mode_color(RobotMode_t mode)
         case SYS_ERROR_OCCURRED:
         case REMOTE_NOT_CONNECTED:
             return lv_color_hex(0xFF4D4F);
-        case REMOTE_CONNECTED:
+        case REMOTE_NOT_READY:
+            return lv_color_hex(0xEDEDED);
+        case REMOTE_READY:
+            return lv_color_hex(0xC678FF);
+        case REMOTE_PROTECT:
             return lv_color_hex(0xFFD666);
         case AUTO_SHOOTING_MODE:
             return lv_color_hex(0x40C4FF);
@@ -212,7 +223,11 @@ static lv_color_t prts_robot_mode_text_color(RobotMode_t mode)
         case SYS_ERROR_OCCURRED:
         case REMOTE_NOT_CONNECTED:
             return lv_color_hex(0xFFE2E2);
-        case REMOTE_CONNECTED:
+        case REMOTE_NOT_READY:
+            return lv_color_hex(0xFFFFFF);
+        case REMOTE_READY:
+            return lv_color_hex(0xF5E6FF);
+        case REMOTE_PROTECT:
             return lv_color_hex(0xFFF3C4);
         default:
             return lv_color_hex(0xFFFFFF);
@@ -338,9 +353,6 @@ static void prts_init_styles(void)
         LV_STYLE_BG_COLOR,
         LV_STYLE_BORDER_COLOR,
         LV_STYLE_BORDER_WIDTH,
-        LV_STYLE_TRANSFORM_WIDTH,
-        LV_STYLE_TRANSFORM_HEIGHT,
-        LV_STYLE_SHADOW_OPA,
         0
     };
 
@@ -373,8 +385,8 @@ static void prts_init_styles(void)
     lv_style_set_bg_color(&prts_style_card_focused, lv_color_hex(0x3A3A3C));
     lv_style_set_border_color(&prts_style_card_focused, lv_color_hex(0x0A84FF));
     lv_style_set_border_width(&prts_style_card_focused, 2);
-    lv_style_set_transform_width(&prts_style_card_focused, 4);
+    lv_style_set_transform_width(&prts_style_card_focused, 0);
-    lv_style_set_transform_height(&prts_style_card_focused, 3);
+    lv_style_set_transform_height(&prts_style_card_focused, 0);
     lv_style_set_shadow_width(&prts_style_card_focused, 0);
     lv_style_set_shadow_color(&prts_style_card_focused, lv_color_hex(0x0A84FF));
     lv_style_set_shadow_opa(&prts_style_card_focused, LV_OPA_0);
@@ -449,13 +461,16 @@ static lv_obj_t *prts_create_status_bar(lv_obj_t *parent, const char *title_text
     brand = lv_label_create(bar);
     lv_label_set_text(brand, "PRTS");
     prts_style_label(brand, lv_color_hex(0x6EE7F9));
-    lv_obj_set_pos(brand, 10, 6);
+    lv_obj_set_pos(brand, PRTS_STATUS_BRAND_X, 6);
+    lv_obj_set_size(brand, PRTS_STATUS_BRAND_W, 18);
+    lv_obj_set_style_text_align(brand, LV_TEXT_ALIGN_CENTER, 0);
 
     title = lv_label_create(bar);
     lv_label_set_text(title, title_text);
     prts_style_label(title, lv_color_hex(0xEBEBF5));
-    lv_obj_set_pos(title, 74, 6);
+    lv_obj_set_pos(title, (PRTS_SCREEN_W - PRTS_STATUS_TITLE_W) / 2, 6);
-    lv_obj_set_size(title, 130, 18);
+    lv_obj_set_size(title, PRTS_STATUS_TITLE_W, 18);
+    lv_obj_set_style_text_align(title, LV_TEXT_ALIGN_CENTER, 0);
 
     if (parent == prts_main_screen)
     {
@@ -605,7 +620,7 @@ static void prts_page_key_event_cb(lv_event_t *e)
 
     if (lv_event_get_key(e) == LV_KEY_ESC)
     {
-        prts_show_page(PRTS_PAGE_MAIN, LV_SCREEN_LOAD_ANIM_OVER_RIGHT);
+        prts_show_page(PRTS_PAGE_MAIN, LV_SCREEN_LOAD_ANIM_NONE);
     }
 }
 
@@ -629,7 +644,7 @@ static void prts_card_event_cb(lv_event_t *e)
     else if (code == LV_EVENT_CLICKED)
     {
         prts_current_card = (uint8_t) index;
-        prts_show_page(prts_menu_cards_data[index].page, LV_SCREEN_LOAD_ANIM_OVER_LEFT);
+        prts_show_page(prts_menu_cards_data[index].page, LV_SCREEN_LOAD_ANIM_NONE);
     }
 }