andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

MKS H43 fix, cleanup (#21485) 

Co-authored-by: Scott Lahteine <github@thinkyhead.com>
vanilla_fb_2.0.x
Sola 4 years ago
committed by Scott Lahteine
parent
fe99bb4b9b
commit
a4f1623012
8 changed files with 207 additions and 210 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      Marlin/Configuration.h
  2. 3
      Marlin/src/HAL/LPC1768/HAL.h
  3. 8
      Marlin/src/lcd/extui/lib/dgus/DGUSDisplay.cpp
  4. 97
      Marlin/src/lcd/extui/lib/dgus/mks/DGUSDisplayDef.cpp
  5. 37
      Marlin/src/lcd/extui/lib/dgus/mks/DGUSDisplayDef.h
  6. 219
      Marlin/src/lcd/extui/lib/dgus/mks/DGUSScreenHandler.cpp
  7. 6
      Marlin/src/lcd/extui/lib/dgus/mks/DGUSScreenHandler.h
  8. 41
      Marlin/src/module/settings.cpp

6
Marlin/Configuration.h
View File

@ -2373,7 +2373,11 @@
//#define DGUS_LCD_UI_ORIGIN
//#define DGUS_LCD_UI_FYSETC
//#define DGUS_LCD_UI_HIPRECY
//#define DGUS_LCD_UI_MKS
// #define DGUS_LCD_UI_MKS
#if ENABLED(DGUS_LCD_UI_MKS)
#define USE_MKS_GREEN_UI
#endif
//
// Touch-screen LCD for Malyan M200/M300 printers

3
Marlin/src/HAL/LPC1768/HAL.h
View File

@ -102,6 +102,9 @@ extern DefaultSerial1 USBSerial;
#else
#error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
#endif
#if HAS_DGUS_LCD
#define SERIAL_GET_TX_BUFFER_FREE() MSerial0.available()
#endif
#endif
//

8
Marlin/src/lcd/extui/lib/dgus/DGUSDisplay.cpp
View File

@ -62,9 +62,11 @@ void DGUSDisplay::InitDisplay() {
#define LCD_BAUDRATE 115200
#endif
LCD_SERIAL.begin(LCD_BAUDRATE);
#if BOTH(DGUS_LCD_UI_MKS, POWER_LOSS_RECOVERY)
if (!recovery.valid()) delay(LOGO_TIME_DELAY);
#endif
if (TERN1(POWER_LOSS_RECOVERY, !recovery.valid())) { // If no Power-Loss Recovery is needed...
TERN_(DGUS_LCD_UI_MKS, delay(LOGO_TIME_DELAY)); // Show the logo for a little while
}
RequestScreen(TERN(SHOW_BOOTSCREEN, DGUSLCD_SCREEN_BOOT, DGUSLCD_SCREEN_MAIN));
}

97
Marlin/src/lcd/extui/lib/dgus/mks/DGUSDisplayDef.cpp
View File

@ -43,58 +43,45 @@
uint16_t distanceToMove = 10;
#endif
uint16_t distanceMove = 1;
uint16_t manualMoveStep = 1;
float distanceFilament = 10;
uint16_t FilamentSpeed = 25;
float ZOffset_distance = 0.1;
float mesh_adj_distance = 0.1;
float mesh_adj_distance = 0.01;
float Z_distance = 0.1;
int16_t level_1_x_point = 20;
int16_t level_1_y_point = 20;
int16_t level_2_x_point = 20;
int16_t level_2_y_point = 20;
int16_t level_3_x_point = 20;
int16_t level_3_y_point = 20;
int16_t level_4_x_point = 20;
int16_t level_4_y_point = 20;
int16_t level_5_x_point = X_MAX_POS / 2;
int16_t level_5_y_point = Y_MAX_POS / 2;
uint16_t tim_h;
uint16_t tim_m;
uint16_t tim_s;
uint16_t x_park_pos = 20;
uint16_t y_park_pos = 20;
uint16_t z_park_pos = 10;
//struct { uint16_t h, m, s; } dgus_time;
//
// Persistent settings
//
xy_int_t mks_corner_offsets[5]; // Initialized by settings.load()
xyz_int_t mks_park_pos; // Initialized by settings.load()
celsius_t mks_min_extrusion_temp; // Initialized by settings.load()
void MKS_reset_settings() {
constexpr xy_int_t init_dgus_level_offsets[5] = {
{ 20, 20 }, { 20, 20 },
{ 20, 20 }, { 20, 20 },
{ X_CENTER, Y_CENTER }
};
mks_language_index = 0;
COPY(mks_corner_offsets, init_dgus_level_offsets);
mks_park_pos.set(20, 20, 10);
mks_min_extrusion_temp = 0;
}
xyz_pos_t position_before_pause;
void MKS_pause_print_move() {
queue.exhaust();
position_before_pause = current_position;
do_blocking_move_to(X_MIN_POS + x_park_pos, Y_MIN_POS + y_park_pos, current_position.z + z_park_pos);
do_blocking_move_to(X_MIN_POS + mks_park_pos.x, Y_MIN_POS + mks_park_pos.y, current_position.z + mks_park_pos.z);
}
void MKS_resume_print_move() { do_blocking_move_to(position_before_pause); }
uint16_t min_ex_temp = 0;
float z_offset_add = 0;
#if ENABLED(SENSORLESS_HOMING)
uint16_t tmc_x_step = 0;
uint16_t tmc_y_step = 0;
uint16_t tmc_z_step = 0;
#else
uint16_t tmc_x_step = 0;
uint16_t tmc_y_step = 0;
uint16_t tmc_z_step = 0;
#endif
xyz_int_t tmc_step; // = { 0, 0, 0 }
uint16_t lcd_default_light = 50;
@ -525,7 +512,7 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
VPHELPER(VP_Y_HOME, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_Z_HOME, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_MOVE_DISTANCE, &distanceMove, &ScreenHandler.GetManualMovestep, nullptr),
VPHELPER(VP_MOVE_DISTANCE, &manualMoveStep, &ScreenHandler.GetManualMovestep, nullptr),
VPHELPER(VP_MOTOR_LOCK_UNLOK, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_LEVEL_POINT, nullptr, &ScreenHandler.ManualAssistLeveling, nullptr),
@ -567,7 +554,7 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
VPHELPER(VP_LOAD_Filament, nullptr, &ScreenHandler.MKS_FilamentLoad, nullptr),
VPHELPER(VP_UNLOAD_Filament, nullptr, &ScreenHandler.MKS_FilamentUnLoad, nullptr),
VPHELPER(VP_Filament_distance, &distanceFilament, &ScreenHandler.GetManualFilament, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Filament_distance, &distanceFilament, &ScreenHandler.GetManualFilament, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_Filament_speed, &FilamentSpeed, &ScreenHandler.GetManualFilamentSpeed, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#endif
@ -623,16 +610,16 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
VPHELPER(VP_ZPos, &current_position.z, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
// Level Point Set
VPHELPER(VP_Level_Point_One_X, &level_1_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_One_Y, &level_1_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Two_X, &level_2_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Two_Y, &level_2_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Three_X, &level_3_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Three_Y, &level_3_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Four_X, &level_4_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Four_Y, &level_4_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Five_X, &level_5_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Five_Y, &level_5_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_One_X, &mks_corner_offsets[0].x, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_One_Y, &mks_corner_offsets[0].y, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Two_X, &mks_corner_offsets[1].x, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Two_Y, &mks_corner_offsets[1].y, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Three_X, &mks_corner_offsets[2].x, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Three_Y, &mks_corner_offsets[2].y, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Four_X, &mks_corner_offsets[3].x, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Four_Y, &mks_corner_offsets[3].y, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Five_X, &mks_corner_offsets[4].x, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Five_Y, &mks_corner_offsets[4].y, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
// Print Progress
VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, ScreenHandler.DGUSLCD_SendPrintProgressToDisplay),
@ -679,20 +666,20 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
VPHELPER(VP_T_F_SPEED, (uint16_t *)&planner.settings.min_travel_feedrate_mm_s, ScreenHandler.HandleMin_T_F_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_ACC_SPEED, (uint16_t *)&planner.settings.acceleration, ScreenHandler.HandleAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_X_PARK_POS, &x_park_pos, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Y_PARK_POS, &y_park_pos, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Z_PARK_POS, &z_park_pos, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_X_PARK_POS, &mks_park_pos.x, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Y_PARK_POS, &mks_park_pos.y, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Z_PARK_POS, &mks_park_pos.z, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_MIN_EX_T, &thermalManager.extrude_min_temp, ScreenHandler.HandleGetExMinTemp_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#if ENABLED(SENSORLESS_HOMING) // TMC SENSORLESS Setting
#if AXIS_HAS_STEALTHCHOP(X)
VPHELPER(VP_TMC_X_STEP, &tmc_x_step, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
VPHELPER(VP_TMC_X_STEP, &tmc_step.x, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
#endif
#if AXIS_HAS_STEALTHCHOP(Y)
VPHELPER(VP_TMC_Y_STEP, &tmc_y_step, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
VPHELPER(VP_TMC_Y_STEP, &tmc_step.y, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
#endif
#if AXIS_HAS_STEALTHCHOP(Z)
VPHELPER(VP_TMC_Z_STEP, &tmc_z_step, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
VPHELPER(VP_TMC_Z_STEP, &tmc_step.z, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
#endif
#endif

37
Marlin/src/lcd/extui/lib/dgus/mks/DGUSDisplayDef.h
View File

@ -23,7 +23,6 @@
#include "../DGUSDisplayDef.h"
#define USE_MKS_GREEN_UI
//#define DGUS_MKS_RUNOUT_SENSOR
#define LOGO_TIME_DELAY TERN(USE_MKS_GREEN_UI, 8000, 1500)
@ -36,43 +35,27 @@
#define MKS_FINSH
extern uint16_t distanceMove;
extern uint16_t manualMoveStep;
extern float distanceFilament;
extern uint16_t FilamentSpeed;
extern float ZOffset_distance;
extern float mesh_adj_distance;
extern float Z_distance;
extern int16_t level_1_x_point;
extern int16_t level_1_y_point;
extern int16_t level_2_x_point;
extern int16_t level_2_y_point;
extern int16_t level_3_x_point;
extern int16_t level_3_y_point;
extern int16_t level_4_x_point;
extern int16_t level_4_y_point;
extern int16_t level_5_x_point;
extern int16_t level_5_y_point;
extern uint16_t tim_h;
extern uint16_t tim_m;
extern uint16_t tim_s;
extern uint16_t x_park_pos;
extern uint16_t y_park_pos;
extern uint16_t z_park_pos;
extern xyz_pos_t position_before_pause;
//extern struct { uint16_t h, m, s; } dgus_time;
extern xy_int_t mks_corner_offsets[5];
extern xyz_int_t mks_park_pos;
extern celsius_t mks_min_extrusion_temp;
void MKS_reset_settings(); // Restore persistent settings to defaults
void MKS_pause_print_move();
void MKS_resume_print_move();
extern uint16_t min_ex_temp;
extern float z_offset_add;
extern uint16_t tmc_x_step;
extern uint16_t tmc_y_step;
extern uint16_t tmc_z_step;
xyz_int_t tmc_step;
extern uint16_t lcd_default_light;

219
Marlin/src/lcd/extui/lib/dgus/mks/DGUSScreenHandler.cpp
View File

@ -55,7 +55,7 @@
#endif
bool DGUSAutoTurnOff = false;
uint8_t DGUSLanguageSwitch = 0; // Switch language for MKS DGUS
uint8_t mks_language_index; // Initialized by settings.load()
// endianness swap
uint32_t swap32(const uint32_t value) { return (value & 0x000000FFU) << 24U | (value & 0x0000FF00U) << 8U | (value & 0x00FF0000U) >> 8U | (value & 0xFF000000U) >> 24U; }
@ -125,11 +125,11 @@ void DGUSScreenHandler::DGUSLCD_SendGbkToDisplay(DGUS_VP_Variable &var) {
}
void DGUSScreenHandler::DGUSLCD_SendStringToDisplay_Language_MKS(DGUS_VP_Variable &var) {
if (DGUSLanguageSwitch == MKS_English) {
if (mks_language_index == MKS_English) {
char *tmp = (char*) var.memadr;
dgusdisplay.WriteVariable(var.VP, tmp, var.size, true);
}
else if (DGUSLanguageSwitch == MKS_SimpleChinese) {
else if (mks_language_index == MKS_SimpleChinese) {
uint16_t *tmp = (uint16_t *)var.memadr;
dgusdisplay.WriteVariable(var.VP, tmp, var.size, true);
}
@ -138,15 +138,15 @@ void DGUSScreenHandler::DGUSLCD_SendStringToDisplay_Language_MKS(DGUS_VP_Variabl
void DGUSScreenHandler::DGUSLCD_SendTMCStepValue(DGUS_VP_Variable &var) {
#if ENABLED(SENSORLESS_HOMING)
#if AXIS_HAS_STEALTHCHOP(X)
tmc_x_step = stepperX.homing_threshold();
tmc_step.x = stepperX.homing_threshold();
dgusdisplay.WriteVariable(var.VP, *(int16_t*)var.memadr);
#endif
#if AXIS_HAS_STEALTHCHOP(Y)
tmc_y_step = stepperY.homing_threshold();
tmc_step.y = stepperY.homing_threshold();
dgusdisplay.WriteVariable(var.VP, *(int16_t*)var.memadr);
#endif
#if AXIS_HAS_STEALTHCHOP(Z)
tmc_z_step = stepperZ.homing_threshold();
tmc_step.z = stepperZ.homing_threshold();
dgusdisplay.WriteVariable(var.VP, *(int16_t*)var.memadr);
#endif
#endif
@ -329,7 +329,7 @@ void DGUSScreenHandler::ZoffsetConfirm(DGUS_VP_Variable &var, void *val_ptr) {
}
void DGUSScreenHandler::GetTurnOffCtrl(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("ctrl turn off\n");
DEBUG_ECHOLNPGM("GetTurnOffCtrl\n");
const uint16_t value = swap16(*(uint16_t *)val_ptr);
switch (value) {
case 0 ... 1: DGUSAutoTurnOff = (bool)value; break;
@ -338,15 +338,15 @@ void DGUSScreenHandler::GetTurnOffCtrl(DGUS_VP_Variable &var, void *val_ptr) {
}
void DGUSScreenHandler::GetMinExtrudeTemp(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("MinExtrudeTempChange DistanceChange");
DEBUG_ECHOLNPGM("GetMinExtrudeTemp");
const uint16_t value = swap16(*(uint16_t *)val_ptr);
thermalManager.extrude_min_temp = value;
min_ex_temp = value;
mks_min_extrusion_temp = value;
settings.save();
}
void DGUSScreenHandler::GetZoffsetDistance(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("Zoffset DistanceChange");
DEBUG_ECHOLNPGM("GetZoffsetDistance");
const uint16_t value = swap16(*(uint16_t *)val_ptr);
float val_distance = 0;
switch (value) {
@ -360,7 +360,7 @@ void DGUSScreenHandler::GetZoffsetDistance(DGUS_VP_Variable &var, void *val_ptr)
}
void DGUSScreenHandler::GetManualMovestep(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("\nMove DistanceChange");
DEBUG_ECHOLNPGM("\nGetManualMovestep");
*(uint16_t *)var.memadr = swap16(*(uint16_t *)val_ptr);
}
@ -414,14 +414,14 @@ void DGUSScreenHandler::LanguageChange_MKS(DGUS_VP_Variable &var, void *val_ptr)
switch (lag_flag) {
case MKS_SimpleChinese:
DGUS_LanguageDisplay(MKS_SimpleChinese);
DGUSLanguageSwitch = MKS_SimpleChinese;
mks_language_index = MKS_SimpleChinese;
dgusdisplay.MKS_WriteVariable(VP_LANGUAGE_CHANGE1, MKS_Language_Choose);
dgusdisplay.MKS_WriteVariable(VP_LANGUAGE_CHANGE2, MKS_Language_NoChoose);
settings.save();
break;
case MKS_English:
DGUS_LanguageDisplay(MKS_English);
DGUSLanguageSwitch = MKS_English;
mks_language_index = MKS_English;
dgusdisplay.MKS_WriteVariable(VP_LANGUAGE_CHANGE1, MKS_Language_NoChoose);
dgusdisplay.MKS_WriteVariable(VP_LANGUAGE_CHANGE2, MKS_Language_Choose);
settings.save();
@ -454,11 +454,11 @@ void DGUSScreenHandler::Level_Ctrl_MKS(DGUS_VP_Variable &var, void *val_ptr) {
mesh_point_count = GRID_MAX_POINTS;
if (DGUSLanguageSwitch == MKS_English) {
if (mks_language_index == MKS_English) {
const char level_buf_en[] = "Start Level";
dgusdisplay.WriteVariable(VP_AutoLevel_1_Dis, level_buf_en, 32, true);
}
else if (DGUSLanguageSwitch == MKS_SimpleChinese) {
else if (mks_language_index == MKS_SimpleChinese) {
const uint16_t level_buf_ch[] = {0xAABF, 0xBCCA, 0xF7B5, 0xBDC6, 0x2000};
dgusdisplay.WriteVariable(VP_AutoLevel_1_Dis, level_buf_ch, 32, true);
}
@ -532,15 +532,17 @@ void DGUSScreenHandler::MeshLevel(DGUS_VP_Variable &var, void *val_ptr) {
break;
case 2:
if (mesh_point_count == GRID_MAX_POINTS) { // 第1个点
if (mesh_point_count == GRID_MAX_POINTS) { // The first point
queue.enqueue_now_P(PSTR("G28"));
queue.enqueue_now_P(PSTR("G29S1"));
mesh_point_count--;
if (DGUSLanguageSwitch == MKS_English) {
if (mks_language_index == MKS_English) {
const char level_buf_en1[] = "Next Point";
dgusdisplay.WriteVariable(VP_AutoLevel_1_Dis, level_buf_en1, 32, true);
}
else if (DGUSLanguageSwitch == MKS_SimpleChinese) {
else if (mks_language_index == MKS_SimpleChinese) {
const uint16_t level_buf_ch1[] = {0xC2CF, 0xBBD2, 0xE3B5, 0x2000};
dgusdisplay.WriteVariable(VP_AutoLevel_1_Dis, level_buf_ch1, 32, true);
}
@ -548,11 +550,11 @@ void DGUSScreenHandler::MeshLevel(DGUS_VP_Variable &var, void *val_ptr) {
else if (mesh_point_count > 1) { // 倒数第二个点
queue.enqueue_now_P(PSTR("G29S2"));
mesh_point_count--;
if (DGUSLanguageSwitch == MKS_English) {
if (mks_language_index == MKS_English) {
const char level_buf_en2[] = "Next Point";
dgusdisplay.WriteVariable(VP_AutoLevel_1_Dis, level_buf_en2, 32, true);
}
else if (DGUSLanguageSwitch == MKS_SimpleChinese) {
else if (mks_language_index == MKS_SimpleChinese) {
const uint16_t level_buf_ch2[] = {0xC2CF, 0xBBD2, 0xE3B5, 0x2000};
dgusdisplay.WriteVariable(VP_AutoLevel_1_Dis, level_buf_ch2, 32, true);
}
@ -560,11 +562,11 @@ void DGUSScreenHandler::MeshLevel(DGUS_VP_Variable &var, void *val_ptr) {
else if (mesh_point_count == 1) {
queue.enqueue_now_P(PSTR("G29S2"));
mesh_point_count--;
if (DGUSLanguageSwitch == MKS_English) {
if (mks_language_index == MKS_English) {
const char level_buf_en2[] = "Level Finsh";
dgusdisplay.WriteVariable(VP_AutoLevel_1_Dis, level_buf_en2, 32, true);
}
else if (DGUSLanguageSwitch == MKS_SimpleChinese) {
else if (mks_language_index == MKS_SimpleChinese) {
const uint16_t level_buf_ch2[] = {0xF7B5, 0xBDC6, 0xEACD, 0xC9B3, 0x2000};
dgusdisplay.WriteVariable(VP_AutoLevel_1_Dis, level_buf_ch2, 32, true);
}
@ -597,85 +599,52 @@ void DGUSScreenHandler::LCD_BLK_Adjust(DGUS_VP_Variable &var, void *val_ptr) {
void DGUSScreenHandler::ManualAssistLeveling(DGUS_VP_Variable &var, void *val_ptr) {
const int16_t point_value = swap16(*(uint16_t *)val_ptr);
int16_t level_x_pos, level_y_pos;
char buf_level[32] = {0};
unsigned int level_speed = 1500;
// Insist on leveling first time at this screen
static bool first_level_flag = false;
if (!first_level_flag)
if (!first_level_flag || point_value == 0x0001) {
queue.enqueue_now_P(G28_STR);
first_level_flag = true;
}
constexpr uint16_t level_speed = 1500;
auto enqueue_corner_move = [](int16_t lx, int16_t ly, uint16_t fr) {
char buf_level[32];
sprintf_P(buf_level, "G0X%dY%dF%d", lx, ly, fr);
queue.enqueue_one_now(buf_level);
};
if (WITHIN(point_value, 0x0001, 0x0005))
queue.enqueue_now_P(PSTR("G1Z10"));
switch (point_value) {
case 0x0001:
if (first_level_flag)
queue.enqueue_now_P(G28_STR);
queue.enqueue_now_P(PSTR("G1 Z10"));
//level_x_pos = X_MIN_POS + 20;
//level_y_pos = Y_MIN_POS + 20;
level_x_pos = X_MIN_POS + abs(level_1_x_point);
level_y_pos = Y_MIN_POS + abs(level_1_y_point);
memset(buf_level, 0, sizeof(buf_level));
sprintf_P(buf_level, "G0 X%d Y%d F%d", level_x_pos, level_y_pos, level_speed);
queue.enqueue_one_now(buf_level);
queue.enqueue_now_P(PSTR("G28 Z"));
enqueue_corner_move(X_MIN_POS + abs(mks_corner_offsets[0].x),
Y_MIN_POS + abs(mks_corner_offsets[0].y), level_speed);
queue.enqueue_now_P(PSTR("G28Z"));
break;
case 0x0002:
queue.enqueue_now_P(PSTR("G1 Z10"));
//level_x_pos = X_MAX_POS - 20;
//level_y_pos = Y_MIN_POS + 20;
level_x_pos = X_MAX_POS - abs(level_2_x_point);
level_y_pos = Y_MIN_POS + abs(level_2_y_point);
sprintf_P(buf_level, "G0 X%d Y%d F%d", level_x_pos, level_y_pos, level_speed);
queue.enqueue_one_now(buf_level);
//queue.enqueue_now_P(PSTR("G28Z"));
queue.enqueue_now_P(PSTR("G1 Z-10"));
enqueue_corner_move(X_MAX_POS - abs(mks_corner_offsets[1].x),
Y_MIN_POS + abs(mks_corner_offsets[1].y), level_speed);
break;
case 0x0003:
queue.enqueue_now_P(PSTR("G1 Z10"));
//level_x_pos = X_MAX_POS - 20;
//level_y_pos = Y_MAX_POS - 20;
level_x_pos = X_MAX_POS - abs(level_3_x_point);
level_y_pos = Y_MAX_POS - abs(level_3_y_point);
sprintf_P(buf_level, "G0 X%d Y%d F%d", level_x_pos, level_y_pos, level_speed);
queue.enqueue_one_now(buf_level);
//sprintf_P(buf_level, PSTR("G28 Z"));
queue.enqueue_now_P(PSTR("G1 Z-10"));
enqueue_corner_move(X_MAX_POS - abs(mks_corner_offsets[2].x),
Y_MAX_POS - abs(mks_corner_offsets[2].y), level_speed);
break;
case 0x0004:
queue.enqueue_now_P(PSTR("G1 Z10"));
//level_x_pos = X_MIN_POS + 20;
//level_y_pos = Y_MAX_POS - 20;
level_x_pos = X_MIN_POS + abs(level_4_x_point);
level_y_pos = Y_MAX_POS - abs(level_4_y_point);
sprintf_P(buf_level, "G0 X%d Y%d F%d", level_x_pos, level_y_pos, level_speed);
queue.enqueue_one_now(buf_level);
//sprintf_P(buf_level, PSTR("G28 Z"));
queue.enqueue_now_P(PSTR("G1 Z-10"));
enqueue_corner_move(X_MIN_POS + abs(mks_corner_offsets[3].x),
Y_MAX_POS - abs(mks_corner_offsets[3].y), level_speed);
break;
case 0x0005:
queue.enqueue_now_P(PSTR("G1 Z10"));
//level_x_pos = (uint16_t)(X_MAX_POS / 2);
//level_y_pos = (uint16_t)(Y_MAX_POS / 2);
level_x_pos = abs(level_5_x_point);
level_y_pos = abs(level_5_y_point);
sprintf_P(buf_level, "G0 X%d Y%d F%d", level_x_pos, level_y_pos, level_speed);
queue.enqueue_one_now(buf_level);
queue.enqueue_now_P(PSTR("G1 Z-10"));
enqueue_corner_move(abs(mks_corner_offsets[4].x),
abs(mks_corner_offsets[4].y), level_speed);
break;
}
// Only once
first_level_flag = true;
if (WITHIN(point_value, 0x0002, 0x0005)) {
//queue.enqueue_now_P(PSTR("G28Z"));
queue.enqueue_now_P(PSTR("G1Z-10"));
}
}
#define mks_min(a, b) ((a) < (b)) ? (a) : (b)
@ -691,7 +660,7 @@ void DGUSScreenHandler::TMC_ChangeConfig(DGUS_VP_Variable &var, void *val_ptr) {
#if AXIS_HAS_STEALTHCHOP(X)
stepperX.homing_threshold(mks_min(tmc_value, 255));
settings.save();
//tmc_x_step = stepperX.homing_threshold();
//tmc_step.x = stepperX.homing_threshold();
#endif
#endif
break;
@ -700,7 +669,7 @@ void DGUSScreenHandler::TMC_ChangeConfig(DGUS_VP_Variable &var, void *val_ptr) {
#if AXIS_HAS_STEALTHCHOP(Y)
stepperY.homing_threshold(mks_min(tmc_value, 255));
settings.save();
//tmc_y_step = stepperY.homing_threshold();
//tmc_step.y = stepperY.homing_threshold();
#endif
#endif
break;
@ -709,7 +678,7 @@ void DGUSScreenHandler::TMC_ChangeConfig(DGUS_VP_Variable &var, void *val_ptr) {
#if AXIS_HAS_STEALTHCHOP(Z)
stepperZ.homing_threshold(mks_min(tmc_value, 255));
settings.save();
//tmc_z_step = stepperZ.homing_threshold();
//tmc_step.z = stepperZ.homing_threshold();
#endif
#endif
break;
@ -767,13 +736,13 @@ void DGUSScreenHandler::TMC_ChangeConfig(DGUS_VP_Variable &var, void *val_ptr) {
}
#if USE_SENSORLESS
#if AXIS_HAS_STEALTHCHOP(X)
tmc_x_step = stepperX.homing_threshold();
tmc_step.x = stepperX.homing_threshold();
#endif
#if AXIS_HAS_STEALTHCHOP(Y)
tmc_y_step = stepperY.homing_threshold();
tmc_step.y = stepperY.homing_threshold();
#endif
#if AXIS_HAS_STEALTHCHOP(Z)
tmc_z_step = stepperZ.homing_threshold();
tmc_step.z = stepperZ.homing_threshold();
#endif
#endif
}
@ -784,9 +753,9 @@ void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
int16_t movevalue = swap16(*(uint16_t*)val_ptr);
// Choose Move distance
if (distanceMove == 0x01) distanceMove = 10;
else if (distanceMove == 0x02) distanceMove = 100;
else if (distanceMove == 0x03) distanceMove = 1000;
if (manualMoveStep == 0x01) manualMoveStep = 10;
else if (manualMoveStep == 0x02) manualMoveStep = 100;
else if (manualMoveStep == 0x03) manualMoveStep = 1000;
DEBUG_ECHOLNPAIR("QUEUE LEN:", queue.length);
@ -853,8 +822,8 @@ void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOPAIR("movevalue = ", movevalue);
if (movevalue != 0 && movevalue != 5) { // get move distance
switch (movevalue) {
case 0x0001: movevalue = distanceMove; break;
case 0x0002: movevalue = -distanceMove; break;
case 0x0001: movevalue = manualMoveStep; break;
case 0x0002: movevalue = -manualMoveStep; break;
default: movevalue = 0; break;
}
}
@ -929,16 +898,16 @@ void DGUSScreenHandler::GetParkPos_MKS(DGUS_VP_Variable &var, void *val_ptr) {
const int16_t value_pos = swap16(*(int16_t*)val_ptr);
switch (var.VP) {
case VP_X_PARK_POS: x_park_pos = value_pos; break;
case VP_Y_PARK_POS: y_park_pos = value_pos; break;
case VP_Z_PARK_POS: z_park_pos = value_pos; break;
case VP_X_PARK_POS: mks_park_pos.x = value_pos; break;
case VP_Y_PARK_POS: mks_park_pos.y = value_pos; break;
case VP_Z_PARK_POS: mks_park_pos.z = value_pos; break;
default: break;
}
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandler::HandleChangeLevelPoint_MKS(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleStepPerMMChanged");
DEBUG_ECHOLNPGM("HandleChangeLevelPoint_MKS");
const int16_t value_raw = swap16(*(int16_t*)val_ptr);
DEBUG_ECHOLNPAIR_F("value_raw:", value_raw);
@ -950,7 +919,7 @@ void DGUSScreenHandler::HandleChangeLevelPoint_MKS(DGUS_VP_Variable &var, void *
}
void DGUSScreenHandler::HandleStepPerMMChanged_MKS(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleStepPerMMChanged");
DEBUG_ECHOLNPGM("HandleStepPerMMChanged_MKS");
const uint16_t value_raw = swap16(*(uint16_t*)val_ptr);
const float value = (float)value_raw;
@ -972,7 +941,7 @@ void DGUSScreenHandler::HandleStepPerMMChanged_MKS(DGUS_VP_Variable &var, void *
}
void DGUSScreenHandler::HandleStepPerMMExtruderChanged_MKS(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleStepPerMMExtruderChanged");
DEBUG_ECHOLNPGM("HandleStepPerMMExtruderChanged_MKS");
const uint16_t value_raw = swap16(*(uint16_t*)val_ptr);
const float value = (float)value_raw;
@ -1019,7 +988,7 @@ void DGUSScreenHandler::HandleMaxSpeedChange_MKS(DGUS_VP_Variable &var, void *va
}
void DGUSScreenHandler::HandleExtruderMaxSpeedChange_MKS(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleMaxSpeedChange_MKS");
DEBUG_ECHOLNPGM("HandleExtruderMaxSpeedChange_MKS");
const uint16_t value_raw = swap16(*(uint16_t*)val_ptr);
const float value = (float)value_raw;
@ -1044,7 +1013,7 @@ void DGUSScreenHandler::HandleExtruderMaxSpeedChange_MKS(DGUS_VP_Variable &var,
}
void DGUSScreenHandler::HandleMaxAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleMaxSpeedChange_MKS");
DEBUG_ECHOLNPGM("HandleMaxAccChange_MKS");
const uint16_t value_raw = swap16(*(uint16_t*)val_ptr);
const float value = (float)value_raw;
@ -1066,7 +1035,7 @@ void DGUSScreenHandler::HandleMaxAccChange_MKS(DGUS_VP_Variable &var, void *val_
}
void DGUSScreenHandler::HandleExtruderAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleMaxSpeedChange_MKS");
DEBUG_ECHOLNPGM("HandleExtruderAccChange_MKS");
uint16_t value_raw = swap16(*(uint16_t*)val_ptr);
DEBUG_ECHOLNPAIR("value_raw:", value_raw);
@ -1199,7 +1168,7 @@ void DGUSScreenHandler::HandleGetExMinTemp_MKS(DGUS_VP_Variable &var, void *val_
#endif // BABYSTEPPING
void DGUSScreenHandler::GetManualFilament(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleGetFilament");
DEBUG_ECHOLNPGM("GetManualFilament");
uint16_t value_len = swap16(*(uint16_t*)val_ptr);
@ -1212,7 +1181,7 @@ void DGUSScreenHandler::GetManualFilament(DGUS_VP_Variable &var, void *val_ptr)
}
void DGUSScreenHandler::GetManualFilamentSpeed(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleGetFilamentSpeed");
DEBUG_ECHOLNPGM("GetManualFilamentSpeed");
uint16_t value_len = swap16(*(uint16_t*)val_ptr);
@ -1225,8 +1194,10 @@ void DGUSScreenHandler::GetManualFilamentSpeed(DGUS_VP_Variable &var, void *val_
void DGUSScreenHandler::MKS_FilamentLoadUnload(DGUS_VP_Variable &var, void *val_ptr, const int filamentDir) {
#if EITHER(HAS_MULTI_HOTEND, SINGLENOZZLE)
char buf[40];
uint8_t swap_tool = 0;
#endif
#if HAS_HOTEND
uint8_t hotend_too_cold = 0;
#endif
@ -1234,13 +1205,19 @@ void DGUSScreenHandler::MKS_FilamentLoadUnload(DGUS_VP_Variable &var, void *val_
if (!print_job_timer.isPaused() && !queue.ring_buffer.empty())
return;
char buf[40];
const uint16_t val_t = swap16(*(uint16_t*)val_ptr);
switch (val_t) {
default: break;
case 0:
#if HAS_HOTEND
if (thermalManager.tooColdToExtrude(0)) hotend_too_cold = 1; else swap_tool = 1;
if (thermalManager.tooColdToExtrude(0)) {
hotend_too_cold = 1;
}
else {
#if EITHER(HAS_MULTI_HOTEND, SINGLENOZZLE)
swap_tool = 2;
#endif
}
#endif
break;
case 1:
@ -1273,12 +1250,12 @@ void DGUSScreenHandler::MKS_FilamentLoadUnload(DGUS_VP_Variable &var, void *val_
}
void DGUSScreenHandler::MKS_FilamentLoad(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("Load Filament");
DEBUG_ECHOLNPGM("MKS_FilamentLoad");
MKS_FilamentLoadUnload(var, val_ptr, 1);
}
void DGUSScreenHandler::MKS_FilamentUnLoad(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("UnLoad Filament");
DEBUG_ECHOLNPGM("MKS_FilamentUnLoad");
MKS_FilamentLoadUnload(var, val_ptr, -1);
}
@ -1403,7 +1380,7 @@ bool DGUSScreenHandler::loop() {
if (language_times != 0) {
LanguagePInit();
DGUS_LanguageDisplay(DGUSLanguageSwitch);
DGUS_LanguageDisplay(mks_language_index);
language_times--;
}
@ -1413,18 +1390,18 @@ bool DGUSScreenHandler::loop() {
booted = true;
#if USE_SENSORLESS
#if AXIS_HAS_STEALTHCHOP(X)
tmc_x_step = stepperX.homing_threshold();
tmc_step.x = stepperX.homing_threshold();
#endif
#if AXIS_HAS_STEALTHCHOP(Y)
tmc_y_step = stepperY.homing_threshold();
tmc_step.y = stepperY.homing_threshold();
#endif
#if AXIS_HAS_STEALTHCHOP(Z)
tmc_z_step = stepperZ.homing_threshold();
tmc_step.z = stepperZ.homing_threshold();
#endif
#endif
if (min_ex_temp != 0)
thermalManager.extrude_min_temp = min_ex_temp;
if (mks_min_extrusion_temp != 0)
thermalManager.extrude_min_temp = mks_min_extrusion_temp;
DGUS_ExtrudeLoadInit();
@ -1446,7 +1423,7 @@ bool DGUSScreenHandler::loop() {
}
void DGUSScreenHandler::LanguagePInit() {
switch (DGUSLanguageSwitch) {
switch (mks_language_index) {
case MKS_SimpleChinese:
dgusdisplay.MKS_WriteVariable(VP_LANGUAGE_CHANGE1, MKS_Language_Choose);
dgusdisplay.MKS_WriteVariable(VP_LANGUAGE_CHANGE2, MKS_Language_NoChoose);
@ -1705,10 +1682,10 @@ void DGUSScreenHandler::DGUS_LanguageDisplay(uint8_t var) {
const char Printing_buf_en[] = "Printing";
dgusdisplay.WriteVariable(VP_Printing_Dis, Printing_buf_en, 32, true);
const char Info_EEPROM_1_buf_en[] = "Store setting？";
const char Info_EEPROM_1_buf_en[] = "Store setting?";
dgusdisplay.WriteVariable(VP_Info_EEPROM_1_Dis, Info_EEPROM_1_buf_en, 32, true);
const char Info_EEPROM_2_buf_en[] = "Revert setting？";
const char Info_EEPROM_2_buf_en[] = "Revert setting?";
dgusdisplay.WriteVariable(VP_Info_EEPROM_2_Dis, Info_EEPROM_2_buf_en, 32, true);
const char Info_PrinfFinsh_1_buf_en[] = "Print Done";
@ -1963,7 +1940,7 @@ void DGUSScreenHandler::DGUS_LanguageDisplay(uint8_t var) {
const uint16_t Info_EEPROM_1_buf_ch[] = { 0xC7CA, 0xF1B7, 0xA3B1, 0xE6B4, 0xE8C9, 0xC3D6, 0xBFA3, 0x2000 };
dgusdisplay.WriteVariable(VP_Info_EEPROM_1_Dis, Info_EEPROM_1_buf_ch, 32, true);
const uint16_t Info_EEPROM_2_buf_ch[] = { 0xC7CA, 0xF1B7, 0xD6BB, 0xB4B8, 0xF6B3, 0xA7B3, 0xE8C9, 0xC3D6, 0x2000 };
const uint16_t Info_EEPROM_2_buf_ch[] = { 0xC7CA, 0xF1B7, 0xD6BB, 0xB4B8, 0xF6B3, 0xA7B3, 0xE8C9, 0xC3D6, 0xBFA3, 0x2000 };
dgusdisplay.WriteVariable(VP_Info_EEPROM_2_Dis, Info_EEPROM_2_buf_ch, 32, true);
const uint16_t TMC_X_Step_buf_ch[] = { 0x2058, 0xE9C1, 0xF4C3, 0xC8B6, 0x2000 };

6
Marlin/src/lcd/extui/lib/dgus/mks/DGUSScreenHandler.h
View File

@ -158,13 +158,13 @@ public:
static void GetManualFilamentSpeed(DGUS_VP_Variable &var, void *val_ptr);
#endif
// File touched.
static void DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(SDSUPPORT)
// Callback for VP "Display wants to change screen when there is a SD card"
static void ScreenChangeHookIfSD(DGUS_VP_Variable &var, void *val_ptr);
// Scroll buttons on the file listing screen.
static void DGUSLCD_SD_ScrollFilelist(DGUS_VP_Variable &var, void *val_ptr);
// File touched.
static void DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr);
// start print after confirmation received.
static void DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr);
// User hit the pause, resume or abort button.
@ -301,7 +301,7 @@ private:
#define MKS_SimpleChinese 0
#define MKS_English 1
extern uint8_t DGUSLanguageSwitch;
extern uint8_t mks_language_index;
extern bool DGUSAutoTurnOff;
#if ENABLED(POWER_LOSS_RECOVERY)

41
Marlin/src/module/settings.cpp
View File

@ -153,6 +153,11 @@
#include "../libs/buzzer.h"
#endif
#if ENABLED(DGUS_LCD_UI_MKS)
#include "../lcd/extui/lib/dgus/DGUSScreenHandler.h"
#include "../lcd/extui/lib/dgus/DGUSDisplayDef.h"
#endif
#pragma pack(push, 1) // No padding between variables
#if HAS_ETHERNET
@ -461,6 +466,16 @@ typedef struct SettingsDataStruct {
bool buzzer_enabled;
#endif
//
// MKS UI controller
//
#if ENABLED(DGUS_LCD_UI_MKS)
uint8_t mks_language_index; // Display Language
xy_int_t mks_corner_offsets[5]; // Bed Tramming
xyz_int_t mks_park_pos; // Custom Parking (without NOZZLE_PARK)
celsius_t mks_min_extrusion_temp; // Min E Temp (shadow M302 value)
#endif
#if HAS_MULTI_LANGUAGE
uint8_t ui_language; // M414 S
#endif
@ -1402,6 +1417,16 @@ void MarlinSettings::postprocess() {
EEPROM_WRITE(ui.buzzer_enabled);
#endif
//
// MKS UI controller
//
#if ENABLED(DGUS_LCD_UI_MKS)
EEPROM_WRITE(mks_language_index);
EEPROM_WRITE(mks_corner_offsets);
EEPROM_WRITE(mks_park_pos);
EEPROM_WRITE(mks_min_extrusion_temp);
#endif
//
// Selected LCD language
//
@ -2302,6 +2327,17 @@ void MarlinSettings::postprocess() {
EEPROM_READ(ui.buzzer_enabled);
#endif
//
// MKS UI controller
//
#if ENABLED(DGUS_LCD_UI_MKS)
_FIELD_TEST(mks_language_index);
EEPROM_READ(mks_language_index);
EEPROM_READ(mks_corner_offsets);
EEPROM_READ(mks_park_pos);
EEPROM_READ(mks_min_extrusion_temp);
#endif
//
// Selected LCD language
//
@ -2967,6 +3003,11 @@ void MarlinSettings::reset() {
#endif
#endif
//
// MKS UI controller
//
TERN_(DGUS_LCD_UI_MKS, MKS_reset_settings());
postprocess();
DEBUG_ECHO_START();

Write Preview
Loading…
Cancel
Save