MKS WiFi for TFT_LVGL_UI (#20191)

Marlin/Configuration.h

 //#define TFT_COLOR_UI
 //#define TFT_LVGL_UI
 
+#if ENABLED(TFT_LVGL_UI)
+  //#define MKS_WIFI_MODULE  // MKS WiFi module
+#endif
+
 /**
  * TFT Rotation. Set to one of the following values:
  *

Marlin/src/lcd/extui/lib/mks_ui/draw_cloud_bind.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * 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 3 of the License, 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.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if BOTH(HAS_TFT_LVGL_UI, MKS_WIFI_MODULE)
+
+#include "lv_conf.h"
+#include "draw_ui.h"
+
+#include "../../../../MarlinCore.h"
+#include "../../../../module/temperature.h"
+
+#include "QR_Encode.h"
+
+extern lv_group_t * g;
+static lv_obj_t * scr;
+static lv_obj_t *button_bind_or_not = NULL, *label_bind_or_not = NULL;
+static lv_obj_t *buttonReleaseBind = NULL, *label_ReleaseBind = NULL;
+static lv_obj_t * text_id;
+
+static uint8_t unbinding_flag = 0;
+static uint8_t id_mark        = 0;
+
+#define ID_CLOUD_BIND_RETURN  1
+#define ID_CLOUD_BIND_OR_NOT  2
+#define ID_CLOUD_RELEASE_BIND 3
+
+static void event_handler(lv_obj_t * obj, lv_event_t event) {
+  if (event != LV_EVENT_RELEASED) return;
+  switch (obj->mks_obj_id) {
+    case ID_CLOUD_BIND_RETURN:
+      clear_cur_ui();
+      draw_return_ui();
+      break;
+    case ID_CLOUD_RELEASE_BIND:
+      if (cloud_para.state == 0x12) {
+        clear_cur_ui();
+        lv_draw_dialog(DIALOG_TYPE_UNBIND);
+      }
+      break;
+  }
+}
+
+void lv_draw_cloud_bind(void) {
+  lv_obj_t *buttonBack = NULL, *label_Back = NULL;
+  scr = lv_screen_create(BIND_UI);
+
+  button_bind_or_not = lv_btn_create(scr, NULL);
+  lv_obj_set_pos(button_bind_or_not, TFT_WIDTH - 130, TFT_HEIGHT - 80 * 3);
+  lv_obj_set_size(button_bind_or_not, PARA_UI_VALUE_BTN_X_SIZE + 15, PARA_UI_VALUE_BTN_Y_SIZE + 15);
+  lv_obj_set_event_cb_mks(button_bind_or_not, event_handler, ID_CLOUD_BIND_OR_NOT, NULL, 0);
+  lv_btn_set_style(button_bind_or_not, LV_BTN_STYLE_REL, &style_para_value);
+  lv_btn_set_style(button_bind_or_not, LV_BTN_STYLE_PR, &style_para_value);
+  label_bind_or_not = lv_label_create_empty(button_bind_or_not);
+
+  buttonReleaseBind = lv_btn_create(scr, NULL);
+  lv_obj_set_pos(buttonReleaseBind, TFT_WIDTH - 130, TFT_HEIGHT - 80 * 2);
+  lv_obj_set_size(buttonReleaseBind, PARA_UI_VALUE_BTN_X_SIZE + 15, PARA_UI_VALUE_BTN_Y_SIZE + 15);
+  lv_obj_set_event_cb_mks(buttonReleaseBind, event_handler, ID_CLOUD_RELEASE_BIND, NULL, 0);
+  label_ReleaseBind = lv_label_create_empty(buttonReleaseBind);
+  lv_label_set_text(label_ReleaseBind, cloud_menu.unbind);
+  lv_obj_align(label_ReleaseBind, buttonReleaseBind, LV_ALIGN_CENTER, 0, 0);
+
+  buttonBack = lv_btn_create(scr, NULL);
+  lv_obj_set_pos(buttonBack, TFT_WIDTH - 130, TFT_HEIGHT - 80);
+  lv_obj_set_size(buttonBack, PARA_UI_VALUE_BTN_X_SIZE + 15, PARA_UI_VALUE_BTN_Y_SIZE + 15);
+  lv_obj_set_event_cb_mks(buttonBack, event_handler, ID_CLOUD_BIND_RETURN, NULL, 0);
+  lv_btn_set_style(buttonBack, LV_BTN_STYLE_REL, &style_para_back);
+  lv_btn_set_style(buttonBack, LV_BTN_STYLE_PR, &style_para_back);
+  label_Back = lv_label_create_empty(buttonBack);
+  lv_label_set_text(label_Back, common_menu.text_back);
+  lv_obj_align(label_Back, buttonBack, LV_ALIGN_CENTER, 0, 0);
+
+  #if BUTTONS_EXIST(EN1, EN2, ENC)
+    if (gCfgItems.encoder_enable) {
+      lv_group_add_obj(g, buttonReleaseBind);
+      lv_group_add_obj(g, buttonBack);
+    }
+  #endif
+
+  text_id = lv_label_create_empty(scr);
+  lv_obj_set_pos(text_id, 50, 60 + 200 + 20);
+  lv_obj_set_style(text_id, &tft_style_label_rel);
+  lv_label_set_text(text_id, (char *)cloud_para.id);
+
+  id_mark = 0;
+
+  disp_bind_state();
+}
+
+void disp_bind_state() {
+  if (cloud_para.state != 0x12)
+    unbinding_flag = 0;
+
+  if (unbinding_flag) {
+    lv_label_set_text(label_bind_or_not, cloud_menu.unbinding);
+    lv_obj_align(label_bind_or_not, button_bind_or_not, LV_ALIGN_CENTER, 0, 0);
+    lv_btn_set_style(buttonReleaseBind, LV_BTN_STYLE_REL, &style_para_value);
+    lv_btn_set_style(buttonReleaseBind, LV_BTN_STYLE_PR, &style_para_value);
+  }
+  else {
+    if (cloud_para.state == 0x10) {
+      lv_label_set_text(label_bind_or_not, cloud_menu.disconnected);
+      lv_obj_align(label_bind_or_not, button_bind_or_not, LV_ALIGN_CENTER, 0, 0);
+    }
+    else if (cloud_para.state == 0x11) {
+      lv_label_set_text(label_bind_or_not, cloud_menu.unbinded);
+      lv_obj_align(label_bind_or_not, button_bind_or_not, LV_ALIGN_CENTER, 0, 0);
+    }
+    else if (cloud_para.state == 0x12) {
+      lv_label_set_text(label_bind_or_not, cloud_menu.binded);
+      lv_obj_align(label_bind_or_not, button_bind_or_not, LV_ALIGN_CENTER, 0, 0);
+    }
+    else {
+      lv_label_set_text(label_bind_or_not, cloud_menu.disable);
+      lv_obj_align(label_bind_or_not, button_bind_or_not, LV_ALIGN_CENTER, 0, 0);
+    }
+  }
+
+  if (cloud_para.state == 0x12 && !unbinding_flag) {
+    lv_btn_set_style(buttonReleaseBind, LV_BTN_STYLE_REL, &style_para_back);
+    lv_btn_set_style(buttonReleaseBind, LV_BTN_STYLE_PR, &style_para_back);
+  }
+  else {
+    lv_btn_set_style(buttonReleaseBind, LV_BTN_STYLE_REL, &style_para_value);
+    lv_btn_set_style(buttonReleaseBind, LV_BTN_STYLE_PR, &style_para_value);
+  }
+}
+
+static char last_cloud_state = 0;
+void refresh_bind_ui() {
+  if ((last_cloud_state != cloud_para.state) || unbinding_flag) {
+    disp_bind_state();
+    last_cloud_state = cloud_para.state;
+  }
+  if (cloud_para.id[0]) {
+    if (!id_mark) {
+      display_qrcode((uint8_t *)cloud_para.id);
+      lv_label_set_text(text_id, (char *)cloud_para.id);
+    }
+  }
+  else
+    id_mark = 0;
+}
+
+void display_qrcode(uint8_t *qrcode_data) {
+  uint8_t i, j;
+  uint16_t x, y, p;
+
+  if (!id_mark) {
+    EncodeData((char *)qrcode_data);
+    id_mark = 1;
+  }
+
+  lv_fill_rect(10, QRCODE_Y, 300, QRCODE_Y + 300, LV_COLOR_WHITE);
+
+  if (m_nSymbleSize * 2 > QRCODE_WIDTH) return;
+
+  for (i = 0; i < 40; i++)
+    if ((m_nSymbleSize * i * 2) > QRCODE_WIDTH) break;
+
+  p = (i - 1) * 2;
+
+  x = QRCODE_X + 70;
+  y = QRCODE_Y + 70;
+
+  for (i = 0; i < m_nSymbleSize; i++)
+    for (j = 0; j < m_nSymbleSize; j++)
+      if (m_byModuleData[i][j] == 1)
+        lv_fill_rect(x + p * i, y + p * j, x + p * (i + 1) - 1, y + p * (j + 1) - 1, LV_COLOR_BACKGROUND);
+}
+
+void cloud_unbind() {
+  package_to_wifi(WIFI_CLOUD_UNBIND, (uint8_t *)0, 0);
+  unbinding_flag = 1;
+}
+
+void lv_clear_cloud_bind() {
+  #if BUTTONS_EXIST(EN1, EN2, ENC)
+    if (gCfgItems.encoder_enable)
+      lv_group_remove_all_objs(g);
+  #endif
+  lv_obj_del(scr);
+}
+
+#endif // HAS_TFT_LVGL_UI

Marlin/src/lcd/extui/lib/mks_ui/draw_cloud_bind.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * 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 3 of the License, 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.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" { /* C-declarations for C++ */
+#endif
+
+extern void lv_draw_cloud_bind(void);
+extern void lv_clear_cloud_bind();
+extern void disp_bind_state();
+extern void refresh_bind_ui();
+extern void display_qrcode(uint8_t *qrcode_data);
+extern void cloud_unbind();
+
+#ifdef __cplusplus
+} /* C-declarations for C++ */
+#endif

Marlin/src/lcd/extui/lib/mks_ui/draw_dialog.cpp

     clear_cur_ui();
     draw_return_ui();
   }
+  #if ENABLED(MKS_WIFI_MODULE)
+    else if (DIALOG_IS(TYPE_UNBIND)) {
+      cloud_unbind();
+      clear_cur_ui();
+      draw_return_ui();
+    }
+  #endif
+  else {
+    clear_cur_ui();
+    draw_return_ui();
+  }
 }
 
 static void btn_cancel_event_cb(lv_obj_t *btn, lv_event_t event) {
         lv_label_set_text(labelOk, print_file_dialog_menu.confirm);
       }
     }
+    else if (DIALOG_IS(TYPE_UPDATE_ESP_FIRMARE)) {
+      // nothing to do
+    }
   #endif
   else if (DIALOG_IS(TYPE_FILAMENT_LOAD_HEAT, TYPE_FILAMENT_UNLOAD_HEAT)) {
     btnCancel = lv_button_btn_create(scr, BTN_OK_X+90, BTN_OK_Y, 100, 50, btn_cancel_event_cb);
         lv_obj_align(labelDialog, nullptr, LV_ALIGN_CENTER, 0, -20);
       }
     }
+    else if (DIALOG_IS(TYPE_UPDATE_ESP_FIRMARE)) {
+      lv_label_set_text(labelDialog, DIALOG_UPDATE_WIFI_FIRMWARE_EN);
+      lv_obj_align(labelDialog, NULL, LV_ALIGN_CENTER, 0, -20);
+    }
   #endif // MKS_WIFI_MODULE
   else if (DIALOG_IS(TYPE_FILAMENT_LOAD_HEAT)) {
     lv_label_set_text(labelDialog, filament_menu.filament_dialog_load_heat);
     lv_label_set_text(labelDialog, filament_menu.filament_dialog_unloading);
     lv_obj_align(labelDialog, nullptr, LV_ALIGN_CENTER, 0, -70);
   }
+  #if ENABLED(MKS_WIFI_MODULE)
+    else if (DIALOG_IS(TYPE_UNBIND)) {
+      lv_label_set_text(labelDialog, common_menu.unbind_printer_tips);
+      lv_obj_align(labelDialog, NULL, LV_ALIGN_CENTER, 0, -70);
+    }
+  #endif
   #if HAS_ROTARY_ENCODER
     if (gCfgItems.encoder_enable) {
       if (btnOk) lv_group_add_obj(g, btnOk);

Marlin/src/lcd/extui/lib/mks_ui/draw_home.cpp

       queue.inject_P(PSTR("M84 X Y"));
       break;
     case ID_H_RETURN:
-      lv_clear_home();
-      lv_draw_tool();
+      clear_cur_ui();
+      draw_return_ui();
       break;
   }
 }

Marlin/src/lcd/extui/lib/mks_ui/draw_keyboard.cpp

     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     LV_KB_CTRL_BTN_FLAGS | 2, 2, 6, 2, LV_KB_CTRL_BTN_FLAGS | 2};
 
-static const char * kb_map_spec[] = {"0", "1", "2", "3", "4" ,"5", "6", "7", "8", "9", LV_SYMBOL_BACKSPACE, "\n",
+static const char * kb_map_spec[] = {"0", "1", "2", "3", "4" ,"5", "6", "7", "8", "9", ".", LV_SYMBOL_BACKSPACE, "\n",
                                      "abc", "+", "-", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n",
                                      "\\",  "@", "$", "(", ")", "{", "}", "[", "]", ";", "\"", "'", "\n",
                                      LV_SYMBOL_CLOSE, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""};
 
 static const lv_btnm_ctrl_t kb_ctrl_spec_map[] = {
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, LV_KB_CTRL_BTN_FLAGS | 2,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, LV_KB_CTRL_BTN_FLAGS | 2,
     LV_KB_CTRL_BTN_FLAGS | 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     LV_KB_CTRL_BTN_FLAGS | 2, 2, 6, 2, LV_KB_CTRL_BTN_FLAGS | 2};

Marlin/src/lcd/extui/lib/mks_ui/draw_more.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * 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 3 of the License, 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.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if HAS_TFT_LVGL_UI
+
+#include "../../../../MarlinCore.h"
+#include "draw_ready_print.h"
+#include "draw_set.h"
+#include "lv_conf.h"
+#include "draw_ui.h"
+#include "../../../../gcode/queue.h"
+
+extern lv_group_t * g;
+static lv_obj_t * scr;
+
+#define ID_CUSTOM_1   1
+#define ID_CUSTOM_2   2
+#define ID_CUSTOM_3   3
+#define ID_CUSTOM_4   4
+#define ID_CUSTOM_5   5
+#define ID_CUSTOM_6   6
+#define ID_CUSTOM_7   7
+#define ID_M_RETURN   8
+
+static void event_handler(lv_obj_t * obj, lv_event_t event) {
+  if (event != LV_EVENT_RELEASED) return;
+  switch (obj->mks_obj_id) {
+    #if ENABLED(USER_CMD_1_ENABLE)
+      case ID_CUSTOM_1:
+        queue.inject_P(PSTR(USER_GCODE_1));
+        break;
+    #endif
+    #if ENABLED(USER_CMD_2_ENABLE)
+      case ID_CUSTOM_2:
+        queue.inject_P(PSTR(USER_GCODE_2));
+        break;
+    #endif
+    #if ENABLED(USER_CMD_3_ENABLE)
+      case ID_CUSTOM_3:
+        queue.inject_P(PSTR(USER_GCODE_3));
+        break;
+    #endif
+    #if ENABLED(USER_CMD_4_ENABLE)
+      case ID_CUSTOM_4:
+        queue.inject_P(PSTR(USER_GCODE_4));
+        break;
+    #endif
+    #if ENABLED(USER_CMD_5_ENABLE)
+      case ID_CUSTOM_5:
+        queue.inject_P(PSTR(USER_GCODE_5));
+        break;
+    #endif
+    #if ENABLED(USER_CMD_6_ENABLE)
+      case ID_CUSTOM_6:
+        queue.inject_P(PSTR(USER_GCODE_6));
+        break;
+    #endif
+    #if ENABLED(USER_CMD_7_ENABLE)
+      case ID_CUSTOM_7:
+        queue.inject_P(PSTR(USER_GCODE_7));
+        break;
+    #endif
+    case ID_M_RETURN:
+      lv_clear_more();
+      lv_draw_tool();
+      break;
+  }
+}
+
+void lv_draw_more(void) {
+  scr = lv_screen_create(MORE_UI);
+
+  const bool enc_ena = TERN0(HAS_ROTARY_ENCODER, gCfgItems.encoder_enable);
+
+  #if ENABLED(USER_CMD_1_ENABLE)
+    lv_obj_t *buttonCustom1 = lv_imgbtn_create(scr, "F:/bmp_custom1.bin", INTERVAL_V, titleHeight, event_handler, ID_CUSTOM_1);
+    if (enc_ena) lv_group_add_obj(g, buttonCustom1);
+    lv_obj_t *labelCustom1 = lv_label_create_empty(buttonCustom1);
+  #endif
+
+  #if ENABLED(USER_CMD_2_ENABLE)
+    lv_obj_t *buttonCustom2 = lv_imgbtn_create(scr, "F:/bmp_custom2.bin", BTN_X_PIXEL + INTERVAL_V * 2, titleHeight, event_handler, ID_CUSTOM_2);
+    if (enc_ena) lv_group_add_obj(g, buttonCustom2);
+    lv_obj_t *labelCustom2 = lv_label_create_empty(buttonCustom2);
+  #endif
+
+  #if ENABLED(USER_CMD_3_ENABLE)
+    lv_obj_t *buttonCustom3 = lv_imgbtn_create(scr, "F:/bmp_custom3.bin", BTN_X_PIXEL * 2 + INTERVAL_V * 3, titleHeight, event_handler, ID_CUSTOM_3);
+    if (enc_ena) lv_group_add_obj(g, buttonCustom3);
+    lv_obj_t *labelCustom3 = lv_label_create_empty(buttonCustom3);
+  #endif
+
+  #if ENABLED(USER_CMD_4_ENABLE)
+    lv_obj_t *buttonCustom4 = lv_imgbtn_create(scr, "F:/bmp_custom4.bin", BTN_X_PIXEL * 3 + INTERVAL_V * 4, titleHeight, event_handler, ID_CUSTOM_4);
+    if (enc_ena) lv_group_add_obj(g, buttonCustom4);
+    lv_obj_t *labelCustom4 = lv_label_create_empty(buttonCustom4);
+  #endif
+
+  #if ENABLED(USER_CMD_5_ENABLE)
+    lv_obj_t *buttonCustom5 = lv_imgbtn_create(scr, "F:/bmp_custom5.bin", INTERVAL_V, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_CUSTOM_5);
+    if (enc_ena) lv_group_add_obj(g, buttonCustom5);
+    lv_obj_t *labelCustom5 = lv_label_create_empty(buttonCustom5);
+  #endif
+
+  #if ENABLED(USER_CMD_6_ENABLE)
+    lv_obj_t *buttonCustom6 = lv_imgbtn_create(scr, "F:/bmp_custom6.bin", BTN_X_PIXEL + INTERVAL_V * 2, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_CUSTOM_6);
+    if (enc_ena) lv_group_add_obj(g, buttonCustom6);
+    lv_obj_t *labelCustom6 = lv_label_create_empty(buttonCustom6);
+  #endif
+
+  #if ENABLED(USER_CMD_7_ENABLE)
+    blv_obj_t *uttonCustom7 = lv_imgbtn_create(scr, "F:/bmp_custom7.bin", BTN_X_PIXEL * 2 + INTERVAL_V * 3, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_CUSTOM_7);
+    if (enc_ena) lv_group_add_obj(g, buttonCustom7);
+    lv_obj_t *labelCustom7 = lv_label_create_empty(buttonCustom7);
+  #endif
+
+  lv_obj_t *buttonBack = lv_imgbtn_create(scr, "F:/bmp_return.bin", BTN_X_PIXEL * 3 + INTERVAL_V * 4, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_M_RETURN);
+  if (enc_ena) lv_group_add_obj(g, buttonBack);
+  lv_obj_t *label_Back = lv_label_create_empty(buttonBack);
+
+  if (gCfgItems.multiple_language != 0) {
+    #if ENABLED(USER_CMD_1_ENABLE)
+      lv_label_set_text(labelCustom1, more_menu.custom1);
+      lv_obj_align(labelCustom1, buttonCustom1, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+    #endif
+    #if ENABLED(USER_CMD_2_ENABLE)
+      lv_label_set_text(labelCustom2, more_menu.custom2);
+      lv_obj_align(labelCustom2, buttonCustom2, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+    #endif
+    #if ENABLED(USER_CMD_3_ENABLE)
+      lv_label_set_text(labelCustom3, more_menu.custom3);
+      lv_obj_align(labelCustom3, buttonCustom3, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+    #endif
+    #if ENABLED(USER_CMD_4_ENABLE)
+      lv_label_set_text(labelCustom4, more_menu.custom4);
+      lv_obj_align(labelCustom4, buttonCustom4, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+    #endif
+    #if ENABLED(USER_CMD_5_ENABLE)
+      lv_label_set_text(labelCustom5, more_menu.custom5);
+      lv_obj_align(labelCustom5, buttonCustom5, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+    #endif
+    #if ENABLED(USER_CMD_6_ENABLE)
+      lv_label_set_text(labelCustom6, more_menu.custom6);
+      lv_obj_align(labelCustom6, buttonCustom6, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+    #endif
+    #if ENABLED(USER_CMD_7_ENABLE)
+      lv_label_set_text(labelCustom7, more_menu.custom7);
+      lv_obj_align(labelCustom7, buttonCustom7, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+    #endif
+    lv_label_set_text(label_Back, common_menu.text_back);
+    lv_obj_align(label_Back, buttonBack, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+  }
+
+  #if BUTTONS_EXIST(EN1, EN2, ENC)
+    if (enc_ena) {
+      #if ENABLED(USER_CMD_1_ENABLE)
+        lv_group_add_obj(g, buttonCustom1);
+      #endif
+      #if ENABLED(USER_CMD_2_ENABLE)
+        lv_group_add_obj(g, buttonCustom2);
+      #endif
+      #if ENABLED(USER_CMD_3_ENABLE)
+        lv_group_add_obj(g, buttonCustom3);
+      #endif
+      #if ENABLED(USER_CMD_4_ENABLE)
+        lv_group_add_obj(g, buttonCustom4);
+      #endif
+      #if ENABLED(USER_CMD_5_ENABLE)
+        lv_group_add_obj(g, buttonCustom5);
+      #endif
+      #if ENABLED(USER_CMD_6_ENABLE)
+        lv_group_add_obj(g, buttonCustom6);
+      #endif
+      #if ENABLED(USER_CMD_7_ENABLE)
+        lv_group_add_obj(g, buttonCustom7);
+      #endif
+      lv_group_add_obj(g, buttonBack);
+    }
+  #endif
+}
+
+void lv_clear_more() {
+  #if BUTTONS_EXIST(EN1, EN2, ENC)
+    if (gCfgItems.encoder_enable) lv_group_remove_all_objs(g);
+  #endif
+  lv_obj_del(scr);
+}
+
+#endif // HAS_TFT_LVGL_UI

Marlin/src/lcd/extui/lib/mks_ui/draw_more.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * 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 3 of the License, 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.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" { /* C-declarations for C++ */
+#endif
+
+extern void lv_draw_more(void);
+extern void lv_clear_more();
+
+#ifdef __cplusplus
+} /* C-declarations for C++ */
+#endif

Marlin/src/lcd/extui/lib/mks_ui/draw_move_motor.cpp

 #include <lv_conf.h>
 
 #include "../../../../gcode/queue.h"
+#include "../../../../module/motion.h"
 #include "../../../../inc/MarlinConfig.h"
 
 extern lv_group_t *g;
 static lv_obj_t *scr;
 
-static lv_obj_t *labelV, *buttonV;
+static lv_obj_t *labelV, *buttonV, *labelP;
+static lv_task_t *updatePosTask;
+static char cur_label = 'Z'; 
+static float cur_pos = 0;
+
+void disp_cur_pos();
 
 enum {
   ID_M_X_P = 1,
 
 static void event_handler(lv_obj_t *obj, lv_event_t event) {
   if (event != LV_EVENT_RELEASED) return;
+  if (queue.length <= (BUFSIZE - 3)) {
+    float dist = uiCfg.move_dist;
+    switch (obj->mks_obj_id) {
+      case ID_M_X_N: dist *= -1; case ID_M_X_P: cur_label = 'X'; break;
+      case ID_M_Y_N: dist *= -1; case ID_M_Y_P: cur_label = 'Y'; break;
+      case ID_M_Z_N: dist *= -1; case ID_M_Z_P: cur_label = 'Z'; break;
+    }
+    sprintf_P(public_buf_l, PSTR("G91\nG1 %c%3.1f F%d\nG90"), cur_label, dist, uiCfg.moveSpeed);
+    queue.inject(public_buf_l);
+  }
+
   switch (obj->mks_obj_id) {
-    case ID_M_X_P:
-      if (queue.length <= (BUFSIZE - 3)) {
-        queue.enqueue_one_P(PSTR("G91"));
-        sprintf_P(public_buf_l, PSTR("G1 X%3.1f F%d"), uiCfg.move_dist, uiCfg.moveSpeed);
-        queue.enqueue_one_now(public_buf_l);
-        queue.enqueue_one_P(PSTR("G90"));
-      }
-      break;
-    case ID_M_X_N:
-      if (queue.length <= (BUFSIZE - 3)) {
-        queue.enqueue_now_P(PSTR("G91"));
-        sprintf_P(public_buf_l, PSTR("G1 X-%3.1f F%d"), uiCfg.move_dist, uiCfg.moveSpeed);
-        queue.enqueue_one_now(public_buf_l);
-        queue.enqueue_now_P(PSTR("G90"));
-      }
-      break;
-    case ID_M_Y_P:
-      if (queue.length <= (BUFSIZE - 3)) {
-        queue.enqueue_now_P(PSTR("G91"));
-        sprintf_P(public_buf_l, PSTR("G1 Y%3.1f F%d"), uiCfg.move_dist, uiCfg.moveSpeed);
-        queue.enqueue_one_now(public_buf_l);
-        queue.enqueue_now_P(PSTR("G90"));
-      }
-      break;
-    case ID_M_Y_N:
-      if (queue.length <= (BUFSIZE - 3)) {
-        queue.enqueue_now_P(PSTR("G91"));
-        sprintf_P(public_buf_l, PSTR("G1 Y-%3.1f F%d"), uiCfg.move_dist, uiCfg.moveSpeed);
-        queue.enqueue_one_now(public_buf_l);
-        queue.enqueue_now_P(PSTR("G90"));
-      }
-      break;
-    case ID_M_Z_P:
-      if (queue.length <= (BUFSIZE - 3)) {
-        queue.enqueue_now_P(PSTR("G91"));
-        sprintf_P(public_buf_l, PSTR("G1 Z%3.1f F%d"), uiCfg.move_dist, uiCfg.moveSpeed);
-        queue.enqueue_one_now(public_buf_l);
-        queue.enqueue_now_P(PSTR("G90"));
-      }
-      break;
-    case ID_M_Z_N:
-      if (queue.length <= (BUFSIZE - 3)) {
-        queue.enqueue_now_P(PSTR("G91"));
-        sprintf_P(public_buf_l, PSTR("G1 Z-%3.1f F%d"), uiCfg.move_dist, uiCfg.moveSpeed);
-        queue.enqueue_one_now(public_buf_l);
-        queue.enqueue_now_P(PSTR("G90"));
-      }
-      break;
     case ID_M_STEP:
       if (abs(10 * (int)uiCfg.move_dist) == 100)
         uiCfg.move_dist = 0.1;
       else
-        uiCfg.move_dist *= (float)10;
+        uiCfg.move_dist *= 10.0f;
       disp_move_dist();
       break;
     case ID_M_RETURN:
       clear_cur_ui();
       draw_return_ui();
-      break;
+      return;
   }
+  disp_cur_pos();
+}
+
+void refresh_pos(lv_task_t *) {
+  switch (cur_label) {
+    case 'X': cur_pos = current_position.x; break;
+    case 'Y': cur_pos = current_position.y; break;
+    case 'Z': cur_pos = current_position.z; break;
+    default: return;
+  }
+  disp_cur_pos();
 }
 
 void lv_draw_move_motor(void) {
   buttonV = lv_imgbtn_create(scr, nullptr, BTN_X_PIXEL * 3 + INTERVAL_V * 4, titleHeight, event_handler, ID_M_STEP);
   labelV = lv_label_create_empty(buttonV);
   #if HAS_ROTARY_ENCODER
-    if (gCfgItems.encoder_enable) {
-      lv_group_add_obj(g, buttonV);
-    }
+    if (gCfgItems.encoder_enable) lv_group_add_obj(g, buttonV);
   #endif
 
   lv_big_button_create(scr, "F:/bmp_return.bin", common_menu.text_back, BTN_X_PIXEL * 3 + INTERVAL_V * 4, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_M_RETURN);
 
+  // We need to patch the title to leave some space on the right for displaying the status
+  lv_obj_t * title = lv_obj_get_child_back(scr, NULL);
+  if (title != NULL) lv_obj_set_width(title, TFT_WIDTH - 101);
+  labelP = lv_label_create(scr, TFT_WIDTH - 100, TITLE_YPOS, "Z:0.0mm");
+  if (labelP != NULL)
+    updatePosTask = lv_task_create(refresh_pos, 300, LV_TASK_PRIO_LOWEST, 0);
+
   disp_move_dist();
+  disp_cur_pos();
 }
 
-void disp_move_dist() {
-  // char buf[30] = {0};
+void disp_cur_pos() {
+  sprintf_P(public_buf_l, PSTR("%c:%3.1fmm"), cur_label, cur_pos);
+  if (labelP) lv_label_set_text(labelP, public_buf_l);
+}
 
+void disp_move_dist() {
   if ((int)(10 * uiCfg.move_dist) == 1)
     lv_imgbtn_set_src_both(buttonV, "F:/bmp_step_move0_1.bin");
   else if ((int)(10 * uiCfg.move_dist) == 10)
   #if HAS_ROTARY_ENCODER
     if (gCfgItems.encoder_enable) lv_group_remove_all_objs(g);
   #endif
+  lv_task_del(updatePosTask);
   lv_obj_del(scr);
 }
 

Marlin/src/lcd/extui/lib/mks_ui/draw_ui.cpp

   gCfgItems.levelingPos[3][1] = Y_MAX_POS - 30;
   gCfgItems.levelingPos[4][0] = X_BED_SIZE / 2;
   gCfgItems.levelingPos[4][1] = Y_BED_SIZE / 2;
-  gCfgItems.cloud_enable  = true;
-  #if ENABLED(MKS_WIFI_MODULE)
-    gCfgItems.wifi_mode_sel = STA_MODEL;
-    gCfgItems.fileSysType   = FILE_SYS_SD;
-    gCfgItems.wifi_type     = ESP_WIFI;
-  #endif
+  gCfgItems.cloud_enable      = false;
+  gCfgItems.wifi_mode_sel = STA_MODEL;
+  gCfgItems.fileSysType   = FILE_SYS_SD;
+  gCfgItems.wifi_type     = ESP_WIFI;
   gCfgItems.filamentchange_load_length   = 200;
   gCfgItems.filamentchange_load_speed    = 1000;
   gCfgItems.filamentchange_unload_length = 200;
 
 char *getDispText(int index) {
 
+  ZERO(public_buf_l);
 
   switch (disp_state_stack._disp_state[index]) {
     case PRINT_READY_UI:
 
   if (strlen(public_buf_m) > MAX_TITLE_LEN) {
     ZERO(public_buf_m);
-    tmpText = getDispText(0);
+    tmpText = 0;
+    for (index = 0; index <= disp_state_stack._disp_index && (!tmpText || *tmpText == 0); index++)
+      tmpText = getDispText(index);
     if (*tmpText != 0) {
       titleText_cat(public_buf_m, sizeof(public_buf_m), tmpText);
       titleText_cat(public_buf_m, sizeof(public_buf_m), (char *)">...>");
     #endif
   }
 
-  #if 1
-
-    void gcode_preview(char *path, int xpos_pixel, int ypos_pixel) {
-      #if ENABLED(SDSUPPORT)
-        //uint8_t ress;
-        //uint32_t write;
-        volatile uint32_t i, j;
-        volatile uint16_t *p_index;
-        //int res;
-        char *cur_name;
-
-        cur_name = strrchr(path, '/');
-        card.openFileRead(cur_name);
-
-        if (gPicturePreviewStart <= 0) {
-          while (1) {
-            uint32_t br  = card.read(public_buf, 400);
-            uint32_t* p1 = (uint32_t *)strstr((char *)public_buf, ";gimage:");
-            if (p1) {
-              gPicturePreviewStart += (uint32_t)p1 - (uint32_t)((uint32_t *)(&public_buf[0]));
-              break;
-            }
-            else {
-              gPicturePreviewStart += br;
-            }
-            if (br < 400) break;
-          }
-        }
-
-        card.setIndex((gPicturePreviewStart + To_pre_view) + size * row + 8);
-        SPI_TFT.setWindow(xpos_pixel, ypos_pixel + row, 200, 1);
+  void gcode_preview(char *path, int xpos_pixel, int ypos_pixel) {
+    #if ENABLED(SDSUPPORT)
+      volatile uint32_t i, j;
+      volatile uint16_t *p_index;
+      char *cur_name;
 
-        j = i = 0;
+      cur_name = strrchr(path, '/');
+      card.openFileRead(cur_name);
 
+      if (gPicturePreviewStart <= 0) {
         while (1) {
-          card.read(public_buf, 400);
-          for (i = 0; i < 400;) {
-            bmp_public_buf[j] = ascii2dec_test((char*)&public_buf[i]) << 4 | ascii2dec_test((char*)&public_buf[i + 1]);
-            i                += 2;
-            j++;
-          }
-          if (j >= 400) break;
-        }
-        for (i = 0; i < 400; i += 2) {
-          p_index  = (uint16_t *)(&bmp_public_buf[i]);
-          if (*p_index == 0x0000) *p_index = LV_COLOR_BACKGROUND.full;
-        }
-        SPI_TFT.tftio.WriteSequence((uint16_t*)bmp_public_buf, 200);
-        #if HAS_BAK_VIEW_IN_FLASH
-          W25QXX.init(SPI_QUARTER_SPEED);
-          if (row < 20) W25QXX.SPI_FLASH_SectorErase(BAK_VIEW_ADDR_TFT35 + row * 4096);
-          W25QXX.SPI_FLASH_BufferWrite(bmp_public_buf, BAK_VIEW_ADDR_TFT35 + row * 400, 400);
-        #endif
-        row++;
-        if (row >= 200) {
-          size = 809;
-          row  = 0;
-
-          gcode_preview_over = false;
-          //flash_preview_begin = true;
-
-          card.closefile();
-
-          /*
-          if (gCurFileState.file_open_flag != 0xAA) {
-            reset_file_info();
-            res = f_open(file, curFileName, FA_OPEN_EXISTING | FA_READ);
-            if (res == FR_OK) {
-              f_lseek(file,PREVIEW_SIZE+To_pre_view);
-              gCurFileState.file_open_flag = 0xAA;
-              //bakup_file_path((uint8_t *)curFileName, strlen(curFileName));
-              srcfp = file;
-              mksReprint.mks_printer_state = MKS_WORKING;
-              once_flag = false;
-            }
-          }
-          */
-          char *cur_name;
-
-          cur_name = strrchr(list_file.file_name[sel_id], '/');
-
-          SdFile file;
-          SdFile *curDir;
-          card.endFilePrint();
-          const char * const fname = card.diveToFile(true, curDir, cur_name);
-          if (!fname) return;
-          if (file.open(curDir, fname, O_READ)) {
-            gCfgItems.curFilesize = file.fileSize();
-            file.close();
-            update_spi_flash();
+          uint32_t br  = card.read(public_buf, 400);
+          uint32_t* p1 = (uint32_t *)strstr((char *)public_buf, ";gimage:");
+          if (p1) {
+            gPicturePreviewStart += (uint32_t)p1 - (uint32_t)((uint32_t *)(&public_buf[0]));
+            break;
           }
-
-          card.openFileRead(cur_name);
-          if (card.isFileOpen()) {
-            feedrate_percentage = 100;
-            //saved_feedrate_percentage = feedrate_percentage;
-            planner.flow_percentage[0] = 100;
-            planner.e_factor[0]        = planner.flow_percentage[0] * 0.01;
-            #if HAS_MULTI_EXTRUDER
-              planner.flow_percentage[1] = 100;
-              planner.e_factor[1]        = planner.flow_percentage[1] * 0.01;
-            #endif
-            card.startFileprint();
-            TERN_(POWER_LOSS_RECOVERY, recovery.prepare());
-            once_flag = false;
+          else {
+            gPicturePreviewStart += br;
           }
-          return;
+          if (br < 400) break;
         }
-        card.closefile();
-      #endif // SDSUPPORT
-    }
-
-  #else // if 1
-
-    void gcode_preview(char *path, int xpos_pixel, int ypos_pixel) {
-      #if ENABLED(SDSUPPORT)
-        //uint8_t ress;
-        //uint32_t write;
-        volatile uint32_t i, j;
-        volatile uint16_t *p_index;
-        //int res;
-        char *cur_name;
-        uint16_t Color;
-
-        cur_name = strrchr(path, '/');
-        card.openFileRead(cur_name);
-
-        card.setIndex((PREVIEW_LITTLE_PIC_SIZE + To_pre_view) + size * row + 8);
-        #if HAS_TFT_LVGL_UI_SPI
-          SPI_TFT.setWindow(xpos_pixel, ypos_pixel + row, 200, 1);
-        #else
-          LCD_setWindowArea(xpos_pixel, ypos_pixel + row, 200, 1);
-          LCD_WriteRAM_Prepare();
-        #endif
-
-        j = 0;
-        i = 0;
+      }
 
-        while (1) {
-          card.read(public_buf, 400);
-          for (i = 0; i < 400;) {
-            bmp_public_buf[j] = ascii2dec_test((char*)&public_buf[i]) << 4 | ascii2dec_test((char*)&public_buf[i + 1]);
-            i += 2;
-            j++;
-          }
+      card.setIndex(gPicturePreviewStart + size * row + 8);
+      SPI_TFT.setWindow(xpos_pixel, ypos_pixel + row, 200, 1);
 
-          //if (i > 800) break;
-          //#ifdef TFT70
-          //  if (j > 400) {
-          //    f_read(file, buff_pic, 1, &read);
-          //    break;
-          //  }
-          //#elif defined(TFT35)
-          if (j >= 400)
-            //f_read(file, buff_pic, 1, &read);
-            break;
-          //#endif
+      j = i = 0;
 
+      while (1) {
+        card.read(public_buf, 400);
+        for (i = 0; i < 400;) {
+          bmp_public_buf[j] = ascii2dec_test((char*)&public_buf[i]) << 4 | ascii2dec_test((char*)&public_buf[i + 1]);
+          i                += 2;
+          j++;
         }
-        #if HAS_TFT_LVGL_UI_SPI
-          for (i = 0; i < 400;) {
-            p_index = (uint16_t *)(&bmp_public_buf[i]);
-
-            Color    = (*p_index >> 8);
-            *p_index = Color | ((*p_index & 0xFF) << 8);
-            i       += 2;
-            if (*p_index == 0x0000) *p_index = 0xC318;
-          }
-          TFT_CS_L;
-          TFT_DC_H;
-          SPI.dmaSend(bmp_public_buf, 400, true);
-          TFT_CS_H;
-
-        #else
-          for (i = 0; i < 400;) {
-            p_index = (uint16_t *)(&bmp_public_buf[i]);
-            if (*p_index == 0x0000) *p_index = 0x18C3;
-            LCD_IO_WriteData(*p_index);
-            i = i + 2;
-          }
-        #endif
+        if (j >= 400) break;
+      }
+      for (i = 0; i < 400; i += 2) {
+        p_index  = (uint16_t *)(&bmp_public_buf[i]);
+        if (*p_index == 0x0000) *p_index = LV_COLOR_BACKGROUND.full;
+      }
+      SPI_TFT.tftio.WriteSequence((uint16_t*)bmp_public_buf, 200);
+      #if HAS_BAK_VIEW_IN_FLASH
         W25QXX.init(SPI_QUARTER_SPEED);
-        if (row < 20)
-          W25QXX.SPI_FLASH_SectorErase(BAK_VIEW_ADDR_TFT35 + row * 4096);
+        if (row < 20) W25QXX.SPI_FLASH_SectorErase(BAK_VIEW_ADDR_TFT35 + row * 4096);
         W25QXX.SPI_FLASH_BufferWrite(bmp_public_buf, BAK_VIEW_ADDR_TFT35 + row * 400, 400);
-        row++;
-        if (row >= 200) {
-          size = 809;
-          row  = 0;
-
-          gcode_preview_over = false;
-          //flash_preview_begin = true;
-
-          card.closefile();
-
-          /*
-          if (gCurFileState.file_open_flag != 0xAA) {
-            reset_file_info();
-            res = f_open(file, curFileName, FA_OPEN_EXISTING | FA_READ);
-            if (res == FR_OK) {
-              f_lseek(file,PREVIEW_SIZE+To_pre_view);
-              gCurFileState.file_open_flag = 0xAA;
-              //bakup_file_path((uint8_t *)curFileName, strlen(curFileName));
-              srcfp = file;
-              mksReprint.mks_printer_state = MKS_WORKING;
-              once_flag = false;
-            }
-          }
-          */
-          char *cur_name;
-
-          cur_name = strrchr(list_file.file_name[sel_id], '/');
-
-          SdFile file;
-          SdFile *curDir;
-          card.endFilePrint();
-          const char * const fname = card.diveToFile(true, curDir, cur_name);
-          if (!fname) return;
-          if (file.open(curDir, fname, O_READ)) {
-            gCfgItems.curFilesize = file.fileSize();
-            file.close();
-            update_spi_flash();
-          }
+      #endif
+      row++;
+      if (row >= 200) {
+        size = 809;
+        row  = 0;
+
+        gcode_preview_over = false;
 
-          card.openFileRead(cur_name);
-          if (card.isFileOpen()) {
-            feedrate_percentage = 100;
-            //saved_feedrate_percentage = feedrate_percentage;
-            planner.flow_percentage[0] = 100;
-            planner.e_factor[0]        = planner.flow_percentage[0] * 0.01;
-            #if HAS_MULTI_EXTRUDER
-              planner.flow_percentage[1] = 100;
-              planner.e_factor[1]        = planner.flow_percentage[1] * 0.01;
-            #endif
-            card.startFileprint();
-            TERN_(POWER_LOSS_RECOVERY, recovery.prepare());
-            once_flag = false;
-          }
-          return;
-        }
         card.closefile();
-      #endif // SDSUPPORT
-    }
+        char *cur_name;
 
-  #endif // if 1
+        cur_name = strrchr(list_file.file_name[sel_id], '/');
+
+        SdFile file;
+        SdFile *curDir;
+        card.endFilePrint();
+        const char * const fname = card.diveToFile(true, curDir, cur_name);
+        if (!fname) return;
+        if (file.open(curDir, fname, O_READ)) {
+          gCfgItems.curFilesize = file.fileSize();
+          file.close();
+          update_spi_flash();
+        }
 
-  void Draw_default_preview(int xpos_pixel, int ypos_pixel, uint8_t sel) {
+        card.openFileRead(cur_name);
+        if (card.isFileOpen()) {
+          feedrate_percentage = 100;
+          planner.flow_percentage[0] = 100;
+          planner.e_factor[0]        = planner.flow_percentage[0] * 0.01;
+          #if HAS_MULTI_EXTRUDER
+            planner.flow_percentage[1] = 100;
+            planner.e_factor[1]        = planner.flow_percentage[1] * 0.01;
+          #endif
+          card.startFileprint();
+          TERN_(POWER_LOSS_RECOVERY, recovery.prepare());
+          once_flag = false;
+        }
+        return;
+      }
+      card.closefile();
+    #endif // SDSUPPORT
+  }
+
+  void draw_default_preview(int xpos_pixel, int ypos_pixel, uint8_t sel) {
     int index;
     int y_off = 0;
     W25QXX.init(SPI_QUARTER_SPEED);
     #if HAS_BAK_VIEW_IN_FLASH
       if (flash_preview_begin) {
         flash_preview_begin = false;
-        Draw_default_preview(xpos_pixel, ypos_pixel, 1);
+        draw_default_preview(xpos_pixel, ypos_pixel, 1);
       }
     #endif
     #if HAS_GCODE_DEFAULT_VIEW_IN_FLASH
       if (default_preview_flg) {
-        Draw_default_preview(xpos_pixel, ypos_pixel, 0);
+        draw_default_preview(xpos_pixel, ypos_pixel, 0);
         default_preview_flg = false;
       }
     #endif
           temps_update_flag = false;
         }
         break;
-    #endif
-
-    case BIND_UI:
-      /*refresh_bind_ui();*/
-      break;
 
+      case BIND_UI:
+        refresh_bind_ui();
+        break;
+    #endif
     case FILAMENTCHANGE_UI:
       if (temps_update_flag) {
         temps_update_flag = false;
   last_disp_state = disp_state_stack._disp_state[disp_state_stack._disp_index];
 
   switch (disp_state_stack._disp_state[disp_state_stack._disp_index]) {
-    case PRINT_READY_UI:
-                                      lv_clear_ready_print(); break;
+    case PRINT_READY_UI:              lv_clear_ready_print(); break;
     case PRINT_FILE_UI:               lv_clear_print_file(); break;
     case PRINTING_UI:                 lv_clear_printing(); break;
     case MOVE_MOTOR_UI:               lv_clear_move_motor(); break;
     #if ENABLED(MKS_WIFI_MODULE)
       case WIFI_UI:                   lv_clear_wifi(); break;
     #endif
-    case MORE_UI:                     /* Clear_more(); */ break;
+    case MORE_UI:                     lv_clear_more(); break;
     case FILETRANSFER_UI:             break;
     case DIALOG_UI:                   lv_clear_dialog(); break;
     case FILETRANSFERSTATE_UI:        break;
     case PRINT_MORE_UI:               break;
     case FILAMENTCHANGE_UI:           lv_clear_filament_change(); break;
     case LEVELING_UI:                 lv_clear_manualLevel(); break;
-    case BIND_UI:                     /* Clear_Bind(); */ break;
+    #if ENABLED(MKS_WIFI_MODULE)
+      case BIND_UI:                   lv_clear_cloud_bind(); break;
+    #endif
     #if HAS_BED_PROBE
       case NOZZLE_PROBE_OFFSET_UI:    lv_clear_auto_level_offset_settings(); break;
     #endif
       #if ENABLED(MKS_WIFI_MODULE)
         case WIFI_UI:                   lv_draw_wifi(); break;
       #endif
-      case PRINT_MORE_UI:               /* draw_printmore(); */ break;
       case MORE_UI:                     break;
+      case PRINT_MORE_UI:               lv_draw_more(); break;
       case FILAMENTCHANGE_UI:           lv_draw_filament_change(); break;
       case LEVELING_UI:                 lv_draw_manualLevel(); break;
-      case BIND_UI:                     /* draw_bind(); */ break;
+      #if ENABLED(MKS_WIFI_MODULE)
+        case BIND_UI:                   lv_draw_cloud_bind(); break;
+      #endif
       #if HAS_BED_PROBE
         case NOZZLE_PROBE_OFFSET_UI:    lv_draw_auto_level_offset_settings(); break;
       #endif

Marlin/src/lcd/extui/lib/mks_ui/draw_ui.h

 #include "draw_preHeat.h"
 #include "draw_extrusion.h"
 #include "draw_home.h"
+#include "draw_more.h"
 #include "draw_move_motor.h"
 #include "draw_fan.h"
 #include "draw_about.h"
 #include "draw_keyboard.h"
 #include "draw_encoder_settings.h"
 
+#include "../../inc/MarlinConfigPre.h"
+
 #if ENABLED(MKS_WIFI_MODULE)
   #include "wifiSerial.h"
   #include "wifi_module.h"
   #include "draw_wifi.h"
   #include "draw_wifi_list.h"
   #include "draw_wifi_tips.h"
+  #include "draw_cloud_bind.h"
 #endif
 
-#include "../../../../inc/MarlinConfigPre.h"
-#define FILE_SYS_USB  0
-#define FILE_SYS_SD 1
+#define ESP_WIFI          0x02
+#define AP_MODEL          0x01
+#define STA_MODEL         0x02
+
+#define FILE_SYS_USB      0
+#define FILE_SYS_SD       1
 
 #define TICK_CYCLE 1
 
   #define PARA_UI_BACK_BTN_X_SIZE   70
   #define PARA_UI_BACK_BTN_Y_SIZE   40
 
+  #define QRCODE_X                  20
+  #define QRCODE_Y                  40
+  #define QRCODE_WIDTH              160
+
 #else // ifdef TFT35
 
   #define TFT_WIDTH     320
   float desireSprayerTempBak;
   float current_x_position_bak;
   float current_y_position_bak;
+  float current_z_position_bak;
   float current_e_position_bak;
 } UI_CFG;
 

Marlin/src/lcd/extui/lib/mks_ui/draw_wifi.cpp

 
 static void event_handler(lv_obj_t *obj, lv_event_t event) {
   if (event != LV_EVENT_RELEASED) return;
+  clear_cur_ui();
   switch (obj->mks_obj_id) {
     case ID_W_RETURN:
-      clear_cur_ui();
       lv_draw_set();
       break;
     case ID_W_CLOUD:
-      //clear_cur_ui();
-      //draw_return_ui();
-      break;
-    case ID_W_RECONNECT:
-      clear_cur_ui();
-      lv_draw_wifi_list();
+      lv_draw_cloud_bind();
       break;
+    #if ENABLED(MKS_WIFI_MODULE)
+      case ID_W_RECONNECT: {
+        uint8_t cmd_wifi_list[] = { 0xA5, 0x07, 0x00, 0x00, 0xFC };
+        raw_send_to_wifi(cmd_wifi_list, COUNT(cmd_wifi_list));
+        lv_draw_wifi_list();
+      } break;
+    #endif
   }
 }
 
 void lv_draw_wifi(void) {
   scr = lv_screen_create(WIFI_UI);
 
-  // Create an Image button
-  lv_obj_t *buttonBack = lv_imgbtn_create(scr, "F:/bmp_return.bin", BTN_X_PIXEL * 3 + INTERVAL_V * 4, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_W_RETURN);
-  #if HAS_ROTARY_ENCODER
-    if (gCfgItems.encoder_enable) lv_group_add_obj(g, buttonBack);
-  #endif
-  lv_obj_t *label_Back = lv_label_create_empty(buttonBack);
-
   lv_obj_t *buttonReconnect = nullptr, *label_Reconnect = nullptr;
+  lv_obj_t *buttonCloud = nullptr, *label_Cloud = nullptr;
+
+  const bool enc_ena = TERN0(HAS_ROTARY_ENCODER, gCfgItems.encoder_enable);
 
   if (gCfgItems.wifi_mode_sel == STA_MODEL) {
 
-    buttonReconnect = lv_imgbtn_create(scr, nullptr);
+    if (gCfgItems.cloud_enable)
+      buttonCloud = lv_imgbtn_create(scr, "F:/bmp_cloud.bin", BTN_X_PIXEL+INTERVAL_V*2, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_W_CLOUD);
 
-    lv_obj_set_event_cb_mks(buttonReconnect, event_handler, ID_W_RECONNECT, "", 0);
-    lv_imgbtn_set_src_both(buttonReconnect, "F:/bmp_wifi.bin");
-    lv_imgbtn_use_label_style(buttonReconnect);
+    buttonReconnect = lv_imgbtn_create(scr, "F:/bmp_wifi.bin", BTN_X_PIXEL * 2 + INTERVAL_V * 3, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_W_RECONNECT);
 
     #if HAS_ROTARY_ENCODER
-      if (gCfgItems.encoder_enable) lv_group_add_obj(g, buttonReconnect);
+      if (gCfgItems.cloud_enable) lv_group_add_obj(g, buttonCloud);
+      if (enc_ena) lv_group_add_obj(g, buttonReconnect);
     #endif
 
-    lv_obj_set_pos(buttonReconnect, BTN_X_PIXEL * 2 + INTERVAL_V * 3, BTN_Y_PIXEL + INTERVAL_H + titleHeight);
-    lv_btn_set_layout(buttonReconnect, LV_LAYOUT_OFF);
-
     label_Reconnect = lv_label_create_empty(buttonReconnect);
+    if (gCfgItems.cloud_enable) label_Cloud = lv_label_create_empty(buttonCloud);
   }
 
-  if (gCfgItems.multiple_language) {
-    lv_label_set_text(label_Back, common_menu.text_back);
-    lv_obj_align(label_Back, buttonBack, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+  // Create an Image button
+  lv_obj_t *buttonBack = lv_imgbtn_create(scr, "F:/bmp_return.bin", BTN_X_PIXEL * 3 + INTERVAL_V * 4, BTN_Y_PIXEL + INTERVAL_H + titleHeight, event_handler, ID_W_RETURN);
+  if (enc_ena) lv_group_add_obj(g, buttonBack);
+  lv_obj_t *label_Back = lv_label_create_empty(buttonBack);
 
+  if (gCfgItems.multiple_language) {
     if (gCfgItems.wifi_mode_sel == STA_MODEL) {
+      if (gCfgItems.cloud_enable) {
+        lv_label_set_text(label_Cloud, wifi_menu.cloud);
+        lv_obj_align(label_Cloud, buttonCloud, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
+      }
       lv_label_set_text(label_Reconnect, wifi_menu.reconnect);
       lv_obj_align(label_Reconnect, buttonReconnect, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
     }
+    lv_label_set_text(label_Back, common_menu.text_back);
+    lv_obj_align(label_Back, buttonBack, LV_ALIGN_IN_BOTTOM_MID, 0, BUTTON_TEXT_Y_OFFSET);
   }
 
   wifi_ip_text = lv_label_create_empty(scr);

Marlin/src/lcd/extui/lib/mks_ui/irq_overrid.cpp

 #define WIFI_IO1_RESET()  WRITE(WIFI_IO1_PIN, LOW);
 
 void __irq_usart1(void) {
-  WIFISERIAL.wifi_usart_irq(USART1_BASE);
-  if (wifi_link_state == WIFI_TRANS_FILE) {
-    if (WIFISERIAL.available() == (400)) WIFI_IO1_SET();
-    if (WIFISERIAL.wifi_rb_is_full()) {
-      if (esp_state == TRANSFER_IDLE) esp_state = TRANSFERING;
-      if (storeRcvData(UART_RX_BUFFER_SIZE)) {
-        if (wifiTransError.flag != 0x1) WIFI_IO1_RESET();
-      }
-      else {
-        WIFI_IO1_SET();
-        esp_state = TRANSFER_STORE;
-      }
-    }
-  }
+   if ((USART1_BASE->CR1 & USART_CR1_RXNEIE) && (USART1_BASE->SR & USART_SR_RXNE))
+     WRITE(WIFI_IO1_PIN, HIGH);
+
+   WIFISERIAL.wifi_usart_irq(USART1_BASE);
 }
 
 #ifdef __cplusplus

Marlin/src/lcd/extui/lib/mks_ui/pic_manager.cpp

 #endif
 
 static const char assets[][LONG_FILENAME_LENGTH] = {
-  //homing screen
+  // Homing screen
   "bmp_zeroAll.bin",
   "bmp_zero.bin",
   "bmp_zeroX.bin",
   "bmp_zeroZ.bin",
   "bmp_manual_off.bin",
 
-  //tool screen
+  // Tool screen
   "bmp_preHeat.bin",
   "bmp_extruct.bin",
   "bmp_mov.bin",
   "bmp_leveling.bin",
   "bmp_filamentchange.bin",
+  "bmp_more.bin",
 
-  //fan screen
+  // Fan screen
   "bmp_Add.bin",
   "bmp_Dec.bin",
   "bmp_speed255.bin",
   "bmp_step5_degree.bin",
   "bmp_step10_degree.bin",
 
-  //extrusion screen
+  // Extrusion screen
   "bmp_in.bin",
   "bmp_out.bin",
   "bmp_extru1.bin",
   "bmp_step5_mm.bin",
   "bmp_step10_mm.bin",
 
-  //select file screen
+  // Select file screen
   "bmp_pageUp.bin",
   "bmp_pageDown.bin",
   "bmp_back.bin", //TODO: why two back buttons? Why not just one? (return / back)
   "bmp_dir.bin",
   "bmp_file.bin",
 
-  //move motor screen
-  //TODO: 6 equal icons, just in diffenct rotation... it may be optimized too
+  // Move motor screen
+  // TODO: 6 equal icons, just in diffenct rotation... it may be optimized too
   "bmp_xAdd.bin",
   "bmp_xDec.bin",
   "bmp_yAdd.bin",
   "bmp_step_move1.bin",
   "bmp_step_move10.bin",
 
-  //operation screen
+  // Operation screen
   "bmp_auto_off.bin",
   "bmp_speed.bin",
   "bmp_fan.bin",
   "bmp_extrude_opr.bin",
   "bmp_move_opr.bin",
 
-  //change speed screen
+  // Change speed screen
   "bmp_step1_percent.bin",
   "bmp_step5_percent.bin",
   "bmp_step10_percent.bin",
   "bmp_mov_sel.bin",
   "bmp_speed_extruct.bin",
 
-  //printing screen
+  // Printing screen
   "bmp_pause.bin",
   "bmp_resume.bin",
   "bmp_stop.bin",
   "bmp_zpos_state.bin",
   "bmp_operate.bin",
 
-  //manual leval screen (only if disabled auto level)
+  // Manual Level screen (only if auto level is disabled)
   #if DISABLED(AUTO_BED_LEVELING_BILINEAR)
     "bmp_leveling1.bin",
     "bmp_leveling2.bin",
     "bmp_leveling5.bin",
   #endif
 
-  //lang select screen
+  // Language Select screen
   #if HAS_LANG_SELECT_SCREEN
     "bmp_language.bin",
     "bmp_simplified_cn.bin",
     "bmp_italy_sel.bin",
   #endif // HAS_LANG_SELECT_SCREEN
 
-  // gcode preview
+  // G-code preview
   #if HAS_GCODE_DEFAULT_VIEW_IN_FLASH
     "bmp_preview.bin",
   #endif
     "bmp_logo.bin",
   #endif
 
-  // settings screen
+  // Settings screen
   "bmp_about.bin",
+  "bmp_eeprom_settings.bin",
+  "bmp_machine_para.bin",
+  "bmp_function1.bin",
 
-  //start screen
+  // Start screen
   "bmp_printing.bin",
   "bmp_set.bin",
   "bmp_tool.bin",
 
-  // settings screen
-  "bmp_eeprom_settings.bin",
-  "bmp_machine_para.bin",
-  "bmp_function1.bin",
-
-  // base icons
+  // Base icons
   "bmp_arrow.bin",
   "bmp_back70x40.bin",
   "bmp_value_blank.bin",
   "bmp_return.bin",
 
   #if ENABLED(MKS_WIFI_MODULE)
-    // wifi screen
+    // Wifi screen
     "bmp_wifi.bin",
+    "bmp_cloud.bin",
   #endif
 
-  // babystep screen
+  // Babystep screen
   "bmp_baby_move0_01.bin",
   "bmp_baby_move0_05.bin",
-  "bmp_baby_move0_1.bin"
+  "bmp_baby_move0_1.bin",
+
+  // More screen
+  "bmp_custom1.bin",
+  "bmp_custom2.bin",
+  "bmp_custom3.bin",
+  "bmp_custom4.bin",
+  "bmp_custom5.bin",
+  "bmp_custom6.bin",
+  "bmp_custom7.bin"
 };
 
 #if HAS_SPI_FLASH_FONT
     } while (PIC.name[j++] != '\0');
 
     if ((strcasecmp((char*)Pname, (char*)PIC.name)) == 0) {
-      if ((DeviceCode == 0x9488) || (DeviceCode == 0x5761))
+      if (DeviceCode == 0x9488 || DeviceCode == 0x5761)
         addr = PIC_DATA_ADDR_TFT35 + i * PER_PIC_MAX_SPACE_TFT35;
       else
         addr = PIC_DATA_ADDR_TFT32 + i * PER_PIC_MAX_SPACE_TFT32;
       return addr;
     }
   }
-
   return addr;
 }
 

Marlin/src/lcd/extui/lib/mks_ui/pic_manager.h

 
 // SD card information first addr
 #define VAR_INF_ADDR                    0x000000
-#define FLASH_INF_VALID_FLAG            0x20200831
+#define FLASH_INF_VALID_FLAG            0x20201118
 
 //Store some gcode commands, such as auto leveling commands
 #define GCODE_COMMAND_ADDR              VAR_INF_ADDR + 3*1024

Marlin/src/lcd/extui/lib/mks_ui/printer_operation.cpp

 #include "../../../../sd/cardreader.h"
 #include "../../../../inc/MarlinConfig.h"
 #include "../../../../MarlinCore.h"
+#include "../../../../gcode/queue.h"
 
 #if ENABLED(POWER_LOSS_RECOVERY)
   #include "../../../../feature/powerloss.h"
         //save the positon
         uiCfg.current_x_position_bak = current_position.x;
         uiCfg.current_y_position_bak = current_position.y;
+        uiCfg.current_z_position_bak = current_position.z;
 
         if (gCfgItems.pausePosZ != (float)-1) {
           gcode.process_subcommands_now_P(PSTR("G91"));
         gcode.process_subcommands_now(public_buf_m);
       }
       if (gCfgItems.pausePosZ != (float)-1) {
-        gcode.process_subcommands_now_P(PSTR("G91"));
-        sprintf_P(public_buf_l, PSTR("G1 Z-%.1f"), gCfgItems.pausePosZ);
-        gcode.process_subcommands_now(public_buf_l);
-        gcode.process_subcommands_now_P(PSTR("G90"));
+        ZERO(public_buf_m);
+        sprintf_P(public_buf_m, PSTR("G1 Z%.1f"), uiCfg.current_z_position_bak);
+        gcode.process_subcommands_now(public_buf_m);
       }
       gcode.process_subcommands_now_P(M24_STR);
       uiCfg.print_state = WORKING;

Marlin/src/lcd/extui/lib/mks_ui/tft_Language_en.h

 #define PROBE_Z_SPEED_EN                "Probe Z-axis speed"
 #define ENABLE_EN                       "YES"
 #define DISABLE_EN                      "NO"
+#define LOCKED_EN                       "N/A"
 #define Z_MIN_EN                        "ZMin"
 #define Z_MAX_EN                        "ZMax"
 
 #define EEPROM_STORE_TIPS_EN  "Store settings to EEPROM?"
 #define EEPROM_READ_TIPS_EN   "Read settings from EEPROM?"
 #define EEPROM_REVERT_TIPS_EN "Revert settings to factory defaults?"
+
+#define MORE_CUSTOM1_TEXT_EN  USER_DESC_1
+#define MORE_CUSTOM2_TEXT_EN  USER_DESC_2
+#define MORE_CUSTOM3_TEXT_EN  USER_DESC_3
+#define MORE_CUSTOM4_TEXT_EN  USER_DESC_4
+#define MORE_CUSTOM5_TEXT_EN  USER_DESC_5
+#define MORE_CUSTOM6_TEXT_EN  USER_DESC_6
+#define MORE_CUSTOM7_TEXT_EN  USER_DESC_7

Marlin/src/lcd/extui/lib/mks_ui/tft_Language_fr.h

 #define EEPROM_STORE_TIPS_FR  "Stocker les paramètres dans l'EEPROM?"
 #define EEPROM_READ_TIPS_FR   "Lire les paramètres de l'EEPROM?"
 #define EEPROM_REVERT_TIPS_FR "Rétablir les paramètres par défaut d'usine?"
+
+#define MORE_CUSTOM1_TEXT_FR  USER_DESC_1
+#define MORE_CUSTOM2_TEXT_FR  USER_DESC_2
+#define MORE_CUSTOM3_TEXT_FR  USER_DESC_3
+#define MORE_CUSTOM4_TEXT_FR  USER_DESC_4
+#define MORE_CUSTOM5_TEXT_FR  USER_DESC_5
+#define MORE_CUSTOM6_TEXT_FR  USER_DESC_6
+#define MORE_CUSTOM7_TEXT_FR  USER_DESC_7

Marlin/src/lcd/extui/lib/mks_ui/tft_Language_it.h

 #define EEPROM_STORE_TIPS_IT              "Memorizzare le impostazioni su EEPROM?"
 #define EEPROM_READ_TIPS_IT               "Leggi le impostazioni dalla EEPROM?"
 #define EEPROM_REVERT_TIPS_IT             "Ripristinare le impostazioni predefinite?"
+
+#define MORE_CUSTOM1_TEXT_IT  USER_DESC_1
+#define MORE_CUSTOM2_TEXT_IT  USER_DESC_2
+#define MORE_CUSTOM3_TEXT_IT  USER_DESC_3
+#define MORE_CUSTOM4_TEXT_IT  USER_DESC_4
+#define MORE_CUSTOM5_TEXT_IT  USER_DESC_5
+#define MORE_CUSTOM6_TEXT_IT  USER_DESC_6
+#define MORE_CUSTOM7_TEXT_IT  USER_DESC_7

Marlin/src/lcd/extui/lib/mks_ui/tft_Language_ru.h

 #define PRINT_TEXT_RU                   " печать"
 #define EXTRUDE_TEXT_RU                 "экструзия"
 #define LEVELING_TEXT_RU                "уровень"
-#define AUTO_LEVELING_TEXT_RU           "aвто"
+#define AUTO_LEVELING_TEXT_RU           "aвтоуровень"
 #define SET_TEXT_RU                     "настройки"
 #define MORE_TEXT_RU                    "больше"
 
 #define BACK_TEXT_RU                    "назад"
 
 #define TOOL_PREHEAT_RU                 "нагрев"
-#define TOOL_EXTRUDE_RU                 "экструзия"
+#define TOOL_EXTRUDE_RU                 "экструдер"
 #define TOOL_MOVE_RU                    "движение"
 #define TOOL_HOME_RU                    "домой"
 #define TOOL_LEVELING_RU                "уровень"
-#define TOOL_AUTO_LEVELING_RU           "aвто"
+#define TOOL_AUTO_LEVELING_RU           "aвтоуровень"
 #define TOOL_FILAMENT_RU                "замена"
 #define TOOL_MORE_RU                    "больше"
 
-#define AXIS_X_ADD_TEXT_RU              "X+"
-#define AXIS_X_DEC_TEXT_RU              "X-"
-#define AXIS_Y_ADD_TEXT_RU              "Y+"
-#define AXIS_Y_DEC_TEXT_RU              "Y-"
-#define AXIS_Z_ADD_TEXT_RU              "Z+"
-#define AXIS_Z_DEC_TEXT_RU              "Z-"
-#define TEXT_01MM_RU                    "0.1mm"
-#define TEXT_1MM_RU                     "1mm"
-#define TEXT_10MM_RU                    "10mm"
+#define AXIS_X_ADD_TEXT_RU              "X +"
+#define AXIS_X_DEC_TEXT_RU              "X -"
+#define AXIS_Y_ADD_TEXT_RU              "Y +"
+#define AXIS_Y_DEC_TEXT_RU              "Y -"
+#define AXIS_Z_ADD_TEXT_RU              "Z +"
+#define AXIS_Z_DEC_TEXT_RU              "Z -"
+#define TEXT_01MM_RU                    "0.1 mm"
+#define TEXT_1MM_RU                     "1 mm"
+#define TEXT_10MM_RU                    "10 mm"
 
 #define HOME_X_TEXT_RU                  "X"
 #define HOME_Y_TEXT_RU                  "Y"
 
 #define EXTRUDER_IN_TEXT_RU             "втянуть"
 #define EXTRUDER_OUT_TEXT_RU            "выдавить"
-#define EXTRUDE_1MM_TEXT_RU             "1mm"
-#define EXTRUDE_5MM_TEXT_RU             "5mm"
-#define EXTRUDE_10MM_TEXT_RU            "10mm"
+#define EXTRUDE_1MM_TEXT_RU             "1 mm"
+#define EXTRUDE_5MM_TEXT_RU             "5 mm"
+#define EXTRUDE_10MM_TEXT_RU            "10 mm"
 #define EXTRUDE_LOW_SPEED_TEXT_RU       "мин"
 #define EXTRUDE_MEDIUM_SPEED_TEXT_RU    "сред"
 #define EXTRUDE_HIGH_SPEED_TEXT_RU      "выс"
 
-#define LEVELING_POINT1_TEXT_RU         "1точка"
-#define LEVELING_POINT2_TEXT_RU         "2точка"
-#define LEVELING_POINT3_TEXT_RU         "3точка"
-#define LEVELING_POINT4_TEXT_RU         "4точка"
-#define LEVELING_POINT5_TEXT_RU         "5точка"
+#define LEVELING_POINT1_TEXT_RU         "1 точка"
+#define LEVELING_POINT2_TEXT_RU         "2 точка"
+#define LEVELING_POINT3_TEXT_RU         "3 точка"
+#define LEVELING_POINT4_TEXT_RU         "4 точка"
+#define LEVELING_POINT5_TEXT_RU         "5 точка"
 
 #define FILESYS_TEXT_RU                 "система"
 #define WIFI_TEXT_RU                    "WiFi"
 #define BREAK_POINT_TEXT_RU             "продолжить"
 #define FILAMENT_TEXT_RU                "замена"
 #define LANGUAGE_TEXT_RU                "язык"
-#define MOTOR_OFF_TEXT_RU               "отклмотор"
+#define MOTOR_OFF_TEXT_RU               "откл. мотор"
 #define MOTOR_OFF_XY_TEXT_RU            "Off-XY"
 #define SHUTDOWN_TEXT_RU                "выключение"
 #define MACHINE_PARA_RU                 "конфиг"
-#define EEPROM_SETTINGS_RU              "Eeprom Set"
 
 #define U_DISK_TEXT_RU                  "U диск"
 #define SD_CARD_TEXT_RU                 "SD диск"
 #define WIFI_CONNECTED_TEXT_RU          "подключен"
 #define WIFI_DISCONNECTED_TEXT_RU       "не подключен"
 #define WIFI_EXCEPTION_TEXT_RU          "исключение"
-#define WIFI_RECONNECT_TEXT_RU          "Reconnect"
+#define WIFI_RECONNECT_TEXT_RU          "выбор сети"
 #define CLOUD_TEXT_RU                   "облако"
 #define CLOUD_BIND_RU                   "соединён"
-#define CLOUD_UNBIND_RU                 "не соединён"
-#define CLOUD_UNBINDING_RU              "Unbinding"
-#define CLOUD_DISCONNECTED_RU           "Disconnected"
-#define CLOUD_UNBINDED_RU               "Unbinded"
-#define CLOUD_BINDED_RU                 "Binded"
+#define CLOUD_UNBIND_RU                 "отсоед."
+#define CLOUD_UNBINDING_RU              "отвязано"
+#define CLOUD_DISCONNECTED_RU           "отключено"
+#define CLOUD_UNBINDED_RU               "несвяз."
+#define CLOUD_BINDED_RU                 "связано"
 #define CLOUD_DISABLE_RU                "Disable"
 
 #define FAN_ADD_TEXT_RU                 "добавить"
 #define ABOUT_VERSION_TEXT_RU               "Firmware: "
 #define ABOUT_WIFI_TEXT_RU                  "WiFi: "
 
-#define PRINTING_OPERATION_RU               "управление"
+#define PRINTING_OPERATION_RU               "опции"
 #define PRINTING_PAUSE_RU                   "пауза"
 #define PRINTING_TEMP_RU                    "темп"
 #define PRINTING_CHANGESPEED_RU             "скорости"
-#define PRINTING_RESUME_RU                  "возобновить"
+#define PRINTING_RESUME_RU                  "возобн.   "
 #define PRINTING_STOP_RU                    "стоп"
 #define PRINTING_MORE_RU                    "больше"
 #define PRINTING_EXTRUDER_RU                "экстр"
 #define TITLE_HOME_RU                       "Home"
 #define TITLE_EXTRUDE_RU                    "экструзия"
 #define TITLE_LEVELING_RU                   "уровень"
+#define TITLE_MLEVELING_RU                  "углы"
 #define TITLE_SET_RU                        "настройки"
 #define TITLE_MORE_RU                       "больше"
 #define TITLE_CHOOSEFILE_RU                 "файла"
 #define DIALOG_CLOSE_MACHINE_RU             "Closing machine......"
 #define DIALOG_UNBIND_PRINTER_RU            "Unbind the printer?"
 #define DIALOG_FILAMENT_NO_PRESS_RU         "Filament detection switch is not pressed"
-#define DIALOG_PRINT_FINISH_RU              "Печать завершена!"
+#define DIALOG_PRINT_FINISH_RU              "печать завершена!"
 #define DIALOG_PRINT_TIME_RU                "Время печати: "
 #define DIALOG_REPRINT_RU                   "Print again"
 #define DIALOG_WIFI_ENABLE_TIPS_RU          "The wifi module is being configured,\nplease wait a moment....."
 #define EEPROM_SETTINGS_READ_RU       "Чтение настроек из EEPROM"
 #define EEPROM_SETTINGS_REVERT_RU     "Bосстановить заводские настройки по умолчанию"
 
-#define EEPROM_STORE_TIPS_RU          "Сохранить настройки в EEPROM?"
-#define EEPROM_READ_TIPS_RU           "Читать настройки из EEPROM?"
-#define EEPROM_REVERT_TIPS_RU         "Revert settings to factory defaults?"
+#define MORE_CUSTOM1_TEXT_RU  USER_DESC_1
+#define MORE_CUSTOM2_TEXT_RU  USER_DESC_2
+#define MORE_CUSTOM3_TEXT_RU  USER_DESC_3
+#define MORE_CUSTOM4_TEXT_RU  USER_DESC_4
+#define MORE_CUSTOM5_TEXT_RU  USER_DESC_5
+#define MORE_CUSTOM6_TEXT_RU  USER_DESC_6
+#define MORE_CUSTOM7_TEXT_RU  USER_DESC_7
+
+//Malderin translate
+//
+//
+#define EEPROM_STORE_TIPS_RU          "Cохранить настройки в EEPROM?"
+#define EEPROM_READ_TIPS_RU           "читать настройки из EEPROM?"
+#define EEPROM_REVERT_TIPS_RU         "Cбросить настройки к значениям по умолчанию?"
+#define EEPROM_SETTINGS_RU            "EEPROM"
+
+#define NEXT_RU                       "след."
+#define PREVIOUS_RU                   "пред."
+#define ENABLE_RU                     "да "
+#define DISABLE_RU                    "нет"
+#define KEY_CONFIRM_RU                "OK"
+
+#define MACHINE_PARA_TITLE_RU          "настройки"
+#define MACHINE_TYPE_CNOFIG_RU         "Hастройки принтера"
+#define MOTOR_CONFIG_RU                "Hастройки моторов"
+#define MACHINE_LEVELING_CONFIG_RU     "Hастройки уровня"
+#define ADVANCE_CONFIG_RU              "Pасширенные настройки"
+#define MACHINE_FILAMENT_CONFIG_RU     "Hастройки филамента"
+#define ENCODER_SETTINGS_RU            "Hастройки энкодера"
+
+#define LEVELING_CONF_TITLE_RU          "Hастройки принтера>Hастройки уровня"
+#define LEVELING_PARA_CONF_RU           "настройки уровня"
+#define LEVELING_MANUAL_POS_RU          "настройки координат для уровня"
+#define LEVELING_AUTO_COMMAND_RU        "настройки комманд увтоуровня"
+#define LEVELING_AUTO_ZOFFSET_RU        "координаты смещения сопла"
+
+#define MACHINE_CONFIG_TITLE_RU         "Hастройки принтера>настройки притера"
+#define MAXFEEDRATE_CONF_RU             "настройки максимальной скорости"
+#define ACCELERATION_CONF_RU            "настройки ускорений"
+#define JERKCONF_RU                     "настройки рывков"
+
+#define MOTOR_CONF_TITLE_RU             "Hастройки принтера>Hастройки моторов"
+#define STEPSCONF_RU                    "настройки шагов"
+#define TMC_CURRENT_RU                  "TMC настройки токов"
+#define TMC_STEP_MODE_RU                "TMC настрйоки режима шагов"
+
+#define ACCELERATION_CONF_TITLE_RU      "Hастройки принтера>ускорения"
+#define PRINT_ACCELERATION_RU           "ускорение печати"
+#define RETRACT_ACCELERATION_RU         "ускорение ретракта"
+#define TRAVEL_ACCELERATION_RU          "ускорение перемещений"
+#define X_ACCELERATION_RU               "ускорение оси X"
+#define Y_ACCELERATION_RU               "ускорение оси Y"
+#define Z_ACCELERATION_RU               "ускорение оси Z"
+#define E0_ACCELERATION_RU              "ускорение E0"
+#define E1_ACCELERATION_RU              "ускорение E1"
+
+#define MAXFEEDRATE_CONF_TITLE_RU       "Hастройки принтера>максимальная скорость"
+#define X_MAXFEEDRATE_RU                "максимальная скорость оси X"
+#define Y_MAXFEEDRATE_RU                "максимальная скорость оси Y"
+#define Z_MAXFEEDRATE_RU                "максимальная скорость оси Z"
+#define E0_MAXFEEDRATE_RU               "максимальная скорость E0"
+#define E1_MAXFEEDRATE_RU               "максимальная скорость E1"
+
+#define JERK_CONF_TITLE_RU              "Hастройки принтера>скорость рывка"
+#define X_JERK_RU                       "скорость рывка оси X"
+#define Y_JERK_RU                       "скорость рывка оси Y"
+#define Z_JERK_RU                       "скорость рывка оси Z"
+#define E_JERK_RU                       "скорость рывка оси E"
+
+#define STEPS_CONF_TITLE_RU             "Hастройки принтера>настройки шагов"
+#define X_STEPS_RU                      "шаги оси X"
+#define Y_STEPS_RU                      "шаги оси Y"
+#define Z_STEPS_RU                      "шаги оси Z"
+#define E0_STEPS_RU                     "шаги E0"
+#define E1_STEPS_RU                     "шаги E1"
+
+#define TMC_CURRENT_CONF_TITLE_RU       "Hастройки принтера>TMC настройка токов"
+#define X_TMC_CURRENT_RU                "ток оси X (mA)"
+#define Y_TMC_CURRENT_RU                "ток оси Y (mA)"
+#define Z_TMC_CURRENT_RU                "ток оси Z (mA)"
+#define E0_TMC_CURRENT_RU               "ток E0 (mA)"
+#define E1_TMC_CURRENT_RU               "ток E1 (mA)"
+
+#define TMC_MODE_CONF_TITLE_RU          "Hастройки принтера>TMC настройки режима шагов"
+#define X_TMC_MODE_RU                   "включает ли двигатель X режим StealthChop"
+#define Y_TMC_MODE_RU                   "включает ли ось Y режим StealthChop"
+#define Z_TMC_MODE_RU                   "включает ли ось Z режим StealthChop"
+#define E0_TMC_MODE_RU                  "включает ли E0 режим StealthChop"
+#define E1_TMC_MODE_RU                  "включает ли E1 режим StealthChop"
+
+#define ADVANCED_CONF_TITLE_RU          "Hастройки принтера>Pасширенные"
+#define PAUSE_POSITION_RU    "Hастройки позиции паузы печати"
+#define PAUSE_POSITION_X_RU  "положение по X (абс. полож., -1 недействит.)"
+#define PAUSE_POSITION_Y_RU  "положение по Y (абс. полож., -1 недействит.)"
+#define PAUSE_POSITION_Z_RU  "положение по Z (абс. полож., -1 недействит.)"
+
+#define OFFSET_TITLE_RU  "Hастройки принтера>отступ"
+#define OFFSET_X_RU      "X отступ"
+#define OFFSET_Y_RU      "Y отступ"
+#define OFFSET_Z_RU      "Z отступ"
+
+#define FILAMENT_CONF_TITLE_RU          "Hастройки принтера>Hастройки филамента"
+#define FILAMENT_IN_LENGTH_RU           "длинна загрузки"
+#define FILAMENT_IN_SPEED_RU            "скорость загрузки"
+#define FILAMENT_TEMPERATURE_RU         "температура филамента"
+#define FILAMENT_OUT_LENGTH_RU          "длинна извлечения"
+#define FILAMENT_OUT_SPEED_RU           "скорость извлечения"
+
+#define ENCODER_CONF_TITLE_RU           "Hастройки принтера>Hастройки энкодера"
+#define ENCODER_CONF_TEXT_RU            "энкодер используется?"
+
+//end of Malderin translate

Marlin/src/lcd/extui/lib/mks_ui/tft_Language_s_cn.h

 #define PROBE_Z_SPEED_CN              "探针Z方向移动速度"
 #define ENABLE_CN                     "是"
 #define DISABLE_CN                    "否"
+#define LOCKED_CN                     "否"
 #define Z_MIN_CN                      "ZMin"
 #define Z_MAX_CN                      "ZMax"
 
 #define EEPROM_STORE_TIPS_CN  "是否保存参数到EEPROM?"
 #define EEPROM_READ_TIPS_CN   "是否使用EEPROM参数?"
 #define EEPROM_REVERT_TIPS_CN "是否恢复默认参数?"
+
+#define MORE_CUSTOM1_TEXT_CN  USER_DESC_1
+#define MORE_CUSTOM2_TEXT_CN  USER_DESC_2
+#define MORE_CUSTOM3_TEXT_CN  USER_DESC_3
+#define MORE_CUSTOM4_TEXT_CN  USER_DESC_4
+#define MORE_CUSTOM5_TEXT_CN  USER_DESC_5
+#define MORE_CUSTOM6_TEXT_CN  USER_DESC_6
+#define MORE_CUSTOM7_TEXT_CN  USER_DESC_7

Marlin/src/lcd/extui/lib/mks_ui/tft_Language_sp.h

 #define PRINT_TEXT_SP           "Imprimir"
 #define EXTRUDE_TEXT_SP         "Extrusor"
 #define LEVELING_TEXT_SP        "Leveling"
+#define MLEVELING_TEXT_SP       "Leveling"
 #define AUTO_LEVELING_TEXT_SP   "Autolevel"
 #define SET_TEXT_SP             "Config"
 #define MORE_TEXT_SP            "Más"
 #define TOOL_MOVE_SP            "Mover"
 #define TOOL_HOME_SP            "Origen"
 #define TOOL_LEVELING_SP        "Leveling"
+#define TOOL_MLEVELING_SP       "Leveling"
 #define TOOL_AUTO_LEVELING_SP   "Autolevel"
 #define TOOL_FILAMENT_SP        "Filamento"
 #define TOOL_MORE_SP            "Más"
 #define EEPROM_STORE_TIPS_SP  "¿Guardar ajustes en EEPROM?"
 #define EEPROM_READ_TIPS_SP   "Leer la configuración de EEPROM?"
 #define EEPROM_REVERT_TIPS_SP "Revert settings to factory defaults?"
+
+#define MORE_CUSTOM1_TEXT_SP  USER_DESC_1
+#define MORE_CUSTOM2_TEXT_SP  USER_DESC_2
+#define MORE_CUSTOM3_TEXT_SP  USER_DESC_3
+#define MORE_CUSTOM4_TEXT_SP  USER_DESC_4
+#define MORE_CUSTOM5_TEXT_SP  USER_DESC_5
+#define MORE_CUSTOM6_TEXT_SP  USER_DESC_6
+#define MORE_CUSTOM7_TEXT_SP  USER_DESC_7

Marlin/src/lcd/extui/lib/mks_ui/tft_Language_t_cn.h

 #define PROBE_Z_SPEED_T_CN              "探针Z方向移動速度"
 #define ENABLE_T_CN                     "是"
 #define DISABLE_T_CN                    "否"
+#define LOCKED_T_CN                     "否"
 #define Z_MIN_T_CN                      "ZMin"
 #define Z_MAX_T_CN                      "ZMax"
 
 #define EEPROM_STORE_TIPS_T_CN        "是否保存參數到EEPROM?"
 #define EEPROM_READ_TIPS_T_CN         "是否使用EEPROM參數?"
 #define EEPROM_REVERT_TIPS_T_CN       "是否恢復默認參數?"
+
+#define MORE_CUSTOM1_TEXT_T_CN  USER_DESC_1
+#define MORE_CUSTOM2_TEXT_T_CN  USER_DESC_2
+#define MORE_CUSTOM3_TEXT_T_CN  USER_DESC_3
+#define MORE_CUSTOM4_TEXT_T_CN  USER_DESC_4
+#define MORE_CUSTOM5_TEXT_T_CN  USER_DESC_5
+#define MORE_CUSTOM6_TEXT_T_CN  USER_DESC_6
+#define MORE_CUSTOM7_TEXT_T_CN  USER_DESC_7

Marlin/src/lcd/extui/lib/mks_ui/tft_lvgl_configuration.cpp

  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
-
-/**
- * @file tft_lvgl_configuration.cpp
- * @date    2020-02-21
- */
-
 #include "../../../../inc/MarlinConfigPre.h"
 
 #if HAS_TFT_LVGL_UI
   #include "draw_touch_calibration.h"
 #endif
 
+#if ENABLED(MKS_WIFI_MODULE)
+  #include "wifi_module.h"
+#endif
+
 #include <SPI.h>
 
 #ifndef TFT_WIDTH
 
   watchdog_refresh();     // LVGL init takes time
 
+  #if MB(MKS_ROBIN_NANO)
+    OUT_WRITE(PB0, LOW);  // HE1
+  #endif
+
   // Init TFT first!
   SPI_TFT.spi_init(SPI_FULL_SPEED);
   SPI_TFT.LCD_init();
 
   lv_init();
 
-  lv_disp_buf_init(&disp_buf, bmp_public_buf, nullptr, LV_HOR_RES_MAX * 14); /*Initialize the display buffer*/
+  lv_disp_buf_init(&disp_buf, bmp_public_buf, nullptr, LV_HOR_RES_MAX * 14); // Initialize the display buffer
 
-  lv_disp_drv_t disp_drv;     /*Descriptor of a display driver*/
-  lv_disp_drv_init(&disp_drv);    /*Basic initialization*/
-  disp_drv.flush_cb = my_disp_flush; /*Set your driver function*/
-  disp_drv.buffer = &disp_buf;    /*Assign the buffer to the display*/
-  lv_disp_drv_register(&disp_drv);  /*Finally register the driver*/
+  lv_disp_drv_t disp_drv;     // Descriptor of a display driver
+  lv_disp_drv_init(&disp_drv);    // Basic initialization
+  disp_drv.flush_cb = my_disp_flush; // Set your driver function
+  disp_drv.buffer = &disp_buf;    // Assign the buffer to the display
+  lv_disp_drv_register(&disp_drv);  // Finally register the driver
 
   lv_indev_drv_t indev_drv;
-  lv_indev_drv_init(&indev_drv);     /*Descriptor of a input device driver*/
-  indev_drv.type = LV_INDEV_TYPE_POINTER; /*Touch pad is a pointer-like device*/
-  indev_drv.read_cb = my_touchpad_read;  /*Set your driver function*/
-  lv_indev_drv_register(&indev_drv);   /*Finally register the driver*/
+  lv_indev_drv_init(&indev_drv);     // Descriptor of a input device driver
+  indev_drv.type = LV_INDEV_TYPE_POINTER; // Touch pad is a pointer-like device
+  indev_drv.read_cb = my_touchpad_read;  // Set your driver function
+  lv_indev_drv_register(&indev_drv);   // Finally register the driver
 
   #if HAS_ROTARY_ENCODER
     g = lv_group_create();
 
   lv_encoder_pin_init();
 
+  TERN_(MKS_WIFI_MODULE, mks_wifi_firmware_update());
+
   bool ready = true;
   #if ENABLED(POWER_LOSS_RECOVERY)
     recovery.load();
     }
   #endif
 
-  if (ready) {
-    lv_draw_ready_print();
-  }
+  if (ready) lv_draw_ready_print();
 
-  if (mks_test_flag == 0x1E)
-    mks_gpio_test();
+  if (mks_test_flag == 0x1E) mks_gpio_test();
 }
 
 void my_disp_flush(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * color_p) {
   for (uint16_t i = 0; i < height; i++)
     SPI_TFT.tftio.WriteSequence((uint16_t*)(color_p + width * i), width);
 
-  lv_disp_flush_ready(disp);       /* Indicate you are ready with the flushing*/
+  lv_disp_flush_ready(disp); // Indicate you are ready with the flushing
+
+  W25QXX.init(SPI_QUARTER_SPEED);
+}
 
+void lv_fill_rect(lv_coord_t x1, lv_coord_t y1, lv_coord_t x2, lv_coord_t y2, lv_color_t bk_color) {
+  uint16_t width, height;
+  width = x2 - x1 + 1;
+  height = y2 - y1 + 1;
+  SPI_TFT.setWindow((uint16_t)x1, (uint16_t)y1, width, height);
+  SPI_TFT.tftio.WriteMultiple(bk_color.full, width * height);
   W25QXX.init(SPI_QUARTER_SPEED);
 }
 
 lv_indev_state_t state = LV_INDEV_STATE_REL;
 
 bool my_mousewheel_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data) {
-  (void) indev_drv;   /*Unused*/
+  (void) indev_drv;   // Unused
 
   data->state = state;
   data->enc_diff = enc_diff;
   enc_diff = 0;
 
-  return false;       /*No more data to read so return false*/
+  return false;       // No more data to read so return false
 }
 
 extern uint8_t currentFlashPage;
 
 lv_fs_res_t spi_flash_close_cb (lv_fs_drv_t * drv, void * file_p) {
   lv_fs_res_t res = LV_FS_RES_OK;
-  /* Add your code here*/
+  /* Add your code here */
   pic_read_addr_offset = pic_read_base_addr;
   return res;
 }
 }
 
 lv_fs_res_t sd_close_cb (lv_fs_drv_t * drv, void * file_p) {
-  /* Add your code here*/
+  /* Add your code here */
   lv_close_gcode_file();
   return LV_FS_RES_OK;
 }

Marlin/src/lcd/extui/lib/mks_ui/tft_lvgl_configuration.h

 #include <lvgl.h>
 
 //#define TFT_ROTATION TFT_ROTATE_180
-#define MKS_WIFI_MODULE 0
+
+extern uint8_t bmp_public_buf[14 * 1024];
+extern uint8_t public_buf[513];
 
 extern uint8_t bmp_public_buf[14 * 1024];
 extern uint8_t public_buf[513];
 extern lv_fs_res_t sd_seek_cb(lv_fs_drv_t * drv, void * file_p, uint32_t pos);
 extern lv_fs_res_t sd_tell_cb(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
 
+extern void lv_fill_rect(lv_coord_t x1, lv_coord_t y1, lv_coord_t x2, lv_coord_t y2, lv_color_t bk_color);
+
 #ifdef __cplusplus
   } /* C-declarations for C++ */
 #endif

Marlin/src/lcd/extui/lib/mks_ui/tft_multi_language.cpp

     machine_menu.ProbeZspeed          = PROBE_Z_SPEED_CN;
     machine_menu.enable               = ENABLE_CN;
     machine_menu.disable              = DISABLE_CN;
+    machine_menu.locked               = LOCKED_CN;
     machine_menu.z_min                = Z_MIN_CN;
     machine_menu.z_max                = Z_MAX_CN;
 
     machine_menu.ProbeZspeed          = PROBE_Z_SPEED_T_CN;
     machine_menu.enable               = ENABLE_T_CN;
     machine_menu.disable              = DISABLE_T_CN;
+    machine_menu.locked               = LOCKED_T_CN;
     machine_menu.z_min                = Z_MIN_T_CN;
     machine_menu.z_max                = Z_MAX_T_CN;
 
     machine_menu.ProbeZspeed          = PROBE_Z_SPEED_EN;
     machine_menu.enable               = ENABLE_EN;
     machine_menu.disable              = DISABLE_EN;
+    machine_menu.locked               = LOCKED_EN;
     machine_menu.z_min                = Z_MIN_EN;
     machine_menu.z_max                = Z_MAX_EN;
 
       filesys_menu.sd_sys  = SD_CARD_TEXT_CN;
       filesys_menu.usb_sys = U_DISK_TEXT_CN;
       //
-      more_menu.title       = TITLE_MORE_CN;
+      more_menu.title = TITLE_MORE_CN;
+      #if ENABLED(USER_CMD_1_ENABLE)
+        more_menu.custom1 = MORE_CUSTOM1_TEXT_CN;
+      #endif
+      #if ENABLED(USER_CMD_2_ENABLE)
+        more_menu.custom2 = MORE_CUSTOM2_TEXT_CN;
+      #endif
+      #if ENABLED(USER_CMD_3_ENABLE)
+        more_menu.custom3 = MORE_CUSTOM3_TEXT_CN;
+      #endif
+      #if ENABLED(USER_CMD_4_ENABLE)
+        more_menu.custom4 = MORE_CUSTOM4_TEXT_CN;
+      #endif
+      #if ENABLED(USER_CMD_5_ENABLE)
+        more_menu.custom5 = MORE_CUSTOM5_TEXT_CN;
+      #endif
+      #if ENABLED(USER_CMD_6_ENABLE)
+        more_menu.custom6 = MORE_CUSTOM6_TEXT_CN;
+      #endif
+      #if ENABLED(USER_CMD_7_ENABLE)
+        more_menu.custom7 = MORE_CUSTOM7_TEXT_CN;
+      #endif
       // WIFI
       wifi_menu.title = WIFI_TEXT;
       wifi_menu.cloud     = CLOUD_TEXT_CN;
       cloud_menu.unbind       = CLOUD_UNBIND_CN;
       cloud_menu.unbinding    = CLOUD_UNBINDED_CN;
       cloud_menu.disconnected = CLOUD_DISCONNECTED_CN;
+      cloud_menu.unbinded     = CLOUD_UNBINDED_CN;
       cloud_menu.disable      = CLOUD_DISABLE_CN;
       //
       about_menu.title   = ABOUT_TEXT_CN;
             filesys_menu.sd_sys   = SD_CARD_TEXT_T_CN;
             filesys_menu.usb_sys  = U_DISK_TEXT_T_CN;
             //
-            more_menu.title       = TITLE_MORE_T_CN;
+            more_menu.title     = TITLE_MORE_T_CN;
+            #if ENABLED(USER_CMD_1_ENABLE)
+              more_menu.custom1 = MORE_CUSTOM1_TEXT_T_CN;
+            #endif
+            #if ENABLED(USER_CMD_2_ENABLE)
+              more_menu.custom2 = MORE_CUSTOM2_TEXT_T_CN;
+            #endif
+            #if ENABLED(USER_CMD_3_ENABLE)
+              more_menu.custom3 = MORE_CUSTOM3_TEXT_T_CN;
+            #endif
+            #if ENABLED(USER_CMD_4_ENABLE)
+              more_menu.custom4 = MORE_CUSTOM4_TEXT_T_CN;
+            #endif
+            #if ENABLED(USER_CMD_5_ENABLE)
+              more_menu.custom5 = MORE_CUSTOM5_TEXT_T_CN;
+            #endif
+            #if ENABLED(USER_CMD_6_ENABLE)
+              more_menu.custom6 = MORE_CUSTOM6_TEXT_T_CN;
+            #endif
+            #if ENABLED(USER_CMD_7_ENABLE)
+              more_menu.custom7 = MORE_CUSTOM7_TEXT_T_CN;
+            #endif
             // WIFI
-            wifi_menu.title = WIFI_TEXT;
+            wifi_menu.title     = WIFI_TEXT;
             wifi_menu.cloud     = CLOUD_TEXT_T_CN;
             wifi_menu.reconnect = WIFI_RECONNECT_TEXT_T_CN;
             // CLOUD
             cloud_menu.unbind       = CLOUD_UNBIND_T_CN;
             cloud_menu.unbinding    = CLOUD_UNBINDED_T_CN;
             cloud_menu.disconnected = CLOUD_DISCONNECTED_T_CN;
+            cloud_menu.unbinded     = CLOUD_UNBINDED_T_CN;
             cloud_menu.disable      = CLOUD_DISABLE_T_CN;
             //
             about_menu.title   = ABOUT_TEXT_T_CN;
             preheat_menu.hotbed       = HEATBED_TEXT_EN;
             preheat_menu.off          = CLOSE_TEXT_EN;
             //
-            move_menu.title = TITLE_MOVE_EN;
+            move_menu.title    = TITLE_MOVE_EN;
             //
             home_menu.title    = TITLE_HOME_EN;
             home_menu.stopmove = HOME_STOPMOVE_EN;
             set_menu.machine_para = MACHINE_PARA_EN;
             set_menu.eepromSet    = EEPROM_SETTINGS_EN;
             more_menu.title       = TITLE_MORE_EN;
+            #if ENABLED(USER_CMD_1_ENABLE)
+              more_menu.custom1 = MORE_CUSTOM1_TEXT_EN;
+            #endif
+            #if ENABLED(USER_CMD_2_ENABLE)
+              more_menu.custom2 = MORE_CUSTOM2_TEXT_EN;
+            #endif
+            #if ENABLED(USER_CMD_3_ENABLE)
+              more_menu.custom3 = MORE_CUSTOM3_TEXT_EN;
+            #endif
+            #if ENABLED(USER_CMD_4_ENABLE)
+              more_menu.custom4 = MORE_CUSTOM4_TEXT_EN;
+            #endif
+            #if ENABLED(USER_CMD_5_ENABLE)
+              more_menu.custom5 = MORE_CUSTOM5_TEXT_EN;
+            #endif
+            #if ENABLED(USER_CMD_6_ENABLE)
+              more_menu.custom6 = MORE_CUSTOM6_TEXT_EN;
+            #endif
+            #if ENABLED(USER_CMD_7_ENABLE)
+              more_menu.custom7 = MORE_CUSTOM7_TEXT_EN;
+            #endif
+
             //
             filesys_menu.title   = TITLE_FILESYS_EN;
             filesys_menu.sd_sys  = SD_CARD_TEXT_EN;
             filesys_menu.usb_sys = U_DISK_TEXT_EN;
             // WIFI
-            wifi_menu.title = WIFI_TEXT;
+            wifi_menu.title     = WIFI_TEXT;
             wifi_menu.cloud     = CLOUD_TEXT_EN;
             wifi_menu.reconnect = WIFI_RECONNECT_TEXT_EN;
 
             cloud_menu.unbind       = CLOUD_UNBIND_EN;
             cloud_menu.unbinding    = CLOUD_UNBINDED_EN;
             cloud_menu.disconnected = CLOUD_DISCONNECTED_EN;
+            cloud_menu.unbinded     = CLOUD_UNBINDED_EN;
             cloud_menu.disable      = CLOUD_DISABLE_EN;
             //
             about_menu.title   = TITLE_ABOUT_EN;
             preheat_menu.hotbed       = HEATBED_TEXT_RU;
             preheat_menu.off          = CLOSE_TEXT_RU;
             //
-            move_menu.title = MOVE_TEXT_RU;
+            move_menu.title    = MOVE_TEXT_RU;
             //
             home_menu.title    = TITLE_HOME_RU;
             home_menu.stopmove = HOME_STOPMOVE_RU;
             set_menu.machine_para = MACHINE_PARA_RU;
             set_menu.eepromSet    = EEPROM_SETTINGS_RU;
             more_menu.title       = TITLE_MORE_RU;
+            #if ENABLED(USER_CMD_1_ENABLE)
+              more_menu.custom1 = MORE_CUSTOM1_TEXT_RU;
+            #endif
+            #if ENABLED(USER_CMD_2_ENABLE)
+              more_menu.custom2 = MORE_CUSTOM2_TEXT_RU;
+            #endif
+            #if ENABLED(USER_CMD_3_ENABLE)
+              more_menu.custom3 = MORE_CUSTOM3_TEXT_RU;
+            #endif
+            #if ENABLED(USER_CMD_4_ENABLE)
+              more_menu.custom4 = MORE_CUSTOM4_TEXT_RU;
+            #endif
+            #if ENABLED(USER_CMD_5_ENABLE)
+              more_menu.custom5 = MORE_CUSTOM5_TEXT_RU;
+            #endif
+            #if ENABLED(USER_CMD_6_ENABLE)
+              more_menu.custom6 = MORE_CUSTOM6_TEXT_RU;
+            #endif
+            #if ENABLED(USER_CMD_7_ENABLE)
+              more_menu.custom7 = MORE_CUSTOM7_TEXT_RU;
+            #endif
             //
             filesys_menu.title   = TITLE_FILESYS_RU;
             filesys_menu.sd_sys  = SD_CARD_TEXT_RU;
             filesys_menu.usb_sys = U_DISK_TEXT_RU;
             // WIFI
-            wifi_menu.title = WIFI_TEXT;
+            wifi_menu.title     = WIFI_TEXT;
             wifi_menu.cloud     = CLOUD_TEXT_RU;
             wifi_menu.reconnect = WIFI_RECONNECT_TEXT_RU;
 
+            machine_menu.next          = NEXT_RU;
+            machine_menu.previous      = PREVIOUS_RU;
+            machine_menu.enable        = ENABLE_RU;
+            machine_menu.disable       = DISABLE_RU;
+            machine_menu.key_confirm   = KEY_CONFIRM_RU;
+
+            MachinePara_menu.MachineSetting    = MACHINE_TYPE_CNOFIG_RU;
+            MachinePara_menu.title             = MACHINE_PARA_TITLE_RU;
+            machine_menu.MachineConfigTitle    = MACHINE_CONFIG_TITLE_RU;
+            MachinePara_menu.MotorSetting      = MOTOR_CONFIG_RU;
+            MachinePara_menu.leveling          = MACHINE_LEVELING_CONFIG_RU;
+            MachinePara_menu.AdvanceSetting    = ADVANCE_CONFIG_RU;
+            machine_menu.MotorConfTitle        = MOTOR_CONF_TITLE_RU;
+            machine_menu.MaxFeedRateConf       = MAXFEEDRATE_CONF_RU;
+            machine_menu.AccelerationConf      = ACCELERATION_CONF_RU;
+            machine_menu.JerkConf              = JERKCONF_RU;
+            machine_menu.StepsConf             = STEPSCONF_RU;
+            machine_menu.TMCcurrentConf        = TMC_CURRENT_RU;
+            machine_menu.TMCStepModeConf       = TMC_STEP_MODE_RU;
+            machine_menu.PausePosition         = PAUSE_POSITION_RU;
+            machine_menu.FilamentConf          = MACHINE_FILAMENT_CONFIG_RU;
+            machine_menu.EncoderSettings       = ENCODER_SETTINGS_RU;
+            machine_menu.AdvancedConfTitle     = ADVANCED_CONF_TITLE_RU;
+
+            machine_menu.LevelingParaConfTitle   = LEVELING_CONF_TITLE_RU;
+            machine_menu.LevelingParaConf        = LEVELING_PARA_CONF_RU;
+            machine_menu.LevelingManuPosConf     = LEVELING_MANUAL_POS_RU;
+            machine_menu.LevelingAutoCommandConf = LEVELING_AUTO_COMMAND_RU;
+            machine_menu.LevelingAutoZoffsetConf = LEVELING_AUTO_ZOFFSET_RU;
+
+            machine_menu.AccelerationConfTitle = ACCELERATION_CONF_TITLE_RU;
+            machine_menu.PrintAcceleration     = PRINT_ACCELERATION_RU;
+            machine_menu.RetractAcceleration   = RETRACT_ACCELERATION_RU;
+            machine_menu.TravelAcceleration    = TRAVEL_ACCELERATION_RU;
+            machine_menu.X_Acceleration        = X_ACCELERATION_RU;
+            machine_menu.Y_Acceleration        = Y_ACCELERATION_RU;
+            machine_menu.Z_Acceleration        = Z_ACCELERATION_RU;
+            machine_menu.E0_Acceleration       = E0_ACCELERATION_RU;
+            machine_menu.E1_Acceleration       = E1_ACCELERATION_RU;
+
+            machine_menu.MaxFeedRateConfTitle = MAXFEEDRATE_CONF_TITLE_RU;
+            machine_menu.XMaxFeedRate         = X_MAXFEEDRATE_RU;
+            machine_menu.YMaxFeedRate         = Y_MAXFEEDRATE_RU;
+            machine_menu.ZMaxFeedRate         = Z_MAXFEEDRATE_RU;
+            machine_menu.E0MaxFeedRate        = E0_MAXFEEDRATE_RU;
+            machine_menu.E1MaxFeedRate        = E1_MAXFEEDRATE_RU;
+
+            machine_menu.JerkConfTitle = JERK_CONF_TITLE_RU;
+            machine_menu.X_Jerk        = X_JERK_RU;
+            machine_menu.Y_Jerk        = Y_JERK_RU;
+            machine_menu.Z_Jerk        = Z_JERK_RU;
+            machine_menu.E_Jerk        = E_JERK_RU;
+
+            machine_menu.StepsConfTitle = STEPS_CONF_TITLE_RU;
+            machine_menu.X_Steps        = X_STEPS_RU;
+            machine_menu.Y_Steps        = Y_STEPS_RU;
+            machine_menu.Z_Steps        = Z_STEPS_RU;
+            machine_menu.E0_Steps       = E0_STEPS_RU;
+            machine_menu.E1_Steps       = E1_STEPS_RU;
+
+            machine_menu.TmcCurrentConfTitle = TMC_CURRENT_CONF_TITLE_RU;
+            machine_menu.X_Current           = X_TMC_CURRENT_RU;
+            machine_menu.Y_Current           = Y_TMC_CURRENT_RU;
+            machine_menu.Z_Current           = Z_TMC_CURRENT_RU;
+            machine_menu.E0_Current          = E0_TMC_CURRENT_RU;
+            machine_menu.E1_Current          = E1_TMC_CURRENT_RU;
+
+            machine_menu.TmcStepModeConfTitle = TMC_MODE_CONF_TITLE_RU;
+            machine_menu.X_StepMode           = X_TMC_MODE_RU;
+            machine_menu.Y_StepMode           = Y_TMC_MODE_RU;
+            machine_menu.Z_StepMode           = Z_TMC_MODE_RU;
+            machine_menu.E0_StepMode          = E0_TMC_MODE_RU;
+            machine_menu.E1_StepMode          = E1_TMC_MODE_RU;
+
+            machine_menu.PausePosText   = PAUSE_POSITION_RU;
+            machine_menu.xPos           = PAUSE_POSITION_X_RU;
+            machine_menu.yPos           = PAUSE_POSITION_Y_RU;
+            machine_menu.zPos           = PAUSE_POSITION_Z_RU;
+
+            machine_menu.OffsetConfTitle = OFFSET_TITLE_RU;
+            machine_menu.Xoffset         = OFFSET_X_RU;
+            machine_menu.Yoffset         = OFFSET_Y_RU;
+            machine_menu.Zoffset         = OFFSET_Z_RU;
+
+            machine_menu.FilamentConfTitle   = FILAMENT_CONF_TITLE_RU;
+            machine_menu.InLength            = FILAMENT_IN_LENGTH_RU;
+            machine_menu.InSpeed             = FILAMENT_IN_SPEED_RU;
+            machine_menu.FilamentTemperature = FILAMENT_TEMPERATURE_RU;
+            machine_menu.OutLength           = FILAMENT_OUT_LENGTH_RU;
+            machine_menu.OutSpeed            = FILAMENT_OUT_SPEED_RU;
+
+            machine_menu.EncoderConfTitle    = ENCODER_CONF_TITLE_RU;
+            machine_menu.EncoderConfText     = ENCODER_CONF_TEXT_RU;
+
             cloud_menu.title        = TITLE_CLOUD_TEXT_RU;
             cloud_menu.bind         = CLOUD_BINDED_RU;
             cloud_menu.binded       = CLOUD_BINDED_RU;
             cloud_menu.unbind       = CLOUD_UNBIND_RU;
             cloud_menu.unbinding    = CLOUD_UNBINDED_RU;
             cloud_menu.disconnected = CLOUD_DISCONNECTED_RU;
+            cloud_menu.unbinded     = CLOUD_UNBINDED_RU;
             cloud_menu.disable      = CLOUD_DISABLE_RU;
             //
             about_menu.title   = ABOUT_TEXT_RU;
             set_menu.machine_para = MACHINE_PARA_SP;
             set_menu.eepromSet    = EEPROM_SETTINGS_SP;
             more_menu.title       = TITLE_MORE_SP;
+            #if ENABLED(USER_CMD_1_ENABLE)
+              more_menu.custom1 = MORE_CUSTOM1_TEXT_SP;
+            #endif
+            #if ENABLED(USER_CMD_2_ENABLE)
+              more_menu.custom2 = MORE_CUSTOM2_TEXT_SP;
+            #endif
+            #if ENABLED(USER_CMD_3_ENABLE)
+              more_menu.custom3 = MORE_CUSTOM3_TEXT_SP;
+            #endif
+            #if ENABLED(USER_CMD_4_ENABLE)
+              more_menu.custom4 = MORE_CUSTOM4_TEXT_SP;
+            #endif
+            #if ENABLED(USER_CMD_5_ENABLE)
+              more_menu.custom5 = MORE_CUSTOM5_TEXT_SP;
+            #endif
+            #if ENABLED(USER_CMD_6_ENABLE)
+              more_menu.custom6 = MORE_CUSTOM6_TEXT_SP;
+            #endif
+            #if ENABLED(USER_CMD_7_ENABLE)
+              more_menu.custom7 = MORE_CUSTOM7_TEXT_SP;
+            #endif
             //
             filesys_menu.title   = TITLE_FILESYS_SP;
             filesys_menu.sd_sys  = SD_CARD_TEXT_SP;
             filesys_menu.usb_sys = U_DISK_TEXT_SP;
 
             // WIFI
-            wifi_menu.title = WIFI_TEXT;
+            wifi_menu.title     = WIFI_TEXT;
             wifi_menu.cloud     = CLOUD_TEXT_SP;
             wifi_menu.reconnect = WIFI_RECONNECT_TEXT_SP;
 
             cloud_menu.unbind       = CLOUD_UNBIND_SP;
             cloud_menu.unbinding    = CLOUD_UNBINDED_SP;
             cloud_menu.disconnected = CLOUD_DISCONNECTED_SP;
+            cloud_menu.unbinded     = CLOUD_UNBINDED_SP;
             cloud_menu.disable      = CLOUD_DISABLE_SP;
             //
             about_menu.title   = ABOUT_TEXT_SP;
           set_menu.machine_para = MACHINE_PARA_FR;
           set_menu.eepromSet    = EEPROM_SETTINGS_FR;
           more_menu.title       = TITLE_MORE_FR;
+          #if ENABLED(USER_CMD_1_ENABLE)
+            more_menu.custom1 = MORE_CUSTOM1_TEXT_FR;
+          #endif
+          #if ENABLED(USER_CMD_2_ENABLE)
+            more_menu.custom2 = MORE_CUSTOM2_TEXT_FR;
+          #endif
+          #if ENABLED(USER_CMD_3_ENABLE)
+            more_menu.custom3 = MORE_CUSTOM3_TEXT_FR;
+          #endif
+          #if ENABLED(USER_CMD_4_ENABLE)
+            more_menu.custom4 = MORE_CUSTOM4_TEXT_FR;
+          #endif
+          #if ENABLED(USER_CMD_5_ENABLE)
+            more_menu.custom5 = MORE_CUSTOM5_TEXT_FR;
+          #endif
+          #if ENABLED(USER_CMD_6_ENABLE)
+            more_menu.custom6 = MORE_CUSTOM6_TEXT_FR;
+          #endif
+          #if ENABLED(USER_CMD_7_ENABLE)
+            more_menu.custom7 = MORE_CUSTOM7_TEXT_FR;
+          #endif
           //
           filesys_menu.title          = TITLE_FILESYS_FR;
           filesys_menu.sd_sys         = SD_CARD_TEXT_FR;
           file_menu.no_file           = NO_FILE_FR;
           file_menu.no_file_and_check = NO_FILE_FR;
           // WIFI
-          wifi_menu.title = WIFI_NAME_TEXT_FR;
+          wifi_menu.title     = WIFI_NAME_TEXT_FR;
           wifi_menu.cloud     = CLOUD_TEXT_FR;
           wifi_menu.reconnect = WIFI_RECONNECT_TEXT_FR;
 
           cloud_menu.unbind       = CLOUD_UNBIND_FR;
           cloud_menu.unbinding    = CLOUD_UNBINDED_FR;
           cloud_menu.disconnected = CLOUD_DISCONNECTED_FR;
+          cloud_menu.unbinded     = CLOUD_UNBINDED_FR;
           cloud_menu.disable      = CLOUD_DISABLE_FR;
           //
           about_menu.title   = ABOUT_TEXT_FR;
           set_menu.machine_para = MACHINE_PARA_IT;
           set_menu.eepromSet    = EEPROM_SETTINGS_IT;
           more_menu.title       = TITLE_MORE_IT;
+          #if ENABLED(USER_CMD_1_ENABLE)
+            more_menu.custom1 = MORE_CUSTOM1_TEXT_IT;
+          #endif
+          #if ENABLED(USER_CMD_2_ENABLE)
+            more_menu.custom2 = MORE_CUSTOM2_TEXT_IT;
+          #endif
+          #if ENABLED(USER_CMD_3_ENABLE)
+            more_menu.custom3 = MORE_CUSTOM3_TEXT_IT;
+          #endif
+          #if ENABLED(USER_CMD_4_ENABLE)
+            more_menu.custom4 = MORE_CUSTOM4_TEXT_IT;
+          #endif
+          #if ENABLED(USER_CMD_5_ENABLE)
+            more_menu.custom5 = MORE_CUSTOM5_TEXT_IT;
+          #endif
+          #if ENABLED(USER_CMD_6_ENABLE)
+            more_menu.custom6 = MORE_CUSTOM6_TEXT_IT;
+          #endif
+          #if ENABLED(USER_CMD_7_ENABLE)
+            more_menu.custom7 = MORE_CUSTOM7_TEXT_IT;
+          #endif
           //
           filesys_menu.title   = TITLE_FILESYS_IT;
           filesys_menu.sd_sys  = SD_CARD_TEXT_IT;
           filesys_menu.usb_sys = U_DISK_TEXT_IT;
 
           // WIFI
-          wifi_menu.title = WIFI_NAME_TEXT_IT;
+          wifi_menu.title     = WIFI_NAME_TEXT_IT;
           wifi_menu.cloud     = CLOSE_TEXT_IT;
           wifi_menu.reconnect = WIFI_RECONNECT_TEXT_IT;
 
           cloud_menu.unbind       = CLOUD_UNBIND_IT;
           cloud_menu.unbinding    = CLOUD_UNBINDED_IT;
           cloud_menu.disconnected = CLOUD_DISCONNECTED_IT;
+          cloud_menu.unbinded     = CLOUD_UNBINDED_IT;
           cloud_menu.disable      = CLOUD_DISABLE_IT;
           //
           about_menu.title   = ABOUT_TEXT_IT;
       set_menu.machine_para = MACHINE_PARA_EN;
       set_menu.eepromSet    = EEPROM_SETTINGS_EN;
       //
-      more_menu.title       = TITLE_MORE_EN;
+      more_menu.title     = TITLE_MORE_EN;
+      #if ENABLED(USER_CMD_1_ENABLE)
+        more_menu.custom1 = MORE_CUSTOM1_TEXT_EN;
+      #endif
+      #if ENABLED(USER_CMD_2_ENABLE)
+        more_menu.custom2 = MORE_CUSTOM2_TEXT_EN;
+      #endif
+      #if ENABLED(USER_CMD_3_ENABLE)
+        more_menu.custom3 = MORE_CUSTOM3_TEXT_EN;
+      #endif
+      #if ENABLED(USER_CMD_4_ENABLE)
+        more_menu.custom4 = MORE_CUSTOM4_TEXT_EN;
+      #endif
+      #if ENABLED(USER_CMD_5_ENABLE)
+        more_menu.custom5 = MORE_CUSTOM5_TEXT_EN;
+      #endif
+      #if ENABLED(USER_CMD_6_ENABLE)
+        more_menu.custom6 = MORE_CUSTOM6_TEXT_EN;
+      #endif
+      #if ENABLED(USER_CMD_7_ENABLE)
+        more_menu.custom7 = MORE_CUSTOM7_TEXT_EN;
+      #endif
       //
       filesys_menu.title   = TITLE_FILESYS_EN;
       filesys_menu.sd_sys  = SD_CARD_TEXT_EN;
       filesys_menu.usb_sys = U_DISK_TEXT_EN;
       // WIFI
-      wifi_menu.title = WIFI_TEXT;
+      wifi_menu.title     = WIFI_TEXT;
       wifi_menu.cloud     = CLOUD_TEXT_EN;
       wifi_menu.reconnect = WIFI_RECONNECT_TEXT_EN;
 
       cloud_menu.unbind       = CLOUD_UNBIND_EN;
       cloud_menu.unbinding    = CLOUD_UNBINDED_EN;
       cloud_menu.disconnected = CLOUD_DISCONNECTED_EN;
+      cloud_menu.unbinded     = CLOUD_UNBINDED_EN;
       cloud_menu.disable      = CLOUD_DISABLE_EN;
       //
       about_menu.title   = TITLE_ABOUT_EN;

Marlin/src/lcd/extui/lib/mks_ui/tft_multi_language.h

   const char *ProbeZspeed;
   const char *enable;
   const char *disable;
+  const char *locked;
   const char *z_min;
   const char *z_max;
 
 
 typedef struct more_menu_disp {
   const char *title;
+  const char *custom1;
+  const char *custom2;
+  const char *custom3;
+  const char *custom4;
+  const char *custom5;
+  const char *custom6;
+  const char *custom7;
   const char *back;
 } more_menu_def;
 
 #define AXIS_Y_DEC_TEXT     "Y-"
 #define AXIS_Z_ADD_TEXT     "Z+"
 #define AXIS_Z_DEC_TEXT     "Z-"
-#define TEXT_001MM          "0.01mm"
-#define TEXT_005MM          "0.05mm"
-#define TEXT_01MM           "0.1mm"
-#define TEXT_1MM            "1mm"
-#define TEXT_10MM           "10mm"
+#define TEXT_001MM          "0.01 mm"
+#define TEXT_005MM          "0.05 mm"
+#define TEXT_01MM           "0.1 mm"
+#define TEXT_1MM            "1 mm"
+#define TEXT_10MM           "10 mm"
 
-#define EXTRUDE_1MM_TEXT    "1mm"
-#define EXTRUDE_5MM_TEXT    "5mm"
-#define EXTRUDE_10MM_TEXT   "10mm"
+#define EXTRUDE_1MM_TEXT    "1 mm"
+#define EXTRUDE_5MM_TEXT    "5 mm"
+#define EXTRUDE_10MM_TEXT   "10 mm"
 
 #define STEP_1PERCENT       "1%"
 #define STEP_5PERCENT       "5%"
 #define DIALOG_UPDATE_WIFI_WEB_EN       "Updating wifi model web data"
 #define DIALOG_UPDATE_NO_DEVICE_EN      "Please check whether\nmemory device inserted!"
 
-#define ZOFFSET_STEP001                 "0.01mm"
-#define ZOFFSET_STEP01                  "0.1mm"
-#define ZOFFSET_STEP1                   "1mm"
+#define ZOFFSET_STEP001                 "0.01 mm"
+#define ZOFFSET_STEP01                  "0.1 mm"
+#define ZOFFSET_STEP1                   "1 mm"

Marlin/src/lcd/extui/lib/mks_ui/wifiSerial.cpp

   static void disable_timer_if_necessary(timer_dev *dev, uint8 ch) {
     if (dev) timer_set_mode(dev, ch, TIMER_DISABLED);
   }
+  static void usart_enable_no_irq(usart_dev *usart_device, bool with_irq) {
+    if (with_irq) usart_enable(usart_device);
+    else {
+      usart_reg_map *regs = usart_device->regs;
+	    regs->CR1 |= (USART_CR1_TE | USART_CR1_RE);// don't change the word length etc, and 'or' in the patten not overwrite |USART_CR1_M_8N1);
+      regs->CR1 |= USART_CR1_UE;
+    }
+  }
+
 #elif STM32_MCU_SERIES == STM32_SERIES_F2 || STM32_MCU_SERIES == STM32_SERIES_F4
   #define disable_timer_if_necessary(dev, ch) ((void)0)
+
+  static void usart_enable_no_irq(usart_dev *usart_device, bool with_irq) {
+    if (with_irq) usart_enable(usart_device);
+    else {
+      usart_reg_map *regs = usart_device->regs;
+	    regs->CR1 |= (USART_CR1_TE | USART_CR1_RE);// don't change the word length etc, and 'or' in the patten not overwrite |USART_CR1_M_8N1);
+      regs->CR1 |= USART_CR1_UE;
+    }
+  }
 #else
   #warning "Unsupported STM32 series; timer conflicts are possible"
+  #define usart_enable_no_irq(X, Y) usart_enable(X)
 #endif
 
 void WifiSerial::begin(uint32 baud) { begin(baud, SERIAL_8N1); }
                            txi->gpio_device, txi->gpio_bit,
                            config);
   usart_set_baud_rate(this->usart_device, USART_USE_PCLK, baud);
-  usart_enable(this->usart_device);
+  usart_enable_no_irq(this->usart_device, baud == WIFI_BAUDRATE);
 }
 
 void WifiSerial::end(void) {

Marlin/src/lcd/extui/lib/mks_ui/wifiSerial.h

 
     int wifi_rb_is_full(void);
 
-  private:
+
     struct usart_dev *usart_device;
+    private:
     uint8 tx_pin;
     uint8 rx_pin;
 };

Marlin/src/lcd/extui/lib/mks_ui/wifi_module.cpp

 #include "draw_ui.h"
 #include "wifi_module.h"
 #include "wifi_upload.h"
+#include "SPI_TFT.h"
 
 #if ENABLED(MKS_WIFI_MODULE)
 
 #include "../../../../lcd/marlinui.h"
 #include "../../../../sd/cardreader.h"
 #include "../../../../module/planner.h"
+#include "../../../../module/servo.h"
+#include "../../../../module/probe.h"
 #if ENABLED(POWER_LOSS_RECOVERY)
   #include "../../../../feature/powerloss.h"
 #endif
 extern CLOUD_PARA cloud_para;
 
 extern bool once_flag, flash_preview_begin, default_preview_flg, gcode_preview_over;
+extern bool flash_dma_mode;
 
-uint32_t getWifiTick() {
-  return millis();
-}
+uint32_t getWifiTick() { return millis(); }
 
 uint32_t getWifiTickDiff(int32_t lastTick, int32_t curTick) {
   if (lastTick <= curTick)
   }
 }
 
-static void dma_init() {
-  #if 0
-  __HAL_RCC_DMA1_CLK_ENABLE();
-
-  //HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
-  HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 4, 0);
-  HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
-
-  hdma_usart1_rx.Instance = DMA1_Channel5;
-  //hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
-  hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
-  hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
-  hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
-  hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
-  hdma_usart1_rx.Init.MemDataAlignment = DMA_PDATAALIGN_BYTE;
-  hdma_usart1_rx.Init.Mode = DMA_NORMAL;
-  hdma_usart1_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
-  if (HAL_DMA_Init((DMA_HandleTypeDef *)&hdma_usart1_rx) != HAL_OK) {
-    Error_Handler();
+#include <libmaple/timer.h>
+#include <libmaple/util.h>
+#include <libmaple/rcc.h>
+
+#include <boards.h>
+#include <wirish.h>
+
+#include <libmaple/dma.h>
+#include <libmaple/bitband.h>
+
+#include <libmaple/libmaple.h>
+#include <libmaple/gpio.h>
+#include <libmaple/usart.h>
+#include <libmaple/ring_buffer.h>
+
+void changeFlashMode(const bool dmaMode) {
+  if (flash_dma_mode != dmaMode) {
+    flash_dma_mode = dmaMode;
+    if (!flash_dma_mode) {
+      dma_disable(DMA1, DMA_CH5);
+      dma_clear_isr_bits(DMA1, DMA_CH4);
+    }
   }
+}
 
+static bool longName2DosName(const char *longName, uint8_t *dosName) {
+  uint8_t i;
+  for (i = FILENAME_LENGTH; i--;) dosName[i] = '\0';
+  while (*longName) {
+    uint8_t c = *longName++;
+    if (c == '.') { // For a dot...
+      if (i == 0) return false;
+      strcat((char *)dosName, ".GCO");
+      break;
+    }
+    else {
+      if (c < 0x21 || c == 0x7F) return false;                  // Check size, non-printable characters
+      // Fail for illegal characters
+      PGM_P p = PSTR("|<>^+=?/[];,*\"\\");
+      while (const uint8_t b = pgm_read_byte(p++)) if (b == c) return false;
+      dosName[i++] = c + (WITHIN(c, 'a', 'z') ? 'A' - 'a' : 0); // Uppercase required for 8.3 name
+    }
+    if (i >= 5) {
+      strcat((char *)dosName, "~1.GCO");
+      break;
+    }
+  }
+  return dosName[0] != '\0'; // Return true if any name was set
+}
 
-  HAL_DMA_Start_IT((DMA_HandleTypeDef *)&hdma_usart1_rx,
-      (uint32_t)&huart1.Instance->DR,
-      (uint32_t)(&WifiRxFifo.uartTxBuffer[0]),
-      UART_RX_BUFFER_SIZE);
+static int storeRcvData(volatile uint8_t *bufToCpy, int32_t len) {
+  unsigned char tmpW = wifiDmaRcvFifo.write_cur;
 
-    //HAL_UART_Receive_DMA(&huart1,(uint8_t*)&WifiRxFifo.uartTxBuffer[0], UART_RX_BUFFER_SIZE);
+  if (len > UDISKBUFLEN) return 0;
 
-      /* Enable the DMA transfer for the receiver request by setting the DMAR bit
-       in the UART CR3 register */
-      SET_BIT(huart1.Instance->CR3, USART_CR3_DMAR);
+  if (wifiDmaRcvFifo.state[tmpW] == udisk_buf_empty) {
+    memcpy((unsigned char *) wifiDmaRcvFifo.bufferAddr[tmpW], (uint8_t *)bufToCpy, len);
+    wifiDmaRcvFifo.state[tmpW] = udisk_buf_full;
+    wifiDmaRcvFifo.write_cur = (tmpW + 1) % TRANS_RCV_FIFO_BLOCK_NUM;
+    return 1;
+  }
+
+  return 0;
+}
+
+static void esp_dma_pre() {
+  dma_channel_reg_map *channel_regs = dma_tube_regs(DMA1, DMA_CH5);
+
+  CBI32(channel_regs->CCR, 0);
+  channel_regs->CMAR = (uint32_t)WIFISERIAL.usart_device->rb->buf;
+  channel_regs->CNDTR = 0x0000;
+  channel_regs->CNDTR = UART_RX_BUFFER_SIZE;
+  DMA1->regs->IFCR = 0xF0000;
+  SBI32(channel_regs->CCR, 0);
+}
+
+static void dma_ch5_irq_handle() {
+    uint8 status_bits = dma_get_isr_bits(DMA1, DMA_CH5);
+    dma_clear_isr_bits(DMA1, DMA_CH5);
+    if (status_bits & 0x8) {
+      // DMA transmit Error
+    }
+    else if (status_bits & 0x2) {
+      // DMA transmit complete
+      if (esp_state == TRANSFER_IDLE)
+        esp_state = TRANSFERING;
+
+      if (storeRcvData(WIFISERIAL.usart_device->rb->buf, UART_RX_BUFFER_SIZE)) {
+        esp_dma_pre();
+        if (wifiTransError.flag != 0x1)
+          WIFI_IO1_RESET();
+      }
+      else {
+        WIFI_IO1_SET();
+        esp_state = TRANSFER_STORE;
+      }
+    }
+    else if (status_bits & 0x4) {
+      // DMA transmit half
+      WIFI_IO1_SET();
+    }
+}
+static void wifi_usart_dma_init() {
+  dma_init(DMA1);
+  uint32_t flags = ( DMA_MINC_MODE | DMA_TRNS_CMPLT | DMA_HALF_TRNS | DMA_TRNS_ERR);
+  dma_xfer_size dma_bit_size = DMA_SIZE_8BITS;
+  dma_setup_transfer(DMA1, DMA_CH5, &USART1_BASE->DR, dma_bit_size,
+             (volatile void*)WIFISERIAL.usart_device->rb->buf, dma_bit_size, flags);// Transmit buffer DMA
+  dma_set_priority(DMA1, DMA_CH5, DMA_PRIORITY_LOW);
+  dma_attach_interrupt(DMA1, DMA_CH5, &dma_ch5_irq_handle);
+
+  dma_clear_isr_bits(DMA1, DMA_CH5);
+  dma_set_num_transfers(DMA1, DMA_CH5, UART_RX_BUFFER_SIZE);
+
+  bb_peri_set_bit(&USART1_BASE->CR3, USART_CR3_DMAR_BIT, 1);
+  dma_enable(DMA1, DMA_CH5);   // enable transmit
 
-  #endif
   for (uint8_t i = 0; i < TRANS_RCV_FIFO_BLOCK_NUM; i++) {
     wifiDmaRcvFifo.bufferAddr[i] = &bmp_public_buf[1024 * i];
     wifiDmaRcvFifo.state[i] = udisk_buf_empty;
   wifiDmaRcvFifo.write_cur = 0;
 }
 
-static void wifi_deInit() {
-  #if 0
-  HAL_DMA_Abort((DMA_HandleTypeDef *)&hdma_usart1_rx);
-  HAL_DMA_DeInit((DMA_HandleTypeDef *)&hdma_usart1_rx);
-  __HAL_DMA_DISABLE((DMA_HandleTypeDef *)&hdma_usart1_rx);
-  #endif
-}
-
-extern uint8_t mksUsart1Rx;
-
 void esp_port_begin(uint8_t interrupt) {
   WifiRxFifo.uart_read_point = 0;
   WifiRxFifo.uart_write_point = 0;
-  #if 0
-  NVIC_InitTypeDef NVIC_InitStructure;
 
-  USART_InitTypeDef USART_InitStructure;
-  GPIO_InitTypeDef GPIO_InitStruct;
+  #if 1
 
-  WifiRxFifo.uart_read_point = 0;
-  WifiRxFifo.uart_write_point = 0;
-  memset((uint8_t*)WifiRxFifo.uartTxBuffer, 0, sizeof(WifiRxFifo.uartTxBuffer));
-
-  if (interrupt) {
-  #if TAN
-    wifi_deInit ();
-
-    //SZ_STM32_COMInit(COM1, 115200);
-    __HAL_UART_ENABLE_IT(USART1, USART_IT_RXNE);
-
-    USART_InitStructure.USART_BaudRate = 115200;        //���ڵIJ����ʣ�����115200 ��ߴ�4.5Mbits/s
-    USART_InitStructure.USART_WordLength = USART_WordLength_8b; //�����ֳ���(8λ��9λ)
-    USART_InitStructure.USART_StopBits = USART_StopBits_1;    //�����õ�ֹͣλ-֧��1��2��ֹͣλ
-    USART_InitStructure.USART_Parity = USART_Parity_No;     //����żУ��
-    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //��Ӳ��������
-    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //˫��ģʽ��ʹ�ܷ��ͺͽ���
-
-    __HAL_RCC_USART1_CLK_ENABLE();
-
-    GPIO_InitStruct.Pin = TFT_WIFI_TX_Pin|TFT_WIFI_RX_Pin;
-    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-    GPIO_InitStruct.Pull = GPIO_PULLUP;
-    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
-    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
-    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-      GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
-      GPIO_InitStruct.Pin = TFT_WIFI_RX_Pin;
-      HAL_GPIO_Init(GPIOA,&GPIO_InitStruct);
-
-    USART_Init(USART1, &USART_InitStructure);
-
-    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
-  //  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
-  //  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
-    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
-    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
-    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
-
-    NVIC_Init(&NVIC_InitStructure);
-    #else
-    HAL_UART_DeInit(&huart1);
-    MX_USART1_UART_Init(3);
-    //__HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);
-    HAL_UART_Receive_IT(&huart1,&mksUsart1Rx,1);
+    #if ENABLED(MKS_WIFI_MODULE)
+      WIFISERIAL.end();
+      if (interrupt) {
+        for (uint16_t i = 0; i < 65535; i++) { /*nada*/ }
+        WIFISERIAL.begin(WIFI_BAUDRATE);
+        uint32_t serial_connect_timeout = millis() + 1000UL;
+        while (PENDING(millis(), serial_connect_timeout)) { /*nada*/ }
+      }
+      else {
+        WIFISERIAL.usart_device->regs->CR1 &= ~USART_CR1_RXNEIE;
+        WIFISERIAL.begin(WIFI_UPLOAD_BAUDRATE);
+        wifi_usart_dma_init();
+      }
     #endif
-  }
-  else{
-    #if 0
-    NVIC_DisableIRQ(SZ_STM32_COM1_IRQn);
-
-    USART_Cmd(SZ_STM32_COM1, DISABLE);
-
-    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, DISABLE);
-    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
 
-    SZ_STM32_COMInit(COM1, 1958400);
+  #else
 
-    USART_Cmd(SZ_STM32_COM1, ENABLE);
-
-    wifi_delay(10);
-
-    dma_init();
+    #if MKS_WIFI_MODULE
+      WIFISERIAL.end();
+      for (uint16_t i = 0; i < 65535; i++) { /*nada*/ }
+      WIFISERIAL.begin(interrupt ? WIFI_BAUDRATE : WIFI_UPLOAD_BAUDRATE);
+      uint32_t serial_connect_timeout = millis() + 1000UL;
+      while (PENDING(millis(), serial_connect_timeout)) { /*nada*/ }
     #endif
-    HAL_UART_DeInit(&huart1);
-    MX_USART1_UART_Init(5);
-        //dma1_5_IRQ_sel = 1;
-    dma_init();
-  }
-  #endif
-
-  #if ENABLED(MKS_WIFI_MODULE)
-    WIFISERIAL.end();
-    for (uint16_t i = 0; i < 65535; i++) { /*nada*/ }
-    WIFISERIAL.begin(interrupt ? WIFI_BAUDRATE : WIFI_UPLOAD_BAUDRATE);
+    if (!interrupt) wifi_usart_dma_init();
 
-    const millis_t serial_connect_timeout = millis() + 1000UL;
-    while (/*!WIFISERIAL && */PENDING(millis(), serial_connect_timeout)) { /*nada*/ }
-
-    if (interrupt) {
-      //for (uint8_t i=0;i<100;i++) WIFISERIAL.write(0x33);
-    }
-    else {
-      //for (uint16_t i=0;i<65535;i++); //WIFISERIAL.write(0x33);
-    }
   #endif
-
-  if (!interrupt) dma_init();
 }
 
 #if ENABLED(MKS_WIFI_MODULE)
     ZERO(buf_to_wifi);
     index_to_wifi = 0;
   }
+  return 1;
 }
 
 
-int send_to_wifi(char *buf, int len) { return package_to_wifi(WIFI_TRANS_INF, buf, len); }
+#define SEND_OK_TO_WIFI send_to_wifi((uint8_t *)"ok\r\n", strlen("ok\r\n"))
+int send_to_wifi(uint8_t *buf, int len) { return package_to_wifi(WIFI_TRANS_INF, buf, len); }
 
 void set_cur_file_sys(int fileType) { gCfgItems.fileSysType = fileType; }
 
 char wait_ip_back_flag = 0;
 
 typedef struct {
-  char write_buf[513];
   int write_index;
   uint8_t saveFileName[30];
+  uint8_t fileTransfer;
   uint32_t fileLen;
   uint32_t tick_begin;
   uint32_t tick_end;
 
 int32_t lastFragment = 0;
 
-char lastBinaryCmd[50] = { 0 };
+char saveFilePath[50];
 
-int total_write = 0;
-char binary_head[2] = { 0, 0 };
-unsigned char binary_data_len = 0;
+static SdFile upload_file, *upload_curDir;
+static filepos_t pos;
 
 int write_to_file(char *buf, int len) {
-  for (int i = 0; i < len; i++) {
-    file_writer.write_buf[file_writer.write_index++] = buf[i];
+  int i;
+  int res = 0;
+
+  for (i = 0; i < len; i++) {
+    public_buf[file_writer.write_index++] = buf[i];
     if (file_writer.write_index >= 512) {
-      int res = card.write(file_writer.write_buf, file_writer.write_index);
-      if (res == -1) return -1;
-      ZERO(file_writer.write_buf);
+      res = upload_file.write(public_buf, file_writer.write_index);
+
+      if (res == -1) {
+        upload_file.close();
+        const char * const fname = card.diveToFile(true, upload_curDir, saveFilePath);
+
+        if (upload_file.open(upload_curDir, fname, O_WRITE)) {
+          upload_file.setpos(&pos);
+          res = upload_file.write(public_buf, file_writer.write_index);
+        }
+      }
+      if (res == -1) {
+        return  -1;
+      }
+      upload_file.getpos(&pos);
       file_writer.write_index = 0;
     }
   }
+
+  if (res == -1) {
+    memset(public_buf, 0, sizeof(public_buf));
+    file_writer.write_index = 0;
+    return  -1;
+  }
+
   return 0;
 }
 
   for (uint8_t i = 0; i < fileCnt; i++) {
     card.getfilename_sorted(SD_ORDER(i, fileCnt));
 
-    //if (card.longFilename[0] == 0)
-      strcpy(tmp, card.filename);
-    //else
-    //  strcpy(tmp, card.longFilename);
+    memset(tmp, 0, sizeof(tmp));
+    strcpy(tmp, card.filename);
 
     ZERO(Fstream);
     strcpy(Fstream, tmp);
       switch (cmd_value) {
 
         case 20: // M20: Print SD / µdisk file
+          file_writer.fileTransfer = 0;
           if (uiCfg.print_state == IDLE) {
             int index = 0;
 
               gCfgItems.fileSysType = FILE_SYS_SD;
               send_to_wifi((uint8_t *)"Begin file list\r\n", strlen("Begin file list\r\n"));
               get_file_list((char *)"0:/");
-              send_to_wifi((char *)"End file list\r\n", strlen("End file list\r\n"));
-              send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+              send_to_wifi((uint8_t *)"End file list\r\n", strlen("End file list\r\n"));
+              SEND_OK_TO_WIFI;
               break;
             }
 
                 get_file_list(path);
                 send_to_wifi((uint8_t *)"End file list\r\n", strlen("End file list\r\n"));
               }
-              send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+              SEND_OK_TO_WIFI;
             }
           }
           break;
 
         case 21:
           /*init sd card*/
-          send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+          SEND_OK_TO_WIFI;
           break;
 
         case 23:
             if (strstr((char *)&tmpStr[index], ".g") || strstr((char *)&tmpStr[index], ".G")) {
               if (strlen((char *)&tmpStr[index]) < 80) {
                 ZERO(list_file.file_name[sel_id]);
+                ZERO(list_file.long_name[sel_id]);
+                uint8_t has_path_selected = 0;
 
                 if (gCfgItems.wifi_type == ESP_WIFI) {
-                  if (strncmp((char *)&tmpStr[index], "1:", 2) == 0)
+                  if (strncmp((char *)&tmpStr[index], "1:", 2) == 0) {
                     gCfgItems.fileSysType = FILE_SYS_SD;
-                  else if (strncmp((char *)&tmpStr[index], "0:", 2) == 0)
+                    has_path_selected = 1;
+                  }
+                  else if (strncmp((char *)&tmpStr[index], "0:", 2) == 0) {
                     gCfgItems.fileSysType = FILE_SYS_USB;
+                    has_path_selected = 1;
+                  }
                   else if (tmpStr[index] != '/')
-                    strcat((char *)list_file.file_name[0], "/");
-                  strcat((char *)list_file.file_name[sel_id], (char *)&tmpStr[index]);
+                      strcat((char *)list_file.file_name[sel_id], "/");
+
+                  if (file_writer.fileTransfer == 1) {
+                    uint8_t dosName[FILENAME_LENGTH];
+                    uint8_t fileName[sizeof(list_file.file_name[sel_id])];
+                    fileName[0] = '\0';
+                    if (has_path_selected == 1) {
+                      strcat((char *)fileName, (char *)&tmpStr[index + 3]);
+                      strcat((char *)list_file.file_name[sel_id], "/");
+                    }
+                    else strcat((char *)fileName, (char *)&tmpStr[index]);
+                    if (!longName2DosName((const char *)fileName, dosName)) {
+                      strcpy(list_file.file_name[sel_id], "notValid");
+                    }
+                    strcat((char *)list_file.file_name[sel_id], (char *)dosName);
+                    strcat((char *)list_file.long_name[sel_id], (char *)dosName);
+                  }
+                  else {
+                    strcat((char *)list_file.file_name[sel_id], (char *)&tmpStr[index]);
+                    strcat((char *)list_file.long_name[sel_id], (char *)&tmpStr[index]);
+                  }
 
                 }
                 else
                   send_to_wifi((uint8_t *)"file.open failed\r\n", strlen("file.open failed\r\n"));
                   strcpy(list_file.file_name[sel_id], "notValid");
                 }
-                send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+                SEND_OK_TO_WIFI;
               }
             }
           }
 
                   SdFile file;
                   SdFile *curDir;
+                  card.endFilePrint();
                   const char * const fname = card.diveToFile(true, curDir, cur_name);
                   if (!fname) return;
                   if (file.open(curDir, fname, O_READ)) {
               lv_draw_printing();
             }
           }
-          send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+          SEND_OK_TO_WIFI;
           break;
 
         case 25:
             else
               default_preview_flg = true;
             lv_draw_printing();
-            send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+            SEND_OK_TO_WIFI;
           }
           break;
 
 
             lv_draw_ready_print();
 
-            send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+            SEND_OK_TO_WIFI;
           }
           break;
 
                   ZERO(tempBuf);
                   sprintf((char *)tempBuf, "Writing to file: %s\r\n", (char *)file_writer.saveFileName);
                   wifi_ret_ack();
-                  send_to_wifi((char *)tempBuf, strlen((char *)tempBuf));
-                  total_write = 0;
+                  send_to_wifi((uint8_t *)tempBuf, strlen((char *)tempBuf));
                   wifi_link_state = WIFI_WAIT_TRANS_START;
                 }
                 else {
         case 991:
           ZERO(tempBuf);
           if (cmd_value == 105) {
-            send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+            SEND_OK_TO_WIFI;
             sprintf((char *)tempBuf,"T:%.1f /%.1f B:%.1f /%.1f T0:%.1f /%.1f T1:%.1f /%.1f @:0 B@:0\r\n",
 
             (float)thermalManager.temp_hotend[0].celsius, (float)thermalManager.temp_hotend[0].target,
           }
           else if (uiCfg.print_state == PAUSED) {
             wifi_ret_ack();
-            send_to_wifi((char *)"M997 PAUSE\r\n", strlen("M997 PAUSE\r\n"));
+            send_to_wifi((uint8_t *)"M997 PAUSE\r\n", strlen("M997 PAUSE\r\n"));
           }
           else if (uiCfg.print_state == REPRINTING) {
             wifi_ret_ack();
 
         case 115:
           ZERO(tempBuf);
-          send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
-          send_to_wifi((char *)"FIRMWARE_NAME:Robin_nano\r\n", strlen("FIRMWARE_NAME:Robin_nano\r\n"));
+          SEND_OK_TO_WIFI;
+          send_to_wifi((uint8_t *)"FIRMWARE_NAME:Robin_nano\r\n", strlen("FIRMWARE_NAME:Robin_nano\r\n"));
           break;
 
         default:
                 index++;
               }
               if (left - WIFI_GCODE_BUFFER_LEAST_SIZE >= strlen((const char *)cmd_line))
-                send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+                SEND_OK_TO_WIFI;
               else
                 need_ok_later = true;
             }
             index++;
           }
           if (left_g - WIFI_GCODE_BUFFER_LEAST_SIZE >= strlen((const char *)cmd_line))
-            send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+            SEND_OK_TO_WIFI;
           else
             need_ok_later = true;
         }
   COPY(source, FileName_unicode);
 }
 
-char saveFilePath[50];
-
-static bool longName2DosName(const char* longName, uint8_t* dosName) {
-  uint8_t i = 11;
-  while (i--) dosName[i] = '\0';
-  while (*longName) {
-    uint8_t c = *longName++;
-    if (c == '.') {                   // For a dot...
-      if (i == 0) return false;
-      else { strcat((char *)dosName,".GCO"); return dosName[0] != '\0'; }
-    }
-    else {
-      // Fail for illegal characters
-      PGM_P p = PSTR("|<>^+=?/[];,*\"\\");
-      while (uint8_t b = pgm_read_byte(p++)) if (b == c) return false;
-      if (c < 0x21 || c == 0x7F) return false;           // Check size, non-printable characters
-      dosName[i++] = (c < 'a' || c > 'z') ? (c) : (c + ('A' - 'a')); // Uppercase required for 8.3 name
-    }
-    if (i >= 5) strcat((char *)dosName,"~1.GCO");
-  }
-  return dosName[0] != '\0';              // Return true if any name was set
-}
-
 static void file_first_msg_handle(uint8_t * msg, uint16_t msgLen) {
   uint8_t fileNameLen = *msg;
 
 
   utf8_2_unicode(file_writer.saveFileName,fileNameLen);
 
-  ZERO(file_writer.write_buf);
+  ZERO(public_buf);
 
   if (strlen((const char *)file_writer.saveFileName) > sizeof(saveFilePath))
     return;
   ZERO(saveFilePath);
 
   if (gCfgItems.fileSysType == FILE_SYS_SD) {
-    //sprintf((char *)saveFilePath, "/%s", file_writer.saveFileName);
-    card.mount();
-
-    //ZERO(list_file.long_name[sel_id]);
-    //memcpy(list_file.long_name[sel_id],file_writer.saveFileName,sizeof(list_file.long_name[sel_id]));
+    TERN_(SDSUPPORT, card.mount());
   }
   else if (gCfgItems.fileSysType == FILE_SYS_USB) {
 
       lv_draw_dialog(DIALOG_TYPE_UPLOAD_FILE);
       return;
     }
-    sprintf((char *)saveFilePath, "/%s", dosName);
-
-    ZERO(list_file.long_name[sel_id]);
-    memcpy(list_file.long_name[sel_id], dosName, sizeof(dosName));
+    sprintf((char *)saveFilePath, "%s", dosName);
 
-    char *cur_name=strrchr((const char *)saveFilePath,'/');
+    card.cdroot();
+    upload_file.close();
+    const char * const fname = card.diveToFile(true, upload_curDir, saveFilePath);
 
-    SdFile file;
-    SdFile *curDir;
-    card.endFilePrint();
-    const char * const fname = card.diveToFile(true, curDir, cur_name);
-    if (!fname) return;
-    if (file.open(curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC)) {
-      gCfgItems.curFilesize = file.fileSize();
-    }
-    else {
+    if (!upload_file.open(upload_curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC)) {
       clear_cur_ui();
       upload_result = 2;
+
       wifiTransError.flag = 1;
       wifiTransError.start_tick = getWifiTick();
+
       lv_draw_dialog(DIALOG_TYPE_UPLOAD_FILE);
       return;
     }
   lv_task_handler();
 
   file_writer.tick_begin = getWifiTick();
+
+  file_writer.fileTransfer = 1;
 }
 
-#define FRAG_MASK _BV32(31)
+#define FRAG_MASK ~_BV32(31)
 
 static void file_fragment_msg_handle(uint8_t * msg, uint16_t msgLen) {
   uint32_t frag = *((uint32_t *)msg);
-
   if ((frag & FRAG_MASK) != (uint32_t)(lastFragment + 1)) {
-    ZERO(file_writer.write_buf);
+    ZERO(public_buf);
     file_writer.write_index = 0;
     wifi_link_state = WIFI_CONNECTED;
     upload_result = 2;
   }
   else {
     if (write_to_file((char *)msg + 4, msgLen - 4) < 0) {
-      ZERO(file_writer.write_buf);
+      ZERO(public_buf);
       file_writer.write_index = 0;
       wifi_link_state = WIFI_CONNECTED;
       upload_result = 2;
     }
     lastFragment = frag;
 
-    if ((frag & (~FRAG_MASK))) {
-      int res = card.write(file_writer.write_buf, file_writer.write_index);
+    if ((frag & (~FRAG_MASK)) != 0) {
+      int res = upload_file.write(public_buf, file_writer.write_index);
       if (res == -1) {
-        ZERO(file_writer.write_buf);
+        upload_file.close();
+        const char * const fname = card.diveToFile(true, upload_curDir, saveFilePath);
+        if (upload_file.open(upload_curDir, fname, O_WRITE)) {
+          upload_file.setpos(&pos);
+          res = upload_file.write(public_buf, file_writer.write_index);
+        }
+      }
+      upload_file.close();
+      SdFile file, *curDir;
+      const char * const fname = card.diveToFile(true, curDir, saveFilePath);
+      if (file.open(curDir, fname, O_RDWR)) {
+        gCfgItems.curFilesize = file.fileSize();
+        file.close();
+      }
+      else {
+        ZERO(public_buf);
         file_writer.write_index = 0;
         wifi_link_state = WIFI_CONNECTED;
         upload_result = 2;
         return;
       }
-      ZERO(file_writer.write_buf);
+      ZERO(public_buf);
       file_writer.write_index = 0;
       file_writer.tick_end = getWifiTick();
       upload_time = getWifiTickDiff(file_writer.tick_begin, file_writer.tick_end) / 1000;
       wifi_link_state = WIFI_CONNECTED;
       upload_result = 3;
     }
-
   }
 }
 
         esp_msg_index = 0;
         return;
       }
-
       if ((charAtArray(esp_msg_buf, esp_msg_index,  ESP_PROTOC_HEAD) != -1) && (charAtArray(esp_msg_buf, esp_msg_index, ESP_PROTOC_TAIL) != -1))
         loop_again = true;
     }
 }
 
 int32_t tick_net_time1, tick_net_time2;
-
-int storeRcvData(int32_t len) {
-  unsigned char tmpW = wifiDmaRcvFifo.write_cur;
-  if (len <= UDISKBUFLEN && wifiDmaRcvFifo.state[tmpW] == udisk_buf_empty) {
-    for (uint16_t i = 0; i < len; i++)
-      wifiDmaRcvFifo.bufferAddr[tmpW][i] = WIFISERIAL.read();
-    wifiDmaRcvFifo.state[tmpW] = udisk_buf_full;
-    wifiDmaRcvFifo.write_cur = (tmpW + 1) % TRANS_RCV_FIFO_BLOCK_NUM;
-    return 1;
-  }
-  return 0;
-}
-
 int32_t readWifiFifo(uint8_t *retBuf, uint32_t bufLen) {
   unsigned char tmpR = wifiDmaRcvFifo.read_cur;
   if (bufLen >= UDISKBUFLEN && wifiDmaRcvFifo.state[tmpR] == udisk_buf_full) {
     wifiTransError.start_tick = getWifiTick();
     card.removeFile((const char *)saveFilePath);
   }
-  else {
-  }
+
   wifi_delay(200);
   WIFI_IO1_SET();
-  //exchangeFlashMode(1);  //change spi flash to use dma mode
+
+  // disable dma
+  dma_clear_isr_bits(DMA1, DMA_CH5);
+  bb_peri_set_bit(&USART1_BASE->CR3, USART_CR3_DMAR_BIT, 0);
+  dma_disable(DMA1, DMA_CH5);
+
+  wifi_delay(200);
+  changeFlashMode(true); // Set SPI flash to use DMA mode
   esp_port_begin(1);
+  wifi_delay(200);
+
+  W25QXX.init(SPI_QUARTER_SPEED);
+
+  TERN_(HAS_TFT_LVGL_UI_SPI, SPI_TFT.spi_init(SPI_FULL_SPEED));
+  TERN_(HAS_SERVOS, servo_init());
+  TERN_(HAS_Z_SERVO_PROBE, probe.servo_probe_init());
+
   if (wifiTransError.flag != 0x1) WIFI_IO1_RESET();
 }
 
 void wifi_rcv_handle() {
   int32_t len = 0;
-  uint8_t ucStr[(UART_RX_BUFFER_SIZE) + 1] = { 0 };
+  uint8_t ucStr[(UART_RX_BUFFER_SIZE) + 1] = {0};
   int8_t getDataF = 0;
-
   if (wifi_link_state == WIFI_TRANS_FILE) {
     #if 0
       if (WIFISERIAL.available() == UART_RX_BUFFER_SIZE) {
       getDataF = 1;
     }
     if (esp_state == TRANSFER_STORE) {
-      if (storeRcvData(UART_RX_BUFFER_SIZE)) {
+      if (storeRcvData(WIFISERIAL.usart_device->rb->buf, UART_RX_BUFFER_SIZE)) {
         esp_state = TRANSFERING;
-        //esp_dma_pre();
+        esp_dma_pre();
         if (wifiTransError.flag != 0x1) WIFI_IO1_RESET();
       }
       else
     }
   }
   else {
-    //len = readUsartFifo((SZ_USART_FIFO *)&WifiRxFifo, (int8_t *)ucStr, UART_RX_BUFFER_SIZE);
     len = readWifiBuf((int8_t *)ucStr, UART_RX_BUFFER_SIZE);
     if (len > 0) {
       esp_data_parser((char *)ucStr, len);
-
       if (wifi_link_state == WIFI_TRANS_FILE) {
-        //exchangeFlashMode(0);  //change spi flash not use dma mode
+        changeFlashMode(false); // Set SPI flash to use non-DMA mode
         wifi_delay(10);
         esp_port_begin(0);
         wifi_delay(10);
     }
     if (need_ok_later &&  (queue.length < BUFSIZE)) {
       need_ok_later = false;
-      send_to_wifi((char *)"ok\r\n", strlen("ok\r\n"));
+      send_to_wifi((uint8_t *)"ok\r\n", strlen("ok\r\n"));
     }
   }
 
     tick_net_time2 = getWifiTick();
 
     if (wifi_link_state == WIFI_TRANS_FILE) {
-      if ((tick_net_time1 != 0) && (getWifiTickDiff(tick_net_time1, tick_net_time2) > 4500)) {
+      if (tick_net_time1 && getWifiTickDiff(tick_net_time1, tick_net_time2) > 8000) {
         wifi_link_state = WIFI_CONNECTED;
         upload_result = 2;
         clear_cur_ui();
         lv_draw_dialog(DIALOG_TYPE_UPLOAD_FILE);
       }
     }
-
-    if ((tick_net_time1 != 0) && (getWifiTickDiff(tick_net_time1, tick_net_time2) > 10000))
+    if (tick_net_time1 && getWifiTickDiff(tick_net_time1, tick_net_time2) > 10000)
       wifi_link_state = WIFI_NOT_CONFIG;
 
-    if ((tick_net_time1 != 0) && (getWifiTickDiff(tick_net_time1, tick_net_time2) > 120000)) {
+    if (tick_net_time1 && getWifiTickDiff(tick_net_time1, tick_net_time2) > 120000) {
       wifi_link_state = WIFI_NOT_CONFIG;
       wifi_reset();
       tick_net_time1 = getWifiTick();
 }
 
 void wifi_looping() {
-  do { wifi_rcv_handle(); } while (wifi_link_state == WIFI_TRANS_FILE);
+  do {
+    wifi_rcv_handle();
+    watchdog_refresh();
+  } while (wifi_link_state == WIFI_TRANS_FILE);
 }
 
 void mks_esp_wifi_init() {
   wifi_reset();
 
   #if 0
-    res = f_open(&esp_upload.uploadFile, ESP_FIRMWARE_FILE,  FA_OPEN_EXISTING | FA_READ);
-
-    if (res ==  FR_OK) {
-      f_close(&esp_upload.uploadFile);
-
-      wifi_delay(2000);
-
-      if (usartFifoAvailable((SZ_USART_FIFO *)&WifiRxFifo) < 20) {
-        return;
-      }
-
-      clear_cur_ui();
-
-      draw_dialog(DIALOG_TYPE_UPDATE_ESP_FIRMARE);
-
-      if (wifi_upload(0) >= 0) {
-
-        f_unlink("1:/MKS_WIFI_CUR");
-        f_rename(ESP_FIRMWARE_FILE,"/MKS_WIFI_CUR");
-      }
-      draw_return_ui();
-
-      update_flag = 1;
-    }
-    if (update_flag == 0) {
-      res = f_open(&esp_upload.uploadFile, ESP_WEB_FIRMWARE_FILE,  FA_OPEN_EXISTING | FA_READ);
+  if (update_flag == 0) {
+    res = f_open(&esp_upload.uploadFile, ESP_WEB_FIRMWARE_FILE,  FA_OPEN_EXISTING | FA_READ);
 
       if (res ==  FR_OK) {
         f_close(&esp_upload.uploadFile);
   wifi_link_state = WIFI_NOT_CONFIG;
 }
 
-#define BUF_INC_POINTER(p)  ((p + 1 == UART_FIFO_BUFFER_SIZE) ? 0 : (p + 1))
 
-int usartFifoAvailable(SZ_USART_FIFO *fifo) {
-  int diff = fifo->uart_write_point - fifo->uart_read_point;
-  if (diff < 0) diff += UART_FIFO_BUFFER_SIZE;
-  return diff;
-}
+void mks_wifi_firmware_update() {
+  card.openFileRead((char *)ESP_FIRMWARE_FILE);
+
+  if (card.isFileOpen()) {
+    card.closefile();
+
+    wifi_delay(2000);
 
-int readUsartFifo(SZ_USART_FIFO *fifo, int8_t *buf, int32_t len) {
-  int i = 0 ;
-  while (i < len && fifo->uart_read_point != fifo->uart_write_point) {
-    buf[i++] = fifo->uartTxBuffer[fifo->uart_read_point];
-    fifo->uart_read_point = BUF_INC_POINTER(fifo->uart_read_point);
+    if (usartFifoAvailable((SZ_USART_FIFO *)&WifiRxFifo) < 20)
+      return;
+
+    clear_cur_ui();
+
+    lv_draw_dialog(DIALOG_TYPE_UPDATE_ESP_FIRMARE);
+
+    lv_task_handler();
+    watchdog_refresh();
+
+    if (wifi_upload(0) >= 0) {
+      card.removeFile((char *)ESP_FIRMWARE_FILE_RENAME);
+      SdFile file, *curDir;
+      const char * const fname = card.diveToFile(true, curDir, ESP_FIRMWARE_FILE);
+      if (file.open(curDir, fname, O_READ)) {
+        file.rename(curDir, (char *)ESP_FIRMWARE_FILE_RENAME);
+        file.close();
+      }
+    }
+    clear_cur_ui();
   }
-  return i;
 }
 
-int writeUsartFifo(SZ_USART_FIFO *fifo, int8_t *buf, int32_t len) {
-  if (buf == 0 || len <= 0) return -1;
+#define BUF_INC_POINTER(p)  ((p + 1 == UART_FIFO_BUFFER_SIZE) ? 0:(p + 1))
 
-  int i = 0 ;
-  while (i < len && fifo->uart_read_point != BUF_INC_POINTER(fifo->uart_write_point)) {
-    fifo->uartTxBuffer[fifo->uart_write_point] = buf[i++];
-    fifo->uart_write_point = BUF_INC_POINTER(fifo->uart_write_point);
-  }
-  return i;
+int usartFifoAvailable(SZ_USART_FIFO *fifo) {
+  return WIFISERIAL.available();
 }
 
 void get_wifi_commands() {
         if (!wifi_comment_mode) wifi_line_buffer[wifi_read_count++] = wifi_char;
       }
     }
-  }// queue has space, serial has data
-  else {
+  } // queue has space, serial has data
+  else
     espGcodeFifo.wait_tick++;
-  }
 }
 
 int readWifiBuf(int8_t *buf, int32_t len) {

Marlin/src/lcd/extui/lib/mks_ui/wifi_module.h

 #define UART_RX_BUFFER_SIZE   1024
 #define UART_FIFO_BUFFER_SIZE 1024
 
-#define ESP_WIFI              0x02
-
-#define AP_MODEL              0x01
-#define STA_MODEL             0x02
-
 #define WIFI_DECODE_TYPE      1
 
 #define IP_DHCP_FLAG          1
   udisk_buf_full,
 } UDISK_DATA_BUFFER_STATE;
 
-#define TRANS_RCV_FIFO_BLOCK_NUM    8
+#define TRANS_RCV_FIFO_BLOCK_NUM  14
 
 typedef struct {
   unsigned char *bufferAddr[TRANS_RCV_FIFO_BLOCK_NUM];
 typedef struct {
   uint32_t uart_read_point;
   uint32_t uart_write_point;
-  uint8_t uartTxBuffer[UART_FIFO_BUFFER_SIZE];
+  //uint8_t uartTxBuffer[UART_FIFO_BUFFER_SIZE];
 } SZ_USART_FIFO;
 
 #define WIFI_GCODE_BUFFER_LEAST_SIZE    96
 extern void get_wifi_list_command_send();
 extern void get_wifi_commands();
 extern int  readWifiBuf(int8_t *buf, int32_t len);
-extern int  storeRcvData(int32_t len);
+extern void mks_wifi_firmware_update();
 
 #ifdef __cplusplus
   } /* C-declarations for C++ */

Marlin/src/lcd/extui/lib/mks_ui/wifi_upload.cpp

 #include "wifi_upload.h"
 
 #include "../../../../MarlinCore.h"
+#include "../../../../sd/cardreader.h"
 
 #define WIFI_SET()        WRITE(WIFI_RESET_PIN, HIGH);
 #define WIFI_RESET()      WRITE(WIFI_RESET_PIN, LOW);
 static const uint32_t eraseTimeout = 15000;
 static const uint32_t blockWriteTimeout = 200;
 static const uint32_t blockWriteInterval = 15;      // 15ms is long enough, 10ms is mostly too short
+static SdFile update_file, *update_curDir;
 
 // Messages corresponding to result codes, should make sense when followed by " error"
 const char *resultMessages[] = {
   return esp_upload.state == upload_idle;
 }
 
-void uploadPort_write(const uint8_t *buf, size_t len) {
-  #if 0
-  int i;
-
-  for (i = 0; i < len; i++) {
-    while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) { /* nada */ }
-    USART_SendData(USART1, *(buf + i));
-  }
-  #endif
+void uploadPort_write(const uint8_t *buf, const size_t len) {
+  for (size_t i = 0; i < len; i++)
+    WIFISERIAL.write(*(buf + i));
 }
 
 char uploadPort_read() {
   uint8_t retChar;
-  if (readUsartFifo(&WifiRxFifo, (int8_t *)&retChar, 1) == 1)
-    return retChar;
-  else
-    return 0;
+  retChar = WIFISERIAL.read();
+  return _MAX(retChar, 0);
 }
 
 int uploadPort_available() {
 // Extract 1-4 bytes of a value in little-endian order from a buffer beginning at a specified offset
 uint32_t getData(unsigned byteCnt, const uint8_t *buf, int ofst) {
   uint32_t val = 0;
-
   if (buf && byteCnt) {
     unsigned int shiftCnt = 0;
-    if (byteCnt > 4)
-      byteCnt = 4;
-    do{
+    NOMORE(byteCnt, 4);
+    do {
       val |= (uint32_t)buf[ofst++] << shiftCnt;
       shiftCnt += 8;
     } while (--byteCnt);
   }
-  return(val);
+  return val;
 }
 
 // Put 1-4 bytes of a value in little-endian order into a buffer beginning at a specified offset.
 void putData(uint32_t val, unsigned byteCnt, uint8_t *buf, int ofst) {
   if (buf && byteCnt) {
-    if (byteCnt > 4) {
-      byteCnt = 4;
-    }
+    NOMORE(byteCnt, 4);
     do {
       buf[ofst++] = (uint8_t)(val & 0xFF);
       val >>= 8;
 //   -2 - a SLIP escape byte was found but the following byte wasn't available
 //   -3 - a SLIP escape byte was followed by an invalid byte
 int ReadByte(uint8_t *data, signed char slipDecode) {
-  if (uploadPort_available() == 0) {
-    return(0);
-  }
+  if (uploadPort_available() == 0) return 0;
 
-  // at least one byte is available
+  // At least one byte is available
   *data = uploadPort_read();
-  if (!slipDecode) {
-    return(1);
-  }
 
-  if (*data == 0xC0) {
-    // this shouldn't happen
-    return(-1);
-  }
+  if (!slipDecode) return 1;
 
-  // if not the SLIP escape, we're done
-  if (*data != 0xDB) {
-    return(1);
-  }
+  if (*data == 0xC0) return -1; // This shouldn't happen
+  if (*data != 0xDB) return 1;  // If not the SLIP escape, we're done
 
   // SLIP escape, check availability of subsequent byte
-  if (uploadPort_available() == 0) {
-    return(-2);
-  }
+  if (uploadPort_available() == 0) return -2;
 
   // process the escaped byte
   *data = uploadPort_read();
-  if (*data == 0xDC) {
-    *data = 0xC0;
-    return(2);
-  }
+  if (*data == 0xDC) { *data = 0xC0; return 2; }
+  if (*data == 0xDD) { *data = 0xDB; return 2; }
 
-  if (*data == 0xDD) {
-    *data = 0xDB;
-    return(2);
-  }
-  // invalid
-  return(-3);
+  return -3; // invalid
 }
 // When we write a sync packet, there must be no gaps between most of the characters.
 // So use this function, which does a block write to the UART buffer in the latest CoreNG.
 }
 
 // Write a byte to the serial port optionally SLIP encoding. Return the number of bytes actually written.
-void WriteByteSlip(uint8_t b) {
+void WriteByteSlip(const uint8_t b) {
   if (b == 0xC0) {
     WriteByteRaw(0xDB);
     WriteByteRaw(0xDC);
     WriteByteRaw(0xDB);
     WriteByteRaw(0xDD);
   }
-  else {
+  else
     uploadPort_write((const uint8_t *)&b, 1);
-  }
 }
 
 // Wait for a data packet to be returned.  If the body of the packet is
     EspUploadResult stat;
 
     //IWDG_ReloadCounter();
+    watchdog_refresh();
 
-    if (getWifiTickDiff(startTime, getWifiTick()) > msTimeout) {
-      return(timeout);
-    }
+    if (getWifiTickDiff(startTime, getWifiTick()) > msTimeout)
+      return timeout;
 
     if (uploadPort_available() < needBytes) {
       // insufficient data available
     switch (state) {
       case begin: // expecting frame start
         c = uploadPort_read();
-        if (c != (uint8_t)0xC0) {
-          break;
-        }
+        if (c == (uint8_t)0xC0) break;
         state = header;
         needBytes = 2;
         break;
         break;
 
       case header:  // reading an 8-byte header
-      case body:    // reading the response body
-        {
-          int rslt;
-          // retrieve a byte with SLIP decoding
-          rslt = ReadByte(&c, 1);
-          if (rslt != 1 && rslt != 2) {
-            // some error occurred
-            stat = (rslt == 0 || rslt == -2) ? slipData : slipFrame;
-            return stat;
-          }
-          else if (state == header) {
-            //store the header byte
-            hdr[hdrIdx++] = c;
-            if (hdrIdx >= headerLength) {
-              // get the body length, prepare a buffer for it
-              *bodyLen = (uint16_t)getData(2, hdr, 2);
-
-              // extract the value, if requested
-              if (valp != 0) {
-                *valp = getData(4, hdr, 4);
-              }
-
-              if (*bodyLen != 0) {
-                state = body;
-              }
-              else {
-                needBytes = 1;
-                state = end;
-              }
-            }
-          }
-          else {
-            // Store the response body byte, check for completion
-            if (bodyIdx < ARRAY_SIZE(respBuf)) {
-              respBuf[bodyIdx] = c;
-            }
-            ++bodyIdx;
-            if (bodyIdx >= *bodyLen) {
+      case body: {  // reading the response body
+        int rslt;
+        // retrieve a byte with SLIP decoding
+        rslt = ReadByte(&c, 1);
+        if (rslt != 1 && rslt != 2) {
+          // some error occurred
+          stat = (rslt == 0 || rslt == -2) ? slipData : slipFrame;
+          return stat;
+        }
+        else if (state == header) {
+          //store the header byte
+          hdr[hdrIdx++] = c;
+          if (hdrIdx >= headerLength) {
+            // get the body length, prepare a buffer for it
+            *bodyLen = (uint16_t)getData(2, hdr, 2);
+
+            // extract the value, if requested
+            if (valp)
+              *valp = getData(4, hdr, 4);
+
+            if (*bodyLen != 0)
+              state = body;
+            else {
               needBytes = 1;
               state = end;
             }
           }
         }
-        break;
+        else {
+          // Store the response body byte, check for completion
+          if (bodyIdx < ARRAY_SIZE(respBuf))
+            respBuf[bodyIdx] = c;
+
+          if (++bodyIdx >= *bodyLen) {
+            needBytes = 1;
+            state = end;
+          }
+        }
+      } break;
 
       default: return slipState;  // this shouldn't happen
     }
   resp = (uint8_t)getData(1, hdr, 0);
   opRet = (uint8_t)getData(1, hdr, 1);
   // Sync packets often provoke a response with a zero opcode instead of ESP_SYNC
-  if (resp != 0x01 || opRet != op) {
-    return respHeader;
-  }
+  if (resp != 0x01 || opRet != op) return respHeader;
 
   return success;
 }
     for (;;) {
       size_t bodyLen;
       EspUploadResult rc = readPacket(ESP_SYNC, 0, &bodyLen, defaultTimeout);
+      watchdog_refresh();
       if (rc != success || bodyLen != 2) break;
     }
   }
 }
 
 EspUploadResult flashWriteBlock(uint16_t flashParmVal, uint16_t flashParmMask) {
-  #if 0
   const uint32_t blkSize = EspFlashBlockSize;
   int i;
 
   putData(0, 4, blkBuf, hdrOfst + 12);
 
   // Get the data for the block
-  f_read(&esp_upload.uploadFile, blkBuf + dataOfst,  blkSize, &cnt );//->Read(reinterpret_cast<char *>(blkBuf + dataOfst), blkSize);
+  cnt = update_file.read(blkBuf + dataOfst, blkSize); //->Read(reinterpret_cast<char *>(blkBuf + dataOfst), blkSize);
   if (cnt != blkSize) {
-    if (f_tell(&esp_upload.uploadFile) == esp_upload.fileSize) {
+    if (update_file.curPosition() == esp_upload.fileSize) {
       // partial last block, fill the remainder
       memset(blkBuf + dataOfst + cnt, 0xFF, blkSize - cnt);
     }
-    else {
+    else
       return fileRead;
-    }
   }
 
   // Patch the flash parameters into the first block if it is loaded at address 0
     if ((stat = doCommand(ESP_FLASH_DATA, blkBuf, blkBufSize, cksum, 0, blockWriteTimeout)) == success)
       break;
   return stat;
-  #else
-    return success;
-  #endif
 }
 
 void upload_spin() {
-  #if 0
-  switch (esp_upload.state) {
-  case resetting:
-
-    if (esp_upload.connectAttemptNumber == 9) {
-      // Time to give up
-      //Network::ResetWiFi();
-      esp_upload.uploadResult = connected;
-      esp_upload.state = done;
-    }
-    else {
-
-      // Reset the serial port at the new baud rate. Also reset the ESP8266.
-      //  const uint32_t baud = uploadBaudRates[esp_upload.connectAttemptNumber/esp_upload.retriesPerBaudRate];
-      if (esp_upload.connectAttemptNumber % esp_upload.retriesPerBaudRate == 0) {
-      }
-      //uploadPort.begin(baud);
-      //uploadPort_close();
-
-      uploadPort_begin();
-
-      wifi_delay(2000);
-
-      flushInput();
-
-      esp_upload.lastAttemptTime = esp_upload.lastResetTime = getWifiTick();
-      esp_upload.state = connecting;
-    }
 
-    break;
-
-  case connecting:
-    if ((getWifiTickDiff(esp_upload.lastAttemptTime, getWifiTick()) >= connectAttemptInterval) && (getWifiTickDiff(esp_upload.lastResetTime, getWifiTick()) >= 500)) {
-      // Attempt to establish a connection to the ESP8266.
-      EspUploadResult res = Sync(5000);
-      esp_upload.lastAttemptTime = getWifiTick();
-      if (res == success) {
-        // Successful connection
-        //MessageF(" success on attempt %d\n", (connectAttemptNumber % retriesPerBaudRate) + 1);
-        //printf("connect success\n");
-        esp_upload.state = erasing;
-      }
-      else {
-        // This attempt failed
-        esp_upload.connectAttemptNumber++;
-        if (esp_upload.connectAttemptNumber % retriesPerReset == 0) {
-          esp_upload.state = resetting;   // try a reset and a lower baud rate
-        }
-      }
-    }
-    break;
-
-  case erasing:
-    if (getWifiTickDiff(esp_upload.lastAttemptTime, getWifiTick()) >= blockWriteInterval) {
-      uint32_t eraseSize;
-      const uint32_t sectorsPerBlock = 16;
-      const uint32_t sectorSize = 4096;
-      const uint32_t numSectors = (esp_upload.fileSize + sectorSize - 1)/sectorSize;
-      const uint32_t startSector = esp_upload.uploadAddress/sectorSize;
-
-      uint32_t headSectors = sectorsPerBlock - (startSector % sectorsPerBlock);
-      NOMORE(headSectors, numSectors);
-
-      eraseSize = (numSectors < 2 * headSectors)
-                ? (numSectors + 1) / 2 * sectorSize
-                : (numSectors - headSectors) * sectorSize;
-
-      //MessageF("Erasing %u bytes...\n", fileSize);
-      esp_upload.uploadResult = flashBegin(esp_upload.uploadAddress, eraseSize);
-      if (esp_upload.uploadResult == success) {
-        //MessageF("Uploading file...\n");
-        esp_upload.uploadBlockNumber = 0;
-        esp_upload.uploadNextPercentToReport = percentToReportIncrement;
-        esp_upload.lastAttemptTime = getWifiTick();
-        esp_upload.state = uploading;
+  switch (esp_upload.state) {
+    case resetting:
+      if (esp_upload.connectAttemptNumber == 9) {
+        esp_upload.uploadResult = connected;
+        esp_upload.state = done;
       }
       else {
-        //MessageF("Erase failed\n");
-        esp_upload.state = done;
+        uploadPort_begin();
+        wifi_delay(2000);
+        flushInput();
+        esp_upload.lastAttemptTime = esp_upload.lastResetTime = getWifiTick();
+        esp_upload.state = connecting;
       }
-    }
-    break;
-
-  case uploading:
-    // The ESP needs several milliseconds to recover from one packet before it will accept another
-    if (getWifiTickDiff(esp_upload.lastAttemptTime, getWifiTick()) >= 15) {
-      unsigned int percentComplete;
-      const uint32_t blkCnt = (esp_upload.fileSize + EspFlashBlockSize - 1) / EspFlashBlockSize;
-      if (esp_upload.uploadBlockNumber < blkCnt) {
-        esp_upload.uploadResult = flashWriteBlock(0, 0);
+      break;
+
+    case connecting:
+      if ((getWifiTickDiff(esp_upload.lastAttemptTime, getWifiTick()) >= connectAttemptInterval) && (getWifiTickDiff(esp_upload.lastResetTime, getWifiTick()) >= 500)) {
+        EspUploadResult res = Sync(5000);
         esp_upload.lastAttemptTime = getWifiTick();
-        if (esp_upload.uploadResult != success) {
-          //MessageF("Flash block upload failed\n");
-          esp_upload.state = done;
+        if (res == success)
+          esp_upload.state = erasing;
+        else {
+          esp_upload.connectAttemptNumber++;
+          if (esp_upload.connectAttemptNumber % retriesPerReset == 0)
+            esp_upload.state = resetting;
         }
-        percentComplete = (100 * esp_upload.uploadBlockNumber)/blkCnt;
-        ++esp_upload.uploadBlockNumber;
-        if (percentComplete >= esp_upload.uploadNextPercentToReport) {
-          //MessageF("%u%% complete\n", percentComplete);
-          esp_upload.uploadNextPercentToReport += percentToReportIncrement;
-        }
-      }
-      else {
-        esp_upload.state = done;
       }
-    }
-    break;
+      break;
 
-  case done:
-    f_close(&esp_upload.uploadFile);
-    //uploadPort.end();
-    //uploadPort_close();
+    case erasing:
+      if (getWifiTickDiff(esp_upload.lastAttemptTime, getWifiTick()) >= blockWriteInterval) {
+        uint32_t eraseSize;
+        const uint32_t sectorsPerBlock = 16;
+        const uint32_t sectorSize = 4096;
+        const uint32_t numSectors = (esp_upload.fileSize + sectorSize - 1)/sectorSize;
+        const uint32_t startSector = esp_upload.uploadAddress/sectorSize;
+
+        uint32_t headSectors = sectorsPerBlock - (startSector % sectorsPerBlock);
+        NOMORE(headSectors, numSectors);
+
+        eraseSize = (numSectors < 2 * headSectors)
+                  ? (numSectors + 1) / 2 * sectorSize
+                  : (numSectors - headSectors) * sectorSize;
+
+        esp_upload.uploadResult = flashBegin(esp_upload.uploadAddress, eraseSize);
+        if (esp_upload.uploadResult == success) {
+          esp_upload.uploadBlockNumber = 0;
+          esp_upload.uploadNextPercentToReport = percentToReportIncrement;
+          esp_upload.lastAttemptTime = getWifiTick();
+          esp_upload.state = uploading;
+        }
+        else
+          esp_upload.state = done;
+      }
+      break;
 
-    //WIFI_COM.begin(115200, true);
-    //wifi_init();
+    case uploading:
+      // The ESP needs several milliseconds to recover from one packet before it will accept another
+      if (getWifiTickDiff(esp_upload.lastAttemptTime, getWifiTick()) >= 15) {
+        unsigned int percentComplete;
+        const uint32_t blkCnt = (esp_upload.fileSize + EspFlashBlockSize - 1) / EspFlashBlockSize;
+        if (esp_upload.uploadBlockNumber < blkCnt) {
+          esp_upload.uploadResult = flashWriteBlock(0, 0);
+          esp_upload.lastAttemptTime = getWifiTick();
+          if (esp_upload.uploadResult != success)
+            esp_upload.state = done;
+          percentComplete = (100 * esp_upload.uploadBlockNumber)/blkCnt;
+          ++esp_upload.uploadBlockNumber;
+          if (percentComplete >= esp_upload.uploadNextPercentToReport)
+            esp_upload.uploadNextPercentToReport += percentToReportIncrement;
+        }
+        else
+          esp_upload.state = done;
+      }
+      break;
 
-    if (esp_upload.uploadResult == success) {
-      //printf("upload successfully\n");
-    }
-    else {
-      //printf("upload failed\n");
-    }
-    esp_upload.state = upload_idle;//idle;
-    break;
+    case done:
+      update_file.close();
+      esp_upload.state = upload_idle;
+      break;
 
     default: break;
   }
-  #endif
 }
 
 // Try to upload the given file at the given address
 void SendUpdateFile(const char *file, uint32_t address) {
-  #if 0
-  FRESULT res = f_open(&esp_upload.uploadFile, file,  FA_OPEN_EXISTING | FA_READ);
+  const char * const fname = card.diveToFile(true, update_curDir, ESP_FIRMWARE_FILE);
+  if (!update_file.open(update_curDir, fname, O_READ)) return;
 
-  if (res !=  FR_OK) return;
+  esp_upload.fileSize = update_file.fileSize();
 
-  esp_upload.fileSize = f_size(&esp_upload.uploadFile);
   if (esp_upload.fileSize == 0) {
-    f_close(&esp_upload.uploadFile);
+    update_file.close();
     return;
   }
-  f_lseek(&esp_upload.uploadFile, 0);
 
   esp_upload.uploadAddress = address;
   esp_upload.connectAttemptNumber = 0;
   esp_upload.state = resetting;
-  #endif
 }
 
 static const uint32_t FirmwareAddress = 0x00000000, WebFilesAddress = 0x00100000;
 
 void ResetWiFiForUpload(int begin_or_end) {
-  #if 0
-    uint32_t start, now;
-
-    GPIO_InitTypeDef GPIO_InitStructure;
-
-    #if V1_0_V1_1
-      GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
-      GPIO_InitStructure.Pin = GPIO_Pin_8;
-      GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
-      HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
-    #else
-      GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;
-      GPIO_InitStructure.Pin = GPIO_Pin_13;
-      GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
-      HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);
-    #endif
-    start = getWifiTick();
-    now = start;
-
-    if (begin_or_end == 0) {
-      #if V1_0_V1_1
-        HAL_GPIO_WritePin(GPIOA,GPIO_Pin_8,GPIO_PIN_RESET); //update mode
-      #else
-        HAL_GPIO_WritePin(GPIOC,GPIO_Pin_13,GPIO_PIN_RESET); //update mode
-      #endif
-    }
-    else {
-      #if V1_0_V1_1
-        #if V1_0_V1_1
-          HAL_GPIO_WritePin(GPIOA,GPIO_Pin_8,GPIO_PIN_SET); //boot mode
-          GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
-          GPIO_InitStructure.Pin = GPIO_Pin_8;
-          GPIO_InitStructure.Mode = GPIO_MODE_INPUT;
-          HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
-        #endif
-      #else
-        HAL_GPIO_WritePin(GPIOC,GPIO_Pin_13,GPIO_PIN_SET); //boot mode
-        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;
-        GPIO_InitStructure.Pin = GPIO_Pin_13;
-        GPIO_InitStructure.Mode = GPIO_MODE_INPUT;
-        HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);
-      #endif
-    }
-    WIFI_RESET();
-    while (getWifiTickDiff(start, now) < 500) now = getWifiTick();
-    WIFI_SET();
-  #endif
+  //#if 0
+  uint32_t start, now;
+
+  start = getWifiTick();
+  now = start;
+
+  if (begin_or_end == 0) {
+    SET_OUTPUT(WIFI_IO0_PIN);
+    WRITE(WIFI_IO0_PIN, LOW);
+  }
+  else
+    SET_INPUT_PULLUP(WIFI_IO0_PIN);
+
+  WIFI_RESET();
+  while (getWifiTickDiff(start, now) < 500) now = getWifiTick();
+  WIFI_SET();
+  //#endif
 }
 
 int32_t wifi_upload(int type) {
 
   while (esp_upload.state != upload_idle) {
     upload_spin();
-    //IWDG_ReloadCounter();
+    watchdog_refresh();
   }
 
   ResetWiFiForUpload(1);

Marlin/src/lcd/extui/lib/mks_ui/wifi_upload.h

   extern "C" { /* C-declarations for C++ */
 #endif
 
-#define ESP_FIRMWARE_FILE     "1:/MksWifi.bin"
-#define ESP_WEB_FIRMWARE_FILE "1:/MksWifi_Web.bin"
-#define ESP_WEB_FILE          "1:/MksWifi_WebView.bin"
+#define ESP_FIRMWARE_FILE         "MksWifi.bin"
+#define ESP_FIRMWARE_FILE_RENAME  "MKSWIFI.CUR"
+#define ESP_WEB_FIRMWARE_FILE     "1:/MksWifi_Web.bin"
+#define ESP_WEB_FILE              "1:/MksWifi_WebView.bin"
 
 typedef enum {
   upload_idle,

Marlin/src/libs/W25Qxx.cpp

 #define W25QXX_CS_H OUT_WRITE(SPI_FLASH_CS_PIN, HIGH)
 #define W25QXX_CS_L OUT_WRITE(SPI_FLASH_CS_PIN, LOW)
 
+bool flash_dma_mode = true;
+
 void W25QXXFlash::init(uint8_t spiRate) {
 
   OUT_WRITE(SPI_FLASH_CS_PIN, HIGH);
 }
 
 void W25QXXFlash::SPI_FLASH_WriteEnable(void) {
-  /* Select the FLASH: Chip Select low */
+  // Select the FLASH: Chip Select low
   W25QXX_CS_L;
-  /* Send "Write Enable" instruction */
+  // Send "Write Enable" instruction
   spi_flash_Send(W25X_WriteEnable);
-  /* Deselect the FLASH: Chip Select high */
+  // Deselect the FLASH: Chip Select high
   W25QXX_CS_H;
 }
 
 void W25QXXFlash::SPI_FLASH_WaitForWriteEnd(void) {
   uint8_t FLASH_Status = 0;
 
-  /* Select the FLASH: Chip Select low */
+  // Select the FLASH: Chip Select low
   W25QXX_CS_L;
-  /* Send "Read Status Register" instruction */
+  // Send "Read Status Register" instruction
   spi_flash_Send(W25X_ReadStatusReg);
 
-  /* Loop as long as the memory is busy with a write cycle */
+  // Loop as long as the memory is busy with a write cycle
   do
     /* Send a dummy byte to generate the clock needed by the FLASH
     and put the value of the status register in FLASH_Status variable */
     FLASH_Status = spi_flash_Rec();
-  while ((FLASH_Status & WIP_Flag) == 0x01); /* Write in progress */
+  while ((FLASH_Status & WIP_Flag) == 0x01); // Write in progress
 
-  /* Deselect the FLASH: Chip Select high */
+  // Deselect the FLASH: Chip Select high
   W25QXX_CS_H;
 }
 
 void W25QXXFlash::SPI_FLASH_SectorErase(uint32_t SectorAddr) {
-  /* Send write enable instruction */
+  // Send write enable instruction
   SPI_FLASH_WriteEnable();
 
-  /* Sector Erase */
-  /* Select the FLASH: Chip Select low */
+  // Sector Erase
+  // Select the FLASH: Chip Select low
   W25QXX_CS_L;
-  /* Send Sector Erase instruction */
+  // Send Sector Erase instruction
   spi_flash_Send(W25X_SectorErase);
-  /* Send SectorAddr high nibble address byte */
+  // Send SectorAddr high nibble address byte
   spi_flash_Send((SectorAddr & 0xFF0000) >> 16);
-  /* Send SectorAddr medium nibble address byte */
+  // Send SectorAddr medium nibble address byte
   spi_flash_Send((SectorAddr & 0xFF00) >> 8);
-  /* Send SectorAddr low nibble address byte */
+  // Send SectorAddr low nibble address byte
   spi_flash_Send(SectorAddr & 0xFF);
-  /* Deselect the FLASH: Chip Select high */
+  // Deselect the FLASH: Chip Select high
 
   W25QXX_CS_H;
-  /* Wait the end of Flash writing */
+  // Wait the end of Flash writing
   SPI_FLASH_WaitForWriteEnd();
 }
 
 void W25QXXFlash::SPI_FLASH_BlockErase(uint32_t BlockAddr) {
   SPI_FLASH_WriteEnable();
   W25QXX_CS_L;
-  /* Send Sector Erase instruction */
+  // Send Sector Erase instruction
   spi_flash_Send(W25X_BlockErase);
-  /* Send SectorAddr high nibble address byte */
+  // Send SectorAddr high nibble address byte
   spi_flash_Send((BlockAddr & 0xFF0000) >> 16);
-  /* Send SectorAddr medium nibble address byte */
+  // Send SectorAddr medium nibble address byte
   spi_flash_Send((BlockAddr & 0xFF00) >> 8);
-  /* Send SectorAddr low nibble address byte */
+  // Send SectorAddr low nibble address byte
   spi_flash_Send(BlockAddr & 0xFF);
 
   W25QXX_CS_H;
 * Return         : None
 *******************************************************************************/
 void W25QXXFlash::SPI_FLASH_BulkErase(void) {
-  /* Send write enable instruction */
+  // Send write enable instruction
   SPI_FLASH_WriteEnable();
 
-  /* Bulk Erase */
-  /* Select the FLASH: Chip Select low */
+  // Bulk Erase
+  // Select the FLASH: Chip Select low
   W25QXX_CS_L;
 
-  /* Send Bulk Erase instruction  */
+  // Send Bulk Erase instruction
   spi_flash_Send(W25X_ChipErase);
-  /* Deselect the FLASH: Chip Select high */
+  // Deselect the FLASH: Chip Select high
   W25QXX_CS_H;
-  /* Wait the end of Flash writing */
+  // Wait the end of Flash writing
   SPI_FLASH_WaitForWriteEnd();
 }
 
 * Return         : None
 *******************************************************************************/
 void W25QXXFlash::SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) {
-  /* Enable the write access to the FLASH */
+  // Enable the write access to the FLASH
   SPI_FLASH_WriteEnable();
 
-  /* Select the FLASH: Chip Select low */
+  // Select the FLASH: Chip Select low
   W25QXX_CS_L;
-  /* Send "Write to Memory " instruction */
+  // Send "Write to Memory " instruction
   spi_flash_Send(W25X_PageProgram);
-  /* Send WriteAddr high nibble address byte to write to */
+  // Send WriteAddr high nibble address byte to write to
   spi_flash_Send((WriteAddr & 0xFF0000) >> 16);
-  /* Send WriteAddr medium nibble address byte to write to */
+  // Send WriteAddr medium nibble address byte to write to
   spi_flash_Send((WriteAddr & 0xFF00) >> 8);
-  /* Send WriteAddr low nibble address byte to write to */
+  // Send WriteAddr low nibble address byte to write to
   spi_flash_Send(WriteAddr & 0xFF);
 
   NOMORE(NumByteToWrite, SPI_FLASH_PerWritePageSize);
 
-  /* while there is data to be written on the FLASH */
+  // While there is data to be written on the FLASH
   while (NumByteToWrite--) {
-    /* Send the current byte */
+    // Send the current byte
     spi_flash_Send(*pBuffer);
-    /* Point on the next byte to be written */
+    // Point on the next byte to be written
     pBuffer++;
   }
 
-  /* Deselect the FLASH: Chip Select high */
+  // Deselect the FLASH: Chip Select high
   W25QXX_CS_H;
 
-  /* Wait the end of Flash writing */
+  // Wait the end of Flash writing
   SPI_FLASH_WaitForWriteEnd();
 }
 
   NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
   NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
 
-  if (Addr == 0) { /* WriteAddr is SPI_FLASH_PageSize aligned  */
-    if (NumOfPage == 0) { /* NumByteToWrite < SPI_FLASH_PageSize */
+  if (Addr == 0) { // WriteAddr is SPI_FLASH_PageSize aligned
+    if (NumOfPage == 0) { // NumByteToWrite < SPI_FLASH_PageSize
       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     }
-    else { /* NumByteToWrite > SPI_FLASH_PageSize */
+    else { // NumByteToWrite > SPI_FLASH_PageSize
       while (NumOfPage--) {
         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
         WriteAddr += SPI_FLASH_PageSize;
       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     }
   }
-  else { /* WriteAddr is not SPI_FLASH_PageSize aligned  */
-    if (NumOfPage == 0) { /* NumByteToWrite < SPI_FLASH_PageSize */
-      if (NumOfSingle > count) { /* (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize */
+  else { // WriteAddr is not SPI_FLASH_PageSize aligned
+    if (NumOfPage == 0) { // NumByteToWrite < SPI_FLASH_PageSize
+      if (NumOfSingle > count) { // (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize
         temp = NumOfSingle - count;
         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
         WriteAddr += count;
         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
       }
     }
-    else { /* NumByteToWrite > SPI_FLASH_PageSize */
+    else { // NumByteToWrite > SPI_FLASH_PageSize
       NumByteToWrite -= count;
       NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
       NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
 * Return         : None
 *******************************************************************************/
 void W25QXXFlash::SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead) {
-  /* Select the FLASH: Chip Select low */
+  // Select the FLASH: Chip Select low
   W25QXX_CS_L;
 
-  /* Send "Read from Memory " instruction */
+  // Send "Read from Memory " instruction
   spi_flash_Send(W25X_ReadData);
 
-  /* Send ReadAddr high nibble address byte to read from */
+  // Send ReadAddr high nibble address byte to read from
   spi_flash_Send((ReadAddr & 0xFF0000) >> 16);
-  /* Send ReadAddr medium nibble address byte to read from */
+  // Send ReadAddr medium nibble address byte to read from
   spi_flash_Send((ReadAddr & 0xFF00) >> 8);
-  /* Send ReadAddr low nibble address byte to read from */
+  // Send ReadAddr low nibble address byte to read from
   spi_flash_Send(ReadAddr & 0xFF);
 
-  if (NumByteToRead < 33) {
-    while (NumByteToRead--) { /* while there is data to be read */
-      /* Read a byte from the FLASH */
+  if (NumByteToRead <= 32 || !flash_dma_mode) {
+    while (NumByteToRead--) { // While there is data to be read
+      // Read a byte from the FLASH
       *pBuffer = spi_flash_Rec();
-      /* Point to the next location where the byte read will be saved */
+      // Point to the next location where the byte read will be saved
       pBuffer++;
     }
   }

Marlin/src/sd/SdBaseFile.cpp

       // Fail for illegal characters
       PGM_P p = PSTR("|<>^+=?/[];,*\"\\");
       while (uint8_t b = pgm_read_byte(p++)) if (b == c) return false;
-      if (i > n || c < 0x21 || c == 0x7F) return false;           // Check size, non-printable characters
-      name[i++] = (c < 'a' || c > 'z') ? (c) : (c + ('A' - 'a')); // Uppercase required for 8.3 name
+      if (i > n || c < 0x21 || c == 0x7F) return false;       // Check size, non-printable characters
+      name[i++] = c + (WITHIN(c, 'a', 'z') ? 'A' - 'a' : 0);  // Uppercase required for 8.3 name
     }
   }
   *ptr = str;                         // Set passed pointer to the end

platformio.ini

 HAS_TFT_LVGL_UI         = lvgl=https://github.com/makerbase-mks/LVGL-6.1.1-MKS/archive/master.zip
                           src_filter=+<src/lcd/extui/lib/mks_ui>
                           extra_scripts=download_mks_assets.py
+MKS_WIFI_MODULE         = QRCode=https://github.com/makerbase-mks/QRCode/archive/master.zip
 HAS_TRINAMIC_CONFIG     = TMCStepper@~0.7.1
                           src_filter=+<src/feature/tmc_util.cpp> +<src/module/stepper/trinamic.cpp> +<src/gcode/feature/trinamic/M122.cpp> +<src/gcode/feature/trinamic/M906.cpp> +<src/gcode/feature/trinamic/M911-M914.cpp>
 HAS_STEALTHCHOP         = src_filter=+<src/gcode/feature/trinamic/M569.cpp>