diff --git a/CR-6-touchscreen-extui.7z b/CR-6-touchscreen-extui.7z new file mode 100644 index 0000000000..cf07c296af Binary files /dev/null and b/CR-6-touchscreen-extui.7z differ diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index a4d8099080..4750b49e85 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -991,7 +991,7 @@ #define XY_PROBE_SPEED (133*60) // Feedrate (mm/min) for the first approach when double-probing (MULTIPLE_PROBING == 2) -#define Z_PROBE_SPEED_FAST (HOMING_FEEDRATE_Z / 2) +#define Z_PROBE_SPEED_FAST ((4 * 60) / 2) // Feedrate (mm/min) for the "accurate" probe of each point #define Z_PROBE_SPEED_SLOW (Z_PROBE_SPEED_FAST / 2) @@ -1004,21 +1004,6 @@ //#define PROBE_ENABLE_PIN PC6 // Override default pin #endif -// Probe should be tared prior to each probe -// Useful for strain or piezo sensors which must exclude strain such -// as that from cables or bowden cables pulling on the carriage. -#define PROBE_TARE -#if ENABLED(PROBE_TARE) - #define PROBE_TARE_TIME 200 // Time to hold tare pin (milliseconds) - #define PROBE_TARE_DELAY 200 // Delay after tare before (milliseconds) - #define PROBE_TARE_STATE LOW // State to write pin for tare - //#define PROBE_TARE_PIN PA5 // Override default pin - #if ENABLED(PROBE_ACTIVE_INPUT) - // Fail to tare/probe if PROBE_ACTIVE_INPUT reports the probe to be active - //#define PROBE_TARE_ONLY_WHILE_INACTIVE - #endif -#endif - /** * Probe Activation Switch @@ -1031,19 +1016,18 @@ //#define PROBE_ACTIVATION_SWITCH_PIN PC6 // Override default pin #endif -/** - * Tare Probe (determine zero-point) prior to each probe. - * Useful for a strain gauge or piezo sensor that needs to factor out - * elements such as cables pulling on the carriage. - */ -//#define PROBE_TARE +// Probe should be tared prior to each probe +// Useful for strain or piezo sensors which must exclude strain such +// as that from cables or bowden cables pulling on the carriage. +#define PROBE_TARE #if ENABLED(PROBE_TARE) - #define PROBE_TARE_TIME 200 // (ms) Time to hold tare pin - #define PROBE_TARE_DELAY 200 // (ms) Delay after tare before + #define PROBE_TARE_TIME 200 // Time to hold tare pin (milliseconds) + #define PROBE_TARE_DELAY 200 // Delay after tare before (milliseconds) #define PROBE_TARE_STATE HIGH // State to write pin for tare //#define PROBE_TARE_PIN PA5 // Override default pin - #if ENABLED(PROBE_ACTIVATION_SWITCH) - //#define PROBE_TARE_ONLY_WHILE_INACTIVE // Fail to tare/probe if PROBE_ACTIVATION_SWITCH is active + #if ENABLED(PROBE_ACTIVE_INPUT) + // Fail to tare/probe if PROBE_ACTIVE_INPUT reports the probe to be active + //#define PROBE_TARE_ONLY_WHILE_INACTIVE #endif #endif @@ -1421,7 +1405,6 @@ #define LEVEL_CORNERS_HEIGHT 0.0 // (mm) Z height of nozzle at leveling points #define LEVEL_CORNERS_Z_HOP 4.0 // (mm) Z height of nozzle between leveling points //#define LEVEL_CENTER_TOO // Move to the center after the last corner - #endif /** * Corner Leveling Order diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h index a62649315d..f4c23b7eac 100644 --- a/Marlin/Configuration_adv.h +++ b/Marlin/Configuration_adv.h @@ -2050,7 +2050,7 @@ */ #define FWRETRACT #if ENABLED(FWRETRACT) - //#define FWRETRACT_AUTORETRACT // Override slicer retractions + #define FWRETRACT_AUTORETRACT // Override slicer retractions #if ENABLED(FWRETRACT_AUTORETRACT) #define MIN_AUTORETRACT 0.1 // (mm) Don't convert E moves under this length #define MAX_AUTORETRACT 10.0 // (mm) Don't convert E moves over this length @@ -2169,7 +2169,7 @@ // For direct drive, the full length of the nozzle. //#define ADVANCED_PAUSE_CONTINUOUS_PURGE // Purge continuously up to the purge length until interrupted. #define ADVANCED_PAUSE_PURGE_FEEDRATE 3 // (mm/s) Extrude feedrate (after loading). Should be slower than load feedrate. - #define ADVANCED_PAUSE_PURGE_LENGTH 50 // (mm) Length to extrude after loading. + #define ADVANCED_PAUSE_PURGE_LENGTH 0 // (mm) Length to extrude after loading. // Set to 0 for manual extrusion. // Filament can be extruded repeatedly from the Filament Change menu // until extrusion is consistent, and to purge old filament. diff --git a/Marlin/src/HAL/STM32F1/HAL.h b/Marlin/src/HAL/STM32F1/HAL.h index ecfc172953..26f321bfed 100644 --- a/Marlin/src/HAL/STM32F1/HAL.h +++ b/Marlin/src/HAL/STM32F1/HAL.h @@ -121,7 +121,7 @@ #else #error "LCD_SERIAL_PORT must be -1 or from 1 to 3. Please update your configuration." #endif - #if HAS_DGUS_LCD + #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite() #endif #endif diff --git a/Marlin/src/lcd/extui/dgus_creality_lcd.cpp b/Marlin/src/lcd/extui/dgus_creality_lcd.cpp index c9f8c36434..ea274d6a3f 100644 --- a/Marlin/src/lcd/extui/dgus_creality_lcd.cpp +++ b/Marlin/src/lcd/extui/dgus_creality_lcd.cpp @@ -31,16 +31,22 @@ #if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) #include "ui_api.h" +#include "../marlinui.h" #include "lib/dgus_creality/DGUSDisplay.h" #include "lib/dgus_creality/DGUSDisplayDef.h" #include "lib/dgus_creality/DGUSScreenHandler.h" +#include "lib/dgus_creality/creality_touch/PIDHandler.h" + +#if ENABLED(POWER_LOSS_RECOVERY) + #include "../../feature/powerloss.h" +#endif extern const char NUL_STR[]; namespace ExtUI { void onStartup() { - dgusdisplay.InitDisplay(); + ScreenHandler.Init(); ScreenHandler.UpdateScreenVPData(); } @@ -58,15 +64,21 @@ namespace ExtUI { } else { ScreenHandler.GotoScreen(DGUSLCD_SCREEN_KILL); } - + + ScreenHandler.KillScreenCalled(); while (!ScreenHandler.loop()); // Wait while anything is left to be sent - } +} void onMediaInserted() { TERN_(SDSUPPORT, ScreenHandler.SDCardInserted()); } void onMediaError() { TERN_(SDSUPPORT, ScreenHandler.SDCardError()); } void onMediaRemoved() { TERN_(SDSUPPORT, ScreenHandler.SDCardRemoved()); } void onPlayTone(const uint16_t frequency, const uint16_t duration) { + if (ScreenHandler.getCurrentScreen() == DGUSLCD_SCREEN_FEED) { + // We're in the feed (load filament) workflow - no beep - there is no confirmation + return; + } + ScreenHandler.Buzzer(frequency, duration); } @@ -75,9 +87,14 @@ bool hasPrintTimer = false; void onPrintTimerStarted() { hasPrintTimer = true; - if (!ExtUI::isPrintingFromMedia()) { + if (!ExtUI::isPrintingFromMedia() && !(PrintJobRecovery::valid() && PrintJobRecovery::exists())) { ScreenHandler.SetPrintingFromHost(); + } + +#if ENABLED(LCD_SET_PROGRESS_MANUALLY) + ui.progress_reset(); +#endif ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING); } @@ -96,7 +113,10 @@ bool hasPrintTimer = false; } void onFilamentRunout(const extruder_t extruder) { - ScreenHandler.FilamentRunout(); + // Only navigate to filament runout screen when we don't use M600 for changing the filament - otherwise it gets confusing for the user + if (strcmp_P(FILAMENT_RUNOUT_SCRIPT, PSTR("M600")) != 0) { + ScreenHandler.FilamentRunout(); + } } void onUserConfirmed() { @@ -109,23 +129,27 @@ bool hasPrintTimer = false; if (msg) { DEBUG_ECHOLNPAIR("User confirmation requested: ", msg); + if (ScreenHandler.getCurrentScreen() == DGUSLCD_SCREEN_FEED) { + // We're in the feed (load filament) workflow - immediately assume confirmed + onUserConfirmed(); + return; + } + ScreenHandler.setstatusmessagePGM(msg); ScreenHandler.sendinfoscreen(PSTR("Confirmation required"), msg, NUL_STR, PSTR("Ok"), true, true, false, true); - //if (hasPrintTimer) { - // ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_PAUSED); - //} else { + if (ExtUI::isPrinting()) { + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_DIALOG_PAUSE); + } else { ScreenHandler.GotoScreen(DGUSLCD_SCREEN_POPUP); - // } + } } - //else if (ScreenHandler.getCurrentScreen() == DGUSLCD_SCREEN_POPUP) { - // DEBUG_ECHOLNPAIR("User confirmation canceled"); + else if (ScreenHandler.getCurrentScreen() == DGUSLCD_SCREEN_POPUP) { + DEBUG_ECHOLNPAIR("User confirmation canceled"); - // ScreenHandler.setstatusmessagePGM(nullptr); - // ScreenHandler.PopToOldScreen(); - // } - - //while (!ScreenHandler.loop()); // Wait while anything is left to be sent + ScreenHandler.setstatusmessagePGM(nullptr); + ScreenHandler.PopToOldScreen(); + } } void onStatusChanged(const char * const msg) { ScreenHandler.setstatusmessage(msg); } @@ -145,25 +169,13 @@ bool hasPrintTimer = false; void onPrintFinished() { ScreenHandler.OnPrintFinished(); } - + void onStoreSettings(char *buff) { - // Called when saving to EEPROM (i.e. M500). If the ExtUI needs - // permanent data to be stored, it can write up to eeprom_data_size bytes - // into buff. - - // Example: - // static_assert(sizeof(myDataStruct) <= ExtUI::eeprom_data_size); - // memcpy(buff, &myDataStruct, sizeof(myDataStruct)); + ScreenHandler.StoreSettings(buff); } void onLoadSettings(const char *buff) { - // Called while loading settings from EEPROM. If the ExtUI - // needs to retrieve data, it should copy up to eeprom_data_size bytes - // from buff - - // Example: - // static_assert(sizeof(myDataStruct) <= ExtUI::eeprom_data_size); - // memcpy(&myDataStruct, buff, sizeof(myDataStruct)); + ScreenHandler.LoadSettings(buff); } void onConfigurationStoreWritten(bool success) { @@ -200,38 +212,39 @@ bool hasPrintTimer = false; #if ENABLED(POWER_LOSS_RECOVERY) void onPowerLossResume() { // Called on resume from power-loss - ScreenHandler.GotoScreen(DGUSLCD_SCREEN_POWER_LOSS); + ScreenHandler.OnPowerlossResume(); } #endif #if HAS_PID_HEATING void onPidTuning(const result_t rst) { - //Called for temperature PID tuning result - switch (rst) { - case PID_BAD_EXTRUDER_NUM: - ScreenHandler.setstatusmessagePGM(GET_TEXT(MSG_PID_BAD_EXTRUDER_NUM)); - break; - case PID_TEMP_TOO_HIGH: - ScreenHandler.setstatusmessagePGM(GET_TEXT(MSG_PID_TEMP_TOO_HIGH)); - break; - case PID_TUNING_TIMEOUT: - ScreenHandler.setstatusmessagePGM(GET_TEXT(MSG_PID_TIMEOUT)); - break; - case PID_DONE: - ScreenHandler.setstatusmessagePGM(GET_TEXT(MSG_PID_AUTOTUNE_DONE)); - break; - } - ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN); + // Called for temperature PID tuning result + switch (rst) { + case PID_BAD_EXTRUDER_NUM: + PIDHandler::result_message = GET_TEXT(MSG_PID_BAD_EXTRUDER_NUM); + ScreenHandler.setstatusmessagePGM(PIDHandler::result_message); + break; + case PID_TEMP_TOO_HIGH: + PIDHandler::result_message = GET_TEXT(MSG_PID_TEMP_TOO_HIGH); + ScreenHandler.setstatusmessagePGM(PIDHandler::result_message); + break; + case PID_TUNING_TIMEOUT: + PIDHandler::result_message = GET_TEXT(MSG_PID_TIMEOUT); + ScreenHandler.setstatusmessagePGM(PIDHandler::result_message); + break; + case PID_DONE: + PIDHandler::result_message = GET_TEXT(MSG_PID_AUTOTUNE_DONE); + ScreenHandler.setstatusmessagePGM(PIDHandler::result_message); + break; + } } #endif void onSteppersDisabled() { - ScreenHandler.HandleStepperState(false); } void onSteppersEnabled() { - ScreenHandler.HandleStepperState(true); } } diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/DGUSDisplay.cpp b/Marlin/src/lcd/extui/lib/dgus_creality/DGUSDisplay.cpp index 91830892e0..9946696644 100644 --- a/Marlin/src/lcd/extui/lib/dgus_creality/DGUSDisplay.cpp +++ b/Marlin/src/lcd/extui/lib/dgus_creality/DGUSDisplay.cpp @@ -156,6 +156,22 @@ void DGUSDisplay::WriteVariablePGM(uint16_t adr, const void* values, uint8_t val } } +void DGUSDisplay::SetVariableDisplayColor(uint16_t sp, uint16_t color) { + WriteVariable(sp + 0x03, color); +} + +void DGUSDisplay::SetVariableAppendText(uint16_t sp, PGM_P appendText) { + // High byte is length, low byte is first char + if (!appendText) { + WriteVariable(sp + 0x07, static_cast(0)); + return; + } + + uint8_t lengthFirstChar = strlen_P(appendText);// << 8; + WriteVariable(sp + 0x07, lengthFirstChar); + WriteVariablePGM(sp + 0x08, appendText, strlen_P(appendText)); +} + void DGUSDisplay::ProcessRx() { #if ENABLED(DGUS_SERIAL_STATS_RX_BUFFER_OVERRUNS) @@ -230,22 +246,11 @@ void DGUSDisplay::ProcessRx() { if (vp == 0x14 /*PIC_Now*/) { const uint16_t screen_id = tmp[3] << 8 | tmp[4]; - // In the code below DGUSLCD_SCREEN_BOOT acts as a sentinel - if (screen_id == 255) { - // DGUS OS sometimes randomly sends 255 back as an answer. Possible buffer overrun? - ReadCurrentScreen(); // Request again - } else if (displayRequest != DGUSLCD_SCREEN_BOOT && screen_id != displayRequest) { - // A display was requested. If the screen didn't yet switch to that display, we won't give that value back, otherwise the code gets confused. - // The DWIN display mostly honours the PIC_SET requests from the firmware, so after a while we may want to nudge it to the correct screen - DEBUG_ECHOPAIR(" Got a response on the current screen: ", screen_id); - DEBUG_ECHOLNPAIR(" - however, we've requested screen ", displayRequest); - } else { - displayRequest = DGUSLCD_SCREEN_BOOT; - - if (current_screen_update_callback != nullptr) { - current_screen_update_callback(static_cast(screen_id)); - } - } + // A display was requested. If the screen didn't yet switch to that display, we won't give that value back, otherwise the code gets confused. + // The DWIN display mostly honours the PIC_SET requests from the firmware, so after a while we may want to nudge it to the correct screen + DEBUG_ECHOPAIR(" Got a response on the current screen: ", screen_id); + DEBUG_ECHOLNPAIR(" - however, we've requested screen ", displayRequest); + UNUSED(screen_id); } else { //const uint8_t dlen = tmp[2] << 1; // Convert to Bytes. (Display works with words) //DEBUG_ECHOPAIR(" vp=", vp, " dlen=", dlen); @@ -259,9 +264,6 @@ void DGUSDisplay::ProcessRx() { } else DEBUG_ECHOLNPAIR(" VPVar not found:", vp); - - // Always ask for a screen update so we can send a screen update earlier, this prevents a flash of unstyled screen - ReadCurrentScreen(); } rx_datagram_state = DGUS_IDLE; @@ -306,8 +308,25 @@ void DGUSDisplay::RequestScreen(DGUSLCD_Screens screen) { WriteVariable(0x84, gotoscreen, sizeof(gotoscreen)); } -void DGUSDisplay::ReadCurrentScreen() { - ReadVariable(0x14 /*PIC_NOW*/); +void DGUSDisplay::SetTouchScreenConfiguration(bool enable_standby, bool enable_sound, uint8_t standby_brightness) { + // Main configuration (System_Config) + unsigned char cfg_bits = 0x0; + cfg_bits |= 1UL << 5; // 5: load 22 touch file + cfg_bits |= 1UL << 4; // 4: auto-upload should always be enabled + if (enable_sound) cfg_bits |= 1UL << 3; // 3: audio + if (enable_standby) cfg_bits |= 1UL << 2; // 2: backlight on standby + cfg_bits |= 1UL << 1; // 1 & 0: 270 degrees orientation of display + cfg_bits |= 1UL << 0; + + DEBUG_ECHOLNPAIR("Update touch screen config - standby ", enable_standby); + DEBUG_ECHOLNPAIR("Update touch screen config - sound ", enable_sound); + + const unsigned char config_set[] = { 0x5A, 0x00, (unsigned char) (cfg_bits >> 8U), (unsigned char) (cfg_bits & 0xFFU) }; + WriteVariable(0x80 /*System_Config*/, config_set, sizeof(config_set)); + + // Standby brightness (LED_Config) + const unsigned char brightness_set[] = { 100 /*% active*/, standby_brightness /*% standby*/ }; + WriteVariable(0x82 /*LED_Config*/, brightness_set, sizeof(brightness_set)); } rx_datagram_state_t DGUSDisplay::rx_datagram_state = DGUS_IDLE; diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/DGUSDisplay.h b/Marlin/src/lcd/extui/lib/dgus_creality/DGUSDisplay.h index 4b14ccd020..6bb449676c 100644 --- a/Marlin/src/lcd/extui/lib/dgus_creality/DGUSDisplay.h +++ b/Marlin/src/lcd/extui/lib/dgus_creality/DGUSDisplay.h @@ -68,6 +68,9 @@ public: static void WriteVariable(uint16_t adr, int8_t value); static void WriteVariable(uint16_t adr, long value); + static void SetVariableDisplayColor(uint16_t sp, uint16_t color); + static void SetVariableAppendText(uint16_t sp, PGM_P appendText); + static void ReadVariable(uint16_t adr); // Utility functions for bridging ui_api and dgus @@ -82,16 +85,12 @@ public: Setter(newvalue, selector); } - // Until now I did not need to actively read from the display. That's why there is no ReadVariable - // (I extensively use the auto upload of the display) - // Force display into another screen. // (And trigger update of containing VPs) // (to implement a pop up message, which may not be nested) static void RequestScreen(DGUSLCD_Screens screen); - // Request the current displayed screen - will be passed to current_screen_update_callback - static void ReadCurrentScreen(); + static void SetTouchScreenConfiguration(bool enable_standby, bool enable_sound, uint8_t standby_brightness); // Periodic tasks, eg. Rx-Queue handling. static void loop(); @@ -104,8 +103,6 @@ public: // (both boils down that the display answered to our chatting) static inline bool isInitialized() { return Initialized; } - static UPDATE_CURRENT_SCREEN_CALLBACK current_screen_update_callback; - private: static void WriteHeader(uint16_t adr, uint8_t cmd, uint8_t payloadlen); static void WritePGM(const char str[], uint8_t len); diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/DGUSScreenHandler.cpp b/Marlin/src/lcd/extui/lib/dgus_creality/DGUSScreenHandler.cpp index 3504ed47be..b9c0f6d57e 100644 --- a/Marlin/src/lcd/extui/lib/dgus_creality/DGUSScreenHandler.cpp +++ b/Marlin/src/lcd/extui/lib/dgus_creality/DGUSScreenHandler.cpp @@ -61,20 +61,17 @@ uint16_t DGUSScreenHandler::ConfirmVP; static ExtUI::FileList filelist; #endif +// Storage initialization +creality_dwin_settings_t DGUSScreenHandler::Settings = {.settings_size = sizeof(creality_dwin_settings_t)}; DGUSLCD_Screens DGUSScreenHandler::current_screen; DGUSLCD_Screens DGUSScreenHandler::past_screens[NUM_PAST_SCREENS] = {DGUSLCD_SCREEN_MAIN}; uint8_t DGUSScreenHandler::update_ptr; uint16_t DGUSScreenHandler::skipVP; bool DGUSScreenHandler::ScreenComplete; +bool DGUSScreenHandler::SaveSettingsRequested; uint8_t DGUSScreenHandler::MeshLevelIndex = -1; -bool DGUSScreenHandler::are_steppers_enabled = true; -float DGUSScreenHandler::feed_amount = true; - -//DGUSDisplay dgusdisplay; -UPDATE_CURRENT_SCREEN_CALLBACK DGUSDisplay::current_screen_update_callback = &DGUSScreenHandler::updateCurrentScreen; - -// endianness swap -uint16_t swap16(const uint16_t value) { return (value & 0xffU) << 8U | (value >> 8U); } +float DGUSScreenHandler::feed_amount = 100; +bool DGUSScreenHandler::fwretract_available = TERN(FWRETRACT, true, false); void DGUSScreenHandler::sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool l4inflash) { DGUS_VP_Variable ramcopy; @@ -96,6 +93,87 @@ void DGUSScreenHandler::sendinfoscreen(const char* line1, const char* line2, con } } + +void DGUSScreenHandler::Init() { + dgusdisplay.InitDisplay(); +} + +void DGUSScreenHandler::RequestSaveSettings() { + SaveSettingsRequested = true; +} + +void DGUSScreenHandler::DefaultSettings() { + Settings.settings_size = sizeof(creality_dwin_settings_t); + + Settings.led_state = false; + + Settings.display_standby = true; + Settings.display_sound = true; + + Settings.standby_screen_brightness = 10; +} + +void DGUSScreenHandler::LoadSettings(const char* buff) { + static_assert( + ExtUI::eeprom_data_size >= sizeof(creality_dwin_settings_t), + "Insufficient space in EEPROM for UI parameters" + ); + + creality_dwin_settings_t eepromSettings; + memcpy(&eepromSettings, buff, sizeof(creality_dwin_settings_t)); + + // If size is not the same, discard settings + if (eepromSettings.settings_size != sizeof(creality_dwin_settings_t)) { + SERIAL_ECHOLNPGM("Discarding DWIN LCD setting from EEPROM - size incorrect"); + + ScreenHandler.DefaultSettings(); + return; + } else { + // Copy into final location + SERIAL_ECHOLNPGM("Loading DWIN LCD setting from EEPROM"); + memcpy(&Settings, &eepromSettings, sizeof(creality_dwin_settings_t)); + } + + // Apply settings + caselight.on = Settings.led_state; + caselight.update(Settings.led_state); + + ScreenHandler.SetTouchScreenConfiguration(); +} + +void DGUSScreenHandler::StoreSettings(char* buff) { + static_assert( + ExtUI::eeprom_data_size >= sizeof(creality_dwin_settings_t), + "Insufficient space in EEPROM for UI parameters" + ); + + // Update settings from Marlin state, if necessary + Settings.led_state = caselight.on; + + // Write to buffer + SERIAL_ECHOLNPGM("Saving DWIN LCD setting from EEPROM"); + memcpy(buff, &Settings, sizeof(creality_dwin_settings_t)); +} + +void DGUSScreenHandler::SetTouchScreenConfiguration() { + dgusdisplay.SetTouchScreenConfiguration(Settings.display_standby, Settings.display_sound, Settings.standby_screen_brightness); +} + +void DGUSScreenHandler::KillScreenCalled() { + // If killed, always fully wake up + dgusdisplay.SetTouchScreenConfiguration(false, true, 100); + + // Hey! Something is going on! + Buzzer(1000 /*ignored*/, 880); +} + +void DGUSScreenHandler::OnPowerlossResume() { + GotoScreen(DGUSLCD_SCREEN_POWER_LOSS); + + // Send print filename + dgusdisplay.WriteVariable(VP_SD_Print_Filename, PrintJobRecovery::info.sd_filename, VP_SD_FileName_LEN, true); +} + void DGUSScreenHandler::HandleUserConfirmationPopUp(uint16_t VP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1, bool l2, bool l3, bool l4) { if (current_screen == DGUSLCD_SCREEN_CONFIRM) { // Already showing a pop up, so we need to cancel that first. @@ -163,17 +241,21 @@ void DGUSScreenHandler::DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var) { dgusdisplay.WriteVariable(VP_PrintTime, buf, var.size, true); } +void DGUSScreenHandler::DGUSLCD_SendAboutFirmwareWebsite(DGUS_VP_Variable &var) { + const char* websiteUrl = PSTR(WEBSITE_URL); + + dgusdisplay.WriteVariablePGM(var.VP, websiteUrl, strlen(websiteUrl), true); +} + void DGUSScreenHandler::DGUSLCD_SendAboutFirmwareVersion(DGUS_VP_Variable &var) { - const char* fwVersion = PSTR(SOFTVERSION); - const char* fwWebsite = PSTR(WEBSITE_URL); + const char* fwVersion = PSTR(SHORT_BUILD_VERSION); dgusdisplay.WriteVariablePGM(var.VP, fwVersion, strlen(fwVersion), true); - dgusdisplay.WriteVariablePGM(VP_MARLIN_WEBSITE, fwWebsite, strlen(fwWebsite), true); } void DGUSScreenHandler::DGUSLCD_SendAboutPrintSize(DGUS_VP_Variable &var) { char PRINTSIZE[VP_PRINTER_BEDSIZE_LEN] = {0}; - sprintf(PRINTSIZE,"%dx%dx%d",MAC_LENGTH, MAC_WIDTH, MAC_HEIGHT); + sprintf(PRINTSIZE,"%dx%dx%d", X_BED_SIZE, Y_BED_SIZE, Z_MAX_POS); dgusdisplay.WriteVariablePGM(var.VP, &PRINTSIZE, sizeof(PRINTSIZE), true); } @@ -243,6 +325,13 @@ void DGUSScreenHandler::DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var) { dgusdisplay.WriteVariable(var.VP, data_to_send); } } + + void DGUSScreenHandler::DGUSLCD_SendFanSpeedToDisplay(DGUS_VP_Variable &var) { + if (var.memadr) { + int16_t data_to_send = static_cast(round(ExtUI::getTargetFan_percent(ExtUI::fan_t::FAN0))); + dgusdisplay.WriteVariable(var.VP, data_to_send); + } + } #endif // Send heater status value to the display. @@ -351,7 +440,7 @@ void DGUSScreenHandler::DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var) // Setup Confirmation screen file_to_print = touched_nr; - HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), PSTR("?"), true, false, true, true); + HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), nullptr, true, false, true, true); } void DGUSScreenHandler::SetPrintingFromHost() { @@ -423,7 +512,7 @@ void DGUSScreenHandler::DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var) void DGUSScreenHandler::SDCardError() { DGUSScreenHandler::SDCardRemoved(); - ScreenHandler.sendinfoscreen(PSTR("NOTICE"), nullptr, PSTR("SD card error"), PSTR("Ok"), true, true, true, true); + ScreenHandler.sendinfoscreen(PSTR("NOTICE"), nullptr, PSTR("SD card error"), nullptr, true, true, true, true); ScreenHandler.GotoScreen(DGUSLCD_SCREEN_POPUP); } @@ -434,6 +523,7 @@ void DGUSScreenHandler::FilamentRunout() { } void DGUSScreenHandler::OnFactoryReset() { + ScreenHandler.DefaultSettings(); ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN); } @@ -455,6 +545,9 @@ bool DGUSScreenHandler::HandlePendingUserConfirmation() { return false; } + // Switch to the resume screen + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING); + // We might be re-entrant here ExtUI::setUserConfirmed(); @@ -633,21 +726,22 @@ void DGUSScreenHandler::HandleTemperatureChanged(DGUS_VP_Variable &var, void *va ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel } +void DGUSScreenHandler::HandleFanSpeedChanged(DGUS_VP_Variable &var, void *val_ptr) { + uint16_t newValue = swap16(*(uint16_t*)val_ptr); + + SERIAL_ECHOLNPAIR("Fan speed changed: ", newValue); + ExtUI::setTargetFan_percent(newValue, ExtUI::fan_t::FAN0); + + ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel +} + void DGUSScreenHandler::HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr) { #if EXTRUDERS - uint16_t newvalue = swap16(*(uint16_t*)val_ptr); - uint8_t target_extruder; - switch (var.VP) { - default: return; - #if HOTENDS >= 1 - case VP_Flowrate_E0: target_extruder = 0; break; - #endif - #if HOTENDS >= 2 - case VP_Flowrate_E1: target_extruder = 1; break; - #endif - } + uint16_t newValue = swap16(*(uint16_t*)val_ptr); + + SERIAL_ECHOLNPAIR("Flow rate changed: ", newValue); + ExtUI::setFlow_percent(newValue, ExtUI::E0); - planner.set_flow(target_extruder, newvalue); ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel #else UNUSED(var); UNUSED(val_ptr); @@ -842,7 +936,7 @@ void DGUSScreenHandler::HandleFeedAmountChanged(DGUS_VP_Variable &var, void *val void DGUSScreenHandler::HandlePositionChange(DGUS_VP_Variable &var, void *val_ptr) { DEBUG_ECHOLNPGM("HandlePositionChange"); - unsigned int speed = HOMING_FEEDRATE_XY; + unsigned int speed = homing_feedrate_mm_m.x; float target_position = ((float)swap16(*(uint16_t*)val_ptr)) / 10.0; switch (var.VP) { @@ -850,18 +944,18 @@ void DGUSScreenHandler::HandlePositionChange(DGUS_VP_Variable &var, void *val_pt case VP_X_POSITION: if (!ExtUI::canMove(ExtUI::axis_t::X)) return; - current_position.x = target_position; + current_position.x = min(target_position, static_cast(X_MAX_POS)); break; case VP_Y_POSITION: if (!ExtUI::canMove(ExtUI::axis_t::Y)) return; - current_position.y = target_position; + current_position.y = min(target_position, static_cast(Y_MAX_POS)); break; case VP_Z_POSITION: if (!ExtUI::canMove(ExtUI::axis_t::Z)) return; - speed = HOMING_FEEDRATE_Z; - current_position.z = target_position; + speed = homing_feedrate_mm_m.z; + current_position.z = min(target_position, static_cast(Z_MAX_POS)); break; } @@ -871,34 +965,34 @@ void DGUSScreenHandler::HandlePositionChange(DGUS_VP_Variable &var, void *val_pt DEBUG_ECHOLNPGM("poschg done."); } -#if ENABLED(BABYSTEPPING) - void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) { - DEBUG_ECHOLNPGM("HandleLiveAdjustZ"); +void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) { + DEBUG_ECHOLNPGM("HandleLiveAdjustZ"); - float absoluteAmount = float(swap16(*(uint16_t*)val_ptr)) / 100.0f; - float existingAmount = ExtUI::getZOffset_mm(); - float difference = (absoluteAmount - existingAmount) < 0 ? -0.01 : 0.01; + float absoluteAmount = float(swap16(*(uint16_t*)val_ptr)) / 100.0f; + float existingAmount = ExtUI::getZOffset_mm(); + float difference = (absoluteAmount - existingAmount) < 0 ? -0.01 : 0.01; - SERIAL_ECHO("- Absolute: "); - SERIAL_ECHO_F(absoluteAmount); - SERIAL_ECHO("- Existing: "); - SERIAL_ECHO_F(existingAmount); - SERIAL_ECHO(" - Difference: "); - SERIAL_ECHO_F(difference); + SERIAL_ECHO("- Absolute: "); + SERIAL_ECHO_F(absoluteAmount); + SERIAL_ECHO("- Existing: "); + SERIAL_ECHO_F(existingAmount); + SERIAL_ECHO(" - Difference: "); + SERIAL_ECHO_F(difference); - int16_t steps = ExtUI::mmToWholeSteps(difference, ExtUI::axis_t::Z); + int16_t steps = ExtUI::mmToWholeSteps(difference, ExtUI::axis_t::Z); - SERIAL_ECHO(" - Steps: "); - SERIAL_ECHO_F(steps); - SERIAL_ECHOLN(";"); + SERIAL_ECHO(" - Steps: "); + SERIAL_ECHO_F(steps); + SERIAL_ECHOLN(";"); - ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true); + ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true); - ScreenHandler.ForceCompleteUpdate(); - ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel - return; - } -#endif + RequestSaveSettings(); + + ScreenHandler.ForceCompleteUpdate(); + ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel + return; +} void DGUSScreenHandler::HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr) { DEBUG_ECHOLNPGM("HandleHeaterControl"); @@ -1040,19 +1134,42 @@ void DGUSScreenHandler::HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr } #endif -void DGUSScreenHandler::HandleStepperState(bool is_enabled) { - bool steppers_were_enabled = are_steppers_enabled; - are_steppers_enabled = is_enabled; - - if (steppers_were_enabled != are_steppers_enabled) ForceCompleteUpdate(); -} - void DGUSScreenHandler::HandleLEDToggle() { bool newState = !caselight.on; caselight.on = newState; caselight.update(newState); + RequestSaveSettings(); + ForceCompleteUpdate(); +} + +void DGUSScreenHandler::HandleToggleTouchScreenMute(DGUS_VP_Variable &var, void *val_ptr) { + Settings.display_sound = !Settings.display_sound; + ScreenHandler.SetTouchScreenConfiguration(); + + RequestSaveSettings(); + ForceCompleteUpdate(); + + ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel +} + +void DGUSScreenHandler::HandleTouchScreenStandbyBrightnessSetting(DGUS_VP_Variable &var, void *val_ptr) { + uint16_t newvalue = swap16(*(uint16_t*)val_ptr); + + SERIAL_ECHOLNPAIR("HandleTouchScreenStandbyBrightnessSetting: ", newvalue); + Settings.standby_screen_brightness = newvalue; + ScreenHandler.SetTouchScreenConfiguration(); + + RequestSaveSettings(); + ForceCompleteUpdate(); +} + +void DGUSScreenHandler::HandleToggleTouchScreenStandbySetting(DGUS_VP_Variable &var, void *val_ptr) { + Settings.display_standby = !Settings.display_standby; + ScreenHandler.SetTouchScreenConfiguration(); + + RequestSaveSettings(); ForceCompleteUpdate(); } @@ -1066,7 +1183,7 @@ void DGUSScreenHandler::UpdateNewScreen(DGUSLCD_Screens newscreen, bool save_cur DEBUG_ECHOLNPAIR("SetNewScreen: ", newscreen); if (save_current_screen && current_screen != DGUSLCD_SCREEN_POPUP && current_screen != DGUSLCD_SCREEN_CONFIRM) { - DEBUG_ECHOLNPAIR("SetNewScreen: ", newscreen); + DEBUG_ECHOLNPAIR("SetNewScreen (saving): ", newscreen); memmove(&past_screens[1], &past_screens[0], sizeof(past_screens) - 1); past_screens[0] = current_screen; } @@ -1078,25 +1195,22 @@ void DGUSScreenHandler::UpdateNewScreen(DGUSLCD_Screens newscreen, bool save_cur void DGUSScreenHandler::PopToOldScreen() { DEBUG_ECHOLNPAIR("PopToOldScreen s=", past_screens[0]); + if(past_screens[0] != 0) { GotoScreen(past_screens[0], false); memmove(&past_screens[0], &past_screens[1], sizeof(past_screens) - 1); past_screens[sizeof(past_screens) - 1] = DGUSLCD_SCREEN_MAIN; } else { - if(ExtUI::isPrinting()) + if(ExtUI::isPrinting()) { GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING, false); - else + } else { GotoScreen(DGUSLCD_SCREEN_MAIN, false); + } } } -void DGUSScreenHandler::updateCurrentScreen(DGUSLCD_Screens current) { - if (current_screen != current) { - DEBUG_ECHOPAIR("Screen updated at display side: Was ", current_screen); - DEBUG_ECHOLNPAIR(", is now: ", current); - - UpdateNewScreen(current, current != DGUSLCD_SCREEN_POPUP && current != DGUSLCD_SCREEN_CONFIRM); - } +void DGUSScreenHandler::OnBackButton(DGUS_VP_Variable &var, void *val_ptr) { + PopToOldScreen(); } void DGUSScreenHandler::UpdateScreenVPData() { @@ -1153,6 +1267,11 @@ void DGUSScreenHandler::UpdateScreenVPData() { } void DGUSScreenHandler::GotoScreen(DGUSLCD_Screens screen, bool save_current_screen) { + if (current_screen == screen) { + // Ignore this request + return; + } + DEBUG_ECHOLNPAIR("Issuing command to go to screen: ", screen); dgusdisplay.RequestScreen(screen); UpdateNewScreen(screen, save_current_screen); @@ -1171,25 +1290,30 @@ bool DGUSScreenHandler::loop() { GotoScreen(DGUSLCD_SCREEN_PRINT_PAUSED, true); } + if (ELAPSED(ms, next_event_ms) && SaveSettingsRequested) { + // Only save settings so many times in a second - otherwise the EEPROM chip gets overloaded and the watchdog reboots the CPU + settings.save(); + SaveSettingsRequested = false; + } + if (!IsScreenComplete() || ELAPSED(ms, next_event_ms)) { next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS; - UpdateScreenVPData(); - // Read which screen is currently triggered - navigation at display side may occur - if (dgusdisplay.isInitialized()) dgusdisplay.ReadCurrentScreen(); + UpdateScreenVPData(); } if (dgusdisplay.isInitialized()) { static bool booted = false; + if (!booted) { progmem_str message = GET_TEXT_F(WELCOME_MSG); char buff[strlen_P((const char * const)message)+1]; strcpy_P(buff, (const char * const) message); ExtUI::onStatusChanged((const char *)buff); + int16_t percentage = static_cast(((float) ms / (float)BOOTSCREEN_TIMEOUT) * 100); if (percentage > 100) percentage = 100; - dgusdisplay.WriteVariable(VP_STARTPROGRESSBAR, percentage); } @@ -1200,6 +1324,10 @@ bool DGUSScreenHandler::loop() { if (!booted && ELAPSED(ms, BOOTSCREEN_TIMEOUT)) { booted = true; + + // Ensure to pick up the settings + SetTouchScreenConfiguration(); + #if HAS_MESH if (ExtUI::getMeshValid()) { diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/DGUSScreenHandler.h b/Marlin/src/lcd/extui/lib/dgus_creality/DGUSScreenHandler.h index a9bb4b207c..1ae5a09f66 100644 --- a/Marlin/src/lcd/extui/lib/dgus_creality/DGUSScreenHandler.h +++ b/Marlin/src/lcd/extui/lib/dgus_creality/DGUSScreenHandler.h @@ -28,12 +28,34 @@ enum DGUSLCD_Screens : uint8_t; +struct creality_dwin_settings_t { + size_t settings_size; + bool led_state; + bool display_standby; + bool display_sound; + int16_t standby_screen_brightness; +}; + +// endianness swap +inline uint16_t swap16(const uint16_t value) { return (value & 0xffU) << 8U | (value >> 8U); } + class DGUSScreenHandler { public: DGUSScreenHandler() = default; static bool loop(); + static void Init(); + static void DefaultSettings(); + static void LoadSettings(const char* buff); + static void StoreSettings(char* buff); + static void SetTouchScreenConfiguration(); + static void KillScreenCalled(); + + static void OnPowerlossResume(); + + static void RequestSaveSettings(); + /// 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); @@ -52,6 +74,7 @@ public: 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); + static void HandleFanSpeedChanged(DGUS_VP_Variable &var, void *val_ptr); // Hook for "Change Flowrate" static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr); // Hook for manual extrude. @@ -66,12 +89,15 @@ public: 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 HandleFeedAmountChanged(DGUS_VP_Variable &var, void *val_ptr); // Hook for move to position static void HandlePositionChange(DGUS_VP_Variable &var, void *val_ptr); + static void HandleToggleTouchScreenMute(DGUS_VP_Variable &var, void *val_ptr); + static void HandleToggleTouchScreenStandbySetting(DGUS_VP_Variable &var, void *val_ptr); + static void HandleTouchScreenStandbyBrightnessSetting(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); @@ -86,10 +112,10 @@ public: static void OnMeshLevelingUpdate(const int8_t xpos, const int8_t ypos); #endif - #if ENABLED(BABYSTEPPING) - // Hook for live z adjust action - static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr); - #endif + + // Hook for live z adjust action + static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr); + // Hook for heater control static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr); #if ENABLED(DGUS_PREHEAT_UI) @@ -134,8 +160,6 @@ public: static void HandleFanToggle(); - static void HandleStepperState(bool is_enabled); - static void FilamentRunout(); static void OnFactoryReset(); @@ -158,6 +182,7 @@ public: // Recall the remembered screen. static void PopToOldScreen(); + static void OnBackButton(DGUS_VP_Variable &var, void *val_ptr); // Make the display show the screen and update all VPs in it. static void GotoScreen(DGUSLCD_Screens screen, bool save_current_screen = true); @@ -178,12 +203,14 @@ public: #endif #if HAS_FAN static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var); + static void DGUSLCD_SendFanSpeedToDisplay(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 + static void DGUSLCD_SendAboutFirmwareWebsite(DGUS_VP_Variable &var); static void DGUSLCD_SendAboutFirmwareVersion(DGUS_VP_Variable &var); static void DGUSLCD_SendAboutPrintSize(DGUS_VP_Variable &var); @@ -199,6 +226,17 @@ public: *(T*)var.memadr = x.t; } + template + static void DGUSLCD_NavigateToPage(DGUS_VP_Variable &var, void *val_ptr) { + GotoScreen(TPage); + } + + template + static void DGUSLCD_NavigateToPage(DGUS_VP_Variable &var, void *val_ptr) { + GotoScreen(TPage); + Handler::Init(); + } + /// 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... @@ -207,7 +245,10 @@ public: if (var.memadr) { float f = *(float *)var.memadr; f *= cpow(10, decimals); - dgusdisplay.WriteVariable(var.VP, (long)f); + + // Round - truncated values look like skipped numbers + long roundedValue = static_cast(round(f)); + dgusdisplay.WriteVariable(var.VP, roundedValue); } } @@ -217,6 +258,24 @@ public: dgusdisplay.WriteVariable(vp, (long)var); } + // Receive a float from the display - Display will send a 2-byte integer scaled to the number of digits + template + static void DGUSLCD_SetFloatAsIntFromDisplay(DGUS_VP_Variable &var, void *val_ptr) { + if (var.memadr) { + uint16_t value_raw = swap16(*(uint16_t*)val_ptr); + float value = (float)value_raw/10; + *(float *)var.memadr = value; + } + } + + // Toggle a boolean at the specified memory address + static void DGUSLCD_ToggleBoolean(DGUS_VP_Variable &var, void *val_ptr) { + if (var.memadr) { + bool* val = (bool *)var.memadr; + *val = !*val; + } + } + // Send an icon to the display, depending on whether it is true or false template static void DGUSLCD_SendIconValue(DGUS_VP_Variable &var) { @@ -236,7 +295,10 @@ public: float f = *(float *)var.memadr; DEBUG_ECHOLNPAIR_F(" >> ", f, 6); f *= cpow(10, decimals); - dgusdisplay.WriteVariable(var.VP, (int16_t)f); + + // Round - truncated values look like skipped numbers + int16_t roundedValue = static_cast(round(f)); + dgusdisplay.WriteVariable(var.VP, roundedValue); } } @@ -247,6 +309,18 @@ public: dgusdisplay.WriteVariable(vp, (int16_t)var); } + template + static void SendAxisTrustValue(DGUS_VP_Variable &var) { + bool trust = axis_is_trusted(Axis); + + uint16_t color = trust ? 0xFFFF /*White*/ : 0XF800 /*Red*/; + dgusdisplay.SetVariableDisplayColor(var.VP, color); + + //PGM_P suffix = trust ? nullptr : "???"; + //dgusdisplay.SetVariableAppendText(var.VP, suffix); + } + + /// 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 @@ -259,7 +333,7 @@ public: static bool HandlePendingUserConfirmation(); static float feed_amount; - static bool are_steppers_enabled; + static bool fwretract_available; private: static DGUSLCD_Screens current_screen; ///< currently on screen @@ -273,11 +347,15 @@ private: static uint16_t ConfirmVP; ///< context for confirm screen (VP that will be emulated-sent on "OK"). static uint8_t MeshLevelIndex; + static bool SaveSettingsRequested; #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 + +public: // Needed for VP auto-upload + static creality_dwin_settings_t Settings; }; extern DGUSScreenHandler ScreenHandler; diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/DGUSDisplayDef.cpp b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/DGUSDisplayDef.cpp index a47dd29330..3387c33001 100644 --- a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/DGUSDisplayDef.cpp +++ b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/DGUSDisplayDef.cpp @@ -29,6 +29,8 @@ #include "../DGUSDisplayDef.h" #include "../DGUSDisplay.h" #include "../DGUSScreenHandler.h" +#include "../creality_touch/EstepsHandler.h" +#include "../creality_touch/PIDHandler.h" #include "../../../../../module/temperature.h" #include "../../../../../module/motion.h" @@ -36,8 +38,12 @@ #include "../../../../../feature/caselight.h" -#include "../../../../marlinui.h" +#if ENABLED(FWRETRACT) + #include "../../../../../feature/fwretract.h" +#endif + #include "../../../ui_api.h" +#include "../../../../marlinui.h" #include "PageHandlers.h" @@ -113,6 +119,9 @@ const uint16_t VPList_Control[] PROGMEM = { #endif VP_LED_TOGGLE, + VP_MUTE_ICON, + VP_STANDBY_BACKLIGHT_ICON, + VP_SCREEN_BACKLIGHT_STANDBY, 0x0000 }; @@ -128,6 +137,7 @@ const uint16_t VPList_Feed[] PROGMEM = { //VP_Fan0_Percentage, VP_Feedrate_Percentage, + VP_FEED_AMOUNT, 0x0000 }; @@ -194,8 +204,12 @@ const uint16_t VPList_PrintPausingError[] PROGMEM = { #if HAS_HEATED_BED VP_T_Bed_Is, VP_T_Bed_Set,// VP_BED_STATUS, #endif + + VP_X_POSITION, + VP_Y_POSITION, + VP_Z_POSITION, VP_Z_OFFSET, - //VP_Fan0_Percentage, + VP_Fan0_Percentage, VP_Feedrate_Percentage, VP_PrintProgress_Percentage, @@ -216,14 +230,19 @@ const uint16_t VPList_PrintScreen[] PROGMEM = { #endif VP_X_POSITION, VP_Y_POSITION, VP_Z_POSITION, + SP_X_POSITION, SP_Y_POSITION, SP_Z_POSITION, + VP_Z_OFFSET, - //VP_Fan0_Percentage, + VP_Flowrate_E0, + VP_Fan0_Percentage, VP_Feedrate_Percentage, VP_PrintProgress_Percentage, VP_PrintTimeProgressBar, VP_PrintTime, + VP_FWRETRACT_INDICATOR_ICON, + 0x0000 }; @@ -260,6 +279,8 @@ const uint16_t VPList_ZOffsetLevel[] PROGMEM = { const uint16_t VPList_TuneScreen[] PROGMEM = { VP_PrintTime, + VP_Flowrate_E0, + #if HOTENDS >= 1 VP_T_E0_Is, VP_T_E0_Set,// VP_E0_STATUS, #endif @@ -272,7 +293,8 @@ const uint16_t VPList_TuneScreen[] PROGMEM = { VP_LED_TOGGLE, VP_FAN_TOGGLE, - + VP_Fan0_Percentage, + VP_FWRETRACT_NAV_BUTTON_ICON, 0x0000 }; @@ -290,8 +312,6 @@ const uint16_t VPList_Prepare[] PROGMEM = { //VP_Fan0_Percentage, VP_Feedrate_Percentage, - VP_STEPPERS, - 0x0000 }; @@ -309,11 +329,65 @@ const uint16_t VPList_Info[] PROGMEM = { VP_Feedrate_Percentage, VP_PRINTER_BEDSIZE, + VP_MARLIN_WEBSITE, VP_MARLIN_VERSION, 0x0000 }; +const uint16_t VPList_EstepsCalibration[] PROGMEM = { + VP_ESTEPS_CURRENT, + VP_ESTEPS_CALIBRATION_TEMP, + VP_ESTEPS_CALIBRATION_LENGTH, + VP_ESTEPS_CALIBRATION_LEFTOVER_LENGTH, + VP_ESTEPS_CALIBRATION_MARK_LENGTH, + VP_ESTEPS_CALCULATED_ESTEPS, + + #if HOTENDS >= 1 + VP_T_E0_Is, VP_T_E0_Set,// VP_E0_STATUS, + #endif + #if HAS_HEATED_BED + VP_T_Bed_Is, VP_T_Bed_Set,// VP_BED_STATUS, + #endif + + 0x0000 +}; + +const uint16_t VPList_PidTune[] PROGMEM = { + VP_PIDTUNE_TARGET_TEMP, + VP_PIDTUNE_CYCLES, + + #if HOTENDS >= 1 + VP_T_E0_Is, VP_T_E0_Set,// VP_E0_STATUS, + #endif + #if HAS_HEATED_BED + VP_T_Bed_Is, VP_T_Bed_Set,// VP_BED_STATUS, + #endif + + 0x0000 +}; + +const uint16_t VPList_FWRetractTune[] PROGMEM = { + #if HOTENDS >= 1 + VP_T_E0_Is, VP_T_E0_Set,// VP_E0_STATUS, + #endif + #if HAS_HEATED_BED + VP_T_Bed_Is, VP_T_Bed_Set,// VP_BED_STATUS, + #endif + VP_Z_OFFSET, + VP_Feedrate_Percentage, + + VP_FWRETRACT_RETRACT_LENGTH, + VP_FWRETRACT_RETRACT_FEEDRATE, + VP_FWRETRACT_RETRACT_ZHOP, + VP_FWRETRACT_RESTART_LENGTH, + VP_FWRETRACT_RESTART_FEEDRATE, + + VP_FWRETRACT_TOGGLE_BUTTON_ICON, + + 0x0000 +}; + // Toggle button handler void DGUSCrealityDisplay_HandleToggleButton(DGUS_VP_Variable &var, void *val_ptr) { switch (*(uint16_t*)var.memadr) { @@ -337,6 +411,7 @@ const struct VPMapping VPMap[] PROGMEM = { { DGUSLCD_SCREEN_MAIN, VPList_Main }, { DGUSLCD_SCREEN_SDFILELIST, VPList_SDFileList }, + { DGUSLCD_SCREEN_FILAMENTRUNOUT1, VPList_PrintPausingError }, { DGUSLCD_SCREEN_FILAMENTRUNOUT2, VPList_PrintPausingError }, @@ -360,7 +435,7 @@ const struct VPMapping VPMap[] PROGMEM = { { DGUSLCD_SCREEN_TEMP_PLA, VPList_PreheatPLASettings }, { DGUSLCD_SCREEN_TEMP_ABS, VPList_PreheatABSSettings }, - { DGUSLCD_SCREEN_INFO, VPList_Info }, + { DGUSLCD_SCREEN_INFO, VPList_PrintScreen }, { DGUSLCD_SCREEN_ZOFFSET_LEVEL, VPList_ZOffsetLevel }, { DGUSLCD_SCREEN_LEVELING, VPList_Leveling }, @@ -377,6 +452,10 @@ const struct VPMapping VPMap[] PROGMEM = { { DGUSLCD_SCREEN_CONFIRM, VPList_None }, { DGUSLCD_SCREEN_POPUP, VPList_None }, + { DGUSLCD_SCREEN_ESTEPS_CALIBRATION, VPList_EstepsCalibration }, + { DGUSLCD_SCREEN_PIDTUNE_CALIBRATION, VPList_PidTune }, + + { DGUSLCD_SCREEN_TUNEFWRETRACT, VPList_FWRetractTune }, { 0 , nullptr } // List is terminated with an nullptr as table entry. }; @@ -390,9 +469,8 @@ const struct VPMapping VPMap[] PROGMEM = { .set_by_display_handler = RXFPTR, .send_to_display_handler = TXFPTR } const struct DGUS_VP_Variable ListOfVP[] PROGMEM = { - // TODO: - #if HOTENDS >= 1 + VPHELPER(VP_Flowrate_E0, &planner.flow_percentage[ExtUI::extruder_t::E0], ScreenHandler.HandleFlowRateChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), VPHELPER(VP_T_E0_Is, &thermalManager.temp_hotend[0].celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>), VPHELPER(VP_T_E0_Set, &thermalManager.temp_hotend[0].target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), #endif @@ -411,6 +489,29 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = { VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, ScreenHandler.DGUSLCD_SendPrintProgressToDisplay), VPHELPER(VP_PrintTimeProgressBar, nullptr, nullptr, ScreenHandler.DGUSLCD_SendPrintProgressToDisplay), + // Calibration + // ... e-steps + VPHELPER(VP_ESTEPS_CURRENT, &EstepsHandler::set_esteps, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + VPHELPER(VP_ESTEPS_CALIBRATION_TEMP, &EstepsHandler::calibration_temperature, ScreenHandler.DGUSLCD_SetValueDirectly, ScreenHandler.DGUSLCD_SendWordValueToDisplay), + VPHELPER(VP_ESTEPS_CALIBRATION_LENGTH, &EstepsHandler::filament_to_extrude, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + VPHELPER(VP_ESTEPS_CALIBRATION_MARK_LENGTH, &EstepsHandler::mark_filament_mm, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + VPHELPER(VP_ESTEPS_CALIBRATION_LEFTOVER_LENGTH, &EstepsHandler::remaining_filament, EstepsHandler::HandleRemainingFilament, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + VPHELPER(VP_ESTEPS_CALCULATED_ESTEPS, &EstepsHandler::calculated_esteps, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + + VPHELPER(VP_ESTEPS_CALIBRATESTART_BUTTON, nullptr, EstepsHandler::HandleStartButton, nullptr), + VPHELPER(VP_ESTEPS_APPLY_BUTTON, nullptr, EstepsHandler::HandleApplyButton, nullptr), + + VPHELPER(VP_ESTEP_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage), nullptr), + + // ... PID + VPHELPER(VP_PIDTUNE_TARGET_TEMP, &PIDHandler::calibration_temperature, ScreenHandler.DGUSLCD_SetValueDirectly, ScreenHandler.DGUSLCD_SendWordValueToDisplay), + VPHELPER(VP_PIDTUNE_CYCLES, &PIDHandler::cycles, ScreenHandler.DGUSLCD_SetValueDirectly, ScreenHandler.DGUSLCD_SendWordValueToDisplay), + VPHELPER(VP_PIDTUNE_START_BUTTON, nullptr, PIDHandler::HandleStartButton, nullptr), + + VPHELPER(VP_PIDTUNE_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage), nullptr), + + VPHELPER(VP_GENERIC_BACK_BUTTON, nullptr, ScreenHandler.OnBackButton, nullptr), + // Preheat settings #ifdef PREHEAT_1_LABEL VPHELPER(VP_PREHEAT_PLA_HOTEND_TEMP, &ui.material_preset[0].hotend_temp, ScreenHandler.DGUSLCD_SetValueDirectly, &ScreenHandler.DGUSLCD_SendWordValueToDisplay), @@ -423,6 +524,7 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = { #endif // About info + VPHELPER(VP_MARLIN_WEBSITE, nullptr, nullptr, ScreenHandler.DGUSLCD_SendAboutFirmwareWebsite), VPHELPER(VP_MARLIN_VERSION, nullptr, nullptr, ScreenHandler.DGUSLCD_SendAboutFirmwareVersion), VPHELPER(VP_PRINTER_BEDSIZE, nullptr, nullptr, ScreenHandler.DGUSLCD_SendAboutPrintSize), @@ -431,9 +533,14 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = { VPHELPER(VP_Y_POSITION, ¤t_position.y, ScreenHandler.HandlePositionChange, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), VPHELPER(VP_Z_POSITION, ¤t_position.z, ScreenHandler.HandlePositionChange, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + VPHELPER(SP_X_POSITION, nullptr, nullptr, ScreenHandler.SendAxisTrustValue), + VPHELPER(SP_Y_POSITION, nullptr, nullptr, ScreenHandler.SendAxisTrustValue), + VPHELPER(SP_Z_POSITION, nullptr, nullptr, ScreenHandler.SendAxisTrustValue), + VPHELPER(VP_Z_OFFSET, &probe.offset.z, ScreenHandler.HandleZoffsetChange, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<2>), VPHELPER(VP_FAN_TOGGLE, &thermalManager.fan_speed[0], nullptr, ScreenHandler.DGUSLCD_SendFanStatusToDisplay), + VPHELPER(VP_Fan0_Percentage, &thermalManager.fan_speed[0], ScreenHandler.HandleFanSpeedChanged, ScreenHandler.DGUSLCD_SendFanSpeedToDisplay), #if ENABLED(POWER_LOSS_RECOVERY) VPHELPER(VP_POWER_LOSS_RECOVERY, nullptr, &ScreenHandler.HandlePowerLossRecovery, nullptr), @@ -444,7 +551,7 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = { VPHELPER(VP_CONFIRMED, nullptr, ScreenHandler.ScreenConfirmedOK, nullptr), // Feed - VPHELPER(VP_FEED_AMOUNT, &ScreenHandler.feed_amount, ScreenHandler.HandleFeedAmountChanged, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<2>), + VPHELPER(VP_FEED_AMOUNT, &ScreenHandler.feed_amount, ScreenHandler.HandleFeedAmountChanged, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), // Creality has the same button ID mapped all over the place, so let the generic handler figure it out VPHELPER(VP_BUTTON_MAINENTERKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr), @@ -472,9 +579,42 @@ const struct DGUS_VP_Variable ListOfVP[] PROGMEM = { 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), + // Firmware retract +#if ENABLED(FWRETRACT) + VPHELPER(VP_FWRETRACT_NAV_BUTTON, nullptr, ScreenHandler.DGUSLCD_NavigateToPage, nullptr), + + VPHELPER(VP_FWRETRACT_RETRACT_LENGTH, &fwretract.settings.retract_length, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + VPHELPER(VP_FWRETRACT_RETRACT_FEEDRATE, &fwretract.settings.retract_feedrate_mm_s, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + VPHELPER(VP_FWRETRACT_RETRACT_ZHOP, &fwretract.settings.retract_zraise, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + + VPHELPER(VP_FWRETRACT_RESTART_LENGTH, &fwretract.settings.retract_recover_extra, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + VPHELPER(VP_FWRETRACT_RESTART_FEEDRATE, &fwretract.settings.retract_recover_feedrate_mm_s, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>), + + #if ENABLED(FWRETRACT_AUTORETRACT) + VPHELPER(VP_FWRETRACT_INDICATOR_ICON, &fwretract.autoretract_enabled, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), + VPHELPER(VP_FWRETRACT_TOGGLE_BUTTON_ICON, &fwretract.autoretract_enabled, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), + VPHELPER(VP_FWRETRACT_TOGGLE_BUTTON, &fwretract.autoretract_enabled, ScreenHandler.DGUSLCD_ToggleBoolean, nullptr), + #else + VPHELPER(VP_FWRETRACT_INDICATOR_ICON, nullptr, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), + VPHELPER(VP_FWRETRACT_TOGGLE_BUTTON_ICON, nullptr, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), + VPHELPER(VP_FWRETRACT_TOGGLE_BUTTON, nullptr, ScreenHandler.DGUSLCD_ToggleBoolean, nullptr), + #endif +#endif + + // ... Sending after init does not always work + VPHELPER(VP_FWRETRACT_NAV_BUTTON_ICON, &ScreenHandler.fwretract_available, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), + + // Additional buttons + VPHELPER(VP_MUTE_TOGGLE, nullptr, ScreenHandler.HandleToggleTouchScreenMute, nullptr), + VPHELPER(VP_STANDBY_BACKLIGHT_TOGGLE, nullptr, ScreenHandler.HandleToggleTouchScreenStandbySetting, nullptr), + + // Additional settings + VPHELPER(VP_SCREEN_BACKLIGHT_STANDBY, &ScreenHandler.Settings.standby_screen_brightness, ScreenHandler.HandleTouchScreenStandbyBrightnessSetting, ScreenHandler.DGUSLCD_SendWordValueToDisplay), + // Icons - VPHELPER(VP_STEPPERS, &ScreenHandler.are_steppers_enabled, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), - VPHELPER(VP_LED_TOGGLE, &caselight.on, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), + VPHELPER(VP_LED_TOGGLE, &caselight.on, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), + VPHELPER(VP_STANDBY_BACKLIGHT_ICON, &ScreenHandler.Settings.display_standby, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), + VPHELPER(VP_MUTE_ICON, &ScreenHandler.Settings.display_sound, nullptr, (ScreenHandler.DGUSLCD_SendIconValue)), // 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 }, diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/DGUSDisplayDef.h b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/DGUSDisplayDef.h index 318949c313..2d587d10bc 100644 --- a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/DGUSDisplayDef.h +++ b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/DGUSDisplayDef.h @@ -69,6 +69,11 @@ enum DGUSLCD_Screens : uint8_t { DGUSLCD_SCREEN_POPUP = 63, // NEW - does not exist in original display DGUSLCD_SCREEN_KILL = 64, // NEW - does not exist in original display + + DGUSLCD_SCREEN_PIDTUNE_CALIBRATION = 68, + DGUSLCD_SCREEN_ESTEPS_CALIBRATION = 69, + + DGUSLCD_SCREEN_TUNEFWRETRACT = 70 }; // Display Memory layout used (T5UID) @@ -186,7 +191,16 @@ constexpr uint16_t VP_MARLIN_VERSION = 0x2222; constexpr uint8_t VP_MARLIN_VERSION_LEN = 20; // there is more space on the display, if needed. constexpr uint16_t VP_MARLIN_WEBSITE = 0x2242; -constexpr uint8_t VP_MARLIN_WEBSITE_LEN = 32; +constexpr uint8_t VP_MARLIN_WEBSITE_LEN = 32; + +constexpr uint16_t VP_STANDBY_BACKLIGHT_ICON = 0x2280; +constexpr uint16_t VP_STANDBY_BACKLIGHT_TOGGLE = 0x2282; + +constexpr uint16_t VP_MUTE_ICON = 0x2284; +constexpr uint16_t VP_MUTE_TOGGLE = 0x2286; + +constexpr uint16_t VP_SCREEN_BACKLIGHT_STANDBY = 0x228D; + // Material preheat settings constexpr uint16_t VP_PREHEAT_PLA_HOTEND_TEMP = 0x1102; @@ -220,10 +234,9 @@ constexpr uint16_t VP_T_E0_Set = 0x1034; // 2 Byte Integer - HEAD_SET_TEMP_VP constexpr uint16_t VP_T_Bed_Is = 0x103c; // 4 Byte Integer - BED_SET_TEMP_VP constexpr uint16_t VP_T_Bed_Set = 0x103A; // 2 Byte Integer - BED_CURRENT_TEMP_VP -constexpr uint16_t VP_Flowrate_E0 = 0x3090; // 2 Byte Integer -// constexpr uint16_t VP_Flowrate_E1 = 0x3092; // 2 Byte Integer +constexpr uint16_t VP_Flowrate_E0 = 0x228A; // 2 Byte Integer -// constexpr uint16_t VP_Fan0_Percentage = 0x3100; // 2 Byte Integer (0..100) +constexpr uint16_t VP_Fan0_Percentage = 0x228F; // 2 Byte Integer (0..100) // constexpr uint16_t VP_Fan1_Percentage = 0x33A2; // 2 Byte Integer (0..100) // //constexpr uint16_t VP_Fan2_Percentage = 0x33A4; // 2 Byte Integer (0..100) // //constexpr uint16_t VP_Fan3_Percentage = 0x33A6; // 2 Byte Integer (0..100) @@ -248,7 +261,7 @@ constexpr uint16_t VP_Z_OFFSET = 0x1026; constexpr uint16_t VP_SD_ScrollEvent = 0x20D4; // 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 = 0x2200; // Number of file field selected. constexpr uint16_t VP_SD_FileName_LEN = 21; // LEN is shared for all entries. -constexpr uint16_t VP_SD_FileName_CNT = 6; // LEN is shared for all entries. +constexpr uint16_t VP_SD_FileName_CNT = 5; // LEN is shared for all entries. constexpr uint16_t DGUS_SD_FILESPERSCREEN = VP_SD_FileName_CNT; // FIXME move that info to the display and read it from there. constexpr uint16_t VP_SD_FileName0 = 0x20D5; constexpr uint16_t VP_SD_FileName1 = VP_SD_FileName0 + VP_SD_FileName_LEN; @@ -338,7 +351,6 @@ constexpr uint16_t VP_BUTTON_HEATLOADSTARTKEY = 0x1056; // Additional stuff defined by Creality constexpr uint16_t VP_FAN_TOGGLE = 0x101E; constexpr uint16_t VP_LED_TOGGLE = 0x101F; -constexpr uint16_t VP_STEPPERS = 0x1200; constexpr uint16_t VP_MESH_LEVEL_TEMP = 0x108A; constexpr uint16_t VP_MESH_LEVEL_STATUS = 0x108D; constexpr uint16_t VP_MESH_VALUE_START = 0x1300; @@ -347,10 +359,69 @@ constexpr uint16_t VP_FEED_PROGRESS = 0x108e; // Movement screen constexpr uint16_t VP_X_POSITION = 0x1048; +constexpr uint16_t SP_X_POSITION = 0x4000; constexpr uint16_t VP_Y_POSITION = 0x104A; +constexpr uint16_t SP_Y_POSITION = 0x4030; constexpr uint16_t VP_Z_POSITION = 0x104C; +constexpr uint16_t SP_Z_POSITION = 0x4060; constexpr uint16_t VP_BUTTON_MOVEKEY = 0x1046; +// Buttons +constexpr uint16_t VP_ESTEP_NAV_BUTTON = 0x2291; +constexpr uint16_t VP_PIDTUNE_NAV_BUTTON = 0x2293; +constexpr uint16_t VP_GENERIC_BACK_BUTTON = 0x2295; // Generic button for popping back to the old display + +// PID tuning +constexpr uint16_t VP_PIDTUNE_TARGET_TEMP = 0x2297; +constexpr uint16_t VP_PIDTUNE_CYCLES = 0x2299; +constexpr uint16_t VP_PIDTUNE_START_BUTTON = 0x229B; + +// FWRetract +constexpr uint16_t VP_FWRETRACT_NAV_BUTTON = 0x22AD; +constexpr uint16_t VP_FWRETRACT_NAV_BUTTON_ICON = 0x22AF; + +constexpr uint16_t VP_FWRETRACT_RETRACT_LENGTH = 0x22B1; +constexpr uint16_t VP_FWRETRACT_RETRACT_FEEDRATE = 0x22B3; +constexpr uint16_t VP_FWRETRACT_RETRACT_ZHOP = 0x22B5; + +constexpr uint16_t VP_FWRETRACT_RESTART_LENGTH = 0x22B7; +constexpr uint16_t VP_FWRETRACT_RESTART_FEEDRATE = 0x22B9; + +constexpr uint16_t VP_FWRETRACT_TOGGLE_BUTTON = 0x22BB; +constexpr uint16_t VP_FWRETRACT_TOGGLE_BUTTON_ICON = 0x22BD; +constexpr uint16_t VP_FWRETRACT_INDICATOR_ICON = 0x22BF; + + +// E-steps calibration +constexpr uint16_t VP_ESTEPS_CURRENT = 0x229d; +constexpr uint16_t VP_ESTEPS_CALIBRATION_TEMP = 0x229f; +constexpr uint16_t VP_ESTEPS_CALIBRATION_LENGTH = 0x22a1; +constexpr uint16_t VP_ESTEPS_CALIBRATION_MARK_LENGTH = 0x22ab; +constexpr uint16_t VP_ESTEPS_CALIBRATION_LEFTOVER_LENGTH = 0x22a3; +constexpr uint16_t VP_ESTEPS_CALCULATED_ESTEPS = 0x22a5; +constexpr uint16_t VP_ESTEPS_CALIBRATESTART_BUTTON = 0x22a7; +constexpr uint16_t VP_ESTEPS_APPLY_BUTTON = 0x22a9; + // Icons constexpr uint16_t ICON_TOGGLE_ON = 1; constexpr uint16_t ICON_TOGGLE_OFF = 2; + +// Toggles +constexpr uint16_t ICON_FAN_TOGGLE_ON = 1; +constexpr uint16_t ICON_FAN_TOGGLE_OFF = 2; +constexpr uint16_t ICON_LED_TOGGLE_ON = 3; +constexpr uint16_t ICON_LED_TOGGLE_OFF = 4; +constexpr uint16_t ICON_SOUND_TOGGLE_ON = 5; +constexpr uint16_t ICON_SOUND_TOGGLE_OFF = 6; +constexpr uint16_t ICON_STANDBY_TOGGLE_ON = 7; +constexpr uint16_t ICON_STANDBY_TOGGLE_OFF = 8; + +constexpr uint16_t ICON_FWRETRACT_AUTO_TOGGLE_ON = 9; +constexpr uint16_t ICON_FWRETRACT_AUTO_TOGGLE_OFF = 10; + + +constexpr uint16_t ICON_FWRETRACT_NAV_UNAVAILABLE = 14; +constexpr uint16_t ICON_FWRETRACT_NAV_AVAILABLE = 15; + +constexpr uint16_t ICON_FWRETRACT_AUTO_DISENGAGED = 16; // This icon deliberately does not exist +constexpr uint16_t ICON_FWRETRACT_AUTO_ENGAGED = 17; diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/EstepsHandler.cpp b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/EstepsHandler.cpp new file mode 100644 index 0000000000..fb5efffe39 --- /dev/null +++ b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/EstepsHandler.cpp @@ -0,0 +1,159 @@ + +#include "../../../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) + +#include "../DGUSDisplayDef.h" +#include "../DGUSDisplay.h" +#include "../DGUSScreenHandler.h" + +#include "EstepsHandler.h" + +#include "../../../ui_api.h" +#include "../../../../marlinui.h" + +#include "../../../../../module/temperature.h" +#include "../../../../../module/settings.h" +#include "../../../../../module/planner.h" +#include "../../../../../gcode/gcode.h" + +// Storage init +float EstepsHandler::set_esteps = 0; +float EstepsHandler::calculated_esteps = 0; +float EstepsHandler::remaining_filament = 0; +float EstepsHandler::mark_filament_mm = 0; +float EstepsHandler::filament_to_extrude = 0; +uint16_t EstepsHandler::calibration_temperature = 0; + +void EstepsHandler::Init() { + // Use steps + set_esteps = ExtUI::getAxisSteps_per_mm(ExtUI::E0); + calculated_esteps = 0; + + // Reset + filament_to_extrude = 100; + mark_filament_mm = 120; + remaining_filament = 0; + + // Use configured PLA temps + 10 degrees + calibration_temperature = ui.material_preset[0].hotend_temp + 10; + + // Welcome message + SetStatusMessage(PSTR("Ready")); +} + + +void EstepsHandler::HandleStartButton(DGUS_VP_Variable &var, void *val_ptr) { + static_assert(ADVANCED_PAUSE_PURGE_LENGTH == 0, "Assuming PURGE_LENGTH is 0 so we can use M701"); + + // Validate + if (calibration_temperature < EXTRUDE_MINTEMP) { + SetStatusMessage(PSTR("Invalid temperature set")); + return; + } + + if (filament_to_extrude < 10) { + SetStatusMessage(PSTR("Invalid extrusion length set")); + return; + } + + if (mark_filament_mm < filament_to_extrude) { + SetStatusMessage(PSTR("Invalid mark length set")); + return; + } + + // Prepare + bool zAxisWasRelative = GcodeSuite::axis_is_relative(Z_AXIS); + bool eAxisWasRelative = GcodeSuite::axis_is_relative(E_AXIS); + + GcodeSuite::set_e_relative(); + GcodeSuite::set_relative_mode(true); + + ExtUI::injectCommands_P("G0 Z5 F150"); + queue.advance(); + + // Heat up if necessary + if (ExtUI::getActualTemp_celsius(ExtUI::E0) < calibration_temperature && abs(ExtUI::getActualTemp_celsius(ExtUI::E0) - calibration_temperature) > 2) { + thermalManager.setTargetHotend(calibration_temperature, ExtUI::H0); + + SetStatusMessage(PSTR("Heating up...")); + thermalManager.wait_for_hotend(ExtUI::H0, false); + } + + planner.synchronize(); + + // Set-up command + SetStatusMessage(PSTR("Extruding...")); + + char cmd[64]; + sprintf_P(cmd, PSTR("G1 E%f F50"), filament_to_extrude); + + ExtUI::injectCommands(cmd); + queue.advance(); + planner.synchronize(); + + // Restore position + ExtUI::injectCommands_P("G0 Z-5 F150"); + queue.advance(); + planner.synchronize(); + + // Restore defaults + if (!zAxisWasRelative) GcodeSuite::set_relative_mode(false); + if (!eAxisWasRelative) GcodeSuite::set_e_absolute(); + + // Done + ScreenHandler.Buzzer(0, 250); + SetStatusMessage(PSTR("Please measure remaining filament")); +} + +void EstepsHandler::HandleApplyButton(DGUS_VP_Variable &var, void *val_ptr) { + if (abs(calculated_esteps) < 1) { + // User intented to set e-steps directly + ExtUI::setAxisSteps_per_mm(set_esteps, ExtUI::E0); + } else { + ExtUI::setAxisSteps_per_mm(calculated_esteps, ExtUI::E0); + } + + // Save & reset + settings.save(); + Init(); + + ScreenHandler.Buzzer(0, 250); + SetStatusMessage(PSTR("New e-steps value saved")); +} + +void EstepsHandler::HandleRemainingFilament(DGUS_VP_Variable &var, void *val_ptr) { + ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>(var, val_ptr); + + // Calculate + constexpr float precision = 0.01; + float actualExtrusion = mark_filament_mm - remaining_filament; + if (actualExtrusion < (-precision)) { + SetStatusMessage(PSTR("Mark filament further")); + return; + } + + if (actualExtrusion < precision) { + SetStatusMessage(PSTR("E-steps are correct")); + calculated_esteps = set_esteps; + return; + } + + float current_steps = ExtUI::getAxisSteps_per_mm(ExtUI::E0); + SERIAL_ECHOLNPAIR("Current steps: ", current_steps); + SERIAL_ECHOLNPAIR("Actual extrusion: ", actualExtrusion); + + float new_steps = (current_steps * filament_to_extrude) / actualExtrusion; + SERIAL_ECHOLNPAIR("New steps: ", new_steps); + + calculated_esteps = new_steps; + + // Status update + SetStatusMessage(PSTR("Calculated new e-steps")); +} + +void EstepsHandler::SetStatusMessage(PGM_P statusMessage) { + ScreenHandler.setstatusmessagePGM(statusMessage); +} + +#endif \ No newline at end of file diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/EstepsHandler.h b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/EstepsHandler.h new file mode 100644 index 0000000000..2d54ce151f --- /dev/null +++ b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/EstepsHandler.h @@ -0,0 +1,28 @@ +#pragma once + +#include + +class EstepsHandler { + public: + static void Init(); + + static void HandleStartButton(DGUS_VP_Variable &var, void *val_ptr); + static void HandleApplyButton(DGUS_VP_Variable &var, void *val_ptr); + + static void HandleRemainingFilament(DGUS_VP_Variable &var, void *val_ptr); + + public: + static float set_esteps; + static float calculated_esteps; + + static float mark_filament_mm; + static float remaining_filament; + + static float filament_to_extrude; + static uint16_t calibration_temperature; + + private: + + static void SetStatusMessage(PGM_P statusMessage); +}; + diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PIDHandler.cpp b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PIDHandler.cpp new file mode 100644 index 0000000000..2ed4077a9d --- /dev/null +++ b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PIDHandler.cpp @@ -0,0 +1,72 @@ + +#include "../../../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) + +#include "../DGUSDisplayDef.h" +#include "../DGUSDisplay.h" +#include "../DGUSScreenHandler.h" + +#include "PIDHandler.h" + +#include "../../../ui_api.h" +#include "../../../../marlinui.h" + +#include "../../../../../module/temperature.h" +#include "../../../../../module/settings.h" +#include "../../../../../module/planner.h" +#include "../../../../../gcode/gcode.h" + +// Storage init +uint16_t PIDHandler::cycles = 0; +uint16_t PIDHandler::calibration_temperature = 0; +PGM_P PIDHandler::result_message = nullptr; + +void PIDHandler::Init() { + // Reset + cycles = 3; + + // Use configured PLA temps + 10 degrees + calibration_temperature = ui.material_preset[0].hotend_temp + 15; + + // Welcome message + SetStatusMessage(PSTR("Ready")); +} + + +void PIDHandler::HandleStartButton(DGUS_VP_Variable &var, void *val_ptr) { + static_assert(ADVANCED_PAUSE_PURGE_LENGTH == 0, "Assuming PURGE_LENGTH is 0 so we can use M701"); + + // Validate + if (calibration_temperature < EXTRUDE_MINTEMP) { + SetStatusMessage(PSTR("Invalid temperature set")); + return; + } + + if (cycles < 1) { + SetStatusMessage(PSTR("Invalid number of cycles")); + return; + } + + // Set-up command + SetStatusMessage(PSTR("PID tuning. Please wait...")); + + char cmd[64]; + sprintf_P(cmd, PSTR("M303 S%d C%d U1"), calibration_temperature, cycles); + + ExtUI::injectCommands(cmd); + queue.advance(); + planner.synchronize(); + + // Done + ScreenHandler.Buzzer(0, 250); + settings.save(); + + SetStatusMessage(result_message); +} + +void PIDHandler::SetStatusMessage(PGM_P statusMessage) { + ScreenHandler.setstatusmessagePGM(statusMessage); +} + +#endif \ No newline at end of file diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PIDHandler.h b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PIDHandler.h new file mode 100644 index 0000000000..1c5fe1e24a --- /dev/null +++ b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PIDHandler.h @@ -0,0 +1,20 @@ +#pragma once + +#include + +class PIDHandler { + public: + static void Init(); + + static void HandleStartButton(DGUS_VP_Variable &var, void *val_ptr); + + public: + static uint16_t cycles; + static uint16_t calibration_temperature; + static PGM_P result_message; + + private: + + static void SetStatusMessage(PGM_P statusMessage); +}; + diff --git a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PageHandlers.cpp b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PageHandlers.cpp index a540778b9e..3e904ce396 100644 --- a/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PageHandlers.cpp +++ b/Marlin/src/lcd/extui/lib/dgus_creality/creality_touch/PageHandlers.cpp @@ -8,6 +8,7 @@ #include "../../../../../module/motion.h" #include "../../../../../module/planner.h" #include "../../../../../feature/pause.h" +#include "../../../../../gcode/gcode.h" #if ENABLED(FILAMENT_RUNOUT_SENSOR) #include "../../../../../feature/runout.h" @@ -15,8 +16,8 @@ #include "../../../../../module/settings.h" -#include "../../../../marlinui.h" #include "../../../ui_api.h" +#include "../../../../marlinui.h" #include "PageHandlers.h" @@ -25,7 +26,36 @@ // Definitions of page handlers void MainMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { - // Nothing + switch (var.VP) { + case VP_BUTTON_MAINENTERKEY: + switch (buttonValue) { + case 1: + // Try to mount an unmounted card + if (!card.isMounted()) { + card.mount(); + + if (card.isMounted()) { + ExtUI::onMediaInserted(); + } + } + + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_SDFILELIST); + break; + + case 2: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PREPARE); + break; + + case 3: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_CONTROL); + break; + + case 4: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_ZOFFSET_LEVEL); + break; + } + break; + } } void ControlMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { @@ -33,20 +63,28 @@ void ControlMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { case VP_BUTTON_PREPAREENTERKEY: switch(buttonValue) { case 5: // About - // Automatically handled + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_INFO); break; case 7: // Reset to factory settings settings.reset(); settings.save(); + + ExtUI::injectCommands_P(PSTR("M300")); + + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN); break; case 9: // Back button - // TODO: should navigate automatically + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN); break; } break; + case VP_BUTTON_TEMPCONTROL: + if (buttonValue == 2) ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TEMP); + break; + case VP_BUTTON_ADJUSTENTERKEY: ScreenHandler.HandleLEDToggle(); break; @@ -58,29 +96,46 @@ void LevelingModeHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { case VP_BUTTON_BEDLEVELKEY: switch (buttonValue) { case 1: - ExtUI::injectCommands_P("G28\nG0 Z0"); + ExtUI::injectCommands_P("G28"); + + queue.advance(); + planner.synchronize(); + + ExtUI::injectCommands_P("G0 Z0"); + + queue.advance(); break; case 2: // Increase Z-offset ExtUI::smartAdjustAxis_steps(ExtUI::mmToWholeSteps(0.01, ExtUI::axis_t::Z), ExtUI::axis_t::Z, true);; ScreenHandler.ForceCompleteUpdate(); - settings.save(); + ScreenHandler.RequestSaveSettings(); break; case 3: // Decrease Z-offset ExtUI::smartAdjustAxis_steps(ExtUI::mmToWholeSteps(-0.01, ExtUI::axis_t::Z), ExtUI::axis_t::Z, true);; ScreenHandler.ForceCompleteUpdate(); - settings.save(); + ScreenHandler.RequestSaveSettings(); break; } break; + case VP_BUTTON_PREPAREENTERKEY: + if (buttonValue == 9) { + // If we're in the workflow of calibration from the home screen, there is no need to keep the heaters on at this point + thermalManager.disable_all_heaters(); + + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN); + } + break; + case VP_BUTTON_MAINENTERKEY: // Go to leveling screen ExtUI::injectCommands_P("G28\nG29"); + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_LEVELING); break; } } @@ -104,14 +159,46 @@ void TempMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { } break; + + case VP_BUTTON_TEMPCONTROL: + switch (buttonValue){ + case 3: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TEMP_PLA); + break; + + case 4: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TEMP_ABS); + break; + + case 7: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_CONTROL); + break; + } + break; } } void PrepareMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { switch (var.VP) { case VP_BUTTON_PREPAREENTERKEY: - // Disable steppers - ScreenHandler.HandleMotorLockUnlock(var, &buttonValue); + switch (buttonValue){ + case 3: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE10MM); + break; + + case 6: + // Disable steppers + ScreenHandler.HandleMotorLockUnlock(var, &buttonValue); + break; + + case 9: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN); + break; + } + break; + + case VP_BUTTON_HEATLOADSTARTKEY: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_FEED); break; case VP_BUTTON_COOLDOWN: @@ -157,30 +244,61 @@ void TuneMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { } void PrintRunningMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { - // There are actually no buttons to handle here: all buttons navigate to other screens (like confirmation screens) + switch (var.VP) { + case VP_BUTTON_ADJUSTENTERKEY: + switch (buttonValue) { + case 1: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TUNING); + break; + } + break; + + case VP_BUTTON_PAUSEPRINTKEY: + switch (buttonValue) { + case 1: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_DIALOG_PAUSE); + break; + } + break; + + case VP_BUTTON_STOPPRINTKEY: + switch (buttonValue) { + case 1: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_DIALOG_STOP); + break; + } + break; + } } void PrintPausedMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { switch (var.VP) { case VP_BUTTON_RESUMEPRINTKEY: - //SERIAL_ECHOLN("Handling VP_BUTTON_RESUMEPRINTKEY"); - #if ENABLED(FILAMENT_RUNOUT_SENSOR) +#if ENABLED(FILAMENT_RUNOUT_SENSOR) runout.reset(); - //SERIAL_ECHOLN("Runout Reset"); - #endif - if(ExtUI::isWaitingOnUser()) { - ScreenHandler.HandlePendingUserConfirmation(); - //SERIAL_ECHOLN("User Confirmed"); - } - else if(ExtUI::isPrintingFromMediaPaused()) { - //SERIAL_ECHOLN("SD Resume"); - ExtUI::resumePrint(); - } - //SERIAL_ECHOLN("Reasons handled"); - if(!ExtUI::isMoving()) { - ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING); +#endif + + if (!ScreenHandler.HandlePendingUserConfirmation()) { + ExtUI::resumePrint(); + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING); } break; + + case VP_BUTTON_ADJUSTENTERKEY: + switch (buttonValue) { + case 1: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TUNING); + break; + } + break; + + case VP_BUTTON_STOPPRINTKEY: + switch (buttonValue) { + case 1: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_DIALOG_STOP); + break; + } + break; } } @@ -201,6 +319,18 @@ void PrintPauseDialogHandler(DGUS_VP_Variable &var, unsigned short buttonValue) } } +void PrintFinishMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { + switch (var.VP){ + case VP_BUTTON_MAINENTERKEY: + switch (buttonValue) { + case 5: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN); + break; + } + break; + } +} + void FilamentRunoutHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { switch (var.VP){ case VP_BUTTON_RESUMEPRINTKEY: @@ -225,7 +355,7 @@ void StopConfirmScreenHandler(DGUS_VP_Variable &var, unsigned short buttonValue) break; case 3: - ScreenHandler.GotoScreen(ExtUI::isPrintingFromMediaPaused() ? DGUSLCD_SCREEN_PRINT_PAUSED : DGUSLCD_SCREEN_PRINT_RUNNING); + ScreenHandler.GotoScreen(ExtUI::isPrintingPaused() ? DGUSLCD_SCREEN_PRINT_PAUSED : DGUSLCD_SCREEN_PRINT_RUNNING); break; } break; @@ -236,28 +366,45 @@ void PreheatSettingsScreenHandler(DGUS_VP_Variable &var, unsigned short buttonVa switch (var.VP){ case VP_BUTTON_PREPAREENTERKEY: // Save button, save settings and go back - settings.save(); + ScreenHandler.RequestSaveSettings(); ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TEMP); break; - case VP_BUTTON_COOLDOWN: + case VP_BUTTON_COOLDOWN: // You can't make this up // Back button, discard settings settings.load(); + + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TEMP); break; } } +void InfoMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { + switch (var.VP){ + case VP_BUTTON_TEMPCONTROL: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_CONTROL); + break; + } +} + void change_filament_with_temp(PGM_P command, const uint16_t celsius) { - thermalManager.setTargetHotend(celsius, ExtUI::H0); + // Heat if necessary + if (ExtUI::getActualTemp_celsius(ExtUI::E0) < celsius && abs(ExtUI::getActualTemp_celsius(ExtUI::E0) - celsius) > 2) { + thermalManager.setTargetHotend(celsius, ExtUI::H0); + thermalManager.wait_for_hotend(ExtUI::H0, false); + } - char cmd[32]; + // Inject load filament command + char cmd[64]; sprintf_P(cmd, command, ScreenHandler.feed_amount); - + SERIAL_ECHOPAIR("Injecting command: ", cmd); ExtUI::injectCommands(cmd); + // Handle commands SERIAL_ECHOPGM_P("- waiting for queue"); queue.advance(); + planner.synchronize(); SERIAL_ECHOPGM_P("- done"); } @@ -287,28 +434,36 @@ void FeedHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { dgusdisplay.WriteVariable(VP_FEED_PROGRESS, static_cast(0)); break; + + case 3: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PREPARE); + break; } ScreenHandler.ForceCompleteUpdate(); } void MoveHandler(DGUS_VP_Variable &var, unsigned short buttonValue) { - if (var.VP != VP_BUTTON_MOVEKEY) return; + if (var.VP == VP_BUTTON_HEATLOADSTARTKEY) { + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PREPARE); + } - switch (buttonValue) { - case 1: - ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE10MM); - break; - case 2: - ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE1MM); - break; - case 3: - ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE01MM); - break; - case 4: - ExtUI::injectCommands_P("G28"); - break; - } + if (var.VP == VP_BUTTON_MOVEKEY) { + switch (buttonValue) { + case 1: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE10MM); + break; + case 2: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE1MM); + break; + case 3: + ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE01MM); + break; + case 4: + ExtUI::injectCommands_P("G28"); + break; + } + } } // Register the page handlers @@ -321,6 +476,8 @@ const struct PageHandler PageHandlers[] PROGMEM = { PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_ZOFFSET_LEVEL, LevelingModeHandler) PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_LEVELING, LevelingHandler) + PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_INFO, InfoMenuHandler) + PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_TEMP, TempMenuHandler) PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_TEMP_PLA, PreheatSettingsScreenHandler) PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_TEMP_ABS, PreheatSettingsScreenHandler) @@ -332,11 +489,13 @@ const struct PageHandler PageHandlers[] PROGMEM = { PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_MOVE10MM, MoveHandler) PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_FILAMENTRUNOUT1, FilamentRunoutHandler) + PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_FILAMENTRUNOUT2, FilamentRunoutHandler) PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_DIALOG_STOP, StopConfirmScreenHandler) PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_PRINT_RUNNING, PrintRunningMenuHandler) PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_PRINT_PAUSED, PrintPausedMenuHandler) + PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_PRINT_FINISH, PrintFinishMenuHandler) PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_DIALOG_PAUSE, PrintPauseDialogHandler)