Sola
4 years ago
committed by
GitHub
GitHub
33 changed files with 6313 additions and 719 deletions
@ -0,0 +1,418 @@ |
|||
/**
|
|||
* 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 ENABLED(DGUS_LCD_UI_FYSETC) |
|||
|
|||
#include "../DGUSScreenHandler.h" |
|||
|
|||
#include "../../../../../MarlinCore.h" |
|||
#include "../../../../../gcode/queue.h" |
|||
#include "../../../../../libs/duration_t.h" |
|||
#include "../../../../../module/settings.h" |
|||
#include "../../../../../module/temperature.h" |
|||
#include "../../../../../module/motion.h" |
|||
#include "../../../../../module/planner.h" |
|||
#include "../../../../../module/printcounter.h" |
|||
#include "../../../../../sd/cardreader.h" |
|||
|
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
#include "../../../../feature/powerloss.h" |
|||
#endif |
|||
|
|||
#if ENABLED(SDSUPPORT) |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file; |
|||
if (touched_nr > filelist.count()) return; |
|||
if (!filelist.seek(touched_nr)) return; |
|||
|
|||
if (filelist.isDir()) { |
|||
filelist.changeDir(filelist.filename()); |
|||
top_file = 0; |
|||
ForceCompleteUpdate(); |
|||
return; |
|||
} |
|||
|
|||
#if ENABLED(DGUS_PRINT_FILENAME) |
|||
// Send print filename
|
|||
dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true); |
|||
#endif |
|||
|
|||
// Setup Confirmation screen
|
|||
file_to_print = touched_nr; |
|||
|
|||
HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true); |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr) { |
|||
if (!filelist.seek(file_to_print)) return; |
|||
ExtUI::printFile(filelist.shortFilename()); |
|||
GotoScreen(DGUSLCD_SCREEN_SDPRINTMANIPULATION); |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) { |
|||
|
|||
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
|
|||
switch (swap16(*(uint16_t*)val_ptr)) { |
|||
case 0: { // Resume
|
|||
if (ExtUI::isPrintingFromMediaPaused()) { |
|||
ExtUI::resumePrint(); |
|||
} |
|||
} break; |
|||
|
|||
case 1: // Pause
|
|||
|
|||
GotoScreen(MKSLCD_SCREEN_PAUSE); |
|||
if (!ExtUI::isPrintingFromMediaPaused()) { |
|||
ExtUI::pausePrint(); |
|||
//ExtUI::mks_pausePrint();
|
|||
} |
|||
break; |
|||
case 2: // Abort
|
|||
HandleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_SendFilename(DGUS_VP_Variable& var) { |
|||
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN; |
|||
if (target_line > DGUS_SD_FILESPERSCREEN) return; |
|||
char tmpfilename[VP_SD_FileName_LEN + 1] = ""; |
|||
var.memadr = (void*)tmpfilename; |
|||
|
|||
if (filelist.seek(top_file + target_line)) { |
|||
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
|
|||
} |
|||
DGUSLCD_SendStringToDisplay(var); |
|||
} |
|||
|
|||
void DGUSScreenHandler::SDCardInserted() { |
|||
top_file = 0; |
|||
filelist.refresh(); |
|||
auto cs = getCurrentScreen(); |
|||
if (cs == DGUSLCD_SCREEN_MAIN || cs == DGUSLCD_SCREEN_STATUS) |
|||
GotoScreen(DGUSLCD_SCREEN_SDFILELIST); |
|||
} |
|||
|
|||
void DGUSScreenHandler::SDCardRemoved() { |
|||
if (current_screen == DGUSLCD_SCREEN_SDFILELIST |
|||
|| (current_screen == DGUSLCD_SCREEN_CONFIRM && (ConfirmVP == VP_SD_AbortPrintConfirmed || ConfirmVP == VP_SD_FileSelectConfirm)) |
|||
|| current_screen == DGUSLCD_SCREEN_SDPRINTMANIPULATION |
|||
) GotoScreen(DGUSLCD_SCREEN_MAIN); |
|||
} |
|||
|
|||
#endif // SDSUPPORT
|
|||
|
|||
void DGUSScreenHandler::ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint8_t *tmp = (uint8_t*)val_ptr; |
|||
|
|||
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
|
|||
// from screen 1 (main) to 10 (temperature). DGUSLCD_SCREEN_POPUP is special,
|
|||
// meaning "return to previous screen"
|
|||
DGUSLCD_Screens target = (DGUSLCD_Screens)tmp[1]; |
|||
|
|||
DEBUG_ECHOLNPAIR("\n DEBUG target", target); |
|||
|
|||
if (target == DGUSLCD_SCREEN_POPUP) { |
|||
// Special handling for popup is to return to previous menu
|
|||
if (current_screen == DGUSLCD_SCREEN_POPUP && confirm_action_cb) confirm_action_cb(); |
|||
PopToOldScreen(); |
|||
return; |
|||
} |
|||
|
|||
UpdateNewScreen(target); |
|||
|
|||
#ifdef DEBUG_DGUSLCD |
|||
if (!DGUSLCD_FindScreenVPMapList(target)) DEBUG_ECHOLNPAIR("WARNING: No screen Mapping found for ", target); |
|||
#endif |
|||
} |
|||
|
|||
void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleManualMove"); |
|||
|
|||
int16_t movevalue = swap16(*(uint16_t*)val_ptr); |
|||
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION) |
|||
if (movevalue) { |
|||
const uint16_t choice = *(uint16_t*)var.memadr; |
|||
movevalue = movevalue < 0 ? -choice : choice; |
|||
} |
|||
#endif |
|||
char axiscode; |
|||
unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
|
|||
|
|||
switch (var.VP) { |
|||
default: return; |
|||
|
|||
case VP_MOVE_X: |
|||
axiscode = 'X'; |
|||
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_MOVE_Y: |
|||
axiscode = 'Y'; |
|||
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_MOVE_Z: |
|||
axiscode = 'Z'; |
|||
speed = 300; // default to 5mm/s
|
|||
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_HOME_ALL: // only used for homing
|
|||
axiscode = '\0'; |
|||
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
|
|||
break; |
|||
} |
|||
|
|||
if (!movevalue) { |
|||
// homing
|
|||
DEBUG_ECHOPAIR(" homing ", axiscode); |
|||
char buf[6] = "G28 X"; |
|||
buf[4] = axiscode; |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOLNPGM(" ✓");
|
|||
ForceCompleteUpdate(); |
|||
return; |
|||
} |
|||
else { |
|||
// movement
|
|||
DEBUG_ECHOPAIR(" move ", axiscode); |
|||
bool old_relative_mode = relative_mode; |
|||
if (!relative_mode) { |
|||
//DEBUG_ECHOPGM(" G91");
|
|||
queue.enqueue_now_P(PSTR("G91")); |
|||
//DEBUG_ECHOPGM(" ✓ ");
|
|||
} |
|||
char buf[32]; // G1 X9999.99 F12345
|
|||
unsigned int backup_speed = MMS_TO_MMM(feedrate_mm_s); |
|||
char sign[] = "\0"; |
|||
int16_t value = movevalue / 100; |
|||
if (movevalue < 0) { value = -value; sign[0] = '-'; } |
|||
int16_t fraction = ABS(movevalue) % 100; |
|||
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed); |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOLNPGM(" ✓ ");
|
|||
if (backup_speed != speed) { |
|||
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed); |
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
} |
|||
// while (!enqueue_and_echo_command(buf)) idle();
|
|||
//DEBUG_ECHOLNPGM(" ✓ ");
|
|||
if (!old_relative_mode) { |
|||
//DEBUG_ECHOPGM("G90");
|
|||
queue.enqueue_now_P(PSTR("G90")); |
|||
//DEBUG_ECHOPGM(" ✓ ");
|
|||
} |
|||
} |
|||
|
|||
ForceCompleteUpdate(); |
|||
DEBUG_ECHOLNPGM("manmv done."); |
|||
return; |
|||
|
|||
cannotmove: |
|||
DEBUG_ECHOLNPAIR(" cannot move ", axiscode); |
|||
return; |
|||
} |
|||
|
|||
#if HAS_PID_HEATING |
|||
void DGUSScreenHandler::HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr); |
|||
DEBUG_ECHOLNPAIR("V1:", rawvalue); |
|||
float value = (float)rawvalue / 10; |
|||
DEBUG_ECHOLNPAIR("V2:", value); |
|||
float newvalue = 0; |
|||
|
|||
switch (var.VP) { |
|||
default: return; |
|||
#if HOTENDS >= 1 |
|||
case VP_E0_PID_P: newvalue = value; break; |
|||
case VP_E0_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_E0_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
case VP_E1_PID_P: newvalue = value; break; |
|||
case VP_E1_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_E1_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
#if HAS_HEATED_BED |
|||
case VP_BED_PID_P: newvalue = value; break; |
|||
case VP_BED_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_BED_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
} |
|||
|
|||
DEBUG_ECHOLNPAIR_F("V3:", newvalue); |
|||
*(float *)var.memadr = newvalue; |
|||
|
|||
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
|
|||
} |
|||
#endif // HAS_PID_HEATING
|
|||
|
|||
#if ENABLED(BABYSTEPPING) |
|||
void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleLiveAdjustZ"); |
|||
int16_t flag = swap16(*(uint16_t*)val_ptr), |
|||
steps = flag ? -20 : 20; |
|||
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true); |
|||
ForceCompleteUpdate(); |
|||
} |
|||
#endif |
|||
|
|||
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD) |
|||
|
|||
void DGUSScreenHandler::HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleFilamentOption"); |
|||
|
|||
uint8_t e_temp = 0; |
|||
filament_data.heated = false; |
|||
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr); |
|||
if (preheat_option <= 8) { // Load filament type
|
|||
filament_data.action = 1; |
|||
} |
|||
else if (preheat_option >= 10) { // Unload filament type
|
|||
preheat_option -= 10; |
|||
filament_data.action = 2; |
|||
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH; |
|||
} |
|||
else { // Cancel filament operation
|
|||
filament_data.action = 0; |
|||
} |
|||
|
|||
switch (preheat_option) { |
|||
case 0: // Load PLA
|
|||
#ifdef PREHEAT_1_TEMP_HOTEND |
|||
e_temp = PREHEAT_1_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 1: // Load ABS
|
|||
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND); |
|||
break; |
|||
case 2: // Load PET
|
|||
#ifdef PREHEAT_3_TEMP_HOTEND |
|||
e_temp = PREHEAT_3_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 3: // Load FLEX
|
|||
#ifdef PREHEAT_4_TEMP_HOTEND |
|||
e_temp = PREHEAT_4_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 9: // Cool down
|
|||
default: |
|||
e_temp = 0; |
|||
break; |
|||
} |
|||
|
|||
if (filament_data.action == 0) { // Go back to utility screen
|
|||
#if HOTENDS >= 1 |
|||
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0); |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1); |
|||
#endif |
|||
GotoScreen(DGUSLCD_SCREEN_UTILITY); |
|||
} |
|||
else { // Go to the preheat screen to show the heating progress
|
|||
switch (var.VP) { |
|||
default: return; |
|||
#if HOTENDS >= 1 |
|||
case VP_E0_FILAMENT_LOAD_UNLOAD: |
|||
filament_data.extruder = ExtUI::extruder_t::E0; |
|||
thermalManager.setTargetHotend(e_temp, filament_data.extruder); |
|||
break; |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
case VP_E1_FILAMENT_LOAD_UNLOAD: |
|||
filament_data.extruder = ExtUI::extruder_t::E1; |
|||
thermalManager.setTargetHotend(e_temp, filament_data.extruder); |
|||
break; |
|||
#endif |
|||
} |
|||
GotoScreen(DGUSLCD_SCREEN_FILAMENT_HEATING); |
|||
} |
|||
} |
|||
|
|||
void DGUSScreenHandler::HandleFilamentLoadUnload(DGUS_VP_Variable &var) { |
|||
DEBUG_ECHOLNPGM("HandleFilamentLoadUnload"); |
|||
if (filament_data.action <= 0) return; |
|||
|
|||
// If we close to the target temperature, we can start load or unload the filament
|
|||
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \ |
|||
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) { |
|||
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME; |
|||
|
|||
if (filament_data.action == 1) { // load filament
|
|||
if (!filament_data.heated) { |
|||
//GotoScreen(DGUSLCD_SCREEN_FILAMENT_LOADING);
|
|||
filament_data.heated = true; |
|||
} |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue; |
|||
} |
|||
else { // unload filament
|
|||
if (!filament_data.heated) { |
|||
GotoScreen(DGUSLCD_SCREEN_FILAMENT_UNLOADING); |
|||
filament_data.heated = true; |
|||
} |
|||
// Before unloading extrude to prevent jamming
|
|||
if (filament_data.purge_length >= 0) { |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue; |
|||
filament_data.purge_length -= movevalue; |
|||
} |
|||
else { |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue; |
|||
} |
|||
} |
|||
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder); |
|||
} |
|||
} |
|||
#endif // DGUS_FILAMENT_LOADUNLOAD
|
|||
|
|||
bool DGUSScreenHandler::loop() { |
|||
dgusdisplay.loop(); |
|||
|
|||
const millis_t ms = millis(); |
|||
static millis_t next_event_ms = 0; |
|||
|
|||
if (!IsScreenComplete() || ELAPSED(ms, next_event_ms)) { |
|||
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS; |
|||
UpdateScreenVPData(); |
|||
} |
|||
|
|||
#if ENABLED(SHOW_BOOTSCREEN) |
|||
static bool booted = false; |
|||
|
|||
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid())) |
|||
booted = true; |
|||
|
|||
if (!booted && ELAPSED(ms, TERN(USE_MKS_GREEN_UI, 1000, BOOTSCREEN_TIMEOUT))) |
|||
booted = true; |
|||
#endif |
|||
return IsScreenComplete(); |
|||
} |
|||
|
|||
#endif // DGUS_LCD_UI_FYSETC
|
|||
@ -0,0 +1,240 @@ |
|||
/**
|
|||
* 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 |
|||
|
|||
#include "../DGUSDisplay.h" |
|||
#include "../DGUSVPVariable.h" |
|||
#include "../DGUSDisplayDef.h" |
|||
|
|||
#include "../../../../../inc/MarlinConfig.h" |
|||
|
|||
enum DGUSLCD_Screens : uint8_t; |
|||
|
|||
class DGUSScreenHandler { |
|||
public: |
|||
DGUSScreenHandler() = default; |
|||
|
|||
static bool loop(); |
|||
|
|||
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
|
|||
// The bools specifing whether the strings are in RAM or FLASH.
|
|||
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); |
|||
|
|||
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); |
|||
|
|||
// "M117" Message -- msg is a RAM ptr.
|
|||
static void setstatusmessage(const char* msg); |
|||
// The same for messages from Flash
|
|||
static void setstatusmessagePGM(PGM_P const msg); |
|||
// Callback for VP "Display wants to change screen on idle printer"
|
|||
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Callback for VP "Screen has been changed"
|
|||
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Callback for VP "All Heaters Off"
|
|||
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for "Change this temperature"
|
|||
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for "Change Flowrate"
|
|||
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION) |
|||
// Hook for manual move option
|
|||
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
|
|||
// Hook for manual move.
|
|||
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for manual extrude.
|
|||
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for motor lock and unlook
|
|||
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
// Hook for power loss recovery.
|
|||
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
// Hook for settings
|
|||
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
#if HAS_PID_HEATING |
|||
// Hook for "Change this temperature PID para"
|
|||
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for PID autotune
|
|||
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if HAS_BED_PROBE |
|||
// Hook for "Change probe offset z"
|
|||
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if ENABLED(BABYSTEPPING) |
|||
// Hook for live z adjust action
|
|||
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if HAS_FAN |
|||
// Hook for fan control
|
|||
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
// Hook for heater control
|
|||
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(DGUS_PREHEAT_UI) |
|||
// Hook for preheat
|
|||
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD) |
|||
// Hook for filament load and unload filament option
|
|||
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for filament load and unload
|
|||
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var); |
|||
#endif |
|||
|
|||
#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.
|
|||
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr); |
|||
// User confirmed the abort action
|
|||
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr); |
|||
// User hit the tune button
|
|||
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Send a single filename to the display.
|
|||
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var); |
|||
// Marlin informed us that a new SD has been inserted.
|
|||
static void SDCardInserted(); |
|||
// Marlin informed us that the SD Card has been removed().
|
|||
static void SDCardRemoved(); |
|||
// Marlin informed us about a bad SD Card.
|
|||
static void SDCardError(); |
|||
#endif |
|||
|
|||
// OK Button the Confirm screen.
|
|||
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Update data after went to new screen (by display or by GotoScreen)
|
|||
// remember: store the last-displayed screen, so it can get returned to.
|
|||
// (e.g for pop up messages)
|
|||
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false); |
|||
|
|||
// Recall the remembered screen.
|
|||
static void PopToOldScreen(); |
|||
|
|||
// Make the display show the screen and update all VPs in it.
|
|||
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false); |
|||
|
|||
static void UpdateScreenVPData(); |
|||
|
|||
// Helpers to convert and transfer data to the display.
|
|||
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var); |
|||
|
|||
#if ENABLED(PRINTCOUNTER) |
|||
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
#if HAS_FAN |
|||
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var); |
|||
#if ENABLED(DGUS_UI_WAITING) |
|||
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
|
|||
// Send a value from 0..100 to a variable with a range from 0..255
|
|||
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
template<typename T> |
|||
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) { |
|||
if (!var.memadr) return; |
|||
union { unsigned char tmp[sizeof(T)]; T t; } x; |
|||
unsigned char *ptr = (unsigned char*)val_ptr; |
|||
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1]; |
|||
*(T*)var.memadr = x.t; |
|||
} |
|||
|
|||
// Send a float value to the display.
|
|||
// Display will get a 4-byte integer scaled to the number of digits:
|
|||
// Tell the display the number of digits and it cheats by displaying a dot between...
|
|||
template<unsigned int decimals> |
|||
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) { |
|||
if (var.memadr) { |
|||
float f = *(float *)var.memadr; |
|||
f *= cpow(10, decimals); |
|||
dgusdisplay.WriteVariable(var.VP, (long)f); |
|||
} |
|||
} |
|||
|
|||
// Send a float value to the display.
|
|||
// Display will get a 2-byte integer scaled to the number of digits:
|
|||
// Tell the display the number of digits and it cheats by displaying a dot between...
|
|||
template<unsigned int decimals> |
|||
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) { |
|||
if (var.memadr) { |
|||
float f = *(float *)var.memadr; |
|||
DEBUG_ECHOLNPAIR_F(" >> ", f, 6); |
|||
f *= cpow(10, decimals); |
|||
dgusdisplay.WriteVariable(var.VP, (int16_t)f); |
|||
} |
|||
} |
|||
|
|||
// Force an update of all VP on the current screen.
|
|||
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; } |
|||
// Has all VPs sent to the screen
|
|||
static inline bool IsScreenComplete() { return ScreenComplete; } |
|||
|
|||
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; } |
|||
|
|||
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; } |
|||
|
|||
private: |
|||
static DGUSLCD_Screens current_screen; //< currently on screen
|
|||
static constexpr uint8_t NUM_PAST_SCREENS = 4; |
|||
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
|
|||
|
|||
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
|
|||
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
|
|||
static bool ScreenComplete; //< All VPs sent to screen?
|
|||
|
|||
static uint16_t ConfirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
|
|||
|
|||
#if ENABLED(SDSUPPORT) |
|||
static int16_t top_file; //< file on top of file chooser
|
|||
static int16_t file_to_print; //< touched file to be confirmed
|
|||
#endif |
|||
|
|||
static void (*confirm_action_cb)(); |
|||
}; |
|||
|
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
#define PLR_SCREEN_RECOVER DGUSLCD_SCREEN_SDPRINTMANIPULATION |
|||
#define PLR_SCREEN_CANCEL DGUSLCD_SCREEN_STATUS |
|||
#endif |
|||
@ -0,0 +1,418 @@ |
|||
/**
|
|||
* 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 ENABLED(DGUS_LCD_UI_HYPRECY) |
|||
|
|||
#include "../DGUSScreenHandler.h" |
|||
|
|||
#include "../../../../../MarlinCore.h" |
|||
#include "../../../../../gcode/queue.h" |
|||
#include "../../../../../libs/duration_t.h" |
|||
#include "../../../../../module/settings.h" |
|||
#include "../../../../../module/temperature.h" |
|||
#include "../../../../../module/motion.h" |
|||
#include "../../../../../module/planner.h" |
|||
#include "../../../../../module/printcounter.h" |
|||
#include "../../../../../sd/cardreader.h" |
|||
|
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
#include "../../../../feature/powerloss.h" |
|||
#endif |
|||
|
|||
#if ENABLED(SDSUPPORT) |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file; |
|||
if (touched_nr > filelist.count()) return; |
|||
if (!filelist.seek(touched_nr)) return; |
|||
|
|||
if (filelist.isDir()) { |
|||
filelist.changeDir(filelist.filename()); |
|||
top_file = 0; |
|||
ForceCompleteUpdate(); |
|||
return; |
|||
} |
|||
|
|||
#if ENABLED(DGUS_PRINT_FILENAME) |
|||
// Send print filename
|
|||
dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true); |
|||
#endif |
|||
|
|||
// Setup Confirmation screen
|
|||
file_to_print = touched_nr; |
|||
|
|||
HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true); |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr) { |
|||
if (!filelist.seek(file_to_print)) return; |
|||
ExtUI::printFile(filelist.shortFilename()); |
|||
GotoScreen(DGUSLCD_SCREEN_SDPRINTMANIPULATION); |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) { |
|||
|
|||
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
|
|||
switch (swap16(*(uint16_t*)val_ptr)) { |
|||
case 0: { // Resume
|
|||
if (ExtUI::isPrintingFromMediaPaused()) { |
|||
ExtUI::resumePrint(); |
|||
} |
|||
} break; |
|||
|
|||
case 1: // Pause
|
|||
|
|||
GotoScreen(MKSLCD_SCREEN_PAUSE); |
|||
if (!ExtUI::isPrintingFromMediaPaused()) { |
|||
ExtUI::pausePrint(); |
|||
//ExtUI::mks_pausePrint();
|
|||
} |
|||
break; |
|||
case 2: // Abort
|
|||
HandleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_SendFilename(DGUS_VP_Variable& var) { |
|||
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN; |
|||
if (target_line > DGUS_SD_FILESPERSCREEN) return; |
|||
char tmpfilename[VP_SD_FileName_LEN + 1] = ""; |
|||
var.memadr = (void*)tmpfilename; |
|||
|
|||
if (filelist.seek(top_file + target_line)) { |
|||
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
|
|||
} |
|||
DGUSLCD_SendStringToDisplay(var); |
|||
} |
|||
|
|||
void DGUSScreenHandler::SDCardInserted() { |
|||
top_file = 0; |
|||
filelist.refresh(); |
|||
auto cs = getCurrentScreen(); |
|||
if (cs == DGUSLCD_SCREEN_MAIN || cs == DGUSLCD_SCREEN_STATUS) |
|||
GotoScreen(DGUSLCD_SCREEN_SDFILELIST); |
|||
} |
|||
|
|||
void DGUSScreenHandler::SDCardRemoved() { |
|||
if (current_screen == DGUSLCD_SCREEN_SDFILELIST |
|||
|| (current_screen == DGUSLCD_SCREEN_CONFIRM && (ConfirmVP == VP_SD_AbortPrintConfirmed || ConfirmVP == VP_SD_FileSelectConfirm)) |
|||
|| current_screen == DGUSLCD_SCREEN_SDPRINTMANIPULATION |
|||
) GotoScreen(DGUSLCD_SCREEN_MAIN); |
|||
} |
|||
|
|||
#endif // SDSUPPORT
|
|||
|
|||
void DGUSScreenHandler::ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint8_t *tmp = (uint8_t*)val_ptr; |
|||
|
|||
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
|
|||
// from screen 1 (main) to 10 (temperature). DGUSLCD_SCREEN_POPUP is special,
|
|||
// meaning "return to previous screen"
|
|||
DGUSLCD_Screens target = (DGUSLCD_Screens)tmp[1]; |
|||
|
|||
DEBUG_ECHOLNPAIR("\n DEBUG target", target); |
|||
|
|||
if (target == DGUSLCD_SCREEN_POPUP) { |
|||
// Special handling for popup is to return to previous menu
|
|||
if (current_screen == DGUSLCD_SCREEN_POPUP && confirm_action_cb) confirm_action_cb(); |
|||
PopToOldScreen(); |
|||
return; |
|||
} |
|||
|
|||
UpdateNewScreen(target); |
|||
|
|||
#ifdef DEBUG_DGUSLCD |
|||
if (!DGUSLCD_FindScreenVPMapList(target)) DEBUG_ECHOLNPAIR("WARNING: No screen Mapping found for ", target); |
|||
#endif |
|||
} |
|||
|
|||
void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleManualMove"); |
|||
|
|||
int16_t movevalue = swap16(*(uint16_t*)val_ptr); |
|||
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION) |
|||
if (movevalue) { |
|||
const uint16_t choice = *(uint16_t*)var.memadr; |
|||
movevalue = movevalue < 0 ? -choice : choice; |
|||
} |
|||
#endif |
|||
char axiscode; |
|||
unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
|
|||
|
|||
switch (var.VP) { |
|||
default: return; |
|||
|
|||
case VP_MOVE_X: |
|||
axiscode = 'X'; |
|||
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_MOVE_Y: |
|||
axiscode = 'Y'; |
|||
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_MOVE_Z: |
|||
axiscode = 'Z'; |
|||
speed = 300; // default to 5mm/s
|
|||
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_HOME_ALL: // only used for homing
|
|||
axiscode = '\0'; |
|||
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
|
|||
break; |
|||
} |
|||
|
|||
if (!movevalue) { |
|||
// homing
|
|||
DEBUG_ECHOPAIR(" homing ", axiscode); |
|||
char buf[6] = "G28 X"; |
|||
buf[4] = axiscode; |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOLNPGM(" ✓");
|
|||
ForceCompleteUpdate(); |
|||
return; |
|||
} |
|||
else { |
|||
// movement
|
|||
DEBUG_ECHOPAIR(" move ", axiscode); |
|||
bool old_relative_mode = relative_mode; |
|||
if (!relative_mode) { |
|||
//DEBUG_ECHOPGM(" G91");
|
|||
queue.enqueue_now_P(PSTR("G91")); |
|||
//DEBUG_ECHOPGM(" ✓ ");
|
|||
} |
|||
char buf[32]; // G1 X9999.99 F12345
|
|||
unsigned int backup_speed = MMS_TO_MMM(feedrate_mm_s); |
|||
char sign[] = "\0"; |
|||
int16_t value = movevalue / 100; |
|||
if (movevalue < 0) { value = -value; sign[0] = '-'; } |
|||
int16_t fraction = ABS(movevalue) % 100; |
|||
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed); |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOLNPGM(" ✓ ");
|
|||
if (backup_speed != speed) { |
|||
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed); |
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
} |
|||
// while (!enqueue_and_echo_command(buf)) idle();
|
|||
//DEBUG_ECHOLNPGM(" ✓ ");
|
|||
if (!old_relative_mode) { |
|||
//DEBUG_ECHOPGM("G90");
|
|||
queue.enqueue_now_P(PSTR("G90")); |
|||
//DEBUG_ECHOPGM(" ✓ ");
|
|||
} |
|||
} |
|||
|
|||
ForceCompleteUpdate(); |
|||
DEBUG_ECHOLNPGM("manmv done."); |
|||
return; |
|||
|
|||
cannotmove: |
|||
DEBUG_ECHOLNPAIR(" cannot move ", axiscode); |
|||
return; |
|||
} |
|||
|
|||
#if HAS_PID_HEATING |
|||
void DGUSScreenHandler::HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr); |
|||
DEBUG_ECHOLNPAIR("V1:", rawvalue); |
|||
float value = (float)rawvalue / 10; |
|||
DEBUG_ECHOLNPAIR("V2:", value); |
|||
float newvalue = 0; |
|||
|
|||
switch (var.VP) { |
|||
default: return; |
|||
#if HOTENDS >= 1 |
|||
case VP_E0_PID_P: newvalue = value; break; |
|||
case VP_E0_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_E0_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
case VP_E1_PID_P: newvalue = value; break; |
|||
case VP_E1_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_E1_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
#if HAS_HEATED_BED |
|||
case VP_BED_PID_P: newvalue = value; break; |
|||
case VP_BED_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_BED_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
} |
|||
|
|||
DEBUG_ECHOLNPAIR_F("V3:", newvalue); |
|||
*(float *)var.memadr = newvalue; |
|||
|
|||
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
|
|||
} |
|||
#endif // HAS_PID_HEATING
|
|||
|
|||
#if ENABLED(BABYSTEPPING) |
|||
void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleLiveAdjustZ"); |
|||
int16_t flag = swap16(*(uint16_t*)val_ptr), |
|||
steps = flag ? -20 : 20; |
|||
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true); |
|||
ForceCompleteUpdate(); |
|||
} |
|||
#endif |
|||
|
|||
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD) |
|||
|
|||
void DGUSScreenHandler::HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleFilamentOption"); |
|||
|
|||
uint8_t e_temp = 0; |
|||
filament_data.heated = false; |
|||
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr); |
|||
if (preheat_option <= 8) { // Load filament type
|
|||
filament_data.action = 1; |
|||
} |
|||
else if (preheat_option >= 10) { // Unload filament type
|
|||
preheat_option -= 10; |
|||
filament_data.action = 2; |
|||
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH; |
|||
} |
|||
else { // Cancel filament operation
|
|||
filament_data.action = 0; |
|||
} |
|||
|
|||
switch (preheat_option) { |
|||
case 0: // Load PLA
|
|||
#ifdef PREHEAT_1_TEMP_HOTEND |
|||
e_temp = PREHEAT_1_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 1: // Load ABS
|
|||
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND); |
|||
break; |
|||
case 2: // Load PET
|
|||
#ifdef PREHEAT_3_TEMP_HOTEND |
|||
e_temp = PREHEAT_3_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 3: // Load FLEX
|
|||
#ifdef PREHEAT_4_TEMP_HOTEND |
|||
e_temp = PREHEAT_4_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 9: // Cool down
|
|||
default: |
|||
e_temp = 0; |
|||
break; |
|||
} |
|||
|
|||
if (filament_data.action == 0) { // Go back to utility screen
|
|||
#if HOTENDS >= 1 |
|||
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0); |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1); |
|||
#endif |
|||
GotoScreen(DGUSLCD_SCREEN_UTILITY); |
|||
} |
|||
else { // Go to the preheat screen to show the heating progress
|
|||
switch (var.VP) { |
|||
default: return; |
|||
#if HOTENDS >= 1 |
|||
case VP_E0_FILAMENT_LOAD_UNLOAD: |
|||
filament_data.extruder = ExtUI::extruder_t::E0; |
|||
thermalManager.setTargetHotend(e_temp, filament_data.extruder); |
|||
break; |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
case VP_E1_FILAMENT_LOAD_UNLOAD: |
|||
filament_data.extruder = ExtUI::extruder_t::E1; |
|||
thermalManager.setTargetHotend(e_temp, filament_data.extruder); |
|||
break; |
|||
#endif |
|||
} |
|||
GotoScreen(DGUSLCD_SCREEN_FILAMENT_HEATING); |
|||
} |
|||
} |
|||
|
|||
void DGUSScreenHandler::HandleFilamentLoadUnload(DGUS_VP_Variable &var) { |
|||
DEBUG_ECHOLNPGM("HandleFilamentLoadUnload"); |
|||
if (filament_data.action <= 0) return; |
|||
|
|||
// If we close to the target temperature, we can start load or unload the filament
|
|||
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \ |
|||
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) { |
|||
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME; |
|||
|
|||
if (filament_data.action == 1) { // load filament
|
|||
if (!filament_data.heated) { |
|||
//GotoScreen(DGUSLCD_SCREEN_FILAMENT_LOADING);
|
|||
filament_data.heated = true; |
|||
} |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue; |
|||
} |
|||
else { // unload filament
|
|||
if (!filament_data.heated) { |
|||
GotoScreen(DGUSLCD_SCREEN_FILAMENT_UNLOADING); |
|||
filament_data.heated = true; |
|||
} |
|||
// Before unloading extrude to prevent jamming
|
|||
if (filament_data.purge_length >= 0) { |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue; |
|||
filament_data.purge_length -= movevalue; |
|||
} |
|||
else { |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue; |
|||
} |
|||
} |
|||
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder); |
|||
} |
|||
} |
|||
#endif // DGUS_FILAMENT_LOADUNLOAD
|
|||
|
|||
bool DGUSScreenHandler::loop() { |
|||
dgusdisplay.loop(); |
|||
|
|||
const millis_t ms = millis(); |
|||
static millis_t next_event_ms = 0; |
|||
|
|||
if (!IsScreenComplete() || ELAPSED(ms, next_event_ms)) { |
|||
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS; |
|||
UpdateScreenVPData(); |
|||
} |
|||
|
|||
#if ENABLED(SHOW_BOOTSCREEN) |
|||
static bool booted = false; |
|||
|
|||
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid())) |
|||
booted = true; |
|||
|
|||
if (!booted && ELAPSED(ms, TERN(USE_MKS_GREEN_UI, 1000, BOOTSCREEN_TIMEOUT))) |
|||
booted = true; |
|||
#endif |
|||
return IsScreenComplete(); |
|||
} |
|||
|
|||
#endif // DGUS_LCD_UI_HYPRECY
|
|||
@ -0,0 +1,240 @@ |
|||
/**
|
|||
* 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 |
|||
|
|||
#include "../DGUSDisplay.h" |
|||
#include "../DGUSVPVariable.h" |
|||
#include "../DGUSDisplayDef.h" |
|||
|
|||
#include "../../../../../inc/MarlinConfig.h" |
|||
|
|||
enum DGUSLCD_Screens : uint8_t; |
|||
|
|||
class DGUSScreenHandler { |
|||
public: |
|||
DGUSScreenHandler() = default; |
|||
|
|||
static bool loop(); |
|||
|
|||
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
|
|||
// The bools specifing whether the strings are in RAM or FLASH.
|
|||
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); |
|||
|
|||
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); |
|||
|
|||
// "M117" Message -- msg is a RAM ptr.
|
|||
static void setstatusmessage(const char* msg); |
|||
// The same for messages from Flash
|
|||
static void setstatusmessagePGM(PGM_P const msg); |
|||
// Callback for VP "Display wants to change screen on idle printer"
|
|||
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Callback for VP "Screen has been changed"
|
|||
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Callback for VP "All Heaters Off"
|
|||
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for "Change this temperature"
|
|||
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for "Change Flowrate"
|
|||
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION) |
|||
// Hook for manual move option
|
|||
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
|
|||
// Hook for manual move.
|
|||
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for manual extrude.
|
|||
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for motor lock and unlook
|
|||
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
// Hook for power loss recovery.
|
|||
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
// Hook for settings
|
|||
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
#if HAS_PID_HEATING |
|||
// Hook for "Change this temperature PID para"
|
|||
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for PID autotune
|
|||
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if HAS_BED_PROBE |
|||
// Hook for "Change probe offset z"
|
|||
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if ENABLED(BABYSTEPPING) |
|||
// Hook for live z adjust action
|
|||
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if HAS_FAN |
|||
// Hook for fan control
|
|||
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
// Hook for heater control
|
|||
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(DGUS_PREHEAT_UI) |
|||
// Hook for preheat
|
|||
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD) |
|||
// Hook for filament load and unload filament option
|
|||
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for filament load and unload
|
|||
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var); |
|||
#endif |
|||
|
|||
#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.
|
|||
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr); |
|||
// User confirmed the abort action
|
|||
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr); |
|||
// User hit the tune button
|
|||
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Send a single filename to the display.
|
|||
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var); |
|||
// Marlin informed us that a new SD has been inserted.
|
|||
static void SDCardInserted(); |
|||
// Marlin informed us that the SD Card has been removed().
|
|||
static void SDCardRemoved(); |
|||
// Marlin informed us about a bad SD Card.
|
|||
static void SDCardError(); |
|||
#endif |
|||
|
|||
// OK Button the Confirm screen.
|
|||
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Update data after went to new screen (by display or by GotoScreen)
|
|||
// remember: store the last-displayed screen, so it can get returned to.
|
|||
// (e.g for pop up messages)
|
|||
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false); |
|||
|
|||
// Recall the remembered screen.
|
|||
static void PopToOldScreen(); |
|||
|
|||
// Make the display show the screen and update all VPs in it.
|
|||
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false); |
|||
|
|||
static void UpdateScreenVPData(); |
|||
|
|||
// Helpers to convert and transfer data to the display.
|
|||
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var); |
|||
|
|||
#if ENABLED(PRINTCOUNTER) |
|||
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
#if HAS_FAN |
|||
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var); |
|||
#if ENABLED(DGUS_UI_WAITING) |
|||
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
|
|||
// Send a value from 0..100 to a variable with a range from 0..255
|
|||
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
template<typename T> |
|||
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) { |
|||
if (!var.memadr) return; |
|||
union { unsigned char tmp[sizeof(T)]; T t; } x; |
|||
unsigned char *ptr = (unsigned char*)val_ptr; |
|||
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1]; |
|||
*(T*)var.memadr = x.t; |
|||
} |
|||
|
|||
// Send a float value to the display.
|
|||
// Display will get a 4-byte integer scaled to the number of digits:
|
|||
// Tell the display the number of digits and it cheats by displaying a dot between...
|
|||
template<unsigned int decimals> |
|||
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) { |
|||
if (var.memadr) { |
|||
float f = *(float *)var.memadr; |
|||
f *= cpow(10, decimals); |
|||
dgusdisplay.WriteVariable(var.VP, (long)f); |
|||
} |
|||
} |
|||
|
|||
// Send a float value to the display.
|
|||
// Display will get a 2-byte integer scaled to the number of digits:
|
|||
// Tell the display the number of digits and it cheats by displaying a dot between...
|
|||
template<unsigned int decimals> |
|||
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) { |
|||
if (var.memadr) { |
|||
float f = *(float *)var.memadr; |
|||
DEBUG_ECHOLNPAIR_F(" >> ", f, 6); |
|||
f *= cpow(10, decimals); |
|||
dgusdisplay.WriteVariable(var.VP, (int16_t)f); |
|||
} |
|||
} |
|||
|
|||
// Force an update of all VP on the current screen.
|
|||
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; } |
|||
// Has all VPs sent to the screen
|
|||
static inline bool IsScreenComplete() { return ScreenComplete; } |
|||
|
|||
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; } |
|||
|
|||
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; } |
|||
|
|||
private: |
|||
static DGUSLCD_Screens current_screen; //< currently on screen
|
|||
static constexpr uint8_t NUM_PAST_SCREENS = 4; |
|||
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
|
|||
|
|||
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
|
|||
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
|
|||
static bool ScreenComplete; //< All VPs sent to screen?
|
|||
|
|||
static uint16_t ConfirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
|
|||
|
|||
#if ENABLED(SDSUPPORT) |
|||
static int16_t top_file; //< file on top of file chooser
|
|||
static int16_t file_to_print; //< touched file to be confirmed
|
|||
#endif |
|||
|
|||
static void (*confirm_action_cb)(); |
|||
}; |
|||
|
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
#define PLR_SCREEN_RECOVER DGUSLCD_SCREEN_SDPRINTMANIPULATION |
|||
#define PLR_SCREEN_CANCEL DGUSLCD_SCREEN_STATUS |
|||
#endif |
|||
@ -0,0 +1,795 @@ |
|||
/**
|
|||
* 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 ENABLED(DGUS_LCD_UI_MKS) |
|||
|
|||
#include "DGUSDisplayDef.h" |
|||
#include "../DGUSDisplay.h" |
|||
#include "../DGUSScreenHandler.h" |
|||
|
|||
#include "../../../../../module/temperature.h" |
|||
#include "../../../../../module/motion.h" |
|||
#include "../../../../../module/planner.h" |
|||
|
|||
#include "../../../ui_api.h" |
|||
#include "../../../../marlinui.h" |
|||
|
|||
#if ENABLED(HAS_STEALTHCHOP) |
|||
#include "../../../../module/stepper/trinamic.h" |
|||
#endif |
|||
|
|||
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION) |
|||
uint16_t distanceToMove = 10; |
|||
#endif |
|||
|
|||
uint16_t distanceMove = 1; |
|||
float distanceFilament = 10; |
|||
uint16_t FilamentSpeed = 25; |
|||
float ZOffset_distance = 0.1; |
|||
float mesh_adj_distance = 0.1; |
|||
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; |
|||
|
|||
xyz_pos_t position_before_pause; |
|||
|
|||
void MKS_pause_print_move() { |
|||
planner.synchronize(); |
|||
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); |
|||
} |
|||
|
|||
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 |
|||
|
|||
uint16_t lcd_default_light = 50; |
|||
|
|||
EX_FILAMENT_DEF ex_filament; |
|||
RUNOUT_MKS_DEF runout_mks; |
|||
NOZZLE_PARK_DEF nozzle_park_mks; |
|||
|
|||
const uint16_t VPList_Boot[] PROGMEM = { |
|||
VP_MARLIN_VERSION, |
|||
0x0000 |
|||
}; |
|||
|
|||
#define MKSLIST_E_ITEM(N) VP_T_E##N##_Is, VP_T_E##N##_Set, |
|||
|
|||
const uint16_t VPList_Main[] PROGMEM = { |
|||
// VP_M117, for completeness, but it cannot be auto-uploaded.
|
|||
#if HOTENDS >= 1 |
|||
MKSLIST_E_ITEM(0) VP_E0_STATUS, |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
MKSLIST_E_ITEM(1) |
|||
#endif |
|||
#if HAS_HEATED_BED |
|||
VP_T_Bed_Is, VP_T_Bed_Set, VP_BED_STATUS, |
|||
#endif |
|||
#if HAS_FAN |
|||
VP_Fan0_Percentage, VP_FAN0_STATUS, |
|||
#endif |
|||
VP_XPos, VP_YPos, VP_ZPos, |
|||
VP_Fan0_Percentage, |
|||
VP_Feedrate_Percentage, |
|||
#if ENABLED(LCD_SET_PROGRESS_MANUALLY) |
|||
VP_PrintProgress_Percentage, |
|||
#endif |
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_Home[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
// Language
|
|||
// VP_HOME_Dis,
|
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_Setting[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
// Language
|
|||
VP_Setting_Dis, |
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_Tool[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
// Language
|
|||
VP_Tool_Dis, |
|||
// LCD BLK
|
|||
VP_LCD_BLK, |
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_EXTRUE[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
|
|||
VP_Filament_distance, |
|||
VP_Filament_speed, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_LEVEL[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_MOVE[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_Print[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
// Print Percent
|
|||
VP_PrintProgress_Percentage, |
|||
|
|||
VP_PrintTime, |
|||
|
|||
VP_Flowrate_E0, |
|||
VP_Flowrate_E1, |
|||
VP_Feedrate_Percentage, |
|||
|
|||
VP_PrintTime_H, |
|||
VP_PrintTime_M, |
|||
VP_PrintTime_S, |
|||
|
|||
VP_XPos, |
|||
VP_YPos, |
|||
VP_ZPos, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_SD_File[] PROGMEM = { |
|||
VP_SD_FileName0, VP_SD_FileName1, |
|||
VP_SD_FileName2, VP_SD_FileName3, |
|||
VP_SD_FileName4, VP_SD_FileName5, |
|||
VP_SD_FileName6, VP_SD_FileName7, |
|||
VP_SD_FileName8, VP_SD_FileName9, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_TempOnly[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
// LCD BLK
|
|||
VP_LCD_BLK, |
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_Pluse[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
|
|||
// Pluse
|
|||
VP_X_STEP_PER_MM, |
|||
VP_Y_STEP_PER_MM, |
|||
VP_Z_STEP_PER_MM, |
|||
VP_E0_STEP_PER_MM, |
|||
VP_E1_STEP_PER_MM, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_MaxSpeed[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
|
|||
// Pluse
|
|||
VP_X_MAX_SPEED, |
|||
VP_Y_MAX_SPEED, |
|||
VP_Z_MAX_SPEED, |
|||
VP_E0_MAX_SPEED, |
|||
VP_E1_MAX_SPEED, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_MaxAcc[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
|
|||
// ACC
|
|||
VP_ACC_SPEED, |
|||
VP_X_ACC_MAX_SPEED, |
|||
VP_Y_ACC_MAX_SPEED, |
|||
VP_Z_ACC_MAX_SPEED, |
|||
VP_E0_ACC_MAX_SPEED, |
|||
VP_E1_ACC_MAX_SPEED, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_PID[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
|
|||
// PID
|
|||
VP_E0_PID_P, |
|||
VP_E0_PID_I, |
|||
VP_E0_PID_D, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_Level_Point[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
// FAN
|
|||
VP_Fan0_Percentage, |
|||
|
|||
// Level Point
|
|||
VP_Level_Point_One_X, |
|||
VP_Level_Point_One_Y, |
|||
VP_Level_Point_Two_X, |
|||
VP_Level_Point_Two_Y, |
|||
VP_Level_Point_Three_X, |
|||
VP_Level_Point_Three_Y, |
|||
VP_Level_Point_Four_X, |
|||
VP_Level_Point_Four_Y, |
|||
VP_Level_Point_Five_X, |
|||
VP_Level_Point_Five_Y, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_Level_PrintConfig[] PROGMEM = { |
|||
VP_T_E0_Set, |
|||
VP_T_E1_Set, |
|||
VP_T_Bed_Set, |
|||
VP_Flowrate_E0, |
|||
VP_Flowrate_E1, |
|||
VP_Fan0_Percentage, |
|||
VP_Feedrate_Percentage, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_PrintPauseConfig[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
|
|||
VP_X_PARK_POS, |
|||
VP_Y_PARK_POS, |
|||
VP_Z_PARK_POS, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_MotoConfig[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
|
|||
VP_TRAVEL_SPEED, |
|||
VP_FEEDRATE_MIN_SPEED, |
|||
VP_T_F_SPEED, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_EX_Config[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
VP_MIN_EX_T,VP_Min_EX_T_E, |
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSTMC_Config[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
// HB Temp
|
|||
VP_T_Bed_Is, VP_T_Bed_Set, |
|||
VP_MIN_EX_T, |
|||
|
|||
VP_TMC_X_STEP, |
|||
VP_TMC_Y_STEP, |
|||
VP_TMC_Z_STEP, |
|||
VP_TMC_X1_Current, |
|||
VP_TMC_Y1_Current, |
|||
VP_TMC_X_Current, |
|||
VP_TMC_Y_Current, |
|||
VP_TMC_Z_Current, |
|||
VP_TMC_E0_Current, |
|||
VP_TMC_E1_Current, |
|||
VP_TMC_Z1_Current, |
|||
|
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSAuto_Level[] PROGMEM = { |
|||
VP_MESH_LEVEL_POINT_DIS, |
|||
VP_ZPos, |
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSOffset_Config[] PROGMEM = { |
|||
// E Temp
|
|||
REPEAT(EXTRUDERS, MKSLIST_E_ITEM) |
|||
VP_OFFSET_X, |
|||
VP_OFFSET_Y, |
|||
VP_OFFSET_Z, |
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSBabyStep[] PROGMEM = { |
|||
VP_ZOffset_DE_DIS, |
|||
0x0000 |
|||
}; |
|||
|
|||
const uint16_t MKSList_About[] PROGMEM = { |
|||
// Marlin version
|
|||
VP_MARLIN_VERSION, |
|||
// H43 Version
|
|||
VP_MKS_H43_VERSION, |
|||
VP_MKS_H43_UpdataVERSION, |
|||
0x0000 |
|||
}; |
|||
|
|||
// Page data updata
|
|||
const struct VPMapping VPMap[] PROGMEM = { |
|||
{ MKSLCD_SCREEN_BOOT, VPList_Boot }, // Boot Page to show logo 0
|
|||
{ MKSLCD_SCREEN_HOME, MKSList_Home }, // Home, Page 1
|
|||
{ MKSLCD_SCREEN_SETTING, MKSList_Setting }, // Setting, Page 2
|
|||
{ MKSLCD_SCREEM_TOOL, MKSList_Tool }, // Page 3
|
|||
{ MKSLCD_SCREEN_EXTRUDE_P1, MKSList_EXTRUE }, // Page 4
|
|||
{ MKSLCD_SCREEN_EXTRUDE_P2, MKSList_EXTRUE }, // Page 11
|
|||
{ MKSLCD_PAUSE_SETTING_EX, MKSList_EXTRUE }, // Page 57
|
|||
{ MKSLCD_PAUSE_SETTING_EX2, MKSList_EXTRUE }, // Page 61
|
|||
{ MKSLCD_SCREEN_LEVEL, MKSList_LEVEL }, // Page 5
|
|||
{ MKSLCD_SCREEN_MOVE, MKSList_MOVE }, // Page 6
|
|||
{ MKSLCD_SCREEN_PRINT, MKSList_Print }, // Page 7
|
|||
{ MKSLCD_SCREEN_PAUSE, MKSList_Print }, // Page 26
|
|||
{ MKSLCD_SCREEN_CHOOSE_FILE, MKSList_SD_File }, // Page 15
|
|||
{ MKSLCD_SCREEN_MOTOR_PLUSE, MKSList_Pluse }, // Page 51
|
|||
{ MKSLCD_SCREEN_MOTOR_SPEED, MKSList_MaxSpeed }, // Page 55
|
|||
{ MKSLCD_SCREEN_MOTOR_ACC_MAX, MKSList_MaxAcc }, // Page 53
|
|||
{ MKSLCD_SCREEN_LEVEL_DATA, MKSList_Level_Point }, // Page 48
|
|||
{ MKSLCD_PrintPause_SET, MKSList_PrintPauseConfig }, // Page 49
|
|||
{ MKSLCD_FILAMENT_DATA, MKSList_SD_File }, // Page 50
|
|||
{ MKSLCD_SCREEN_Config, MKSList_TempOnly }, // Page 46
|
|||
{ MKSLCD_SCREEN_Config_MOTOR, MKSList_MotoConfig }, // Page 47
|
|||
{ MKSLCD_PID, MKSList_PID }, // Page 56
|
|||
{ MKSLCD_ABOUT, MKSList_About }, // Page 36
|
|||
{ MKSLCD_SCREEN_PRINT_CONFIG, MKSList_Level_PrintConfig }, // Page 60
|
|||
{ MKSLCD_SCREEN_EX_CONFIG, MKSList_EX_Config }, // Page 65
|
|||
{ MKSLCD_SCREEN_TMC_Config, MKSTMC_Config }, // Page 70
|
|||
{ MKSLCD_AUTO_LEVEL, MKSAuto_Level }, // Page 73
|
|||
{ MKSLCD_Screen_Offset_Config, MKSOffset_Config }, // Page 30
|
|||
{ MKSLCD_Screen_PMove, MKSList_MOVE }, // Page 64
|
|||
{ MKSLCD_Screen_Baby, MKSBabyStep }, // Page 71
|
|||
//{ MKSLCD_SCREEN_LEVEL_DATA, MKSList_SD_File},
|
|||
//{ MKSLCD_SCREEN_HOME, VPList_Boot },
|
|||
{ 0, nullptr } // List is terminated with an nullptr as table entry.
|
|||
}; |
|||
|
|||
const char MarlinVersion[] PROGMEM = SHORT_BUILD_VERSION; |
|||
const char H43Version[] PROGMEM = "MKS H43_V1.30"; |
|||
const char Updata_Time[] PROGMEM = STRING_DISTRIBUTION_DATE; |
|||
|
|||
// Helper to define a DGUS_VP_Variable for common use cases.
|
|||
#define VPHELPER(VPADR, VPADRVAR, RXFPTR, TXFPTR) \ |
|||
{ \ |
|||
.VP = VPADR, .memadr = VPADRVAR, .size = sizeof(VPADRVAR), \ |
|||
.set_by_display_handler = RXFPTR, .send_to_display_handler = TXFPTR \ |
|||
} |
|||
|
|||
// Helper to define a DGUS_VP_Variable when the sizeo of the var cannot be determined automaticalyl (eg. a string)
|
|||
#define VPHELPER_STR(VPADR, VPADRVAR, STRLEN, RXFPTR, TXFPTR) \ |
|||
{ \ |
|||
.VP = VPADR, .memadr = VPADRVAR, .size = STRLEN, \ |
|||
.set_by_display_handler = RXFPTR, .send_to_display_handler = TXFPTR \ |
|||
} |
|||
|
|||
const struct DGUS_VP_Variable ListOfVP[] PROGMEM = { |
|||
// Helper to detect touch events
|
|||
VPHELPER(VP_SCREENCHANGE, nullptr, ScreenHandler.ScreenChangeHook, nullptr), |
|||
VPHELPER(VP_SCREENCHANGE_ASK, nullptr, ScreenHandler.ScreenChangeHookIfIdle, nullptr), |
|||
#if ENABLED(SDSUPPORT) |
|||
VPHELPER(VP_SCREENCHANGE_WHENSD, nullptr, ScreenHandler.ScreenChangeHookIfSD, nullptr), |
|||
#endif |
|||
VPHELPER(VP_CONFIRMED, nullptr, ScreenHandler.ScreenConfirmedOK, nullptr), |
|||
|
|||
// Back Button
|
|||
VPHELPER(VP_BACK_PAGE, nullptr, &ScreenHandler.ScreenBackChange, nullptr), |
|||
VPHELPER(VP_TEMP_ALL_OFF, nullptr, &ScreenHandler.HandleAllHeatersOff, nullptr), |
|||
|
|||
VPHELPER(VP_MOVE_X, nullptr, &ScreenHandler.HandleManualMove, nullptr), |
|||
VPHELPER(VP_MOVE_Y, nullptr, &ScreenHandler.HandleManualMove, nullptr), |
|||
VPHELPER(VP_MOVE_Z, nullptr, &ScreenHandler.HandleManualMove, nullptr), |
|||
VPHELPER(VP_HOME_ALL, nullptr, &ScreenHandler.HandleManualMove, nullptr), |
|||
|
|||
VPHELPER(VP_X_HOME, nullptr, &ScreenHandler.HandleManualMove, nullptr), |
|||
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_MOTOR_LOCK_UNLOK, nullptr, &ScreenHandler.HandleManualMove, nullptr), |
|||
VPHELPER(VP_LEVEL_POINT, nullptr, &ScreenHandler.ManualAssistLeveling, nullptr), |
|||
|
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
VPHELPER(VP_POWER_LOSS_RECOVERY, nullptr, &ScreenHandler.HandlePowerLossRecovery, nullptr), |
|||
#endif |
|||
VPHELPER(VP_SETTINGS, nullptr, &ScreenHandler.HandleSettings, nullptr), |
|||
#if ENABLED(SINGLE_Z_CALIBRATION) |
|||
VPHELPER(VP_Z_CALIBRATE, nullptr, &ScreenHandler.HandleZCalibration, nullptr), |
|||
#endif |
|||
#if ENABLED(FIRST_LAYER_CAL) |
|||
VPHELPER(VP_Z_FIRST_LAYER_CAL, nullptr, &ScreenHandler.HandleFirstLayerCal, nullptr), |
|||
#endif |
|||
{.VP = VP_MARLIN_VERSION, .memadr = (void *)MarlinVersion, .size = VP_MARLIN_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM}, |
|||
// M117 LCD String (We don't need the string in memory but "just" push it to the display on demand, hence the nullptr
|
|||
{.VP = VP_M117, .memadr = nullptr, .size = VP_M117_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay}, |
|||
{.VP = VP_MKS_H43_VERSION, .memadr = (void *)H43Version, .size = VP_MKS_H43_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM}, |
|||
{.VP = VP_MKS_H43_UpdataVERSION, .memadr = (void *)Updata_Time, .size = VP_MKS_H43_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM}, |
|||
|
|||
// Temperature Data
|
|||
#if HOTENDS >= 1 |
|||
VPHELPER(VP_T_E0_Is, &thermalManager.temp_hotend[0].celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<0>), |
|||
VPHELPER(VP_T_E0_Set, &thermalManager.temp_hotend[0].target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
VPHELPER(VP_Flowrate_E0, &planner.flow_percentage[ExtUI::extruder_t::E0], ScreenHandler.HandleFlowRateChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
VPHELPER(VP_EPos, &destination.e, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>), |
|||
VPHELPER(VP_MOVE_E0, nullptr, &ScreenHandler.HandleManualExtrude, nullptr), |
|||
VPHELPER(VP_E0_CONTROL, &thermalManager.temp_hotend[0].target, &ScreenHandler.HandleHeaterControl, nullptr), |
|||
VPHELPER(VP_E0_STATUS, &thermalManager.temp_hotend[0].target, nullptr, &ScreenHandler.DGUSLCD_SendHeaterStatusToDisplay), |
|||
#if ENABLED(DGUS_PREHEAT_UI) |
|||
VPHELPER(VP_E0_BED_PREHEAT, nullptr, &ScreenHandler.HandlePreheat, nullptr), |
|||
#endif |
|||
#if ENABLED(PIDTEMP) |
|||
VPHELPER(VP_E0_PID_P, &thermalManager.temp_hotend[0].pid.Kp, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID), |
|||
VPHELPER(VP_E0_PID_I, &thermalManager.temp_hotend[0].pid.Ki, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID), |
|||
VPHELPER(VP_E0_PID_D, &thermalManager.temp_hotend[0].pid.Kd, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID), |
|||
VPHELPER(VP_PID_AUTOTUNE_E0, nullptr, &ScreenHandler.HandlePIDAutotune, nullptr), |
|||
#endif |
|||
#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_speed, &FilamentSpeed, &ScreenHandler.GetManualFilamentSpeed, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#endif |
|||
|
|||
#if HOTENDS >= 2 |
|||
VPHELPER(VP_T_E1_Is, &thermalManager.temp_hotend[1].celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<0>), |
|||
VPHELPER(VP_T_E1_Set, &thermalManager.temp_hotend[1].target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
VPHELPER(VP_Flowrate_E1, &planner.flow_percentage[ExtUI::extruder_t::E1], ScreenHandler.HandleFlowRateChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
VPHELPER(VP_MOVE_E1, nullptr, &ScreenHandler.HandleManualExtrude, nullptr), |
|||
VPHELPER(VP_E1_CONTROL, &thermalManager.temp_hotend[1].target, &ScreenHandler.HandleHeaterControl, nullptr), |
|||
VPHELPER(VP_E1_STATUS, &thermalManager.temp_hotend[1].target, nullptr, &ScreenHandler.DGUSLCD_SendHeaterStatusToDisplay), |
|||
|
|||
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD) |
|||
VPHELPER(VP_Filament_distance, &distanceFilament, &ScreenHandler.GetManualFilament, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
VPHELPER(VP_Filament_speed, &FilamentSpeed, &ScreenHandler.GetManualFilamentSpeed, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
|
|||
#if ENABLED(PIDTEMP) |
|||
VPHELPER(VP_PID_AUTOTUNE_E1, nullptr, &ScreenHandler.HandlePIDAutotune, nullptr), |
|||
#endif |
|||
|
|||
VPHELPER(VP_E1_FILAMENT_LOAD_UNLOAD, nullptr, &ScreenHandler.HandleFilamentOption, &ScreenHandler.HandleFilamentLoadUnload), |
|||
#endif |
|||
|
|||
#if HAS_HEATED_BED |
|||
VPHELPER(VP_T_Bed_Is, &thermalManager.temp_bed.celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<0>), |
|||
VPHELPER(VP_T_Bed_Set, &thermalManager.temp_bed.target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
VPHELPER(VP_BED_CONTROL, &thermalManager.temp_bed.target, &ScreenHandler.HandleHeaterControl, nullptr), |
|||
VPHELPER(VP_BED_STATUS, &thermalManager.temp_bed.target, nullptr, &ScreenHandler.DGUSLCD_SendHeaterStatusToDisplay), |
|||
#if ENABLED(PIDTEMPBED) |
|||
VPHELPER(VP_BED_PID_P, &thermalManager.temp_bed.pid.Kp, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID), |
|||
VPHELPER(VP_BED_PID_I, &thermalManager.temp_bed.pid.Ki, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID), |
|||
VPHELPER(VP_BED_PID_D, &thermalManager.temp_bed.pid.Kd, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID), |
|||
VPHELPER(VP_PID_AUTOTUNE_BED, nullptr, &ScreenHandler.HandlePIDAutotune, nullptr), |
|||
#endif |
|||
#endif |
|||
|
|||
// Fan Data
|
|||
#if HAS_FAN |
|||
#define FAN_VPHELPER(N) \ |
|||
VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], ScreenHandler.DGUSLCD_SetUint8, &ScreenHandler.DGUSLCD_SendFanToDisplay), \ |
|||
VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], &ScreenHandler.HandleFanControl, nullptr), \ |
|||
VPHELPER(VP_FAN##N##_STATUS, &thermalManager.fan_speed[N], nullptr, &ScreenHandler.DGUSLCD_SendFanStatusToDisplay), |
|||
REPEAT(FAN_COUNT, FAN_VPHELPER) |
|||
#endif |
|||
|
|||
// Feedrate
|
|||
VPHELPER(VP_Feedrate_Percentage, &feedrate_percentage, ScreenHandler.DGUSLCD_SetValueDirectly<int16_t>, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
|
|||
// Position Data
|
|||
VPHELPER(VP_XPos, ¤t_position.x, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>), |
|||
VPHELPER(VP_YPos, ¤t_position.y, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>), |
|||
VPHELPER(VP_ZPos, ¤t_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), |
|||
|
|||
// Print Progress
|
|||
VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, ScreenHandler.DGUSLCD_SendPrintProgressToDisplay), |
|||
|
|||
//LCD Control
|
|||
VPHELPER(VP_LCD_BLK, &lcd_default_light, &ScreenHandler.LCD_BLK_Adjust, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
|
|||
// Print Time
|
|||
VPHELPER_STR(VP_PrintTime, nullptr, VP_PrintTime_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintTimeToDisplay_MKS), |
|||
|
|||
#if ENABLED(PRINTCOUNTER) |
|||
VPHELPER_STR(VP_PrintAccTime, nullptr, VP_PrintAccTime_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintAccTimeToDisplay), |
|||
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintsTotalToDisplay), |
|||
#endif |
|||
|
|||
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], ScreenHandler.HandleStepPerMMChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], ScreenHandler.HandleStepPerMMChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], ScreenHandler.HandleStepPerMMChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
|
|||
VPHELPER(VP_X_MAX_SPEED, &planner.settings.max_feedrate_mm_s[X_AXIS], ScreenHandler.HandleMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
VPHELPER(VP_Y_MAX_SPEED, &planner.settings.max_feedrate_mm_s[Y_AXIS], ScreenHandler.HandleMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
VPHELPER(VP_Z_MAX_SPEED, &planner.settings.max_feedrate_mm_s[Z_AXIS], ScreenHandler.HandleMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
|
|||
#if HOTENDS >= 1 |
|||
VPHELPER(VP_E0_MAX_SPEED, &planner.settings.max_feedrate_mm_s[E0_AXIS], ScreenHandler.HandleExtruderMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
VPHELPER(VP_E1_MAX_SPEED, &planner.settings.max_feedrate_mm_s[E1_AXIS], ScreenHandler.HandleExtruderMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
#endif |
|||
|
|||
VPHELPER(VP_X_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[X_AXIS], ScreenHandler.HandleMaxAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
VPHELPER(VP_Y_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[Y_AXIS], ScreenHandler.HandleMaxAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
VPHELPER(VP_Z_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[Z_AXIS], ScreenHandler.HandleMaxAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
|
|||
#if HOTENDS >= 1 |
|||
VPHELPER(VP_E0_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[E0_AXIS], ScreenHandler.HandleExtruderAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
VPHELPER(VP_E1_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[E1_AXIS], ScreenHandler.HandleExtruderAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
|
|||
VPHELPER(VP_TRAVEL_SPEED, (uint16_t *)&planner.settings.travel_acceleration, ScreenHandler.HandleTravelAccChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
VPHELPER(VP_FEEDRATE_MIN_SPEED, (uint16_t *)&planner.settings.min_feedrate_mm_s, ScreenHandler.HandleFeedRateMinChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
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_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), |
|||
#endif |
|||
#if AXIS_HAS_STEALTHCHOP(Y) |
|||
VPHELPER(VP_TMC_Y_STEP, &tmc_y_step, 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), |
|||
#endif |
|||
#endif |
|||
|
|||
#if HAS_TRINAMIC_CONFIG // TMC Current Setting
|
|||
#if AXIS_IS_TMC(X) |
|||
VPHELPER(VP_TMC_X_Current, &stepperX.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#if AXIS_IS_TMC(Y) |
|||
VPHELPER(VP_TMC_Y_Current, &stepperY.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#if AXIS_IS_TMC(Z) |
|||
VPHELPER(VP_TMC_Z_Current, &stepperZ.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#if AXIS_IS_TMC(E0) |
|||
VPHELPER(VP_TMC_E0_Current, &stepperE0.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#if AXIS_IS_TMC(E1) |
|||
VPHELPER(VP_TMC_E1_Current, &stepperE1.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#if AXIS_IS_TMC(X2) |
|||
VPHELPER(VP_TMC_X1_Current, &stepperX2.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#if AXIS_IS_TMC(Y2) |
|||
VPHELPER(VP_TMC_Y1_Current, &stepperY2.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#if AXIS_IS_TMC(Z2) |
|||
VPHELPER(VP_TMC_Z1_Current, &stepperZ2.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
#endif |
|||
#endif |
|||
|
|||
VPHELPER(VP_EEPROM_CTRL, nullptr, ScreenHandler.EEPROM_CTRL, nullptr), |
|||
VPHELPER(VP_LEVEL_BUTTON, nullptr, ScreenHandler.Level_Ctrl_MKS, nullptr), |
|||
VPHELPER(VP_LANGUAGE_CHANGE, nullptr, ScreenHandler.LanguageChange_MKS, nullptr), |
|||
|
|||
//VPHELPER(VP_SD_Print_LiveAdjustZ, nullptr, ScreenHandler.HandleLiveAdjustZ, nullptr),
|
|||
|
|||
VPHELPER(VP_SD_Print_LiveAdjustZ_Confirm, nullptr, ScreenHandler.ZoffsetConfirm, nullptr), |
|||
|
|||
VPHELPER(VP_ZOffset_Distance,nullptr ,ScreenHandler.GetZoffsetDistance, nullptr), |
|||
VPHELPER(VP_MESH_LEVEL_ADJUST, nullptr, ScreenHandler.MeshLevelDistanceConfig, nullptr), |
|||
VPHELPER(VP_MESH_LEVEL_POINT,nullptr, ScreenHandler.MeshLevel,nullptr), |
|||
VPHELPER(VP_Min_EX_T_E, &thermalManager.extrude_min_temp, &ScreenHandler.GetMinExtrudeTemp, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), |
|||
VPHELPER(VP_AutoTurnOffSw, nullptr, &ScreenHandler.GetTurnOffCtrl, nullptr), |
|||
|
|||
#if HOTENDS >= 1 |
|||
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], ScreenHandler.HandleStepPerMMExtruderChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], ScreenHandler.HandleStepPerMMExtruderChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), |
|||
#endif |
|||
|
|||
|
|||
// SDCard File listing
|
|||
#if ENABLED(SDSUPPORT) |
|||
VPHELPER(VP_SD_ScrollEvent, nullptr, ScreenHandler.DGUSLCD_SD_ScrollFilelist, nullptr), |
|||
VPHELPER(VP_SD_FileSelected, nullptr, ScreenHandler.DGUSLCD_SD_FileSelected, nullptr), |
|||
VPHELPER(VP_SD_FileSelectConfirm, nullptr, ScreenHandler.DGUSLCD_SD_StartPrint, nullptr), |
|||
VPHELPER_STR(VP_SD_FileName0, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName1, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName2, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName3, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName4, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName5, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName6, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName7, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName8, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER_STR(VP_SD_FileName9, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename), |
|||
VPHELPER(VP_SD_ResumePauseAbort, nullptr, ScreenHandler.DGUSLCD_SD_ResumePauseAbort, nullptr), |
|||
VPHELPER(VP_SD_AbortPrintConfirmed, nullptr, ScreenHandler.DGUSLCD_SD_ReallyAbort, nullptr), |
|||
VPHELPER(VP_SD_Print_Setting, nullptr, ScreenHandler.DGUSLCD_SD_PrintTune, nullptr), |
|||
#if ENABLED(BABYSTEPPING) |
|||
VPHELPER(VP_SD_Print_LiveAdjustZ,nullptr, ScreenHandler.HandleLiveAdjustZ, &ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<2>), |
|||
VPHELPER(VP_ZOffset_DE_DIS,&z_offset_add,nullptr, &ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>), |
|||
#endif |
|||
#if HAS_BED_PROBE |
|||
VPHELPER(VP_OFFSET_X, &probe.offset.x, ScreenHandler.GetOffsetValue,ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>), |
|||
VPHELPER(VP_OFFSET_Y, &probe.offset.y, ScreenHandler.GetOffsetValue,ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>), |
|||
VPHELPER(VP_OFFSET_Z, &probe.offset.z, ScreenHandler.GetOffsetValue,ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>), |
|||
#endif |
|||
#endif |
|||
|
|||
#if ENABLED(DGUS_UI_WAITING) |
|||
VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, ScreenHandler.DGUSLCD_SendWaitingStatusToDisplay), |
|||
#endif |
|||
|
|||
// Messages for the User, shared by the popup and the kill screen. They cant be autouploaded as we do not buffer content.
|
|||
//{.VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
|
|||
//{.VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
|
|||
//{.VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
|
|||
//{.VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
|
|||
|
|||
{.VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay_Language_MKS}, |
|||
{.VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay_Language_MKS}, |
|||
{.VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay_Language_MKS}, |
|||
{.VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay_Language_MKS}, |
|||
|
|||
VPHELPER(0, 0, 0, 0) // must be last entry.
|
|||
}; |
|||
|
|||
#endif // DGUS_LCD_UI_MKS
|
|||
@ -0,0 +1,908 @@ |
|||
/**
|
|||
* 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 |
|||
|
|||
#include "../DGUSDisplayDef.h" |
|||
|
|||
//#define USE_MKS_GREEN_UI
|
|||
//#define DGUS_MKS_RUNOUT_SENSOR
|
|||
|
|||
#define LOGO_TIME_DELAY TERN(USE_MKS_GREEN_UI, 5000, 1500) |
|||
|
|||
#if ENABLED(DGUS_MKS_RUNOUT_SENSOR) |
|||
#define MT_DET_1_PIN 1 |
|||
#define MT_DET_2_PIN 2 |
|||
#define MT_DET_PIN_INVERTING false |
|||
#endif |
|||
|
|||
#define MKS_FINSH |
|||
|
|||
extern uint16_t distanceMove; |
|||
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; |
|||
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; |
|||
|
|||
extern uint16_t lcd_default_light; |
|||
|
|||
#if AXIS_HAS_STEALTHCHOP(X) |
|||
extern uint16_t tmc_x_current; |
|||
#endif |
|||
#if AXIS_HAS_STEALTHCHOP(Y) |
|||
extern uint16_t tmc_y_current; |
|||
#endif |
|||
#if AXIS_HAS_STEALTHCHOP(Z) |
|||
extern uint16_t tmc_z_current; |
|||
#endif |
|||
#if AXIS_HAS_STEALTHCHOP(E0) |
|||
extern uint16_t tmc_e0_current; |
|||
#endif |
|||
#if AXIS_HAS_STEALTHCHOP(E1) |
|||
extern uint16_t tmc_e1_current; |
|||
#endif |
|||
|
|||
typedef enum { |
|||
EX_HEATING, |
|||
EX_HEAT_STARUS, |
|||
EX_CHANGING, |
|||
EX_CHANGE_STATUS, |
|||
EX_NONE, |
|||
} EX_STATUS_DEF; |
|||
|
|||
typedef struct { |
|||
//uint8_t ex_change_flag:1;
|
|||
//uint8_t ex_heat_flag:1;
|
|||
uint8_t ex_load_unload_flag:1; //0:unload 1:load
|
|||
EX_STATUS_DEF ex_status; |
|||
uint32_t ex_tick_start; |
|||
uint32_t ex_tick_end; |
|||
uint32_t ex_speed; |
|||
uint32_t ex_length; |
|||
uint32_t ex_need_time; |
|||
} EX_FILAMENT_DEF; |
|||
|
|||
extern EX_FILAMENT_DEF ex_filament; |
|||
|
|||
typedef enum { |
|||
UNRUNOUT_STATUS, |
|||
RUNOUT_STATUS, |
|||
RUNOUT_WAITTING_STATUS, |
|||
RUNOUT_BEGIN_STATUS, |
|||
} RUNOUT_MKS_STATUS_DEF; |
|||
|
|||
typedef struct { |
|||
RUNOUT_MKS_STATUS_DEF runout_status; |
|||
uint8_t pin_status; |
|||
uint8_t de_count; |
|||
uint8_t de_times; |
|||
} RUNOUT_MKS_DEF; |
|||
|
|||
extern RUNOUT_MKS_DEF runout_mks; |
|||
|
|||
typedef struct { |
|||
uint8_t print_pause_start_flag:1; |
|||
uint8_t runout_flag:1; |
|||
bool blstatus; |
|||
uint16_t x_pos; |
|||
uint16_t y_pos; |
|||
uint16_t z_pos; |
|||
} NOZZLE_PARK_DEF; |
|||
|
|||
extern NOZZLE_PARK_DEF nozzle_park_mks; |
|||
|
|||
enum DGUSLCD_Screens : uint8_t { |
|||
#if ENABLED(USE_MKS_GREEN_UI) |
|||
|
|||
DGUSLCD_SCREEN_BOOT = 33, |
|||
DGUSLCD_SCREEN_MAIN = 60, |
|||
DGUSLCD_SCREEN_STATUS = 60, |
|||
DGUSLCD_SCREEN_STATUS2 = 60, |
|||
DGUSLCD_SCREEN_PREHEAT = 18, |
|||
DGUSLCD_SCREEN_POWER_LOSS = 100, |
|||
DGUSLCD_SCREEN_MANUALMOVE = 192, |
|||
DGUSLCD_SCREEN_UTILITY = 120, |
|||
DGUSLCD_SCREEN_FILAMENT_UNLOADING = 158, |
|||
DGUSLCD_SCREEN_SDFILELIST = 15, |
|||
DGUSLCD_SCREEN_SDPRINTMANIPULATION = 15, |
|||
DGUSLCD_SCREEN_SDPRINTTUNE = 17, |
|||
|
|||
MKSLCD_SCREEN_BOOT = 33, |
|||
MKSLCD_SCREEN_HOME = 60, // MKS main page
|
|||
MKSLCD_SCREEN_SETTING = 62, // MKS Setting page / no wifi whit
|
|||
MKSLCD_SCREEM_TOOL = 64, // MKS Tool page
|
|||
MKSLCD_SCREEN_EXTRUDE_P1 = 75, |
|||
MKSLCD_SCREEN_EXTRUDE_P2 = 77, |
|||
MKSLCD_SCREEN_LEVEL = 73, |
|||
MKSLCD_AUTO_LEVEL = 81, |
|||
MKSLCD_SCREEN_MOVE = 66, |
|||
MKSLCD_SCREEN_PRINT = 68, |
|||
MKSLCD_SCREEN_PAUSE = 70, |
|||
MKSLCD_SCREEN_CHOOSE_FILE = 87, |
|||
MKSLCD_SCREEN_NO_CHOOSE_FILE = 88, |
|||
MKSLCD_SCREEN_Config = 101, |
|||
MKSLCD_SCREEN_Config_MOTOR = 103, |
|||
MKSLCD_SCREEN_MOTOR_PLUSE = 104, |
|||
MKSLCD_SCREEN_MOTOR_SPEED = 102, |
|||
MKSLCD_SCREEN_MOTOR_ACC_MAX = 105, |
|||
MKSLCD_SCREEN_PRINT_CONFIG = 72, |
|||
MKSLCD_SCREEN_LEVEL_DATA = 106, |
|||
MKSLCD_PrintPause_SET = 107, |
|||
//MKSLCD_FILAMENT_DATA = 50,
|
|||
MKSLCD_ABOUT = 83, |
|||
MKSLCD_PID = 108, |
|||
MKSLCD_PAUSE_SETTING_MOVE = 98, |
|||
MKSLCD_PAUSE_SETTING_EX = 96, |
|||
MKSLCD_PAUSE_SETTING_EX2 = 97, |
|||
MKSLCD_SCREEN_PRINT_CONFIRM = 94, |
|||
MKSLCD_SCREEN_EX_CONFIG = 112, |
|||
MKSLCD_SCREEN_EEP_Config = 89, |
|||
MKSLCD_SCREEN_PrintDone = 92, |
|||
MKSLCD_SCREEN_TMC_Config = 111, |
|||
MKSLCD_Screen_Offset_Config = 109, |
|||
MKSLCD_Screen_PMove = 98, |
|||
MKSLCD_Screen_Baby = 79, |
|||
|
|||
#else |
|||
|
|||
DGUSLCD_SCREEN_BOOT = 120, |
|||
DGUSLCD_SCREEN_MAIN = 1, |
|||
|
|||
DGUSLCD_SCREEN_STATUS = 1, |
|||
DGUSLCD_SCREEN_STATUS2 = 1, |
|||
DGUSLCD_SCREEN_PREHEAT = 18, |
|||
DGUSLCD_SCREEN_POWER_LOSS = 100, |
|||
DGUSLCD_SCREEN_MANUALMOVE = 192, |
|||
DGUSLCD_SCREEN_UTILITY = 120, |
|||
DGUSLCD_SCREEN_FILAMENT_UNLOADING = 158, |
|||
DGUSLCD_SCREEN_SDFILELIST = 15, |
|||
DGUSLCD_SCREEN_SDPRINTMANIPULATION = 15, |
|||
DGUSLCD_SCREEN_SDPRINTTUNE = 17, |
|||
|
|||
MKSLCD_SCREEN_BOOT = 0, |
|||
MKSLCD_SCREEN_HOME = 1, // MKS main page
|
|||
MKSLCD_SCREEN_SETTING = 2, // MKS Setting page / no wifi whit
|
|||
MKSLCD_SCREEM_TOOL = 3, // MKS Tool page
|
|||
MKSLCD_SCREEN_EXTRUDE_P1 = 4, |
|||
MKSLCD_SCREEN_EXTRUDE_P2 = 11, |
|||
MKSLCD_SCREEN_LEVEL = 5, |
|||
MKSLCD_AUTO_LEVEL = 73, |
|||
MKSLCD_SCREEN_LEVEL_PRESS = 9, |
|||
MKSLCD_SCREEN_MOVE = 6, |
|||
MKSLCD_SCREEN_PRINT = 7, |
|||
MKSLCD_SCREEN_PRINT_PRESS = 13, |
|||
MKSLCD_SCREEN_PAUSE = 26, |
|||
MKSLCD_SCREEN_PAUSE_PRESS = 26, |
|||
MKSLCD_SCREEN_CHOOSE_FILE = 15, |
|||
MKSLCD_SCREEN_NO_CHOOSE_FILE = 17, |
|||
MKSLCD_SCREEN_Config = 46, |
|||
MKSLCD_SCREEN_Config_MOTOR = 47, |
|||
MKSLCD_SCREEN_MOTOR_PLUSE = 51, |
|||
MKSLCD_SCREEN_MOTOR_SPEED = 55, |
|||
MKSLCD_SCREEN_MOTOR_ACC_MAX = 53, |
|||
MKSLCD_SCREEN_PRINT_CONFIG = 60, |
|||
MKSLCD_SCREEN_LEVEL_DATA = 48, |
|||
MKSLCD_PrintPause_SET = 49, |
|||
MKSLCD_FILAMENT_DATA = 50, |
|||
MKSLCD_ABOUT = 36, |
|||
MKSLCD_PID = 56, |
|||
MKSLCD_PAUSE_SETTING_MOVE = 58, |
|||
MKSLCD_PAUSE_SETTING_EX = 57, |
|||
MKSLCD_PAUSE_SETTING_EX2 = 61, |
|||
MKSLCD_SCREEN_NO_FILE = 42, |
|||
MKSLCD_SCREEN_PRINT_CONFIRM = 43, |
|||
MKSLCD_SCREEN_EX_CONFIG = 65, |
|||
MKSLCD_SCREEN_EEP_Config = 20, |
|||
MKSLCD_SCREEN_PrintDone = 25, |
|||
MKSLCD_SCREEN_TMC_Config = 70, |
|||
MKSLCD_Screen_Offset_Config = 30, |
|||
MKSLCD_Screen_PMove = 64, |
|||
MKSLCD_Screen_Baby = 71, |
|||
|
|||
#endif |
|||
|
|||
DGUSLCD_SCREEN_CONFIRM = 240, |
|||
DGUSLCD_SCREEN_KILL = 250, ///< Kill Screen. Must always be 250 (to be able to display "Error wrong LCD Version")
|
|||
DGUSLCD_SCREEN_WAITING = 251, |
|||
DGUSLCD_SCREEN_POPUP = 252, ///< special target, popup screen will also return this code to say "return to previous screen"
|
|||
DGUSLDC_SCREEN_UNUSED = 255 |
|||
}; |
|||
|
|||
// Display Memory layout used (T5UID)
|
|||
// Except system variables this is arbitrary, just to organize stuff....
|
|||
|
|||
// 0x0000 .. 0x0FFF -- System variables and reserved by the display
|
|||
// 0x1000 .. 0x1FFF -- Variables to never change location, regardless of UI Version
|
|||
// 0x2000 .. 0x2FFF -- Controls (VPs that will trigger some action)
|
|||
// 0x3000 .. 0x4FFF -- Marlin Data to be displayed
|
|||
// 0x5000 .. -- SPs (if we want to modify display elements, e.g change color or like) -- currently unused
|
|||
|
|||
// As there is plenty of space (at least most displays have >8k RAM), we do not pack them too tight,
|
|||
// so that we can keep variables nicely together in the address space.
|
|||
|
|||
// UI Version always on 0x1000...0x1002 so that the firmware can check this and bail out.
|
|||
|
|||
// constexpr uint16_t VP_UI_VERSION_MAJOR = 0x1000; // Major -- incremented when incompatible
|
|||
// constexpr uint16_t VP_UI_VERSION_MINOR = 0x1001; // Minor -- incremented on new features, but compatible
|
|||
// constexpr uint16_t VP_UI_VERSION_PATCH = 0x1002; // Patch -- fixed which do not change functionality.
|
|||
// constexpr uint16_t VP_UI_FLAVOUR = 0x1010; // lets reserve 16 bytes here to determine if UI is suitable for this Marlin. tbd.
|
|||
|
|||
// Storage space for the Killscreen messages. 0x1100 - 0x1200 . Reused for the popup.
|
|||
// constexpr uint16_t VP_MSGSTR1 = 0x1100;
|
|||
// constexpr uint8_t VP_MSGSTR1_LEN = 0x20; // might be more place for it...
|
|||
// constexpr uint16_t VP_MSGSTR2 = 0x1140;
|
|||
// constexpr uint8_t VP_MSGSTR2_LEN = 0x20;
|
|||
// constexpr uint16_t VP_MSGSTR3 = 0x1180;
|
|||
// constexpr uint8_t VP_MSGSTR3_LEN = 0x20;
|
|||
// constexpr uint16_t VP_MSGSTR4 = 0x11C0;
|
|||
// constexpr uint8_t VP_MSGSTR4_LEN = 0x20;
|
|||
|
|||
// Screenchange request for screens that only make sense when printer is idle.
|
|||
// e.g movement is only allowed if printer is not printing.
|
|||
// Marlin must confirm by setting the screen manually.
|
|||
// constexpr uint16_t VP_SCREENCHANGE_ASK = 0x2000;
|
|||
// constexpr uint16_t VP_SCREENCHANGE = 0x2001; // Key-Return button to new menu pressed. Data contains target screen in low byte and info in high byte.
|
|||
// constexpr uint16_t VP_TEMP_ALL_OFF = 0x2002; // Turn all heaters off. Value arbitrary ;)=
|
|||
// constexpr uint16_t VP_SCREENCHANGE_WHENSD = 0x2003; // "Print" Button touched -- go only there if there is an SD Card.
|
|||
// constexpr uint16_t VP_CONFIRMED = 0x2010; // OK on confirm screen.
|
|||
|
|||
// // Buttons on the SD-Card File listing.
|
|||
// constexpr uint16_t VP_SD_ScrollEvent = 0x2020; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
|
|||
// constexpr uint16_t VP_SD_FileSelected = 0x2022; // Number of file field selected.
|
|||
// constexpr uint16_t VP_SD_FileSelectConfirm = 0x2024; // (This is a virtual VP and emulated by the Confirm Screen when a file has been confirmed)
|
|||
|
|||
// constexpr uint16_t VP_SD_ResumePauseAbort = 0x2026; // Resume(Data=0), Pause(Data=1), Abort(Data=2) SD Card prints
|
|||
// constexpr uint16_t VP_SD_AbortPrintConfirmed = 0x2028; // Abort print confirmation (virtual, will be injected by the confirm dialog)
|
|||
// constexpr uint16_t VP_SD_Print_Setting = 0x2040;
|
|||
// constexpr uint16_t VP_SD_Print_LiveAdjustZ = 0x2050; // Data: 0 down, 1 up
|
|||
|
|||
// Controls for movement (we can't use the incremental / decremental feature of the display at this feature works only with 16 bit values
|
|||
// (which would limit us to 655.35mm, which is likely not a problem for common setups, but i don't want to rule out hangprinters support)
|
|||
// A word about the coding: The VP will be per axis and the return code will be an signed 16 bit value in 0.01 mm resolution, telling us
|
|||
// the relative travel amount t he user wants to do. So eg. if the display sends us VP=2100 with value 100, the user wants us to move X by +1 mm.
|
|||
// constexpr uint16_t VP_MOVE_X = 0x2100;
|
|||
// constexpr uint16_t VP_MOVE_Y = 0x2102;
|
|||
// constexpr uint16_t VP_MOVE_Z = 0x2104;
|
|||
// constexpr uint16_t VP_MOVE_E0 = 0x2110;
|
|||
// constexpr uint16_t VP_MOVE_E1 = 0x2112;
|
|||
// //constexpr uint16_t VP_MOVE_E2 = 0x2114;
|
|||
// //constexpr uint16_t VP_MOVE_E3 = 0x2116;
|
|||
// //constexpr uint16_t VP_MOVE_E4 = 0x2118;
|
|||
// //constexpr uint16_t VP_MOVE_E5 = 0x211A;
|
|||
// constexpr uint16_t VP_HOME_ALL = 0x2120;
|
|||
// constexpr uint16_t VP_MOTOR_LOCK_UNLOK = 0x2130;
|
|||
// constexpr uint16_t VP_XYZ_HOME = 0x2132;
|
|||
|
|||
// Power loss recovery
|
|||
// constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x2180;
|
|||
|
|||
// // Fan Control Buttons , switch between "off" and "on"
|
|||
// constexpr uint16_t VP_FAN0_CONTROL = 0x2200;
|
|||
// constexpr uint16_t VP_FAN1_CONTROL = 0x2202;
|
|||
// constexpr uint16_t VP_FAN2_CONTROL = 0x2204;
|
|||
// constexpr uint16_t VP_FAN3_CONTROL = 0x2206;
|
|||
|
|||
// // Heater Control Buttons , triged between "cool down" and "heat PLA" state
|
|||
// constexpr uint16_t VP_E0_CONTROL = 0x2210;
|
|||
// constexpr uint16_t VP_E1_CONTROL = 0x2212;
|
|||
// //constexpr uint16_t VP_E2_CONTROL = 0x2214;
|
|||
// //constexpr uint16_t VP_E3_CONTROL = 0x2216;
|
|||
// //constexpr uint16_t VP_E4_CONTROL = 0x2218;
|
|||
// //constexpr uint16_t VP_E5_CONTROL = 0x221A;
|
|||
// constexpr uint16_t VP_BED_CONTROL = 0x221C;
|
|||
|
|||
// // Preheat
|
|||
// constexpr uint16_t VP_E0_BED_PREHEAT = 0x2220;
|
|||
// constexpr uint16_t VP_E1_BED_PREHEAT = 0x2222;
|
|||
// //constexpr uint16_t VP_E2_BED_PREHEAT = 0x2224;
|
|||
// //constexpr uint16_t VP_E3_BED_PREHEAT = 0x2226;
|
|||
// //constexpr uint16_t VP_E4_BED_PREHEAT = 0x2228;
|
|||
// //constexpr uint16_t VP_E5_BED_PREHEAT = 0x222A;
|
|||
|
|||
// // Filament load and unload
|
|||
// // constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x2300;
|
|||
// // constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x2302;
|
|||
|
|||
// // Settings store , reset
|
|||
|
|||
// // PID autotune
|
|||
// constexpr uint16_t VP_PID_AUTOTUNE_E0 = 0x2410;
|
|||
// constexpr uint16_t VP_PID_AUTOTUNE_E1 = 0x2412;
|
|||
// //constexpr uint16_t VP_PID_AUTOTUNE_E2 = 0x2414;
|
|||
// //constexpr uint16_t VP_PID_AUTOTUNE_E3 = 0x2416;
|
|||
// //constexpr uint16_t VP_PID_AUTOTUNE_E4 = 0x2418;
|
|||
// //constexpr uint16_t VP_PID_AUTOTUNE_E5 = 0x241A;
|
|||
// constexpr uint16_t VP_PID_AUTOTUNE_BED = 0x2420;
|
|||
// // Calibrate Z
|
|||
// constexpr uint16_t VP_Z_CALIBRATE = 0x2430;
|
|||
|
|||
// First layer cal
|
|||
// constexpr uint16_t VP_Z_FIRST_LAYER_CAL = 0x2500; // Data: 0 - Cancel first layer cal progress, >0 filament type have loaded
|
|||
|
|||
// Firmware version on the boot screen.
|
|||
// constexpr uint16_t VP_MARLIN_VERSION = 0x3000;
|
|||
// constexpr uint8_t VP_MARLIN_VERSION_LEN = 16; // there is more space on the display, if needed.
|
|||
|
|||
// Place for status messages.
|
|||
constexpr uint16_t VP_M117 = 0x7020; |
|||
constexpr uint8_t VP_M117_LEN = 0x20; |
|||
|
|||
// // Temperatures.
|
|||
// constexpr uint16_t VP_T_E0_Is = 0x3060; // 4 Byte Integer
|
|||
// constexpr uint16_t VP_T_E0_Set = 0x3062; // 2 Byte Integer
|
|||
// constexpr uint16_t VP_T_E1_Is = 0x3064; // 4 Byte Integer
|
|||
// // reserved to support up to 6 Extruders:
|
|||
// constexpr uint16_t VP_T_E1_Set = 0x3066; // 2 Byte Integer
|
|||
// constexpr uint16_t VP_T_E2_Is = 0x3068; // 4 Byte Integer
|
|||
// constexpr uint16_t VP_T_E2_Set = 0x306A; // 2 Byte Integer
|
|||
// constexpr uint16_t VP_T_E3_Is = 0x306C; // 4 Byte Integer
|
|||
// constexpr uint16_t VP_T_E3_Set = 0x306E; // 2 Byte Integer
|
|||
// constexpr uint16_t VP_T_E4_Is = 0x3070; // 4 Byte Integer
|
|||
// constexpr uint16_t VP_T_E4_Set = 0x3072; // 2 Byte Integer
|
|||
// constexpr uint16_t VP_T_E5_Is = 0x3074; // 4 Byte Integer
|
|||
// constexpr uint16_t VP_T_E5_Set = 0x3076; // 2 Byte Integer
|
|||
// constexpr uint16_t VP_T_E6_Is = 0x3078; // 4 Byte Integer
|
|||
// constexpr uint16_t VP_T_E6_Set = 0x307A; // 2 Byte Integer
|
|||
// constexpr uint16_t VP_T_E7_Is = 0x3078; // 4 Byte Integer
|
|||
// constexpr uint16_t VP_T_E7_Set = 0x307A; // 2 Byte Integer
|
|||
|
|||
|
|||
// constexpr uint16_t VP_T_Bed_Is = 0x3080; // 4 Byte Integer
|
|||
// constexpr uint16_t VP_T_Bed_Set = 0x3082; // 2 Byte Integer
|
|||
|
|||
// constexpr uint16_t VP_Flowrate_E0 = 0x3090; // 2 Byte Integer
|
|||
// constexpr uint16_t VP_Flowrate_E1 = 0x3092; // 2 Byte Integer
|
|||
// // reserved for up to 6 Extruders:
|
|||
// constexpr uint16_t VP_Flowrate_E2 = 0x3094;
|
|||
// constexpr uint16_t VP_Flowrate_E3 = 0x3096;
|
|||
// constexpr uint16_t VP_Flowrate_E4 = 0x3098;
|
|||
// constexpr uint16_t VP_Flowrate_E5 = 0x309A;
|
|||
|
|||
// constexpr uint16_t VP_Fan0_Percentage = 0x3100; // 2 Byte Integer (0..100)
|
|||
// constexpr uint16_t VP_Fan1_Percentage = 0x3102; // 2 Byte Integer (0..100)
|
|||
// constexpr uint16_t VP_Fan2_Percentage = 0x3104; // 2 Byte Integer (0..100)
|
|||
// constexpr uint16_t VP_Fan3_Percentage = 0x3106; // 2 Byte Integer (0..100)
|
|||
// constexpr uint16_t VP_Feedrate_Percentage = 0x3108; // 2 Byte Integer (0..100)
|
|||
|
|||
// Actual Position
|
|||
// constexpr uint16_t VP_XPos = 0x3110; // 4 Byte Fixed point number; format xxx.yy
|
|||
// constexpr uint16_t VP_YPos = 0x3112; // 4 Byte Fixed point number; format xxx.yy
|
|||
// constexpr uint16_t VP_ZPos = 0x3114; // 4 Byte Fixed point number; format xxx.yy
|
|||
// constexpr uint16_t VP_EPos = 0x3120; // 4 Byte Fixed point number; format xxx.yy
|
|||
|
|||
// constexpr uint16_t VP_PrintProgress_Percentage = 0x3130; // 2 Byte Integer (0..100)
|
|||
|
|||
// constexpr uint16_t VP_PrintTime = 0x3140;
|
|||
// constexpr uint16_t VP_PrintTime_LEN = 32;
|
|||
|
|||
// constexpr uint16_t VP_PrintAccTime = 0x3160;
|
|||
// constexpr uint16_t VP_PrintAccTime_LEN = 32;
|
|||
|
|||
// constexpr uint16_t VP_PrintsTotal = 0x3180;
|
|||
// constexpr uint16_t VP_PrintsTotal_LEN = 16;
|
|||
|
|||
// // SDCard File Listing
|
|||
// constexpr uint16_t VP_SD_FileName_LEN = 32; // LEN is shared for all entries.
|
|||
// constexpr uint16_t DGUS_SD_FILESPERSCREEN = 8; // FIXME move that info to the display and read it from there.
|
|||
// constexpr uint16_t VP_SD_FileName0 = 0x3200;
|
|||
// constexpr uint16_t VP_SD_FileName1 = 0x3220;
|
|||
// constexpr uint16_t VP_SD_FileName2 = 0x3240;
|
|||
// constexpr uint16_t VP_SD_FileName3 = 0x3260;
|
|||
// constexpr uint16_t VP_SD_FileName4 = 0x3280;
|
|||
// constexpr uint16_t VP_SD_FileName5 = 0x32A0;
|
|||
// constexpr uint16_t VP_SD_FileName6 = 0x32C0;
|
|||
// constexpr uint16_t VP_SD_FileName7 = 0x32E0;
|
|||
|
|||
// Heater status
|
|||
constexpr uint16_t VP_E0_STATUS = 0x3410; |
|||
constexpr uint16_t VP_E1_STATUS = 0x3412; |
|||
//constexpr uint16_t VP_E2_STATUS = 0x3414;
|
|||
//constexpr uint16_t VP_E3_STATUS = 0x3416;
|
|||
//constexpr uint16_t VP_E4_STATUS = 0x3418;
|
|||
//constexpr uint16_t VP_E5_STATUS = 0x341A;
|
|||
constexpr uint16_t VP_MOVE_OPTION = 0x3500; |
|||
|
|||
// // PIDs
|
|||
// constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , 2 byte unsigned int , 0~1638.4
|
|||
// constexpr uint16_t VP_E0_PID_I = 0x3702;
|
|||
// constexpr uint16_t VP_E0_PID_D = 0x3704;
|
|||
// constexpr uint16_t VP_E1_PID_P = 0x3706; // at the moment , 2 byte unsigned int , 0~1638.4
|
|||
// constexpr uint16_t VP_E1_PID_I = 0x3708;
|
|||
// constexpr uint16_t VP_E1_PID_D = 0x370A;
|
|||
// constexpr uint16_t VP_BED_PID_P = 0x3710;
|
|||
// constexpr uint16_t VP_BED_PID_I = 0x3712;
|
|||
// constexpr uint16_t VP_BED_PID_D = 0x3714;
|
|||
|
|||
// Wating screen status
|
|||
constexpr uint16_t VP_WAITING_STATUS = 0x3800; |
|||
|
|||
// SPs for certain variables...
|
|||
// located at 0x5000 and up
|
|||
// Not used yet!
|
|||
// This can be used e.g to make controls / data display invisible
|
|||
constexpr uint16_t SP_T_E0_Is = 0x5000; |
|||
constexpr uint16_t SP_T_E0_Set = 0x5010; |
|||
constexpr uint16_t SP_T_E1_Is = 0x5020; |
|||
constexpr uint16_t SP_T_Bed_Is = 0x5030; |
|||
constexpr uint16_t SP_T_Bed_Set = 0x5040; |
|||
|
|||
/*************************************************************************************************************************
|
|||
************************************************************************************************************************* |
|||
* DGUS for MKS Mem layout |
|||
************************************************************************************************************************ |
|||
************************************************************************************************************************/ |
|||
|
|||
#if ENABLED(MKS_FINSH) |
|||
/* -------------------------------0x1000-0x1FFF------------------------------- */ |
|||
constexpr uint16_t VP_MSGSTR1 = 0x1100; |
|||
constexpr uint8_t VP_MSGSTR1_LEN = 0x20; // might be more place for it...
|
|||
constexpr uint16_t VP_MSGSTR2 = 0x1140; |
|||
constexpr uint8_t VP_MSGSTR2_LEN = 0x20; |
|||
constexpr uint16_t VP_MSGSTR3 = 0x1180; |
|||
constexpr uint8_t VP_MSGSTR3_LEN = 0x20; |
|||
constexpr uint16_t VP_MSGSTR4 = 0x11C0; |
|||
constexpr uint8_t VP_MSGSTR4_LEN = 0x20; |
|||
|
|||
constexpr uint16_t VP_MARLIN_VERSION = 0x1A00; |
|||
constexpr uint8_t VP_MARLIN_VERSION_LEN = 16; // there is more space on the display, if needed.
|
|||
|
|||
|
|||
constexpr uint16_t VP_SCREENCHANGE_ASK = 0x1500; |
|||
constexpr uint16_t VP_SCREENCHANGE = 0x1501; // Key-Return button to new menu pressed. Data contains target screen in low byte and info in high byte.
|
|||
constexpr uint16_t VP_TEMP_ALL_OFF = 0x1502; // Turn all heaters off. Value arbitrary ;)=
|
|||
constexpr uint16_t VP_SCREENCHANGE_WHENSD = 0x1503; // "Print" Button touched -- go only there if there is an SD Card.
|
|||
constexpr uint16_t VP_CONFIRMED = 0x1510; // OK on confirm screen.
|
|||
|
|||
constexpr uint16_t VP_BACK_PAGE = 0x1600; |
|||
constexpr uint16_t VP_SETTINGS = 0x1620; |
|||
// Power loss recovery
|
|||
constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x1680; |
|||
/* -------------------------------0x2000-0x2FFF------------------------------- */ |
|||
// Temperatures.
|
|||
constexpr uint16_t VP_T_E0_Is = 0x2000; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_E0_Set = 0x2004; // 2 Byte Integer
|
|||
constexpr uint16_t VP_T_E1_Is = 0x2008; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_E1_Set = 0x200B; // 2 Byte Integer
|
|||
constexpr uint16_t VP_T_E2_Is = 0x2010; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_E2_Set = 0x2014; // 2 Byte Integer
|
|||
constexpr uint16_t VP_T_E3_Is = 0x2018; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_E3_Set = 0x201B; // 2 Byte Integer
|
|||
constexpr uint16_t VP_T_E4_Is = 0x2020; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_E4_Set = 0x2024; // 2 Byte Integer
|
|||
constexpr uint16_t VP_T_E5_Is = 0x2028; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_E5_Set = 0x202B; // 2 Byte Integer
|
|||
constexpr uint16_t VP_T_E6_Is = 0x2030; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_E6_Set = 0x2034; // 2 Byte Integer
|
|||
constexpr uint16_t VP_T_E7_Is = 0x2038; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_E7_Set = 0x203B; // 2 Byte Integer
|
|||
|
|||
constexpr uint16_t VP_T_Bed_Is = 0x2040; // 4 Byte Integer
|
|||
constexpr uint16_t VP_T_Bed_Set = 0x2044; // 2 Byte Integer
|
|||
|
|||
constexpr uint16_t VP_Min_EX_T_E = 0x2100; |
|||
|
|||
constexpr uint16_t VP_Flowrate_E0 = 0x2200; // 2 Byte Integer
|
|||
constexpr uint16_t VP_Flowrate_E1 = 0x2202; // 2 Byte Integer
|
|||
constexpr uint16_t VP_Flowrate_E2 = 0x2204; |
|||
constexpr uint16_t VP_Flowrate_E3 = 0x2206; |
|||
constexpr uint16_t VP_Flowrate_E4 = 0x2208; |
|||
constexpr uint16_t VP_Flowrate_E5 = 0x220A; |
|||
constexpr uint16_t VP_Flowrate_E6 = 0x220C; |
|||
constexpr uint16_t VP_Flowrate_E7 = 0x220E; |
|||
|
|||
// Move
|
|||
constexpr uint16_t VP_MOVE_X = 0x2300; |
|||
constexpr uint16_t VP_MOVE_Y = 0x2302; |
|||
constexpr uint16_t VP_MOVE_Z = 0x2304; |
|||
constexpr uint16_t VP_MOVE_E0 = 0x2310; |
|||
constexpr uint16_t VP_MOVE_E1 = 0x2312; |
|||
constexpr uint16_t VP_MOVE_E2 = 0x2314; |
|||
constexpr uint16_t VP_MOVE_E3 = 0x2316; |
|||
constexpr uint16_t VP_MOVE_E4 = 0x2318; |
|||
constexpr uint16_t VP_MOVE_E5 = 0x231A; |
|||
constexpr uint16_t VP_MOVE_E6 = 0x231C; |
|||
constexpr uint16_t VP_MOVE_E7 = 0x231E; |
|||
constexpr uint16_t VP_HOME_ALL = 0x2320; |
|||
constexpr uint16_t VP_MOTOR_LOCK_UNLOK = 0x2330; |
|||
constexpr uint16_t VP_MOVE_DISTANCE = 0x2334; |
|||
constexpr uint16_t VP_X_HOME = 0x2336; |
|||
constexpr uint16_t VP_Y_HOME = 0x2338; |
|||
constexpr uint16_t VP_Z_HOME = 0x233A; |
|||
|
|||
// Fan Control Buttons , switch between "off" and "on"
|
|||
constexpr uint16_t VP_FAN0_CONTROL = 0x2350; |
|||
constexpr uint16_t VP_FAN1_CONTROL = 0x2352; |
|||
constexpr uint16_t VP_FAN2_CONTROL = 0x2354; |
|||
constexpr uint16_t VP_FAN3_CONTROL = 0x2356; |
|||
constexpr uint16_t VP_FAN4_CONTROL = 0x2358; |
|||
constexpr uint16_t VP_FAN5_CONTROL = 0x235A; |
|||
|
|||
constexpr uint16_t VP_LANGUAGE_CHANGE = 0x2380; |
|||
constexpr uint16_t VP_LANGUAGE_CHANGE1 = 0x2382; |
|||
constexpr uint16_t VP_LANGUAGE_CHANGE2 = 0x2384; |
|||
constexpr uint16_t VP_LANGUAGE_CHANGE3 = 0x2386; |
|||
constexpr uint16_t VP_LANGUAGE_CHANGE4 = 0x2388; |
|||
constexpr uint16_t VP_LANGUAGE_CHANGE5 = 0x238A; |
|||
|
|||
// LEVEL
|
|||
constexpr uint16_t VP_LEVEL_POINT = 0x2400; |
|||
constexpr uint16_t VP_MESH_LEVEL_POINT = 0x2410; |
|||
constexpr uint16_t VP_MESH_LEVEL_ADJUST = 0x2412; |
|||
constexpr uint16_t VP_MESH_LEVEL_DIP = 0x2414; |
|||
constexpr uint16_t VP_MESH_LEVEL_POINT_X = 0x2416; |
|||
constexpr uint16_t VP_MESH_LEVEL_POINT_Y = 0x2418; |
|||
constexpr uint16_t VP_LEVEL_BUTTON = 0x2420; |
|||
constexpr uint16_t VP_MESH_LEVEL_POINT_DIS = 0x2422; |
|||
constexpr uint16_t VP_MESH_LEVEL_BACK = 0x2424; |
|||
|
|||
constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x2500; |
|||
constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x2504; |
|||
constexpr uint16_t VP_LOAD_Filament = 0x2508; |
|||
// constexpr uint16_t VP_LOAD_UNLOAD_Cancle = 0x250A;
|
|||
constexpr uint16_t VP_UNLOAD_Filament = 0x250B; |
|||
constexpr uint16_t VP_Filament_distance = 0x2600; |
|||
constexpr uint16_t VP_Filament_speed = 0x2604; |
|||
constexpr uint16_t VP_MIN_EX_T = 0x2606; |
|||
|
|||
constexpr uint16_t VP_E1_Filament_distance = 0x2614; |
|||
constexpr uint16_t VP_E1_Filament_speed = 0x2616; |
|||
constexpr uint16_t VP_E1_MIN_EX_T = 0x2618; |
|||
|
|||
constexpr uint16_t VP_Fan0_Percentage = 0x2700; // 2 Byte Integer (0..100)
|
|||
constexpr uint16_t VP_Fan1_Percentage = 0x2702; // 2 Byte Integer (0..100)
|
|||
constexpr uint16_t VP_Fan2_Percentage = 0x2704; // 2 Byte Integer (0..100)
|
|||
constexpr uint16_t VP_Fan3_Percentage = 0x2706; // 2 Byte Integer (0..100)
|
|||
constexpr uint16_t VP_Feedrate_Percentage = 0x2708; // 2 Byte Integer (0..100)
|
|||
|
|||
// Fan status
|
|||
constexpr uint16_t VP_FAN0_STATUS = 0x2710; |
|||
constexpr uint16_t VP_FAN1_STATUS = 0x2712; |
|||
constexpr uint16_t VP_FAN2_STATUS = 0x2714; |
|||
constexpr uint16_t VP_FAN3_STATUS = 0x2716; |
|||
|
|||
// Step per mm
|
|||
constexpr uint16_t VP_X_STEP_PER_MM = 0x2900; // at the moment , 2 byte unsigned int , 0~1638.4
|
|||
constexpr uint16_t VP_Y_STEP_PER_MM = 0x2904; |
|||
constexpr uint16_t VP_Z_STEP_PER_MM = 0x2908; |
|||
constexpr uint16_t VP_E0_STEP_PER_MM = 0x2910; |
|||
constexpr uint16_t VP_E1_STEP_PER_MM = 0x2912; |
|||
constexpr uint16_t VP_E2_STEP_PER_MM = 0x2914; |
|||
constexpr uint16_t VP_E3_STEP_PER_MM = 0x2916; |
|||
constexpr uint16_t VP_E4_STEP_PER_MM = 0x2918; |
|||
constexpr uint16_t VP_E5_STEP_PER_MM = 0x291A; |
|||
constexpr uint16_t VP_E6_STEP_PER_MM = 0x291C; |
|||
constexpr uint16_t VP_E7_STEP_PER_MM = 0x291E; |
|||
|
|||
constexpr uint16_t VP_X_MAX_SPEED = 0x2A00; |
|||
constexpr uint16_t VP_Y_MAX_SPEED = 0x2A04; |
|||
constexpr uint16_t VP_Z_MAX_SPEED = 0x2A08; |
|||
constexpr uint16_t VP_E0_MAX_SPEED = 0x2A0C; |
|||
constexpr uint16_t VP_E1_MAX_SPEED = 0x2A10; |
|||
|
|||
constexpr uint16_t VP_X_ACC_MAX_SPEED = 0x2A28; |
|||
constexpr uint16_t VP_Y_ACC_MAX_SPEED = 0x2A2C; |
|||
constexpr uint16_t VP_Z_ACC_MAX_SPEED = 0x2A30; |
|||
constexpr uint16_t VP_E0_ACC_MAX_SPEED = 0x2A34; |
|||
constexpr uint16_t VP_E1_ACC_MAX_SPEED = 0x2A38; |
|||
|
|||
constexpr uint16_t VP_TRAVEL_SPEED = 0x2A3C; |
|||
constexpr uint16_t VP_FEEDRATE_MIN_SPEED = 0x2A40; |
|||
constexpr uint16_t VP_T_F_SPEED = 0x2A44; |
|||
constexpr uint16_t VP_ACC_SPEED = 0x2A48; |
|||
|
|||
/* -------------------------------0x3000-0x3FFF------------------------------- */ |
|||
// Buttons on the SD-Card File listing.
|
|||
constexpr uint16_t VP_SD_ScrollEvent = 0x3020; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
|
|||
constexpr uint16_t VP_SD_FileSelected = 0x3022; // Number of file field selected.
|
|||
constexpr uint16_t VP_SD_FileSelectConfirm = 0x3024; // (This is a virtual VP and emulated by the Confirm Screen when a file has been confirmed)
|
|||
constexpr uint16_t VP_SD_ResumePauseAbort = 0x3026; // Resume(Data=0), Pause(Data=1), Abort(Data=2) SD Card prints
|
|||
constexpr uint16_t VP_SD_AbortPrintConfirmed = 0x3028; // Abort print confirmation (virtual, will be injected by the confirm dialog)
|
|||
constexpr uint16_t VP_SD_Print_Setting = 0x3040; |
|||
constexpr uint16_t VP_SD_Print_LiveAdjustZ = 0x3050; // Data: 0 down, 1 up
|
|||
constexpr uint16_t VP_SD_Print_LiveAdjustZ_Confirm = 0x3060; |
|||
constexpr uint16_t VP_ZOffset_Distance = 0x3070; |
|||
constexpr uint16_t VP_ZOffset_DE_DIS = 0x3080; |
|||
// SDCard File Listing
|
|||
constexpr uint16_t VP_SD_FileName_LEN = 32; // LEN is shared for all entries.
|
|||
constexpr uint16_t DGUS_SD_FILESPERSCREEN = 10; // FIXME move that info to the display and read it from there.
|
|||
constexpr uint16_t VP_SD_FileName0 = 0x3100; |
|||
constexpr uint16_t VP_SD_FileName1 = 0x3120; |
|||
constexpr uint16_t VP_SD_FileName2 = 0x3140; |
|||
constexpr uint16_t VP_SD_FileName3 = 0x3160; |
|||
constexpr uint16_t VP_SD_FileName4 = 0x3180; |
|||
constexpr uint16_t VP_SD_FileName5 = 0x31A0; |
|||
constexpr uint16_t VP_SD_FileName6 = 0x31C0; |
|||
constexpr uint16_t VP_SD_FileName7 = 0x31E0; |
|||
constexpr uint16_t VP_SD_FileName8 = 0x3200; |
|||
constexpr uint16_t VP_SD_FileName9 = 0x3220; |
|||
|
|||
constexpr uint16_t VP_SD_Print_ProbeOffsetZ = 0x32A0; |
|||
constexpr uint16_t VP_SD_Print_Baby = 0x32B0; |
|||
constexpr uint16_t VP_SD_Print_Filename = 0x32C0; |
|||
|
|||
// X Y Z Point
|
|||
constexpr uint16_t VP_XPos = 0x3300; // 4 Byte Fixed point number; format xxx.yy
|
|||
constexpr uint16_t VP_YPos = 0x3302; // 4 Byte Fixed point number; format xxx.yy
|
|||
constexpr uint16_t VP_ZPos = 0x3304; // 4 Byte Fixed point number; format xxx.yy
|
|||
constexpr uint16_t VP_EPos = 0x3306; // 4 Byte Fixed point number; format xxx.yy
|
|||
|
|||
// Print
|
|||
constexpr uint16_t VP_PrintProgress_Percentage = 0x3330; // 2 Byte Integer (0..100)
|
|||
constexpr uint16_t VP_PrintTime = 0x3340; |
|||
constexpr uint16_t VP_PrintTime_LEN = 32; |
|||
constexpr uint16_t VP_PrintAccTime = 0x3360; |
|||
constexpr uint16_t VP_PrintAccTime_LEN = 32; |
|||
constexpr uint16_t VP_PrintsTotal = 0x3380; |
|||
constexpr uint16_t VP_PrintsTotal_LEN = 16; |
|||
|
|||
constexpr uint16_t VP_File_Pictutr0 = 0x3400; |
|||
constexpr uint16_t VP_File_Pictutr1 = 0x3402; |
|||
constexpr uint16_t VP_File_Pictutr2 = 0x3404; |
|||
constexpr uint16_t VP_File_Pictutr3 = 0x3406; |
|||
constexpr uint16_t VP_File_Pictutr4 = 0x3408; |
|||
constexpr uint16_t VP_File_Pictutr5 = 0x340A; |
|||
constexpr uint16_t VP_File_Pictutr6 = 0x340C; |
|||
constexpr uint16_t VP_File_Pictutr7 = 0x340E; |
|||
constexpr uint16_t VP_File_Pictutr8 = 0x3410; |
|||
constexpr uint16_t VP_File_Pictutr9 = 0x3412; |
|||
|
|||
constexpr uint16_t VP_BED_STATUS = 0x341C; |
|||
|
|||
constexpr uint16_t VP_TMC_X_STEP = 0x3430; |
|||
constexpr uint16_t VP_TMC_Y_STEP = 0x3432; |
|||
constexpr uint16_t VP_TMC_Z_STEP = 0x3434; |
|||
|
|||
constexpr uint16_t VP_TMC_X1_Current = 0x3436; |
|||
constexpr uint16_t VP_TMC_Y1_Current = 0x3438; |
|||
constexpr uint16_t VP_TMC_X_Current = 0x343A; |
|||
constexpr uint16_t VP_TMC_Y_Current = 0x343C; |
|||
constexpr uint16_t VP_TMC_Z_Current = 0x343E; |
|||
constexpr uint16_t VP_TMC_E0_Current = 0x3440; |
|||
constexpr uint16_t VP_TMC_E1_Current = 0x3442; |
|||
constexpr uint16_t VP_TMC_Z1_Current = 0x3444; |
|||
|
|||
|
|||
constexpr uint16_t VP_PrintTime_H = 0x3500; |
|||
constexpr uint16_t VP_PrintTime_M = 0x3502; |
|||
constexpr uint16_t VP_PrintTime_S = 0x3504; |
|||
|
|||
// PIDs
|
|||
constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , 2 byte unsigned int , 0~1638.4
|
|||
constexpr uint16_t VP_E0_PID_I = 0x3702; |
|||
constexpr uint16_t VP_E0_PID_D = 0x3704; |
|||
constexpr uint16_t VP_E1_PID_P = 0x3706; // at the moment , 2 byte unsigned int , 0~1638.4
|
|||
constexpr uint16_t VP_E1_PID_I = 0x3708; |
|||
constexpr uint16_t VP_E1_PID_D = 0x370A; |
|||
constexpr uint16_t VP_BED_PID_P = 0x3710; |
|||
constexpr uint16_t VP_BED_PID_I = 0x3712; |
|||
constexpr uint16_t VP_BED_PID_D = 0x3714; |
|||
|
|||
constexpr uint16_t VP_EEPROM_CTRL = 0x3720; |
|||
|
|||
constexpr uint16_t VP_OFFSET_X = 0x3724; |
|||
constexpr uint16_t VP_OFFSET_Y = 0x3728; |
|||
constexpr uint16_t VP_OFFSET_Z = 0x372B; |
|||
|
|||
// PID autotune
|
|||
constexpr uint16_t VP_PID_AUTOTUNE_E0 = 0x3800; |
|||
constexpr uint16_t VP_PID_AUTOTUNE_E1 = 0x3802; |
|||
constexpr uint16_t VP_PID_AUTOTUNE_E2 = 0x3804; |
|||
constexpr uint16_t VP_PID_AUTOTUNE_E3 = 0x3806; |
|||
constexpr uint16_t VP_PID_AUTOTUNE_E4 = 0x3808; |
|||
constexpr uint16_t VP_PID_AUTOTUNE_E5 = 0x380A; |
|||
constexpr uint16_t VP_PID_AUTOTUNE_BED = 0x380C; |
|||
// Calibrate Z
|
|||
constexpr uint16_t VP_Z_CALIBRATE = 0x3810; |
|||
|
|||
constexpr uint16_t VP_AutoTurnOffSw = 0x3812; |
|||
constexpr uint16_t VP_LCD_BLK = 0x3814; |
|||
|
|||
constexpr uint16_t VP_X_PARK_POS = 0x3900; |
|||
constexpr uint16_t VP_Y_PARK_POS = 0x3902; |
|||
constexpr uint16_t VP_Z_PARK_POS = 0x3904; |
|||
|
|||
/* -------------------------------0x4000-0x4FFF------------------------------- */ |
|||
// Heater Control Buttons , triged between "cool down" and "heat PLA" state
|
|||
constexpr uint16_t VP_E0_CONTROL = 0x4010; |
|||
constexpr uint16_t VP_E1_CONTROL = 0x4012; |
|||
//constexpr uint16_t VP_E2_CONTROL = 0x2214;
|
|||
//constexpr uint16_t VP_E3_CONTROL = 0x2216;
|
|||
//constexpr uint16_t VP_E4_CONTROL = 0x2218;
|
|||
//constexpr uint16_t VP_E5_CONTROL = 0x221A;
|
|||
constexpr uint16_t VP_BED_CONTROL = 0x401C; |
|||
|
|||
// Preheat
|
|||
constexpr uint16_t VP_E0_BED_PREHEAT = 0x4020; |
|||
constexpr uint16_t VP_E1_BED_PREHEAT = 0x4022; |
|||
//constexpr uint16_t VP_E2_BED_PREHEAT = 0x4024;
|
|||
//constexpr uint16_t VP_E3_BED_PREHEAT = 0x4026;
|
|||
//constexpr uint16_t VP_E4_BED_PREHEAT = 0x4028;
|
|||
//constexpr uint16_t VP_E5_BED_PREHEAT = 0x402A;
|
|||
|
|||
// Filament load and unload
|
|||
// constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x4030;
|
|||
// constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x4032;
|
|||
|
|||
// Settings store , reset
|
|||
|
|||
// Level data
|
|||
constexpr uint16_t VP_Level_Point_One_X = 0x4100; |
|||
constexpr uint16_t VP_Level_Point_One_Y = 0x4102; |
|||
constexpr uint16_t VP_Level_Point_Two_X = 0x4104; |
|||
constexpr uint16_t VP_Level_Point_Two_Y = 0x4106; |
|||
constexpr uint16_t VP_Level_Point_Three_X = 0x4108; |
|||
constexpr uint16_t VP_Level_Point_Three_Y = 0x410A; |
|||
constexpr uint16_t VP_Level_Point_Four_X = 0x410C; |
|||
constexpr uint16_t VP_Level_Point_Four_Y = 0x410E; |
|||
constexpr uint16_t VP_Level_Point_Five_X = 0x4110; |
|||
constexpr uint16_t VP_Level_Point_Five_Y = 0x4112; |
|||
|
|||
|
|||
/* H43 Version */ |
|||
constexpr uint16_t VP_MKS_H43_VERSION = 0x4A00; // MKS H43 V1.0.0
|
|||
constexpr uint16_t VP_MKS_H43_VERSION_LEN = 16; |
|||
constexpr uint16_t VP_MKS_H43_UpdataVERSION = 0x4A10; // MKS H43 V1.0.0
|
|||
constexpr uint16_t VP_MKS_H43_UpdataVERSION_LEN = 16; |
|||
|
|||
/* -------------------------------0x5000-0xFFFF------------------------------- */ |
|||
constexpr uint16_t VP_HOME_Dis = 0x5000; |
|||
constexpr uint16_t VP_Setting_Dis = 0x5010; |
|||
constexpr uint16_t VP_Tool_Dis = 0x5020; |
|||
constexpr uint16_t VP_Printing_Dis = 0x5030; |
|||
|
|||
constexpr uint16_t VP_Language_Dis = 0x5080; |
|||
constexpr uint16_t VP_LossPoint_Dis = 0x5090; |
|||
|
|||
constexpr uint16_t VP_PrintPauseConfig_Dis = 0x5120; |
|||
constexpr uint16_t VP_MotorPluse_Dis = 0x5140; |
|||
constexpr uint16_t VP_MotorMaxSpeed_Dis = 0x5150; |
|||
constexpr uint16_t VP_MotorMaxAcc_Dis = 0x5160; |
|||
|
|||
constexpr uint16_t VP_X_Pluse_Dis = 0x5170; |
|||
constexpr uint16_t VP_Y_Pluse_Dis = 0x5180; |
|||
constexpr uint16_t VP_Z_Pluse_Dis = 0x5190; |
|||
constexpr uint16_t VP_E0_Pluse_Dis = 0x51A0; |
|||
constexpr uint16_t VP_E1_Pluse_Dis = 0x51B0; |
|||
|
|||
constexpr uint16_t VP_X_Max_Speed_Dis = 0x5280; |
|||
constexpr uint16_t VP_Y_Max_Speed_Dis = 0x5290; |
|||
constexpr uint16_t VP_Z_Max_Speed_Dis = 0x52A0; |
|||
constexpr uint16_t VP_E0_Max_Speed_Dis = 0x52B0; |
|||
constexpr uint16_t VP_E1_Max_Speed_Dis = 0x52C0; |
|||
|
|||
constexpr uint16_t VP_X_Max_Acc_Speed_Dis = 0x51E0; |
|||
constexpr uint16_t VP_Y_Max_Acc_Speed_Dis = 0x51F0; |
|||
constexpr uint16_t VP_Z_Max_Acc_Speed_Dis = 0x5200; |
|||
constexpr uint16_t VP_E0_Max_Acc_Speed_Dis = 0x5210; |
|||
constexpr uint16_t VP_E1_Max_Acc_Speed_Dis = 0x5220; |
|||
|
|||
|
|||
constexpr uint16_t VP_PrintTime_Dis = 0x5470; |
|||
constexpr uint16_t VP_E0_Temp_Dis = 0x5310; |
|||
constexpr uint16_t VP_E1_Temp_Dis = 0x5320; |
|||
constexpr uint16_t VP_HB_Temp_Dis = 0x5330; |
|||
constexpr uint16_t VP_Feedrate_Dis = 0x5350; |
|||
constexpr uint16_t VP_PrintAcc_Dis = 0x5340; |
|||
constexpr uint16_t VP_Fan_Speed_Dis = 0x5360; |
|||
|
|||
constexpr uint16_t VP_Min_Ex_Temp_Dis = 0x5380; |
|||
|
|||
|
|||
constexpr uint16_t VP_X_PARK_POS_Dis = 0x53E0; |
|||
constexpr uint16_t VP_Y_PARK_POS_Dis = 0x53F0; |
|||
constexpr uint16_t VP_Z_PARK_POS_Dis = 0x5400; |
|||
|
|||
|
|||
constexpr uint16_t VP_TravelAcc_Dis = 0x5440; |
|||
constexpr uint16_t VP_FeedRateMin_Dis = 0x5450; |
|||
constexpr uint16_t VP_TravelFeeRateMin_Dis = 0x5460; |
|||
constexpr uint16_t VP_ACC_Dis = 0x5480; |
|||
|
|||
constexpr uint16_t VP_Extrusion_Dis = 0x5230; |
|||
constexpr uint16_t VP_HeatBed_Dis = 0x5240; |
|||
|
|||
constexpr uint16_t VP_Printting_Dis = 0x5430; |
|||
constexpr uint16_t VP_FactoryDefaults_Dis = 0x54C0; |
|||
constexpr uint16_t VP_StoreSetting_Dis = 0x54B0; |
|||
constexpr uint16_t VP_Info_EEPROM_2_Dis = 0x54D0; |
|||
constexpr uint16_t VP_Info_EEPROM_1_Dis = 0x54E0; |
|||
|
|||
constexpr uint16_t VP_AutoLevel_1_Dis = 0x55F0; |
|||
|
|||
constexpr uint16_t VP_TMC_X_Step_Dis = 0x5530; |
|||
constexpr uint16_t VP_TMC_Y_Step_Dis = 0x5540; |
|||
constexpr uint16_t VP_TMC_Z_Step_Dis = 0x5550; |
|||
constexpr uint16_t VP_TMC_X1_Current_Dis = 0x5560; |
|||
constexpr uint16_t VP_TMC_Y1_Current_Dis = 0x5570; |
|||
constexpr uint16_t VP_TMC_X_Current_Dis = 0x5580; |
|||
constexpr uint16_t VP_TMC_Y_Current_Dis = 0x5590; |
|||
constexpr uint16_t VP_TMC_Z_Current_Dis = 0x55A0; |
|||
constexpr uint16_t VP_TMC_E0_Current_Dis = 0x55B0; |
|||
constexpr uint16_t VP_TMC_E1_Current_Dis = 0x55C0; |
|||
constexpr uint16_t VP_TMC_Z1_Current_Dis = 0x55E0; |
|||
|
|||
constexpr uint16_t VP_AutoLEVEL_INFO1 = 0x5600; |
|||
constexpr uint16_t VP_EX_TEMP_INFO1_Dis = 0x5610; |
|||
constexpr uint16_t VP_EX_TEMP_INFO2_Dis = 0x5620; |
|||
constexpr uint16_t VP_EX_TEMP_INFO3_Dis = 0x5630; |
|||
constexpr uint16_t VP_LCD_BLK_Dis = 0x56A0; |
|||
constexpr uint16_t VP_Info_PrinfFinsh_1_Dis = 0x5C00; |
|||
constexpr uint16_t VP_Info_PrinfFinsh_2_Dis = 0x5C10; |
|||
|
|||
constexpr uint16_t VP_Length_Dis = 0x5B00; |
|||
|
|||
constexpr uint16_t VP_PrintConfrim_Info_Dis = 0x5B90; |
|||
constexpr uint16_t VP_StopPrintConfrim_Info_Dis = 0x5B80; |
|||
|
|||
constexpr uint16_t VP_Point_One_Dis = 0x5BA0; |
|||
constexpr uint16_t VP_Point_Two_Dis = 0x5BB0; |
|||
constexpr uint16_t VP_Point_Three_Dis = 0x5BC0; |
|||
constexpr uint16_t VP_Point_Four_Dis = 0x5BD0; |
|||
constexpr uint16_t VP_Point_Five_Dis = 0x5BE0; |
|||
|
|||
constexpr uint16_t VP_Print_Dis = 0x5250; |
|||
|
|||
constexpr uint16_t VP_About_Dis = 0x5A00; |
|||
constexpr uint16_t VP_Config_Dis = 0x5A10; |
|||
constexpr uint16_t VP_Filament_Dis = 0x5A20; |
|||
constexpr uint16_t VP_Move_Dis = 0x5A30; |
|||
constexpr uint16_t VP_Level_Dis = 0x5A50; |
|||
constexpr uint16_t VP_Speed_Dis = 0x5A70; |
|||
constexpr uint16_t VP_InOut_Dis = 0x5A80; |
|||
|
|||
constexpr uint16_t VP_MotorConfig_Dis = 0x5100; |
|||
constexpr uint16_t VP_LevelConfig_Dis = 0x5110; |
|||
constexpr uint16_t VP_Advance_Dis = 0x5130; |
|||
constexpr uint16_t VP_TemperatureConfig_Dis = 0x5390; |
|||
|
|||
#endif // MKS_FINSH
|
|||
File diff suppressed because it is too large
@ -0,0 +1,307 @@ |
|||
/**
|
|||
* 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 |
|||
|
|||
#include "../DGUSDisplay.h" |
|||
#include "../DGUSVPVariable.h" |
|||
#include "../DGUSDisplayDef.h" |
|||
|
|||
#include "../../../../../inc/MarlinConfig.h" |
|||
|
|||
enum DGUSLCD_Screens : uint8_t; |
|||
|
|||
class DGUSScreenHandler { |
|||
public: |
|||
DGUSScreenHandler() = default; |
|||
|
|||
static bool loop(); |
|||
|
|||
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
|
|||
// The bools specifing whether the strings are in RAM or FLASH.
|
|||
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); |
|||
|
|||
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); |
|||
|
|||
static void sendinfoscreen_ch_mks(const uint16_t* line1, const uint16_t* line2, const uint16_t* line3, const uint16_t* line4); |
|||
static void sendinfoscreen_en_mks(const char* line1, const char* line2, const char* line3, const char* line4) ; |
|||
static void sendinfoscreen_mks(const void* line1, const void* line2, const void* line3, const void* line4,uint16_t language); |
|||
|
|||
// "M117" Message -- msg is a RAM ptr.
|
|||
static void setstatusmessage(const char* msg); |
|||
// The same for messages from Flash
|
|||
static void setstatusmessagePGM(PGM_P const msg); |
|||
// Callback for VP "Display wants to change screen on idle printer"
|
|||
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Callback for VP "Screen has been changed"
|
|||
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
static void ScreenBackChange(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Callback for VP "All Heaters Off"
|
|||
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for "Change this temperature"
|
|||
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for "Change Flowrate"
|
|||
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION) |
|||
// Hook for manual move option
|
|||
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
|
|||
static void EEPROM_CTRL(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void LanguageChange_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void GetOffsetValue(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void Level_Ctrl_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void MeshLevel(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void MeshLevelDistanceConfig(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void ManualAssistLeveling(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void ZoffsetConfirm(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void Z_offset_select(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void GetManualMovestep(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void GetZoffsetDistance(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void GetMinExtrudeTemp(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void GetParkPos_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleGetExMinTemp_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void DGUS_LanguageDisplay(uint8_t var); |
|||
static void TMC_ChangeConfig(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void GetTurnOffCtrl(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void LanguagePInit(void); |
|||
static void DGUS_Runout_Idle(void); |
|||
static void DGUS_RunoutInit(void); |
|||
static void DGUS_ExtrudeLoadInit(void); |
|||
static void LCD_BLK_Adjust(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Hook for manual move.
|
|||
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for manual extrude.
|
|||
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for motor lock and unlook
|
|||
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
// Hook for power loss recovery.
|
|||
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
// Hook for settings
|
|||
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
static void HandleStepPerMMChanged_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMExtruderChanged_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleMaxSpeedChange_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleExtruderMaxSpeedChange_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleMaxAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleExtruderAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleChangeLevelPoint_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleTravelAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleFeedRateMinChange_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleMin_T_F_MKS(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
#if HAS_PID_HEATING |
|||
// Hook for "Change this temperature PID para"
|
|||
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for PID autotune
|
|||
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if HAS_BED_PROBE |
|||
// Hook for "Change probe offset z"
|
|||
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if ENABLED(BABYSTEPPING) |
|||
// Hook for live z adjust action
|
|||
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if HAS_FAN |
|||
// Hook for fan control
|
|||
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
// Hook for heater control
|
|||
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(DGUS_PREHEAT_UI) |
|||
// Hook for preheat
|
|||
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD) |
|||
// Hook for filament load and unload filament option
|
|||
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for filament load and unload
|
|||
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var); |
|||
|
|||
static void MKS_FilamentLoad(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void MKS_FilamentUnLoad(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void MKS_LOAD_UNLOAD_IDLE(); |
|||
static void MKS_LOAD_Cancle(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void GetManualFilament(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void GetManualFilamentSpeed(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
|
|||
#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.
|
|||
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr); |
|||
// User confirmed the abort action
|
|||
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr); |
|||
// User hit the tune button
|
|||
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Send a single filename to the display.
|
|||
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var); |
|||
// Marlin informed us that a new SD has been inserted.
|
|||
static void SDCardInserted(); |
|||
// Marlin informed us that the SD Card has been removed().
|
|||
static void SDCardRemoved(); |
|||
// Marlin informed us about a bad SD Card.
|
|||
static void SDCardError(); |
|||
// Marlin informed us about SD print completion.
|
|||
static void SDPrintingFinished(); |
|||
#endif |
|||
|
|||
// OK Button the Confirm screen.
|
|||
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Update data after went to new screen (by display or by GotoScreen)
|
|||
// remember: store the last-displayed screen, so it can get returned to.
|
|||
// (e.g for pop up messages)
|
|||
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false); |
|||
|
|||
// Recall the remembered screen.
|
|||
static void PopToOldScreen(); |
|||
|
|||
// Make the display show the screen and update all VPs in it.
|
|||
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false); |
|||
|
|||
static void UpdateScreenVPData(); |
|||
|
|||
// Helpers to convert and transfer data to the display.
|
|||
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var); |
|||
|
|||
static void DGUSLCD_SendPrintTimeToDisplay_MKS(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendBabyStepToDisplay_MKS(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendFanToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendGbkToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplay_Language_MKS(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendTMCStepValue(DGUS_VP_Variable &var); |
|||
|
|||
#if ENABLED(PRINTCOUNTER) |
|||
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
#if HAS_FAN |
|||
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var); |
|||
#if ENABLED(DGUS_UI_WAITING) |
|||
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
|
|||
// Send a value from 0..100 to a variable with a range from 0..255
|
|||
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
static void DGUSLCD_SetUint8(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
template<typename T> |
|||
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) { |
|||
if (!var.memadr) return; |
|||
union { unsigned char tmp[sizeof(T)]; T t; } x; |
|||
unsigned char *ptr = (unsigned char*)val_ptr; |
|||
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1]; |
|||
*(T*)var.memadr = x.t; |
|||
} |
|||
|
|||
// Send a float value to the display.
|
|||
// Display will get a 4-byte integer scaled to the number of digits:
|
|||
// Tell the display the number of digits and it cheats by displaying a dot between...
|
|||
template<unsigned int decimals> |
|||
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) { |
|||
if (var.memadr) { |
|||
float f = *(float *)var.memadr; |
|||
f *= cpow(10, decimals); |
|||
dgusdisplay.WriteVariable(var.VP, (long)f); |
|||
} |
|||
} |
|||
|
|||
// Send a float value to the display.
|
|||
// Display will get a 2-byte integer scaled to the number of digits:
|
|||
// Tell the display the number of digits and it cheats by displaying a dot between...
|
|||
template<unsigned int decimals> |
|||
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) { |
|||
if (var.memadr) { |
|||
float f = *(float *)var.memadr; |
|||
DEBUG_ECHOLNPAIR_F(" >> ", f, 6); |
|||
f *= cpow(10, decimals); |
|||
dgusdisplay.WriteVariable(var.VP, (int16_t)f); |
|||
} |
|||
} |
|||
|
|||
// Force an update of all VP on the current screen.
|
|||
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; } |
|||
// Has all VPs sent to the screen
|
|||
static inline bool IsScreenComplete() { return ScreenComplete; } |
|||
|
|||
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; } |
|||
|
|||
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; } |
|||
|
|||
private: |
|||
static DGUSLCD_Screens current_screen; //< currently on screen
|
|||
static constexpr uint8_t NUM_PAST_SCREENS = 4; |
|||
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
|
|||
|
|||
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
|
|||
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
|
|||
static bool ScreenComplete; //< All VPs sent to screen?
|
|||
|
|||
static uint16_t ConfirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
|
|||
|
|||
#if ENABLED(SDSUPPORT) |
|||
static int16_t top_file; //< file on top of file chooser
|
|||
static int16_t file_to_print; //< touched file to be confirmed
|
|||
#endif |
|||
|
|||
static void (*confirm_action_cb)(); |
|||
}; |
|||
|
|||
#define MKS_Language_Choose 0x00 |
|||
#define MKS_Language_NoChoose 0x01 |
|||
|
|||
#define MKS_SimpleChinese 0 |
|||
#define MKS_English 1 |
|||
extern uint8_t DGUSLanguageSwitch; |
|||
extern bool DGUSAutoTurnOff; |
|||
|
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
#define PLR_SCREEN_RECOVER MKSLCD_SCREEN_PRINT |
|||
#define PLR_SCREEN_CANCEL MKSLCD_SCREEN_HOME |
|||
#endif |
|||
@ -0,0 +1,418 @@ |
|||
/**
|
|||
* 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 ENABLED(DGUS_LCD_UI_ORIGIN) |
|||
|
|||
#include "../DGUSScreenHandler.h" |
|||
|
|||
#include "../../../../../MarlinCore.h" |
|||
#include "../../../../../gcode/queue.h" |
|||
#include "../../../../../libs/duration_t.h" |
|||
#include "../../../../../module/settings.h" |
|||
#include "../../../../../module/temperature.h" |
|||
#include "../../../../../module/motion.h" |
|||
#include "../../../../../module/planner.h" |
|||
#include "../../../../../module/printcounter.h" |
|||
#include "../../../../../sd/cardreader.h" |
|||
|
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
#include "../../../../feature/powerloss.h" |
|||
#endif |
|||
|
|||
#if ENABLED(SDSUPPORT) |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file; |
|||
if (touched_nr > filelist.count()) return; |
|||
if (!filelist.seek(touched_nr)) return; |
|||
|
|||
if (filelist.isDir()) { |
|||
filelist.changeDir(filelist.filename()); |
|||
top_file = 0; |
|||
ForceCompleteUpdate(); |
|||
return; |
|||
} |
|||
|
|||
#if ENABLED(DGUS_PRINT_FILENAME) |
|||
// Send print filename
|
|||
dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true); |
|||
#endif |
|||
|
|||
// Setup Confirmation screen
|
|||
file_to_print = touched_nr; |
|||
|
|||
HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true); |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr) { |
|||
if (!filelist.seek(file_to_print)) return; |
|||
ExtUI::printFile(filelist.shortFilename()); |
|||
GotoScreen(DGUSLCD_SCREEN_STATUS); |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) { |
|||
|
|||
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
|
|||
switch (swap16(*(uint16_t*)val_ptr)) { |
|||
case 0: { // Resume
|
|||
if (ExtUI::isPrintingFromMediaPaused()) { |
|||
ExtUI::resumePrint(); |
|||
} |
|||
} break; |
|||
|
|||
case 1: // Pause
|
|||
|
|||
GotoScreen(MKSLCD_SCREEN_PAUSE); |
|||
if (!ExtUI::isPrintingFromMediaPaused()) { |
|||
ExtUI::pausePrint(); |
|||
//ExtUI::mks_pausePrint();
|
|||
} |
|||
break; |
|||
case 2: // Abort
|
|||
HandleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
void DGUSScreenHandler::DGUSLCD_SD_SendFilename(DGUS_VP_Variable& var) { |
|||
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN; |
|||
if (target_line > DGUS_SD_FILESPERSCREEN) return; |
|||
char tmpfilename[VP_SD_FileName_LEN + 1] = ""; |
|||
var.memadr = (void*)tmpfilename; |
|||
|
|||
if (filelist.seek(top_file + target_line)) { |
|||
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
|
|||
} |
|||
DGUSLCD_SendStringToDisplay(var); |
|||
} |
|||
|
|||
void DGUSScreenHandler::SDCardInserted() { |
|||
top_file = 0; |
|||
filelist.refresh(); |
|||
auto cs = getCurrentScreen(); |
|||
if (cs == DGUSLCD_SCREEN_MAIN || cs == DGUSLCD_SCREEN_STATUS) |
|||
GotoScreen(DGUSLCD_SCREEN_SDFILELIST); |
|||
} |
|||
|
|||
void DGUSScreenHandler::SDCardRemoved() { |
|||
if (current_screen == DGUSLCD_SCREEN_SDFILELIST |
|||
|| (current_screen == DGUSLCD_SCREEN_CONFIRM && (ConfirmVP == VP_SD_AbortPrintConfirmed || ConfirmVP == VP_SD_FileSelectConfirm)) |
|||
|| current_screen == DGUSLCD_SCREEN_SDPRINTMANIPULATION |
|||
) GotoScreen(DGUSLCD_SCREEN_MAIN); |
|||
} |
|||
|
|||
#endif // SDSUPPORT
|
|||
|
|||
void DGUSScreenHandler::ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint8_t *tmp = (uint8_t*)val_ptr; |
|||
|
|||
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
|
|||
// from screen 1 (main) to 10 (temperature). DGUSLCD_SCREEN_POPUP is special,
|
|||
// meaning "return to previous screen"
|
|||
DGUSLCD_Screens target = (DGUSLCD_Screens)tmp[1]; |
|||
|
|||
DEBUG_ECHOLNPAIR("\n DEBUG target", target); |
|||
|
|||
if (target == DGUSLCD_SCREEN_POPUP) { |
|||
// Special handling for popup is to return to previous menu
|
|||
if (current_screen == DGUSLCD_SCREEN_POPUP && confirm_action_cb) confirm_action_cb(); |
|||
PopToOldScreen(); |
|||
return; |
|||
} |
|||
|
|||
UpdateNewScreen(target); |
|||
|
|||
#ifdef DEBUG_DGUSLCD |
|||
if (!DGUSLCD_FindScreenVPMapList(target)) DEBUG_ECHOLNPAIR("WARNING: No screen Mapping found for ", target); |
|||
#endif |
|||
} |
|||
|
|||
void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleManualMove"); |
|||
|
|||
int16_t movevalue = swap16(*(uint16_t*)val_ptr); |
|||
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION) |
|||
if (movevalue) { |
|||
const uint16_t choice = *(uint16_t*)var.memadr; |
|||
movevalue = movevalue < 0 ? -choice : choice; |
|||
} |
|||
#endif |
|||
char axiscode; |
|||
unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
|
|||
|
|||
switch (var.VP) { |
|||
default: return; |
|||
|
|||
case VP_MOVE_X: |
|||
axiscode = 'X'; |
|||
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_MOVE_Y: |
|||
axiscode = 'Y'; |
|||
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_MOVE_Z: |
|||
axiscode = 'Z'; |
|||
speed = 300; // default to 5mm/s
|
|||
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove; |
|||
break; |
|||
|
|||
case VP_HOME_ALL: // only used for homing
|
|||
axiscode = '\0'; |
|||
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
|
|||
break; |
|||
} |
|||
|
|||
if (!movevalue) { |
|||
// homing
|
|||
DEBUG_ECHOPAIR(" homing ", axiscode); |
|||
char buf[6] = "G28 X"; |
|||
buf[4] = axiscode; |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOLNPGM(" ✓");
|
|||
ForceCompleteUpdate(); |
|||
return; |
|||
} |
|||
else { |
|||
// movement
|
|||
DEBUG_ECHOPAIR(" move ", axiscode); |
|||
bool old_relative_mode = relative_mode; |
|||
if (!relative_mode) { |
|||
//DEBUG_ECHOPGM(" G91");
|
|||
queue.enqueue_now_P(PSTR("G91")); |
|||
//DEBUG_ECHOPGM(" ✓ ");
|
|||
} |
|||
char buf[32]; // G1 X9999.99 F12345
|
|||
unsigned int backup_speed = MMS_TO_MMM(feedrate_mm_s); |
|||
char sign[] = "\0"; |
|||
int16_t value = movevalue / 100; |
|||
if (movevalue < 0) { value = -value; sign[0] = '-'; } |
|||
int16_t fraction = ABS(movevalue) % 100; |
|||
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed); |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOLNPGM(" ✓ ");
|
|||
if (backup_speed != speed) { |
|||
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed); |
|||
queue.enqueue_one_now(buf); |
|||
//DEBUG_ECHOPAIR(" ", buf);
|
|||
} |
|||
// while (!enqueue_and_echo_command(buf)) idle();
|
|||
//DEBUG_ECHOLNPGM(" ✓ ");
|
|||
if (!old_relative_mode) { |
|||
//DEBUG_ECHOPGM("G90");
|
|||
queue.enqueue_now_P(PSTR("G90")); |
|||
//DEBUG_ECHOPGM(" ✓ ");
|
|||
} |
|||
} |
|||
|
|||
ForceCompleteUpdate(); |
|||
DEBUG_ECHOLNPGM("manmv done."); |
|||
return; |
|||
|
|||
cannotmove: |
|||
DEBUG_ECHOLNPAIR(" cannot move ", axiscode); |
|||
return; |
|||
} |
|||
|
|||
#if HAS_PID_HEATING |
|||
void DGUSScreenHandler::HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) { |
|||
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr); |
|||
DEBUG_ECHOLNPAIR("V1:", rawvalue); |
|||
float value = (float)rawvalue / 10; |
|||
DEBUG_ECHOLNPAIR("V2:", value); |
|||
float newvalue = 0; |
|||
|
|||
switch (var.VP) { |
|||
default: return; |
|||
#if HOTENDS >= 1 |
|||
case VP_E0_PID_P: newvalue = value; break; |
|||
case VP_E0_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_E0_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
case VP_E1_PID_P: newvalue = value; break; |
|||
case VP_E1_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_E1_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
#if HAS_HEATED_BED |
|||
case VP_BED_PID_P: newvalue = value; break; |
|||
case VP_BED_PID_I: newvalue = scalePID_i(value); break; |
|||
case VP_BED_PID_D: newvalue = scalePID_d(value); break; |
|||
#endif |
|||
} |
|||
|
|||
DEBUG_ECHOLNPAIR_F("V3:", newvalue); |
|||
*(float *)var.memadr = newvalue; |
|||
|
|||
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
|
|||
} |
|||
#endif // HAS_PID_HEATING
|
|||
|
|||
#if ENABLED(BABYSTEPPING) |
|||
void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleLiveAdjustZ"); |
|||
int16_t flag = swap16(*(uint16_t*)val_ptr), |
|||
steps = flag ? -20 : 20; |
|||
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true); |
|||
ForceCompleteUpdate(); |
|||
} |
|||
#endif |
|||
|
|||
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD) |
|||
|
|||
void DGUSScreenHandler::HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) { |
|||
DEBUG_ECHOLNPGM("HandleFilamentOption"); |
|||
|
|||
uint8_t e_temp = 0; |
|||
filament_data.heated = false; |
|||
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr); |
|||
if (preheat_option <= 8) { // Load filament type
|
|||
filament_data.action = 1; |
|||
} |
|||
else if (preheat_option >= 10) { // Unload filament type
|
|||
preheat_option -= 10; |
|||
filament_data.action = 2; |
|||
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH; |
|||
} |
|||
else { // Cancel filament operation
|
|||
filament_data.action = 0; |
|||
} |
|||
|
|||
switch (preheat_option) { |
|||
case 0: // Load PLA
|
|||
#ifdef PREHEAT_1_TEMP_HOTEND |
|||
e_temp = PREHEAT_1_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 1: // Load ABS
|
|||
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND); |
|||
break; |
|||
case 2: // Load PET
|
|||
#ifdef PREHEAT_3_TEMP_HOTEND |
|||
e_temp = PREHEAT_3_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 3: // Load FLEX
|
|||
#ifdef PREHEAT_4_TEMP_HOTEND |
|||
e_temp = PREHEAT_4_TEMP_HOTEND; |
|||
#endif |
|||
break; |
|||
case 9: // Cool down
|
|||
default: |
|||
e_temp = 0; |
|||
break; |
|||
} |
|||
|
|||
if (filament_data.action == 0) { // Go back to utility screen
|
|||
#if HOTENDS >= 1 |
|||
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0); |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1); |
|||
#endif |
|||
GotoScreen(DGUSLCD_SCREEN_UTILITY); |
|||
} |
|||
else { // Go to the preheat screen to show the heating progress
|
|||
switch (var.VP) { |
|||
default: return; |
|||
#if HOTENDS >= 1 |
|||
case VP_E0_FILAMENT_LOAD_UNLOAD: |
|||
filament_data.extruder = ExtUI::extruder_t::E0; |
|||
thermalManager.setTargetHotend(e_temp, filament_data.extruder); |
|||
break; |
|||
#endif |
|||
#if HOTENDS >= 2 |
|||
case VP_E1_FILAMENT_LOAD_UNLOAD: |
|||
filament_data.extruder = ExtUI::extruder_t::E1; |
|||
thermalManager.setTargetHotend(e_temp, filament_data.extruder); |
|||
break; |
|||
#endif |
|||
} |
|||
GotoScreen(DGUSLCD_SCREEN_FILAMENT_HEATING); |
|||
} |
|||
} |
|||
|
|||
void DGUSScreenHandler::HandleFilamentLoadUnload(DGUS_VP_Variable &var) { |
|||
DEBUG_ECHOLNPGM("HandleFilamentLoadUnload"); |
|||
if (filament_data.action <= 0) return; |
|||
|
|||
// If we close to the target temperature, we can start load or unload the filament
|
|||
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \ |
|||
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) { |
|||
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME; |
|||
|
|||
if (filament_data.action == 1) { // load filament
|
|||
if (!filament_data.heated) { |
|||
//GotoScreen(DGUSLCD_SCREEN_FILAMENT_LOADING);
|
|||
filament_data.heated = true; |
|||
} |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue; |
|||
} |
|||
else { // unload filament
|
|||
if (!filament_data.heated) { |
|||
GotoScreen(DGUSLCD_SCREEN_FILAMENT_UNLOADING); |
|||
filament_data.heated = true; |
|||
} |
|||
// Before unloading extrude to prevent jamming
|
|||
if (filament_data.purge_length >= 0) { |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue; |
|||
filament_data.purge_length -= movevalue; |
|||
} |
|||
else { |
|||
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue; |
|||
} |
|||
} |
|||
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder); |
|||
} |
|||
} |
|||
#endif // DGUS_FILAMENT_LOADUNLOAD
|
|||
|
|||
bool DGUSScreenHandler::loop() { |
|||
dgusdisplay.loop(); |
|||
|
|||
const millis_t ms = millis(); |
|||
static millis_t next_event_ms = 0; |
|||
|
|||
if (!IsScreenComplete() || ELAPSED(ms, next_event_ms)) { |
|||
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS; |
|||
UpdateScreenVPData(); |
|||
} |
|||
|
|||
#if ENABLED(SHOW_BOOTSCREEN) |
|||
static bool booted = false; |
|||
|
|||
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid())) |
|||
booted = true; |
|||
|
|||
if (!booted && ELAPSED(ms, TERN(USE_MKS_GREEN_UI, 1000, BOOTSCREEN_TIMEOUT))) |
|||
booted = true; |
|||
#endif |
|||
return IsScreenComplete(); |
|||
} |
|||
|
|||
#endif // DGUS_LCD_UI_ORIGIN
|
|||
@ -0,0 +1,240 @@ |
|||
/**
|
|||
* 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 |
|||
|
|||
#include "../DGUSDisplay.h" |
|||
#include "../DGUSVPVariable.h" |
|||
#include "../DGUSDisplayDef.h" |
|||
|
|||
#include "../../../../../inc/MarlinConfig.h" |
|||
|
|||
enum DGUSLCD_Screens : uint8_t; |
|||
|
|||
class DGUSScreenHandler { |
|||
public: |
|||
DGUSScreenHandler() = default; |
|||
|
|||
static bool loop(); |
|||
|
|||
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
|
|||
// The bools specifing whether the strings are in RAM or FLASH.
|
|||
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); |
|||
|
|||
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); |
|||
|
|||
// "M117" Message -- msg is a RAM ptr.
|
|||
static void setstatusmessage(const char* msg); |
|||
// The same for messages from Flash
|
|||
static void setstatusmessagePGM(PGM_P const msg); |
|||
// Callback for VP "Display wants to change screen on idle printer"
|
|||
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Callback for VP "Screen has been changed"
|
|||
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Callback for VP "All Heaters Off"
|
|||
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for "Change this temperature"
|
|||
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for "Change Flowrate"
|
|||
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION) |
|||
// Hook for manual move option
|
|||
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
|
|||
// Hook for manual move.
|
|||
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for manual extrude.
|
|||
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for motor lock and unlook
|
|||
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
// Hook for power loss recovery.
|
|||
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
// Hook for settings
|
|||
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
#if HAS_PID_HEATING |
|||
// Hook for "Change this temperature PID para"
|
|||
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for PID autotune
|
|||
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if HAS_BED_PROBE |
|||
// Hook for "Change probe offset z"
|
|||
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if ENABLED(BABYSTEPPING) |
|||
// Hook for live z adjust action
|
|||
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if HAS_FAN |
|||
// Hook for fan control
|
|||
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
// Hook for heater control
|
|||
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr); |
|||
#if ENABLED(DGUS_PREHEAT_UI) |
|||
// Hook for preheat
|
|||
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr); |
|||
#endif |
|||
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD) |
|||
// Hook for filament load and unload filament option
|
|||
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Hook for filament load and unload
|
|||
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var); |
|||
#endif |
|||
|
|||
#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.
|
|||
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr); |
|||
// User confirmed the abort action
|
|||
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr); |
|||
// User hit the tune button
|
|||
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr); |
|||
// Send a single filename to the display.
|
|||
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var); |
|||
// Marlin informed us that a new SD has been inserted.
|
|||
static void SDCardInserted(); |
|||
// Marlin informed us that the SD Card has been removed().
|
|||
static void SDCardRemoved(); |
|||
// Marlin informed us about a bad SD Card.
|
|||
static void SDCardError(); |
|||
#endif |
|||
|
|||
// OK Button the Confirm screen.
|
|||
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
// Update data after went to new screen (by display or by GotoScreen)
|
|||
// remember: store the last-displayed screen, so it can get returned to.
|
|||
// (e.g for pop up messages)
|
|||
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false); |
|||
|
|||
// Recall the remembered screen.
|
|||
static void PopToOldScreen(); |
|||
|
|||
// Make the display show the screen and update all VPs in it.
|
|||
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false); |
|||
|
|||
static void UpdateScreenVPData(); |
|||
|
|||
// Helpers to convert and transfer data to the display.
|
|||
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var); |
|||
|
|||
#if ENABLED(PRINTCOUNTER) |
|||
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var); |
|||
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
#if HAS_FAN |
|||
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var); |
|||
#if ENABLED(DGUS_UI_WAITING) |
|||
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var); |
|||
#endif |
|||
|
|||
// Send a value from 0..100 to a variable with a range from 0..255
|
|||
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr); |
|||
|
|||
template<typename T> |
|||
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) { |
|||
if (!var.memadr) return; |
|||
union { unsigned char tmp[sizeof(T)]; T t; } x; |
|||
unsigned char *ptr = (unsigned char*)val_ptr; |
|||
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1]; |
|||
*(T*)var.memadr = x.t; |
|||
} |
|||
|
|||
// Send a float value to the display.
|
|||
// Display will get a 4-byte integer scaled to the number of digits:
|
|||
// Tell the display the number of digits and it cheats by displaying a dot between...
|
|||
template<unsigned int decimals> |
|||
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) { |
|||
if (var.memadr) { |
|||
float f = *(float *)var.memadr; |
|||
f *= cpow(10, decimals); |
|||
dgusdisplay.WriteVariable(var.VP, (long)f); |
|||
} |
|||
} |
|||
|
|||
// Send a float value to the display.
|
|||
// Display will get a 2-byte integer scaled to the number of digits:
|
|||
// Tell the display the number of digits and it cheats by displaying a dot between...
|
|||
template<unsigned int decimals> |
|||
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) { |
|||
if (var.memadr) { |
|||
float f = *(float *)var.memadr; |
|||
DEBUG_ECHOLNPAIR_F(" >> ", f, 6); |
|||
f *= cpow(10, decimals); |
|||
dgusdisplay.WriteVariable(var.VP, (int16_t)f); |
|||
} |
|||
} |
|||
|
|||
// Force an update of all VP on the current screen.
|
|||
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; } |
|||
// Has all VPs sent to the screen
|
|||
static inline bool IsScreenComplete() { return ScreenComplete; } |
|||
|
|||
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; } |
|||
|
|||
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; } |
|||
|
|||
private: |
|||
static DGUSLCD_Screens current_screen; //< currently on screen
|
|||
static constexpr uint8_t NUM_PAST_SCREENS = 4; |
|||
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
|
|||
|
|||
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
|
|||
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
|
|||
static bool ScreenComplete; //< All VPs sent to screen?
|
|||
|
|||
static uint16_t ConfirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
|
|||
|
|||
#if ENABLED(SDSUPPORT) |
|||
static int16_t top_file; //< file on top of file chooser
|
|||
static int16_t file_to_print; //< touched file to be confirmed
|
|||
#endif |
|||
|
|||
static void (*confirm_action_cb)(); |
|||
}; |
|||
|
|||
#if ENABLED(POWER_LOSS_RECOVERY) |
|||
#define PLR_SCREEN_RECOVER DGUSLCD_SCREEN_SDPRINTMANIPULATION |
|||
#define PLR_SCREEN_CANCEL DGUSLCD_SCREEN_STATUS |
|||
#endif |
|||
Loading…
Reference in new issue