From 9d73fcb959e04839084abb78e9286a778a07ec5d Mon Sep 17 00:00:00 2001 From: mrv96 Date: Tue, 7 Sep 2021 02:51:04 +0200 Subject: [PATCH] =?UTF-8?q?=E2=9C=A8Add=20DGUS=5FLCD=5FUI=5FRELOADED=20(#2?= =?UTF-8?q?1931)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Marlin/Configuration.h | 5 + Marlin/src/inc/Conditionals_LCD.h | 4 + Marlin/src/inc/SanityCheck.h | 31 +- Marlin/src/lcd/extui/dgus/DGUSDisplay.cpp | 4 +- .../src/lcd/extui/dgus/DGUSScreenHandler.cpp | 4 +- Marlin/src/lcd/extui/dgus/dgus_extui.cpp | 4 +- .../lcd/extui/dgus_reloaded/DGUSDisplay.cpp | 407 +++++++ .../src/lcd/extui/dgus_reloaded/DGUSDisplay.h | 171 +++ .../lcd/extui/dgus_reloaded/DGUSRxHandler.cpp | 1059 +++++++++++++++++ .../lcd/extui/dgus_reloaded/DGUSRxHandler.h | 123 ++ .../extui/dgus_reloaded/DGUSScreenHandler.cpp | 540 +++++++++ .../extui/dgus_reloaded/DGUSScreenHandler.h | 152 +++ .../extui/dgus_reloaded/DGUSSetupHandler.cpp | 209 ++++ .../extui/dgus_reloaded/DGUSSetupHandler.h | 43 + .../lcd/extui/dgus_reloaded/DGUSTxHandler.cpp | 632 ++++++++++ .../lcd/extui/dgus_reloaded/DGUSTxHandler.h | 127 ++ .../extui/dgus_reloaded/config/DGUS_Addr.h | 173 +++ .../dgus_reloaded/config/DGUS_Constants.h | 96 ++ .../extui/dgus_reloaded/config/DGUS_Control.h | 50 + .../extui/dgus_reloaded/config/DGUS_Data.h | 148 +++ .../extui/dgus_reloaded/config/DGUS_Screen.h | 52 + .../definition/DGUS_ScreenAddrList.cpp | 240 ++++ .../definition/DGUS_ScreenAddrList.h | 32 + .../definition/DGUS_ScreenSetup.cpp | 57 + .../definition/DGUS_ScreenSetup.h | 31 + .../extui/dgus_reloaded/definition/DGUS_VP.h | 40 + .../dgus_reloaded/definition/DGUS_VPList.cpp | 368 ++++++ .../dgus_reloaded/definition/DGUS_VPList.h | 26 + .../dgus_reloaded/dgus_reloaded_extui.cpp | 142 +++ ini/features.ini | 3 +- platformio.ini | 1 + 31 files changed, 4966 insertions(+), 8 deletions(-) create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.cpp create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.cpp create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.cpp create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.cpp create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.cpp create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Addr.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Constants.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Control.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Data.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Screen.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.cpp create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.cpp create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VP.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VPList.cpp create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VPList.h create mode 100644 Marlin/src/lcd/extui/dgus_reloaded/dgus_reloaded_extui.cpp diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index bfc39298a2..fea0d51e5f 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -2565,10 +2565,15 @@ // - Download https://github.com/makerbase-mks/MKS-H43 // - Copy the downloaded DWIN_SET folder to the SD card. // +// RELOADED (T5UID1) +// - Download https://github.com/Desuuuu/DGUS-reloaded +// - Copy the downloaded DWIN_SET folder to the SD card. +// //#define DGUS_LCD_UI_ORIGIN //#define DGUS_LCD_UI_FYSETC //#define DGUS_LCD_UI_HIPRECY //#define DGUS_LCD_UI_MKS +//#define DGUS_LCD_UI_RELOADED #if ENABLED(DGUS_LCD_UI_MKS) #define USE_MKS_GREEN_UI #endif diff --git a/Marlin/src/inc/Conditionals_LCD.h b/Marlin/src/inc/Conditionals_LCD.h index 9875422742..0715b1f514 100644 --- a/Marlin/src/inc/Conditionals_LCD.h +++ b/Marlin/src/inc/Conditionals_LCD.h @@ -479,6 +479,10 @@ // Aliases for LCD features #if ANY(DGUS_LCD_UI_ORIGIN, DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_HIPRECY, DGUS_LCD_UI_MKS) + #define HAS_DGUS_LCD_CLASSIC 1 +#endif + +#if ANY(HAS_DGUS_LCD_CLASSIC, DGUS_LCD_UI_RELOADED) #define HAS_DGUS_LCD 1 #endif diff --git a/Marlin/src/inc/SanityCheck.h b/Marlin/src/inc/SanityCheck.h index 01fdaa3451..75df13127c 100644 --- a/Marlin/src/inc/SanityCheck.h +++ b/Marlin/src/inc/SanityCheck.h @@ -2655,7 +2655,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS + (DISABLED(IS_LEGACY_TFT) && ENABLED(TFT_GENERIC)) \ + (ENABLED(IS_LEGACY_TFT) && COUNT_ENABLED(TFT_320x240, TFT_320x240_SPI, TFT_480x320, TFT_480x320_SPI)) \ + COUNT_ENABLED(ANYCUBIC_LCD_I3MEGA, ANYCUBIC_LCD_CHIRON, ANYCUBIC_TFT35) \ - + COUNT_ENABLED(DGUS_LCD_UI_ORIGIN, DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_HIPRECY, DGUS_LCD_UI_MKS) \ + + COUNT_ENABLED(DGUS_LCD_UI_ORIGIN, DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_HIPRECY, DGUS_LCD_UI_MKS, DGUS_LCD_UI_RELOADED) \ + COUNT_ENABLED(ENDER2_STOCKDISPLAY, CR10_STOCKDISPLAY) \ + COUNT_ENABLED(DWIN_CREALITY_LCD, DWIN_MARLINUI_PORTRAIT, DWIN_MARLINUI_LANDSCAPE) \ + COUNT_ENABLED(FYSETC_MINI_12864_X_X, FYSETC_MINI_12864_1_2, FYSETC_MINI_12864_2_0, FYSETC_MINI_12864_2_1, FYSETC_GENERIC_12864_1_1) \ @@ -3798,6 +3798,35 @@ static_assert( _ARR_TEST(3,0) && _ARR_TEST(3,1) && _ARR_TEST(3,2) #endif #undef _BAD_DRIVER +/** + * Require certain features for DGUS_LCD_UI_RELOADED. + */ +#if ENABLED(DGUS_LCD_UI_RELOADED) + #if BUFSIZE < 4 + #error "DGUS_LCD_UI_RELOADED requires a BUFSIZE of at least 4." + #elif HOTENDS < 1 + #error "DGUS_LCD_UI_RELOADED requires at least 1 hotend." + #elif EXTRUDERS < 1 + #error "DGUS_LCD_UI_RELOADED requires at least 1 extruder." + #elif !HAS_HEATED_BED + #error "DGUS_LCD_UI_RELOADED requires a heated bed." + #elif FAN_COUNT < 1 + #error "DGUS_LCD_UI_RELOADED requires a fan." + #elif !HAS_BED_PROBE + #error "DGUS_LCD_UI_RELOADED requires a bed probe." + #elif !HAS_MESH + #error "DGUS_LCD_UI_RELOADED requires mesh leveling." + #elif DISABLED(LEVEL_BED_CORNERS) + #error "DGUS_LCD_UI_RELOADED requires LEVEL_BED_CORNERS." + #elif DISABLED(BABYSTEP_ALWAYS_AVAILABLE) + #error "DGUS_LCD_UI_RELOADED requires BABYSTEP_ALWAYS_AVAILABLE." + #elif DISABLED(BABYSTEP_ZPROBE_OFFSET) + #error "DGUS_LCD_UI_RELOADED requires BABYSTEP_ZPROBE_OFFSET." + #elif ENABLED(AUTO_BED_LEVELING_UBL) && DISABLED(UBL_SAVE_ACTIVE_ON_M500) + #warning "Without UBL_SAVE_ACTIVE_ON_M500, your mesh will not be saved when using the touchscreen." + #endif +#endif + // Misc. Cleanup #undef _TEST_PWM #undef _LINEAR_AXES_STR diff --git a/Marlin/src/lcd/extui/dgus/DGUSDisplay.cpp b/Marlin/src/lcd/extui/dgus/DGUSDisplay.cpp index c2390d63a6..535bc96591 100644 --- a/Marlin/src/lcd/extui/dgus/DGUSDisplay.cpp +++ b/Marlin/src/lcd/extui/dgus/DGUSDisplay.cpp @@ -22,7 +22,7 @@ #include "../../../inc/MarlinConfigPre.h" -#if HAS_DGUS_LCD +#if HAS_DGUS_LCD_CLASSIC #if HOTENDS > 2 #warning "More than 2 hotends not implemented on DGUS Display UI." @@ -268,4 +268,4 @@ bool populate_VPVar(const uint16_t VP, DGUS_VP_Variable * const ramcopy) { return true; } -#endif // HAS_DGUS_LCD +#endif // HAS_DGUS_LCD_CLASSIC diff --git a/Marlin/src/lcd/extui/dgus/DGUSScreenHandler.cpp b/Marlin/src/lcd/extui/dgus/DGUSScreenHandler.cpp index 5c108d0709..9e44cf1331 100644 --- a/Marlin/src/lcd/extui/dgus/DGUSScreenHandler.cpp +++ b/Marlin/src/lcd/extui/dgus/DGUSScreenHandler.cpp @@ -22,7 +22,7 @@ #include "../../../inc/MarlinConfigPre.h" -#if HAS_DGUS_LCD +#if HAS_DGUS_LCD_CLASSIC #include "DGUSScreenHandler.h" @@ -772,4 +772,4 @@ void DGUSDisplay::RequestScreen(DGUSLCD_Screens screen) { WriteVariable(0x84, gotoscreen, sizeof(gotoscreen)); } -#endif // HAS_DGUS_LCD +#endif // HAS_DGUS_LCD_CLASSIC diff --git a/Marlin/src/lcd/extui/dgus/dgus_extui.cpp b/Marlin/src/lcd/extui/dgus/dgus_extui.cpp index 4b4521c47f..4f15827a49 100644 --- a/Marlin/src/lcd/extui/dgus/dgus_extui.cpp +++ b/Marlin/src/lcd/extui/dgus/dgus_extui.cpp @@ -26,7 +26,7 @@ #include "../../../inc/MarlinConfigPre.h" -#if HAS_DGUS_LCD +#if HAS_DGUS_LCD_CLASSIC #include "../ui_api.h" #include "DGUSDisplay.h" @@ -159,4 +159,4 @@ namespace ExtUI { void onSteppersEnabled() {} } -#endif // HAS_DGUS_LCD +#endif // HAS_DGUS_LCD_CLASSIC diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.cpp b/Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.cpp new file mode 100644 index 0000000000..e82f63bce1 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.cpp @@ -0,0 +1,407 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +/* DGUS implementation written by coldtobi in 2019 for Marlin */ + +#include "../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "DGUSDisplay.h" + +#include "config/DGUS_Addr.h" +#include "config/DGUS_Constants.h" +#include "definition/DGUS_VPList.h" + +#include "../ui_api.h" +#include "../../../gcode/gcode.h" + +long map_precise(float x, long in_min, long in_max, long out_min, long out_max) { + return LROUND((x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min); +} + +uint8_t DGUSDisplay::gui_version = 0; +uint8_t DGUSDisplay::os_version = 0; + +uint8_t DGUSDisplay::volume = 255; +uint8_t DGUSDisplay::brightness = 100; + +DGUSDisplay::rx_datagram_state_t DGUSDisplay::rx_datagram_state = DGUS_IDLE; +uint8_t DGUSDisplay::rx_datagram_len = 0; + +bool DGUSDisplay::initialized = false; + +void DGUSDisplay::Loop() { + ProcessRx(); +} + +void DGUSDisplay::Init() { + LCD_SERIAL.begin(LCD_BAUDRATE); + + Read(DGUS_VERSION, 1); +} + +void DGUSDisplay::Read(uint16_t addr, uint8_t size) { + WriteHeader(addr, DGUS_READVAR, size); + + LCD_SERIAL.write(size); +} + +void DGUSDisplay::Write(uint16_t addr, const void* data_ptr, uint8_t size) { + if (!data_ptr) return; + + WriteHeader(addr, DGUS_WRITEVAR, size); + + const char* data = static_cast(data_ptr); + + while (size--) { + LCD_SERIAL.write(*data++); + } +} + +void DGUSDisplay::WriteString(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) { + if (!data_ptr) return; + + WriteHeader(addr, DGUS_WRITEVAR, size); + + const char* data = static_cast(data_ptr); + size_t len = strlen(data); + uint8_t left_spaces = 0; + uint8_t right_spaces = 0; + + if (len < size) { + if (!len) { + right_spaces = size; + } + else if ((left && right) || (!left && !right)) { + left_spaces = (size - len) / 2; + right_spaces = size - len - left_spaces; + } + else if (left) { + right_spaces = size - len; + } + else { + left_spaces = size - len; + } + } + else { + len = size; + } + + while (left_spaces--) { + LCD_SERIAL.write(' '); + } + while (len--) { + LCD_SERIAL.write(*data++); + } + while (right_spaces--) { + LCD_SERIAL.write(use_space ? ' ' : '\0'); + } +} + +void DGUSDisplay::WriteStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) { + if (!data_ptr) return; + + WriteHeader(addr, DGUS_WRITEVAR, size); + + const char* data = static_cast(data_ptr); + size_t len = strlen_P(data); + uint8_t left_spaces = 0; + uint8_t right_spaces = 0; + + if (len < size) { + if (!len) { + right_spaces = size; + } + else if ((left && right) || (!left && !right)) { + left_spaces = (size - len) / 2; + right_spaces = size - len - left_spaces; + } + else if (left) { + right_spaces = size - len; + } + else { + left_spaces = size - len; + } + } + else { + len = size; + } + + while (left_spaces--) { + LCD_SERIAL.write(' '); + } + while (len--) { + LCD_SERIAL.write(pgm_read_byte(data++)); + } + while (right_spaces--) { + LCD_SERIAL.write(use_space ? ' ' : '\0'); + } +} + +void DGUSDisplay::SwitchScreen(DGUS_Screen screen) { + DEBUG_ECHOLNPAIR("SwitchScreen ", (uint8_t)screen); + const uint8_t command[] = { 0x5A, 0x01, 0x00, (uint8_t)screen }; + Write(0x84, command, sizeof(command)); +} + +void DGUSDisplay::PlaySound(uint8_t start, uint8_t len, uint8_t volume) { + if (volume == 0) volume = DGUSDisplay::volume; + if (volume == 0) return; + DEBUG_ECHOLNPAIR("PlaySound ", start, ":", len, "\nVolume ", volume); + const uint8_t command[] = { start, len, volume, 0x00 }; + Write(0xA0, command, sizeof(command)); +} + +void DGUSDisplay::EnableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control) { + DEBUG_ECHOLNPAIR("EnableControl ", (uint8_t)control, "\nScreen ", (uint8_t)screen, "\nType ", (uint8_t)type); + + const uint8_t command[] = { 0x5A, 0xA5, 0x00, (uint8_t)screen, (uint8_t)control, type, 0x00, 0x01 }; + Write(0xB0, command, sizeof(command)); + + FlushTx(); + delay(50); +} + +void DGUSDisplay::DisableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control) { + DEBUG_ECHOLNPAIR("DisableControl ", (uint8_t)control, "\nScreen ", (uint8_t)screen, "\nType ", (uint8_t)type); + + const uint8_t command[] = { 0x5A, 0xA5, 0x00, (uint8_t)screen, (uint8_t)control, type, 0x00, 0x00 }; + Write(0xB0, command, sizeof(command)); + + FlushTx(); + delay(50); +} + +uint8_t DGUSDisplay::GetBrightness() { + return brightness; +} + +uint8_t DGUSDisplay::GetVolume() { + return map_precise(volume, 0, 255, 0, 100); +} + +void DGUSDisplay::SetBrightness(uint8_t new_brightness) { + brightness = constrain(new_brightness, 0, 100); + new_brightness = map_precise(brightness, 0, 100, 5, 100); + DEBUG_ECHOLNPAIR("SetBrightness ", new_brightness); + const uint8_t command[] = { new_brightness, new_brightness }; + Write(0x82, command, sizeof(command)); +} + +void DGUSDisplay::SetVolume(uint8_t new_volume) { + volume = map_precise(constrain(new_volume, 0, 100), 0, 100, 0, 255); + DEBUG_ECHOLNPAIR("SetVolume ", volume); + const uint8_t command[] = { volume, 0x00 }; + Write(0xA1, command, sizeof(command)); +} + +void DGUSDisplay::ProcessRx() { + + #if ENABLED(LCD_SERIAL_STATS_RX_BUFFER_OVERRUNS) + if (!LCD_SERIAL.available() && LCD_SERIAL.buffer_overruns()) { + // Overrun, but reset the flag only when the buffer is empty + // We want to extract as many as valid datagrams possible... + DEBUG_ECHOPGM("OVFL"); + rx_datagram_state = DGUS_IDLE; + //LCD_SERIAL.reset_rx_overun(); + LCD_SERIAL.flush(); + } + #endif + + uint8_t receivedbyte; + while (LCD_SERIAL.available()) { + switch (rx_datagram_state) { + + case DGUS_IDLE: // Waiting for the first header byte + receivedbyte = LCD_SERIAL.read(); + DEBUG_ECHOPAIR("< ", receivedbyte); + if (DGUS_HEADER1 == receivedbyte) rx_datagram_state = DGUS_HEADER1_SEEN; + break; + + case DGUS_HEADER1_SEEN: // Waiting for the second header byte + receivedbyte = LCD_SERIAL.read(); + DEBUG_ECHOPAIR(" ", receivedbyte); + rx_datagram_state = (DGUS_HEADER2 == receivedbyte) ? DGUS_HEADER2_SEEN : DGUS_IDLE; + break; + + case DGUS_HEADER2_SEEN: // Waiting for the length byte + rx_datagram_len = LCD_SERIAL.read(); + DEBUG_ECHOPAIR(" (", rx_datagram_len, ") "); + + // Telegram min len is 3 (command and one word of payload) + rx_datagram_state = WITHIN(rx_datagram_len, 3, DGUS_RX_BUFFER_SIZE) ? DGUS_WAIT_TELEGRAM : DGUS_IDLE; + break; + + case DGUS_WAIT_TELEGRAM: // wait for complete datagram to arrive. + if (LCD_SERIAL.available() < rx_datagram_len) return; + + initialized = true; // We've talked to it, so we defined it as initialized. + uint8_t command = LCD_SERIAL.read(); + + DEBUG_ECHOPAIR("# ", command); + + uint8_t readlen = rx_datagram_len - 1; // command is part of len. + unsigned char tmp[rx_datagram_len - 1]; + unsigned char *ptmp = tmp; + + while (readlen--) { + receivedbyte = LCD_SERIAL.read(); + DEBUG_ECHOPAIR(" ", receivedbyte); + *ptmp++ = receivedbyte; + } + DEBUG_ECHOPGM(" # "); + // mostly we'll get this: 5A A5 03 82 4F 4B -- ACK on 0x82, so discard it. + if (command == DGUS_WRITEVAR && 'O' == tmp[0] && 'K' == tmp[1]) { + DEBUG_ECHOLNPGM(">"); + rx_datagram_state = DGUS_IDLE; + break; + } + + /* AutoUpload, (and answer to) Command 0x83 : + | tmp[0 1 2 3 4 ... ] + | Example 5A A5 06 83 20 01 01 78 01 …… + | / / | | \ / | \ \ + | Header | | | | \_____\_ DATA (Words!) + | DatagramLen / VPAdr | + | Command DataLen (in Words) */ + if (command == DGUS_READVAR) { + const uint16_t addr = tmp[0] << 8 | tmp[1]; + const uint8_t dlen = tmp[2] << 1; // Convert to Bytes. (Display works with words) + DEBUG_ECHOPAIR("addr=", addr, " dlen=", dlen, "> "); + + if (addr == DGUS_VERSION && dlen == 2) { + DEBUG_ECHOLNPGM("VERSIONS"); + gui_version = tmp[3]; + os_version = tmp[4]; + rx_datagram_state = DGUS_IDLE; + break; + } + + DGUS_VP vp; + if (!DGUS_PopulateVP((DGUS_Addr)addr, &vp)) { + DEBUG_ECHOLNPGM("VP not found"); + rx_datagram_state = DGUS_IDLE; + break; + } + + if (!vp.rx_handler) { + DEBUG_ECHOLNPGM("VP found, no handler."); + rx_datagram_state = DGUS_IDLE; + break; + } + + gcode.reset_stepper_timeout(); + + if (!vp.size) { + DEBUG_ECHOLN(); + vp.rx_handler(vp, nullptr); + + rx_datagram_state = DGUS_IDLE; + break; + } + + if (vp.flags & VPFLAG_RXSTRING) { + unsigned char buffer[vp.size]; + memset(buffer, 0, vp.size); + + for (uint8_t i = 0; i < dlen; i++) { + if (i >= vp.size) { + break; + } + + if (i + 1 < dlen && tmp[i + 3] == 0xFF && tmp[i + 4] == 0xFF) { + break; + } + + buffer[i] = tmp[i + 3]; + } + + DEBUG_ECHOLN(); + vp.rx_handler(vp, buffer); + + rx_datagram_state = DGUS_IDLE; + break; + } + + if (dlen != vp.size) { + DEBUG_ECHOLNPGM("VP found, size mismatch."); + rx_datagram_state = DGUS_IDLE; + break; + } + + DEBUG_ECHOLN(); + vp.rx_handler(vp, &tmp[3]); + + rx_datagram_state = DGUS_IDLE; + break; + } + + DEBUG_ECHOLNPGM(">"); + rx_datagram_state = DGUS_IDLE; + break; + } + } +} + +size_t DGUSDisplay::GetFreeTxBuffer() { + #ifdef LCD_SERIAL_GET_TX_BUFFER_FREE + return LCD_SERIAL_GET_TX_BUFFER_FREE(); + #else + return SIZE_MAX; + #endif +} + +void DGUSDisplay::FlushTx() { + #ifdef ARDUINO_ARCH_STM32 + LCD_SERIAL.flush(); + #else + LCD_SERIAL.flushTX(); + #endif +} + +void DGUSDisplay::WriteHeader(uint16_t addr, uint8_t command, uint8_t len) { + LCD_SERIAL.write(DGUS_HEADER1); + LCD_SERIAL.write(DGUS_HEADER2); + LCD_SERIAL.write(len + 3); + LCD_SERIAL.write(command); + LCD_SERIAL.write(addr >> 8); + LCD_SERIAL.write(addr & 0xFF); +} + +bool DGUS_PopulateVP(const DGUS_Addr addr, DGUS_VP * const buffer) { + const DGUS_VP *ret = vp_list; + + do { + const uint16_t *paddr = (uint16_t *)(&ret->addr); + const uint16_t addrcheck = pgm_read_word(paddr); + if (addrcheck == 0) break; + if ((DGUS_Addr)addrcheck == addr) { + memcpy_P(buffer, ret, sizeof(*ret)); + return true; + } + } while (++ret); + DEBUG_ECHOLNPAIR("VP not found: ", (uint16_t)addr); + return false; +} + +#endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.h b/Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.h new file mode 100644 index 0000000000..2a679648d1 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.h @@ -0,0 +1,171 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +/* DGUS implementation written by coldtobi in 2019 for Marlin */ + +#include "config/DGUS_Screen.h" +#include "config/DGUS_Control.h" +#include "definition/DGUS_VP.h" + +#include "../../../inc/MarlinConfigPre.h" +#include "../../../MarlinCore.h" + +#define DEBUG_OUT ENABLED(DEBUG_DGUSLCD) +#include "../../../core/debug_out.h" + +#define Swap16(val) ((uint16_t)(((uint16_t)(val) >> 8) |\ + ((uint16_t)(val) << 8))) + +// Low-Level access to the display. +class DGUSDisplay { +public: + + enum DGUS_ControlType : uint8_t { + VARIABLE_DATA_INPUT = 0x00, + POPUP_WINDOW = 0x01, + INCREMENTAL_ADJUST = 0x02, + SLIDER_ADJUST = 0x03, + RTC_SETTINGS = 0x04, + RETURN_KEY_CODE = 0x05, + TEXT_INPUT = 0x06, + FIRMWARE_SETTINGS = 0x07 + }; + + DGUSDisplay() = default; + + static void Init(); + + static void Read(uint16_t addr, uint8_t size); + static void Write(uint16_t addr, const void* data_ptr, uint8_t size); + + static void WriteString(uint16_t addr, const void* data_ptr, uint8_t size, bool left = true, bool right = false, bool use_space = true); + static void WriteStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left = true, bool right = false, bool use_space = true); + + template + static void Write(uint16_t addr, T data) { + Write(addr, static_cast(&data), sizeof(T)); + } + + // 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. + static void SwitchScreen(DGUS_Screen screen); + // Play sounds using the display speaker. + // start: position at which the sound was stored on the display. + // len: how many sounds to play. Sounds will play consecutively from start to start+len-1. + // volume: playback volume. 0 keeps the current volume. + static void PlaySound(uint8_t start, uint8_t len = 1, uint8_t volume = 0); + // Enable/disable a specific touch control. + // type: control type. + // control: index of the control on the page (set during screen development). + static void EnableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control); + static void DisableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control); + + static uint8_t GetBrightness(); + static uint8_t GetVolume(); + + // Set the display brightness/volume, ranging 0 - 100 + static void SetBrightness(uint8_t brightness); + static void SetVolume(uint8_t volume); + + // Periodic tasks, eg. Rx-Queue handling. + static void Loop(); + + // Helper for users of this class to estimate if an interaction would be blocking. + static size_t GetFreeTxBuffer(); + static void FlushTx(); + + // Checks two things: Can we confirm the presence of the display and has we initiliazed it. + // (both boils down that the display answered to our chatting) + static inline bool IsInitialized() { + return initialized; + } + + static uint8_t gui_version; + static uint8_t os_version; + + template + static T SwapBytes(const T value) { + union { + T val; + char byte[sizeof(T)]; + } src, dst; + + src.val = value; + LOOP_L_N(i, sizeof(T)) dst.byte[i] = src.byte[sizeof(T) - i - 1]; + return dst.val; + } + + template + T_out FromFixedPoint(const T_in value) { + return (T_out)((float)value / POW(10, decimals)); + } + + template + T_out ToFixedPoint(const T_in value) { + return (T_out)LROUND((float)value * POW(10, decimals)); + } + +private: + enum dgus_header : uint8_t { + DGUS_HEADER1 = 0x5A, + DGUS_HEADER2 = 0xA5 + }; + + enum dgus_command : uint8_t { + DGUS_WRITEVAR = 0x82, + DGUS_READVAR = 0x83 + }; + + enum rx_datagram_state_t : uint8_t { + DGUS_IDLE, //< waiting for DGUS_HEADER1. + DGUS_HEADER1_SEEN, //< DGUS_HEADER1 received + DGUS_HEADER2_SEEN, //< DGUS_HEADER2 received + DGUS_WAIT_TELEGRAM, //< LEN received, Waiting for to receive all bytes. + }; + + enum dgus_system_addr : uint16_t { + DGUS_VERSION = 0x000f // OS/GUI version + }; + + static void WriteHeader(uint16_t addr, uint8_t command, uint8_t len); + static void ProcessRx(); + + static uint8_t volume; + static uint8_t brightness; + + static rx_datagram_state_t rx_datagram_state; + static uint8_t rx_datagram_len; + + static bool initialized; +}; + +template<> inline uint16_t DGUSDisplay::SwapBytes(const uint16_t value) { + return ((value << 8) | (value >> 8)); +} + +extern DGUSDisplay dgus_display; + +/// Helper to populate a DGUS_VP for a given VP. Return false if not found. +extern bool DGUS_PopulateVP(const DGUS_Addr addr, DGUS_VP * const buffer); diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.cpp b/Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.cpp new file mode 100644 index 0000000000..5f36dac7f6 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.cpp @@ -0,0 +1,1059 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#include "../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "DGUSRxHandler.h" + +#include "DGUSScreenHandler.h" +#include "config/DGUS_Screen.h" + +#include "../ui_api.h" +#include "../../../core/language.h" +#include "../../../module/temperature.h" +#include "../../../module/printcounter.h" +#include "../../../gcode/queue.h" +#if ENABLED(ADVANCED_PAUSE_FEATURE) + #include "../../../feature/pause.h" +#endif +#if ENABLED(POWER_LOSS_RECOVERY) + #include "../../../feature/powerloss.h" +#endif + +void DGUSRxHandler::ScreenChange(DGUS_VP &vp, void *data_ptr) { + const DGUS_Screen screen = (DGUS_Screen)((uint8_t*)data_ptr)[1]; + + if (vp.addr == DGUS_Addr::SCREENCHANGE_SD) { + #if ENABLED(SDSUPPORT) + #if !PIN_EXISTS(SD_DETECT) + card.mount(); + #endif + + if (!ExtUI::isMediaInserted()) { + dgus_screen_handler.SetStatusMessagePGM(GET_TEXT(MSG_NO_MEDIA)); + return; + } + + card.cdroot(); + #else + dgus_screen_handler.SetStatusMessagePGM(GET_TEXT(MSG_NO_MEDIA)); + return; + #endif + } + + if (vp.addr == DGUS_Addr::SCREENCHANGE_Idle + && (printingIsActive() || printingIsPaused())) { + dgus_screen_handler.SetStatusMessagePGM(PSTR("Impossible while printing")); + return; + } + + if (vp.addr == DGUS_Addr::SCREENCHANGE_Printing + && (!printingIsActive() && !printingIsPaused())) { + dgus_screen_handler.SetStatusMessagePGM(PSTR("Impossible while idle")); + return; + } + + dgus_screen_handler.TriggerScreenChange(screen); +} + +#if ENABLED(SDSUPPORT) + void DGUSRxHandler::Scroll(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Scroll scroll = (DGUS_Data::Scroll)((uint8_t*)data_ptr)[1]; + + switch (scroll) { + case DGUS_Data::Scroll::GO_BACK: + if (dgus_screen_handler.filelist.isAtRootDir()) { + return; + } + + dgus_screen_handler.filelist_offset = 0; + dgus_screen_handler.filelist_selected = -1; + dgus_screen_handler.filelist.upDir(); + break; + case DGUS_Data::Scroll::UP: + if (dgus_screen_handler.filelist_offset < 1) { + return; + } + + --dgus_screen_handler.filelist_offset; + break; + case DGUS_Data::Scroll::DOWN: + if (dgus_screen_handler.filelist_offset + 1 + DGUS_FILE_COUNT > dgus_screen_handler.filelist.count()) { + return; + } + + ++dgus_screen_handler.filelist_offset; + break; + } + + dgus_screen_handler.TriggerFullUpdate(); + } + + void DGUSRxHandler::SelectFile(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const uint8_t index = ((uint8_t*)data_ptr)[1]; + + if (!dgus_screen_handler.filelist.seek(dgus_screen_handler.filelist_offset + index)) { + return; + } + + if (dgus_screen_handler.filelist.isDir()) { + dgus_screen_handler.filelist_offset = 0; + dgus_screen_handler.filelist_selected = -1; + dgus_screen_handler.filelist.changeDir(dgus_screen_handler.filelist.filename()); + } + else { + dgus_screen_handler.filelist_selected = dgus_screen_handler.filelist_offset + index; + } + + dgus_screen_handler.TriggerFullUpdate(); + } + + void DGUSRxHandler::PrintFile(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + UNUSED(data_ptr); + + if (dgus_screen_handler.filelist_selected < 0) { + dgus_screen_handler.SetStatusMessagePGM(PSTR("No file selected")); + return; + } + + if (!dgus_screen_handler.filelist.seek(dgus_screen_handler.filelist_selected) + || dgus_screen_handler.filelist.isDir()) { + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + ExtUI::printFile(dgus_screen_handler.filelist.shortFilename()); + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PRINT_STATUS); + } +#endif // SDSUPPORT + +void DGUSRxHandler::PrintAbort(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1]; + + if (result != DGUS_Data::Popup::CONFIRMED) { + return; + } + + if (!printingIsActive() && !printingIsPaused()) { + dgus_screen_handler.TriggerFullUpdate(); + return; + } + + ExtUI::stopPrint(); +} + +void DGUSRxHandler::PrintPause(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1]; + + if (result != DGUS_Data::Popup::CONFIRMED) { + return; + } + + if (!printingIsActive()) { + dgus_screen_handler.TriggerFullUpdate(); + return; + } + + ExtUI::pausePrint(); +} + +void DGUSRxHandler::PrintResume(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1]; + + if (result != DGUS_Data::Popup::CONFIRMED) { + return; + } + + if (!printingIsPaused()) { + dgus_screen_handler.TriggerFullUpdate(); + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + ExtUI::resumePrint(); +} + +void DGUSRxHandler::Feedrate(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const int16_t feedrate = Swap16(*(int16_t*)data_ptr); + + ExtUI::setFeedrate_percent(feedrate); + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::Flowrate(DGUS_VP &vp, void *data_ptr) { + const int16_t flowrate = Swap16(*(int16_t*)data_ptr); + + switch (vp.addr) { + default: return; + case DGUS_Addr::ADJUST_SetFlowrate_CUR: + #if EXTRUDERS > 1 + ExtUI::setFlow_percent(flowrate, ExtUI::getActiveTool()); + #else + ExtUI::setFlow_percent(flowrate, ExtUI::E0); + #endif + break; + #if EXTRUDERS > 1 + case DGUS_Addr::ADJUST_SetFlowrate_E0: + ExtUI::setFlow_percent(flowrate, ExtUI::E0); + break; + case DGUS_Addr::ADJUST_SetFlowrate_E1: + ExtUI::setFlow_percent(flowrate, ExtUI::E1); + break; + #endif + } + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::BabystepSet(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const int16_t data = Swap16(*(int16_t*)data_ptr); + const float offset = dgus_display.FromFixedPoint(data); + + const int16_t steps = ExtUI::mmToWholeSteps(offset - ExtUI::getZOffset_mm(), ExtUI::Z); + + ExtUI::smartAdjustAxis_steps(steps, ExtUI::Z, true); + + dgus_screen_handler.TriggerEEPROMSave(); + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::Babystep(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Adjust adjust = (DGUS_Data::Adjust)((uint8_t*)data_ptr)[1]; + int16_t steps; + + switch (adjust) { + default: return; + case DGUS_Data::Adjust::INCREMENT: + steps = ExtUI::mmToWholeSteps(DGUS_PRINT_BABYSTEP, ExtUI::Z); + break; + case DGUS_Data::Adjust::DECREMENT: + steps = ExtUI::mmToWholeSteps(-DGUS_PRINT_BABYSTEP, ExtUI::Z); + break; + } + + ExtUI::smartAdjustAxis_steps(steps, ExtUI::Z, true); + + dgus_screen_handler.TriggerEEPROMSave(); + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::TempPreset(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::TempPreset preset = (DGUS_Data::TempPreset)((uint8_t*)data_ptr)[1]; + + switch (preset) { + case DGUS_Data::TempPreset::PLA: + #if HOTENDS < 2 + ExtUI::setTargetTemp_celsius(DGUS_PLA_TEMP_HOTEND, ExtUI::H0); + #else + ExtUI::setTargetTemp_celsius(DGUS_PLA_TEMP_HOTEND, ExtUI::getActiveTool()); + #endif + ExtUI::setTargetTemp_celsius(DGUS_PLA_TEMP_BED, ExtUI::BED); + break; + case DGUS_Data::TempPreset::ABS: + #if HOTENDS < 2 + ExtUI::setTargetTemp_celsius(DGUS_ABS_TEMP_HOTEND, ExtUI::H0); + #else + ExtUI::setTargetTemp_celsius(DGUS_ABS_TEMP_HOTEND, ExtUI::getActiveTool()); + #endif + ExtUI::setTargetTemp_celsius(DGUS_ABS_TEMP_BED, ExtUI::BED); + break; + case DGUS_Data::TempPreset::PETG: + #if HOTENDS < 2 + ExtUI::setTargetTemp_celsius(DGUS_PETG_TEMP_HOTEND, ExtUI::H0); + #else + ExtUI::setTargetTemp_celsius(DGUS_PETG_TEMP_HOTEND, ExtUI::getActiveTool()); + #endif + ExtUI::setTargetTemp_celsius(DGUS_PETG_TEMP_BED, ExtUI::BED); + break; + } + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::TempTarget(DGUS_VP &vp, void *data_ptr) { + const int16_t temp = Swap16(*(int16_t*)data_ptr); + + switch (vp.addr) { + default: return; + case DGUS_Addr::TEMP_SetTarget_Bed: + ExtUI::setTargetTemp_celsius(temp, ExtUI::BED); + break; + case DGUS_Addr::TEMP_SetTarget_H0: + ExtUI::setTargetTemp_celsius(temp, ExtUI::H0); + break; + #if HOTENDS > 1 + case DGUS_Addr::TEMP_SetTarget_H1: + ExtUI::setTargetTemp_celsius(temp, ExtUI::H1); + break; + #endif + } + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::TempCool(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Heater heater = (DGUS_Data::Heater)Swap16(*(uint16_t*)data_ptr); + + switch (heater) { + default: return; + case DGUS_Data::Heater::ALL: + ExtUI::setTargetTemp_celsius(0, ExtUI::BED); + ExtUI::setTargetTemp_celsius(0, ExtUI::H0); + #if HOTENDS > 1 + ExtUI::setTargetTemp_celsius(0, ExtUI::H1); + #endif + break; + case DGUS_Data::Heater::BED: + ExtUI::setTargetTemp_celsius(0, ExtUI::BED); + break; + case DGUS_Data::Heater::H0: + ExtUI::setTargetTemp_celsius(0, ExtUI::H0); + break; + #if HOTENDS > 1 + case DGUS_Data::Heater::H1: + ExtUI::setTargetTemp_celsius(0, ExtUI::H1); + break; + #endif + } + + dgus_screen_handler.SetStatusMessagePGM(PSTR("Cooling...")); + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::Steppers(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Control control = (DGUS_Data::Control)((uint8_t*)data_ptr)[1]; + + switch (control) { + case DGUS_Data::Control::ENABLE: + enable_all_steppers(); + break; + case DGUS_Data::Control::DISABLE: + disable_all_steppers(); + break; + } + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::ZOffset(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + if (!ExtUI::isAxisPositionKnown(ExtUI::Z)) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_HOMING_REQUIRED); + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + const int16_t data = Swap16(*(int16_t*)data_ptr); + const float offset = dgus_display.FromFixedPoint(data); + + const int16_t steps = ExtUI::mmToWholeSteps(offset - ExtUI::getZOffset_mm(), ExtUI::Z); + + ExtUI::smartAdjustAxis_steps(steps, ExtUI::Z, true); + + dgus_screen_handler.TriggerEEPROMSave(); + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::ZOffsetStep(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + if (!ExtUI::isAxisPositionKnown(ExtUI::Z)) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_HOMING_REQUIRED); + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + const DGUS_Data::Adjust adjust = (DGUS_Data::Adjust)((uint8_t*)data_ptr)[1]; + int16_t steps; + + switch (dgus_screen_handler.offset_steps) { + default: return; + case DGUS_Data::StepSize::MMP1: + steps = ExtUI::mmToWholeSteps((adjust == DGUS_Data::Adjust::INCREMENT ? 0.1f : -0.1f), ExtUI::Z); + break; + case DGUS_Data::StepSize::MMP01: + steps = ExtUI::mmToWholeSteps((adjust == DGUS_Data::Adjust::INCREMENT ? 0.01f : -0.01f), ExtUI::Z); + break; + } + + ExtUI::smartAdjustAxis_steps(steps, ExtUI::Z, true); + + dgus_screen_handler.TriggerEEPROMSave(); + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::ZOffsetSetStep(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::StepSize size = (DGUS_Data::StepSize)((uint8_t*)data_ptr)[1]; + + dgus_screen_handler.offset_steps = size; + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::MoveToPoint(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + if (!ExtUI::isPositionKnown()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_HOMING_REQUIRED); + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + const uint8_t point = ((uint8_t*)data_ptr)[1]; + constexpr float lfrb[4] = LEVEL_CORNERS_INSET_LFRB; + float x, y; + + switch (point) { + default: return; + case 1: + x = DGUS_LEVEL_CENTER_X; + y = DGUS_LEVEL_CENTER_Y; + break; + case 2: + x = X_MIN_POS + lfrb[0]; + y = Y_MIN_POS + lfrb[1]; + break; + case 3: + x = X_MAX_POS - lfrb[2]; + y = Y_MIN_POS + lfrb[1]; + break; + case 4: + x = X_MAX_POS - lfrb[2]; + y = Y_MAX_POS - lfrb[3]; + break; + case 5: + x = X_MIN_POS + lfrb[0]; + y = Y_MAX_POS - lfrb[3]; + break; + } + + if (ExtUI::getAxisPosition_mm(ExtUI::Z) < Z_MIN_POS + LEVEL_CORNERS_Z_HOP) { + ExtUI::setAxisPosition_mm(Z_MIN_POS + LEVEL_CORNERS_Z_HOP, ExtUI::Z); + } + ExtUI::setAxisPosition_mm(x, ExtUI::X); + ExtUI::setAxisPosition_mm(y, ExtUI::Y); + ExtUI::setAxisPosition_mm(Z_MIN_POS + LEVEL_CORNERS_HEIGHT, ExtUI::Z); +} + +void DGUSRxHandler::Probe(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + UNUSED(data_ptr); + + #if ENABLED(MESH_BED_LEVELING) + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_ABL_REQUIRED); + return; + #endif + + if (!ExtUI::isPositionKnown()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_HOMING_REQUIRED); + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::LEVELING_PROBING); + + #if ENABLED(AUTO_BED_LEVELING_UBL) + queue.enqueue_now_P(PSTR("G29P1\nG29P3\nG29P5C")); + #else + queue.enqueue_now_P(PSTR("G29")); + #endif + queue.enqueue_now_P(DGUS_CMD_EEPROM_SAVE); +} + +void DGUSRxHandler::DisableABL(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + UNUSED(data_ptr); + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + ExtUI::setLevelingActive(false); + + dgus_screen_handler.TriggerEEPROMSave(); + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::FilamentSelect(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Extruder extruder = (DGUS_Data::Extruder)Swap16(*(uint16_t*)data_ptr); + + switch (extruder) { + default: return; + case DGUS_Data::Extruder::CURRENT: + case DGUS_Data::Extruder::E0: + #if EXTRUDERS > 1 + case DGUS_Data::Extruder::E1: + #endif + dgus_screen_handler.filament_extruder = extruder; + break; + } + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::FilamentLength(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const uint16_t length = Swap16(*(uint16_t*)data_ptr); + + dgus_screen_handler.filament_length = constrain(length, 0, EXTRUDE_MAXLENGTH); + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::FilamentMove(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + ExtUI::extruder_t extruder; + + switch (dgus_screen_handler.filament_extruder) { + default: return; + case DGUS_Data::Extruder::CURRENT: + #if EXTRUDERS > 1 + extruder = ExtUI::getActiveTool(); + break; + #endif + case DGUS_Data::Extruder::E0: + extruder = ExtUI::E0; + break; + #if EXTRUDERS > 1 + case DGUS_Data::Extruder::E1: + extruder = ExtUI::E1; + break; + #endif + } + + if (ExtUI::getActualTemp_celsius(extruder) < (float)EXTRUDE_MINTEMP) { + dgus_screen_handler.SetStatusMessagePGM(PSTR("Temperature too low")); + return; + } + + const DGUS_Data::FilamentMove move = (DGUS_Data::FilamentMove)((uint8_t*)data_ptr)[1]; + + switch (move) { + case DGUS_Data::FilamentMove::RETRACT: + UI_DECREMENT_BY(AxisPosition_mm, (float)dgus_screen_handler.filament_length, extruder); + break; + case DGUS_Data::FilamentMove::EXTRUDE: + UI_INCREMENT_BY(AxisPosition_mm, (float)dgus_screen_handler.filament_length, extruder); + break; + } +} + +void DGUSRxHandler::Home(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + DGUS_Data::Axis axis = (DGUS_Data::Axis)((uint8_t*)data_ptr)[1]; + + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 1); + dgus_screen_handler.SetMessageLinePGM(DGUS_MSG_HOMING, 2); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 3); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 4); + dgus_screen_handler.ShowWaitScreen(dgus_screen_handler.GetCurrentScreen()); + + switch (axis) { + case DGUS_Data::Axis::X_Y_Z: + queue.enqueue_now_P(PSTR("G28XYZ")); + break; + case DGUS_Data::Axis::X_Y: + queue.enqueue_now_P(PSTR("G28XY")); + break; + case DGUS_Data::Axis::Z: + queue.enqueue_now_P(PSTR("G28Z")); + break; + } +} + +void DGUSRxHandler::Move(DGUS_VP &vp, void *data_ptr) { + const int16_t data = Swap16(*(int16_t*)data_ptr); + const float position = dgus_display.FromFixedPoint(data); + ExtUI::axis_t axis; + + switch (vp.addr) { + default: return; + case DGUS_Addr::MOVE_SetX: + axis = ExtUI::X; + break; + case DGUS_Addr::MOVE_SetY: + axis = ExtUI::Y; + break; + case DGUS_Addr::MOVE_SetZ: + axis = ExtUI::Z; + break; + } + + if (!ExtUI::isAxisPositionKnown(axis)) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_HOMING_REQUIRED); + return; + } + + ExtUI::setAxisPosition_mm(position, axis); + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::MoveStep(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + float offset; + + switch (dgus_screen_handler.move_steps) { + default: return; + case DGUS_Data::StepSize::MM10: + offset = 10.0f; + break; + case DGUS_Data::StepSize::MM1: + offset = 1.0f; + break; + case DGUS_Data::StepSize::MMP1: + offset = 0.1f; + break; + } + + const DGUS_Data::MoveDirection direction = (DGUS_Data::MoveDirection)((uint8_t*)data_ptr)[1]; + ExtUI::axis_t axis; + + switch (direction) { + default: return; + case DGUS_Data::MoveDirection::XP: + axis = ExtUI::X; + break; + case DGUS_Data::MoveDirection::XM: + axis = ExtUI::X; + offset = -offset; + break; + case DGUS_Data::MoveDirection::YP: + axis = ExtUI::Y; + break; + case DGUS_Data::MoveDirection::YM: + axis = ExtUI::Y; + offset = -offset; + break; + case DGUS_Data::MoveDirection::ZP: + axis = ExtUI::Z; + break; + case DGUS_Data::MoveDirection::ZM: + axis = ExtUI::Z; + offset = -offset; + break; + } + + if (!ExtUI::isAxisPositionKnown(axis)) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_HOMING_REQUIRED); + return; + } + + UI_INCREMENT_BY(AxisPosition_mm, offset, axis); + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::MoveSetStep(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::StepSize size = (DGUS_Data::StepSize)((uint8_t*)data_ptr)[1]; + + dgus_screen_handler.move_steps = size; + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::GcodeClear(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + UNUSED(data_ptr); + + ZERO(dgus_screen_handler.gcode); + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::GcodeExecute(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + UNUSED(data_ptr); + + if (!strlen(dgus_screen_handler.gcode)) { + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 1); + dgus_screen_handler.SetMessageLinePGM(PSTR("Executing command..."), 2); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 3); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 4); + dgus_screen_handler.ShowWaitScreen(DGUS_Screen::GCODE); + + queue.enqueue_one_now(dgus_screen_handler.gcode); +} + +void DGUSRxHandler::ResetEEPROM(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1]; + + if (result != DGUS_Data::Popup::CONFIRMED) { + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + queue.enqueue_now_P(PSTR("M502")); + queue.enqueue_now_P(DGUS_CMD_EEPROM_SAVE); +} + +void DGUSRxHandler::SettingsExtra(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Extra extra = (DGUS_Data::Extra)((uint8_t*)data_ptr)[1]; + + switch (extra) { + default: return; + case DGUS_Data::Extra::BUTTON1: + #if ENABLED(BLTOUCH) + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + queue.enqueue_now_P(PSTR(DGUS_RESET_BLTOUCH)); + #else + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::INFOS); + #endif + break; + #if ENABLED(BLTOUCH) + case DGUS_Data::Extra::BUTTON2: + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::INFOS); + break; + #endif + } +} + +void DGUSRxHandler::PIDSelect(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Heater heater = (DGUS_Data::Heater)Swap16(*(uint16_t*)data_ptr); + + switch (heater) { + default: return; + case DGUS_Data::Heater::BED: + dgus_screen_handler.pid_temp = DGUS_PLA_TEMP_BED; + dgus_screen_handler.pid_heater = heater; + break; + case DGUS_Data::Heater::H0: + #if HOTENDS > 1 + case DGUS_Data::Heater::H1: + #endif + dgus_screen_handler.pid_temp = DGUS_PLA_TEMP_HOTEND; + dgus_screen_handler.pid_heater = heater; + break; + } + + dgus_screen_handler.pid_cycles = 5; + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::PIDSetTemp(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + uint16_t temp = Swap16(*(uint16_t*)data_ptr); + + switch (dgus_screen_handler.pid_heater) { + default: return; + case DGUS_Data::Heater::BED: + temp = constrain(temp, BED_MINTEMP, BED_MAX_TARGET); + break; + case DGUS_Data::Heater::H0: + temp = constrain(temp, HEATER_0_MINTEMP, (HEATER_0_MAXTEMP - HOTEND_OVERSHOOT)); + break; + #if HOTENDS > 1 + case DGUS_Data::Heater::H1: + temp = constrain(temp, HEATER_1_MINTEMP, (HEATER_1_MAXTEMP - HOTEND_OVERSHOOT)); + break; + #endif + } + + dgus_screen_handler.pid_temp = temp; + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::PIDRun(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + UNUSED(data_ptr); + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + heater_id_t heater; + uint8_t cycles = constrain(dgus_screen_handler.pid_cycles, 3, 10); + + switch (dgus_screen_handler.pid_heater) { + default: return; + case DGUS_Data::Heater::BED: + #if ENABLED(PIDTEMPBED) + heater = H_BED; + break; + #else + dgus_screen_handler.SetStatusMessagePGM(PSTR("Bed PID disabled")); + return; + #endif + case DGUS_Data::Heater::H0: + #if ENABLED(PIDTEMP) + heater = H_E0; + break; + #else + dgus_screen_handler.SetStatusMessagePGM(PSTR("PID disabled")); + return; + #endif + #if HOTENDS > 1 + case DGUS_Data::Heater::H1: + #if ENABLED(PIDTEMP) + heater = H_E1; + break; + #else + dgus_screen_handler.SetStatusMessagePGM(PSTR("PID disabled")); + return; + #endif + #endif + } + + char buffer[24]; + snprintf_P(buffer, sizeof(buffer), PSTR("M303C%dE%dS%dU1"), cycles, heater, dgus_screen_handler.pid_temp); + + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 1); + dgus_screen_handler.SetMessageLinePGM(PSTR("PID autotuning..."), 2); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 3); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 4); + dgus_screen_handler.ShowWaitScreen(DGUS_Screen::PID); + + queue.enqueue_one_now(buffer); + queue.enqueue_now_P(DGUS_CMD_EEPROM_SAVE); +} + +#if ENABLED(POWER_LOSS_RECOVERY) + void DGUSRxHandler::PowerLossAbort(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1]; + + if (result != DGUS_Data::Popup::CONFIRMED) { + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::HOME); + + queue.enqueue_now_P(PSTR("M1000C")); + } + + void DGUSRxHandler::PowerLossResume(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1]; + + if (result != DGUS_Data::Popup::CONFIRMED) { + return; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return; + } + + if (!recovery.valid()) { + dgus_screen_handler.SetStatusMessagePGM(PSTR("Invalid recovery data")); + return; + } + + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PRINT_STATUS); + + queue.enqueue_now_P(PSTR("M1000")); + } +#endif // POWER_LOSS_RECOVERY + +void DGUSRxHandler::WaitAbort(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1]; + + if (result != DGUS_Data::Popup::CONFIRMED) { + return; + } + + if (!printingIsPaused() + #if ENABLED(ADVANCED_PAUSE_FEATURE) + || !did_pause_print + #endif + ) { + dgus_screen_handler.TriggerFullUpdate(); + return; + } + + #if ENABLED(ADVANCED_PAUSE_FEATURE) + did_pause_print = 0; + #endif + + ExtUI::setUserConfirmed(); + ExtUI::stopPrint(); + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::WaitContinue(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + UNUSED(data_ptr); + + ExtUI::setUserConfirmed(); + + dgus_screen_handler.TriggerFullUpdate(); +} + +void DGUSRxHandler::FanSpeed(DGUS_VP &vp, void *data_ptr) { + uint8_t speed = ((uint8_t*)data_ptr)[1]; + switch (vp.addr) { + default: return; + case DGUS_Addr::FAN0_Speed: + ExtUI::setTargetFan_percent(speed, ExtUI::FAN0); + break; + } +} + +void DGUSRxHandler::Volume(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + uint8_t volume = ((uint8_t*)data_ptr)[1]; + dgus_display.SetVolume(volume); + + dgus_screen_handler.TriggerEEPROMSave(); +} + +void DGUSRxHandler::Brightness(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + + uint8_t brightness = ((uint8_t*)data_ptr)[1]; + dgus_display.SetBrightness(brightness); + + dgus_screen_handler.TriggerEEPROMSave(); +} + +void DGUSRxHandler::Debug(DGUS_VP &vp, void *data_ptr) { + UNUSED(vp); + UNUSED(data_ptr); + + ++dgus_screen_handler.debug_count; + + if (dgus_screen_handler.debug_count >= 10) { + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::DEBUG); + } +} + +void DGUSRxHandler::StringToExtra(DGUS_VP &vp, void *data_ptr) { + if (!vp.size || !vp.extra) return; + memcpy(vp.extra, data_ptr, vp.size); +} + +#endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.h b/Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.h new file mode 100644 index 0000000000..d092d3a5b7 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.h @@ -0,0 +1,123 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#pragma once + +#include "DGUSDisplay.h" +#include "definition/DGUS_VP.h" + +namespace DGUSRxHandler { + + void ScreenChange(DGUS_VP &, void *); + + #if ENABLED(SDSUPPORT) + void Scroll(DGUS_VP &, void *); + void SelectFile(DGUS_VP &, void *); + void PrintFile(DGUS_VP &, void *); + #endif + + void PrintAbort(DGUS_VP &, void *); + void PrintPause(DGUS_VP &, void *); + void PrintResume(DGUS_VP &, void *); + + void Feedrate(DGUS_VP &, void *); + void Flowrate(DGUS_VP &, void *); + void BabystepSet(DGUS_VP &, void *); + void Babystep(DGUS_VP &, void *); + + void TempPreset(DGUS_VP &, void *); + void TempTarget(DGUS_VP &, void *); + void TempCool(DGUS_VP &, void *); + + void Steppers(DGUS_VP &, void *); + + void ZOffset(DGUS_VP &, void *); + void ZOffsetStep(DGUS_VP &, void *); + void ZOffsetSetStep(DGUS_VP &, void *); + + void MoveToPoint(DGUS_VP &, void *); + + void Probe(DGUS_VP &, void *); + void DisableABL(DGUS_VP &, void *); + + void FilamentSelect(DGUS_VP &, void *); + void FilamentLength(DGUS_VP &, void *); + void FilamentMove(DGUS_VP &, void *); + + void Home(DGUS_VP &, void *); + void Move(DGUS_VP &, void *); + void MoveStep(DGUS_VP &, void *); + void MoveSetStep(DGUS_VP &, void *); + + void GcodeClear(DGUS_VP &, void *); + void GcodeExecute(DGUS_VP &, void *); + + void ResetEEPROM(DGUS_VP &, void *); + + void SettingsExtra(DGUS_VP &, void *); + + void PIDSelect(DGUS_VP &, void *); + void PIDSetTemp(DGUS_VP &, void *); + void PIDRun(DGUS_VP &, void *); + + #if ENABLED(POWER_LOSS_RECOVERY) + void PowerLossAbort(DGUS_VP &, void *); + void PowerLossResume(DGUS_VP &, void *); + #endif + + void WaitAbort(DGUS_VP &, void *); + void WaitContinue(DGUS_VP &, void *); + + void FanSpeed(DGUS_VP &, void *); + + void Volume(DGUS_VP &, void *); + + void Brightness(DGUS_VP &, void *); + + void Debug(DGUS_VP &, void *); + + void StringToExtra(DGUS_VP &, void *); + + template + void IntegerToExtra(DGUS_VP &vp, void *data_ptr) { + if (!vp.size || !vp.extra) return; + switch (vp.size) { + default: return; + case 1: { + const uint8_t data = *(uint8_t*)data_ptr; + *(T*)vp.extra = (T)data; + break; + } + case 2: { + const uint16_t data = Swap16(*(uint16_t*)data_ptr); + *(T*)vp.extra = (T)data; + break; + } + case 4: { + const uint32_t data = dgus_display.SwapBytes(*(uint32_t*)data_ptr); + *(T*)vp.extra = (T)data; + break; + } + } + } + +} diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.cpp b/Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.cpp new file mode 100644 index 0000000000..6316f1194b --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.cpp @@ -0,0 +1,540 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#include "../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "DGUSScreenHandler.h" + +#include "DGUSDisplay.h" +#include "definition/DGUS_ScreenAddrList.h" +#include "definition/DGUS_ScreenSetup.h" + +#include "../../../gcode/queue.h" + +uint8_t DGUSScreenHandler::debug_count = 0; + +#if ENABLED(SDSUPPORT) + ExtUI::FileList DGUSScreenHandler::filelist; + uint16_t DGUSScreenHandler::filelist_offset = 0; + int16_t DGUSScreenHandler::filelist_selected = -1; +#endif + +DGUS_Data::StepSize DGUSScreenHandler::offset_steps = DGUS_Data::StepSize::MMP1; +DGUS_Data::StepSize DGUSScreenHandler::move_steps = DGUS_Data::StepSize::MM10; + +uint16_t DGUSScreenHandler::probing_icons[] = { 0, 0 }; + +DGUS_Data::Extruder DGUSScreenHandler::filament_extruder = DGUS_Data::Extruder::CURRENT; +uint16_t DGUSScreenHandler::filament_length = DGUS_DEFAULT_FILAMENT_LEN; + +char DGUSScreenHandler::gcode[] = ""; + +DGUS_Data::Heater DGUSScreenHandler::pid_heater = DGUS_Data::Heater::H0; +uint16_t DGUSScreenHandler::pid_temp = DGUS_PLA_TEMP_HOTEND; +uint8_t DGUSScreenHandler::pid_cycles = 5; + +bool DGUSScreenHandler::settings_ready = false; +bool DGUSScreenHandler::booted = false; + +DGUS_Screen DGUSScreenHandler::current_screen = DGUS_Screen::BOOT; +DGUS_Screen DGUSScreenHandler::new_screen = DGUS_Screen::BOOT; +bool DGUSScreenHandler::full_update = false; + +DGUS_Screen DGUSScreenHandler::wait_return_screen = DGUS_Screen::HOME; +bool DGUSScreenHandler::wait_continue = false; + +bool DGUSScreenHandler::leveling_active = false; + +millis_t DGUSScreenHandler::status_expire = 0; +millis_t DGUSScreenHandler::eeprom_save = 0; + +const char DGUS_MSG_HOMING_REQUIRED[] PROGMEM = "Homing required", + DGUS_MSG_BUSY[] PROGMEM = "Busy", + DGUS_MSG_UNDEF[] PROGMEM = "-", + DGUS_MSG_HOMING[] PROGMEM = "Homing...", + DGUS_MSG_FW_OUTDATED[] PROGMEM = "DWIN GUI/OS update required", + DGUS_MSG_ABL_REQUIRED[] PROGMEM = "Auto bed leveling required"; + +const char DGUS_CMD_HOME[] PROGMEM = "G28", + DGUS_CMD_EEPROM_SAVE[] PROGMEM = "M500"; + +void DGUSScreenHandler::Init() { + dgus_display.Init(); + + MoveToScreen(DGUS_Screen::BOOT, true); +} + +void DGUSScreenHandler::Ready() { + dgus_display.PlaySound(1); +} + +void DGUSScreenHandler::Loop() { + if (!settings_ready || current_screen == DGUS_Screen::KILL) { + return; + } + + const millis_t ms = ExtUI::safe_millis(); + static millis_t next_event_ms = 0; + + if (new_screen != DGUS_Screen::BOOT) { + const DGUS_Screen screen = new_screen; + new_screen = DGUS_Screen::BOOT; + + if (current_screen == screen) { + TriggerFullUpdate(); + } + else { + MoveToScreen(screen); + } + return; + } + + if (!booted && ELAPSED(ms, 3000)) { + booted = true; + + if (current_screen == DGUS_Screen::BOOT) { + MoveToScreen(DGUS_Screen::HOME); + } + return; + } + + if (ELAPSED(ms, next_event_ms) || full_update) { + next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS; + + if (!SendScreenVPData(current_screen, full_update)) { + DEBUG_ECHOLNPGM("SendScreenVPData failed"); + } + return; + } + + if (current_screen == DGUS_Screen::WAIT + && ((wait_continue && !wait_for_user) + || (!wait_continue && IsPrinterIdle()))) { + MoveToScreen(wait_return_screen, true); + return; + } + + if (current_screen == DGUS_Screen::LEVELING_PROBING + && IsPrinterIdle()) { + dgus_display.PlaySound(3); + + SetStatusMessagePGM(ExtUI::getMeshValid() ? + PSTR("Probing successful") + : PSTR("Probing failed")); + + MoveToScreen(DGUS_Screen::LEVELING_AUTOMATIC); + return; + } + + if (status_expire > 0 && ELAPSED(ms, status_expire)) { + SetStatusMessagePGM(NUL_STR, 0); + return; + } + + if (eeprom_save > 0 && ELAPSED(ms, eeprom_save) && IsPrinterIdle()) { + eeprom_save = 0; + + queue.enqueue_now_P(DGUS_CMD_EEPROM_SAVE); + return; + } + + dgus_display.Loop(); +} + +void DGUSScreenHandler::PrinterKilled(PGM_P error, PGM_P component) { + SetMessageLinePGM(error, 1); + SetMessageLinePGM(component, 2); + SetMessageLinePGM(NUL_STR, 3); + SetMessageLinePGM(GET_TEXT(MSG_PLEASE_RESET), 4); + + dgus_display.PlaySound(3, 1, 200); + + MoveToScreen(DGUS_Screen::KILL, true); +} + +void DGUSScreenHandler::UserConfirmRequired(const char * const msg) { + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 1); + dgus_screen_handler.SetMessageLine(msg, 2); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 3); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 4); + + dgus_display.PlaySound(3); + + dgus_screen_handler.ShowWaitScreen(current_screen, true); +} + +void DGUSScreenHandler::SettingsReset() { + dgus_display.SetVolume(DGUS_DEFAULT_VOLUME); + dgus_display.SetBrightness(DGUS_DEFAULT_BRIGHTNESS); + + if (!settings_ready) { + settings_ready = true; + + Ready(); + } + + SetStatusMessagePGM(PSTR("EEPROM reset")); +} + +void DGUSScreenHandler::StoreSettings(char *buff) { + eeprom_data_t data; + + static_assert(sizeof(data) <= ExtUI::eeprom_data_size, "sizeof(eeprom_data_t) > eeprom_data_size."); + + data.initialized = true; + data.volume = dgus_display.GetVolume(); + data.brightness = dgus_display.GetBrightness(); + data.abl = (ExtUI::getLevelingActive() && ExtUI::getMeshValid()); + + memcpy(buff, &data, sizeof(data)); +} + +void DGUSScreenHandler::LoadSettings(const char *buff) { + eeprom_data_t data; + + static_assert(sizeof(data) <= ExtUI::eeprom_data_size, "sizeof(eeprom_data_t) > eeprom_data_size."); + + memcpy(&data, buff, sizeof(data)); + + dgus_display.SetVolume(data.initialized ? data.volume : DGUS_DEFAULT_VOLUME); + dgus_display.SetBrightness(data.initialized ? data.brightness : DGUS_DEFAULT_BRIGHTNESS); + + if (data.initialized) { + leveling_active = (data.abl && ExtUI::getMeshValid()); + + ExtUI::setLevelingActive(leveling_active); + } +} + +void DGUSScreenHandler::ConfigurationStoreWritten(bool success) { + if (!success) { + SetStatusMessagePGM(PSTR("EEPROM write failed")); + } +} + +void DGUSScreenHandler::ConfigurationStoreRead(bool success) { + if (!success) { + SetStatusMessagePGM(PSTR("EEPROM read failed")); + } + else if (!settings_ready) { + settings_ready = true; + + Ready(); + } +} + +void DGUSScreenHandler::PlayTone(const uint16_t frequency, const uint16_t duration) { + UNUSED(duration); + + if (frequency >= 1 && frequency <= 255) { + if (duration >= 1 && duration <= 255) { + dgus_display.PlaySound((uint8_t)frequency, (uint8_t)duration); + } + else { + dgus_display.PlaySound((uint8_t)frequency); + } + } +} + +void DGUSScreenHandler::MeshUpdate(const int8_t xpos, const int8_t ypos) { + if (current_screen != DGUS_Screen::LEVELING_PROBING) { + if (current_screen == DGUS_Screen::LEVELING_AUTOMATIC) { + TriggerFullUpdate(); + } + + return; + } + + uint8_t point = ypos * GRID_MAX_POINTS_X + xpos; + probing_icons[point < 16 ? 0 : 1] |= (1U << (point % 16)); + + if (xpos >= GRID_MAX_POINTS_X - 1 + && ypos >= GRID_MAX_POINTS_Y - 1 + && !ExtUI::getMeshValid()) { + probing_icons[0] = 0; + probing_icons[1] = 0; + } + + TriggerFullUpdate(); +} + +void DGUSScreenHandler::PrintTimerStarted() { + TriggerScreenChange(DGUS_Screen::PRINT_STATUS); +} + +void DGUSScreenHandler::PrintTimerPaused() { + dgus_display.PlaySound(3); + + TriggerFullUpdate(); +} + +void DGUSScreenHandler::PrintTimerStopped() { + if (current_screen != DGUS_Screen::PRINT_STATUS + && current_screen != DGUS_Screen::PRINT_ADJUST) { + return; + } + + dgus_display.PlaySound(3); + + TriggerScreenChange(DGUS_Screen::PRINT_FINISHED); +} + +void DGUSScreenHandler::FilamentRunout(const ExtUI::extruder_t extruder) { + char buffer[21]; + snprintf_P(buffer, sizeof(buffer), PSTR("Filament runout E%d"), extruder); + + SetStatusMessage(buffer); + + dgus_display.PlaySound(3); +} + +#if ENABLED(SDSUPPORT) + + void DGUSScreenHandler::SDCardInserted() { + if (current_screen == DGUS_Screen::HOME) { + TriggerScreenChange(DGUS_Screen::PRINT); + } + } + + void DGUSScreenHandler::SDCardRemoved() { + if (current_screen == DGUS_Screen::PRINT) { + TriggerScreenChange(DGUS_Screen::HOME); + } + } + + void DGUSScreenHandler::SDCardError() { + SetStatusMessagePGM(GET_TEXT(MSG_MEDIA_READ_ERROR)); + + if (current_screen == DGUS_Screen::PRINT) { + TriggerScreenChange(DGUS_Screen::HOME); + } + } + +#endif // SDSUPPORT + +#if ENABLED(POWER_LOSS_RECOVERY) + + void DGUSScreenHandler::PowerLossResume() { + MoveToScreen(DGUS_Screen::POWERLOSS, true); + } + +#endif // POWER_LOSS_RECOVERY + +#if HAS_PID_HEATING + + void DGUSScreenHandler::PidTuning(const ExtUI::result_t rst) { + switch (rst) { + case ExtUI::PID_STARTED: + SetStatusMessagePGM(GET_TEXT(MSG_PID_AUTOTUNE)); + break; + case ExtUI::PID_BAD_EXTRUDER_NUM: + SetStatusMessagePGM(GET_TEXT(MSG_PID_BAD_EXTRUDER_NUM)); + break; + case ExtUI::PID_TEMP_TOO_HIGH: + SetStatusMessagePGM(GET_TEXT(MSG_PID_TEMP_TOO_HIGH)); + break; + case ExtUI::PID_TUNING_TIMEOUT: + SetStatusMessagePGM(GET_TEXT(MSG_PID_TIMEOUT)); + break; + case ExtUI::PID_DONE: + SetStatusMessagePGM(GET_TEXT(MSG_PID_AUTOTUNE_DONE)); + break; + default: + return; + } + + dgus_display.PlaySound(3); + } + +#endif // HAS_PID_HEATING + +void DGUSScreenHandler::SetMessageLine(const char* msg, uint8_t line) { + switch (line) { + default: return; + case 1: + dgus_display.WriteString((uint16_t)DGUS_Addr::MESSAGE_Line1, msg, DGUS_LINE_LEN, true, true); + break; + case 2: + dgus_display.WriteString((uint16_t)DGUS_Addr::MESSAGE_Line2, msg, DGUS_LINE_LEN, true, true); + break; + case 3: + dgus_display.WriteString((uint16_t)DGUS_Addr::MESSAGE_Line3, msg, DGUS_LINE_LEN, true, true); + break; + case 4: + dgus_display.WriteString((uint16_t)DGUS_Addr::MESSAGE_Line4, msg, DGUS_LINE_LEN, true, true); + break; + } +} + +void DGUSScreenHandler::SetMessageLinePGM(PGM_P msg, uint8_t line) { + switch (line) { + default: return; + case 1: + dgus_display.WriteStringPGM((uint16_t)DGUS_Addr::MESSAGE_Line1, msg, DGUS_LINE_LEN, true, true); + break; + case 2: + dgus_display.WriteStringPGM((uint16_t)DGUS_Addr::MESSAGE_Line2, msg, DGUS_LINE_LEN, true, true); + break; + case 3: + dgus_display.WriteStringPGM((uint16_t)DGUS_Addr::MESSAGE_Line3, msg, DGUS_LINE_LEN, true, true); + break; + case 4: + dgus_display.WriteStringPGM((uint16_t)DGUS_Addr::MESSAGE_Line4, msg, DGUS_LINE_LEN, true, true); + break; + } +} + +void DGUSScreenHandler::SetStatusMessage(const char* msg, const millis_t duration) { + dgus_display.WriteString((uint16_t)DGUS_Addr::MESSAGE_Status, msg, DGUS_STATUS_LEN, false, true); + + status_expire = (duration > 0 ? ExtUI::safe_millis() + duration : 0); +} + +void DGUSScreenHandler::SetStatusMessagePGM(PGM_P msg, const millis_t duration) { + dgus_display.WriteStringPGM((uint16_t)DGUS_Addr::MESSAGE_Status, msg, DGUS_STATUS_LEN, false, true); + + status_expire = (duration > 0 ? ExtUI::safe_millis() + duration : 0); +} + +void DGUSScreenHandler::ShowWaitScreen(DGUS_Screen return_screen, bool has_continue) { + if (return_screen != DGUS_Screen::WAIT) { + wait_return_screen = return_screen; + } + wait_continue = has_continue; + + TriggerScreenChange(DGUS_Screen::WAIT); +} + +DGUS_Screen DGUSScreenHandler::GetCurrentScreen() { + return current_screen; +} + +void DGUSScreenHandler::TriggerScreenChange(DGUS_Screen screen) { + new_screen = screen; +} + +void DGUSScreenHandler::TriggerFullUpdate() { + full_update = true; +} + +void DGUSScreenHandler::TriggerEEPROMSave() { + eeprom_save = ExtUI::safe_millis() + 500; +} + +bool DGUSScreenHandler::IsPrinterIdle() { + return (!ExtUI::commandsInQueue() + && !ExtUI::isMoving()); +} + +const DGUS_Addr* DGUSScreenHandler::FindScreenAddrList(DGUS_Screen screen) { + DGUS_ScreenAddrList list; + const DGUS_ScreenAddrList *map = screen_addr_list_map; + + do { + memcpy_P(&list, map, sizeof(*map)); + if (!list.addr_list) break; + if (list.screen == screen) { + return list.addr_list; + } + } while (++map); + + return nullptr; +} + +bool DGUSScreenHandler::CallScreenSetup(DGUS_Screen screen) { + DGUS_ScreenSetup setup; + const DGUS_ScreenSetup *list = screen_setup_list; + + do { + memcpy_P(&setup, list, sizeof(*list)); + if (!setup.setup_fn) break; + if (setup.screen == screen) { + return setup.setup_fn(); + } + } while (++list); + + return true; +} + +void DGUSScreenHandler::MoveToScreen(DGUS_Screen screen, bool abort_wait) { + if (current_screen == DGUS_Screen::KILL) { + return; + } + + if (current_screen == DGUS_Screen::WAIT) { + if (screen != DGUS_Screen::WAIT) { + wait_return_screen = screen; + } + + if (!abort_wait) return; + + if (wait_continue && wait_for_user) { + ExtUI::setUserConfirmed(); + } + } + + if (!CallScreenSetup(screen)) return; + + if (!SendScreenVPData(screen, true)) { + DEBUG_ECHOLNPGM("SendScreenVPData failed"); + return; + } + + current_screen = screen; + dgus_display.SwitchScreen(current_screen); +} + +bool DGUSScreenHandler::SendScreenVPData(DGUS_Screen screen, bool complete_update) { + if (complete_update) { + full_update = false; + } + + const DGUS_Addr *list = FindScreenAddrList(screen); + + while (true) { + if (!list) return true; // Nothing left to send + + const uint16_t addr = pgm_read_word(list++); + if (!addr) return true; // Nothing left to send + + DGUS_VP vp; + if (!DGUS_PopulateVP((DGUS_Addr)addr, &vp)) continue; // Invalid VP + if (!vp.tx_handler) continue; // Nothing to send + if (!complete_update && !(vp.flags & VPFLAG_AUTOUPLOAD)) continue; // Unnecessary VP + + uint8_t expected_tx = 6 + vp.size; // 6 bytes header + payload. + const millis_t try_until = ExtUI::safe_millis() + 1000; + + while (expected_tx > dgus_display.GetFreeTxBuffer()) { + if (ELAPSED(ExtUI::safe_millis(), try_until)) return false; // Stop trying after 1 second + + dgus_display.FlushTx(); // Flush the TX buffer + delay(50); + } + + vp.tx_handler(vp); + } +} + +#endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.h b/Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.h new file mode 100644 index 0000000000..056757fedf --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.h @@ -0,0 +1,152 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#pragma once + +#include "config/DGUS_Addr.h" +#include "config/DGUS_Data.h" +#include "config/DGUS_Screen.h" +#include "config/DGUS_Constants.h" + +#include "../ui_api.h" +#include "../../../inc/MarlinConfigPre.h" + +class DGUSScreenHandler { +public: + DGUSScreenHandler() = default; + + static void Init(); + static void Ready(); + static void Loop(); + + static void PrinterKilled(PGM_P error, PGM_P component); + static void UserConfirmRequired(const char * const msg); + static void SettingsReset(); + static void StoreSettings(char *buff); + static void LoadSettings(const char *buff); + static void ConfigurationStoreWritten(bool success); + static void ConfigurationStoreRead(bool success); + + static void PlayTone(const uint16_t frequency, const uint16_t duration); + static void MeshUpdate(const int8_t xpos, const int8_t ypos); + static void PrintTimerStarted(); + static void PrintTimerPaused(); + static void PrintTimerStopped(); + static void FilamentRunout(const ExtUI::extruder_t extruder); + + #if ENABLED(SDSUPPORT) + /// 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 + + #if ENABLED(POWER_LOSS_RECOVERY) + static void PowerLossResume(); + #endif + + #if HAS_PID_HEATING + static void PidTuning(const ExtUI::result_t rst); + #endif + + static void SetMessageLine(const char* msg, uint8_t line); + static void SetMessageLinePGM(PGM_P msg, uint8_t line); + + static void SetStatusMessage(const char* msg, const millis_t duration = DGUS_STATUS_EXPIRATION_MS); + static void SetStatusMessagePGM(PGM_P msg, const millis_t duration = DGUS_STATUS_EXPIRATION_MS); + + static void ShowWaitScreen(DGUS_Screen return_screen, bool has_continue = false); + + static DGUS_Screen GetCurrentScreen(); + static void TriggerScreenChange(DGUS_Screen screen); + static void TriggerFullUpdate(); + + static void TriggerEEPROMSave(); + + static bool IsPrinterIdle(); + + static uint8_t debug_count; + + #if ENABLED(SDSUPPORT) + static ExtUI::FileList filelist; + static uint16_t filelist_offset; + static int16_t filelist_selected; + #endif + + static DGUS_Data::StepSize offset_steps; + static DGUS_Data::StepSize move_steps; + + static uint16_t probing_icons[2]; + + static DGUS_Data::Extruder filament_extruder; + static uint16_t filament_length; + + static char gcode[DGUS_GCODE_LEN + 1]; + + static DGUS_Data::Heater pid_heater; + static uint16_t pid_temp; + static uint8_t pid_cycles; + + static bool wait_continue; + + static bool leveling_active; + +private: + static const DGUS_Addr* FindScreenAddrList(DGUS_Screen screen); + static bool CallScreenSetup(DGUS_Screen screen); + + static void MoveToScreen(DGUS_Screen screen, bool abort_wait = false); + static bool SendScreenVPData(DGUS_Screen screen, bool complete_update); + + static bool settings_ready; + static bool booted; + + static DGUS_Screen current_screen; + static DGUS_Screen new_screen; + static bool full_update; + + static DGUS_Screen wait_return_screen; + + static millis_t status_expire; + static millis_t eeprom_save; + + typedef struct { + bool initialized; + uint8_t volume; + uint8_t brightness; + bool abl; + } eeprom_data_t; +}; + +extern DGUSScreenHandler dgus_screen_handler; + +extern const char DGUS_MSG_HOMING_REQUIRED[], + DGUS_MSG_BUSY[], + DGUS_MSG_UNDEF[], + DGUS_MSG_HOMING[], + DGUS_MSG_FW_OUTDATED[], + DGUS_MSG_ABL_REQUIRED[]; + +extern const char DGUS_CMD_HOME[], + DGUS_CMD_EEPROM_SAVE[]; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.cpp b/Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.cpp new file mode 100644 index 0000000000..c12282c4ef --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.cpp @@ -0,0 +1,209 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#include "../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "DGUSSetupHandler.h" + +#include "DGUSDisplay.h" +#include "DGUSScreenHandler.h" + +#include "../../../gcode/queue.h" + +#if ENABLED(SDSUPPORT) + bool DGUSSetupHandler::Print() { + dgus_screen_handler.filelist.refresh(); + + while (!dgus_screen_handler.filelist.isAtRootDir()) { + dgus_screen_handler.filelist.upDir(); + } + + dgus_screen_handler.filelist_offset = 0; + dgus_screen_handler.filelist_selected = -1; + + return true; + } +#endif + +bool DGUSSetupHandler::PrintStatus() { + if (printingIsActive() || printingIsPaused()) { + return true; + } + + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PRINT_FINISHED); + return false; +} + +bool DGUSSetupHandler::PrintAdjust() { + if (printingIsActive() || printingIsPaused()) { + return true; + } + + dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PRINT_FINISHED); + return false; +} + +bool DGUSSetupHandler::LevelingMenu() { + ExtUI::setLevelingActive(dgus_screen_handler.leveling_active); + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return false; + } + + if (ExtUI::isPositionKnown()) { + if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 10.0f) { + queue.enqueue_now_P(PSTR("G0Z10")); + } + + return true; + } + + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 1); + dgus_screen_handler.SetMessageLinePGM(DGUS_MSG_HOMING, 2); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 3); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 4); + dgus_screen_handler.ShowWaitScreen(DGUS_Screen::LEVELING_MENU); + + queue.enqueue_now_P(DGUS_CMD_HOME); + + return false; +} + +bool DGUSSetupHandler::LevelingManual() { + ExtUI::setLevelingActive(false); + + if (ExtUI::isPositionKnown()) { + return true; + } + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return false; + } + + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 1); + dgus_screen_handler.SetMessageLinePGM(DGUS_MSG_HOMING, 2); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 3); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 4); + dgus_screen_handler.ShowWaitScreen(DGUS_Screen::LEVELING_MANUAL); + + queue.enqueue_now_P(DGUS_CMD_HOME); + + return false; +} + +bool DGUSSetupHandler::LevelingOffset() { + dgus_screen_handler.offset_steps = DGUS_Data::StepSize::MMP1; + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return false; + } + + if (ExtUI::isPositionKnown()) { + if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 4.0f) { + queue.enqueue_now_P(PSTR("G0Z4")); + } + + char buffer[20]; + snprintf_P(buffer, sizeof(buffer), PSTR("G0X%dY%d"), DGUS_LEVEL_CENTER_X, DGUS_LEVEL_CENTER_Y); + + queue.enqueue_one_now(buffer); + queue.enqueue_now_P(PSTR("G0Z0")); + + return true; + } + + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 1); + dgus_screen_handler.SetMessageLinePGM(DGUS_MSG_HOMING, 2); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 3); + dgus_screen_handler.SetMessageLinePGM(NUL_STR, 4); + dgus_screen_handler.ShowWaitScreen(DGUS_Screen::LEVELING_OFFSET); + + queue.enqueue_now_P(DGUS_CMD_HOME); + + return false; +} + +bool DGUSSetupHandler::LevelingAutomatic() { + if (ExtUI::getMeshValid()) { + dgus_screen_handler.leveling_active = true; + + ExtUI::setLevelingActive(true); + } + + return true; +} + +bool DGUSSetupHandler::LevelingProbing() { + dgus_screen_handler.probing_icons[0] = 0; + dgus_screen_handler.probing_icons[1] = 0; + + return true; +} + +bool DGUSSetupHandler::Filament() { + dgus_screen_handler.filament_extruder = DGUS_Data::Extruder::CURRENT; + dgus_screen_handler.filament_length = DGUS_DEFAULT_FILAMENT_LEN; + + return true; +} + +bool DGUSSetupHandler::Move() { + dgus_screen_handler.move_steps = DGUS_Data::StepSize::MM10; + + if (!dgus_screen_handler.IsPrinterIdle()) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_BUSY); + return false; + } + + return true; +} + +bool DGUSSetupHandler::Gcode() { + ZERO(dgus_screen_handler.gcode); + + if (dgus_display.gui_version < 0x30 || dgus_display.os_version < 0x21) { + dgus_screen_handler.SetStatusMessagePGM(DGUS_MSG_FW_OUTDATED); + return false; + } + + return true; +} + +bool DGUSSetupHandler::PID() { + dgus_screen_handler.pid_heater = DGUS_Data::Heater::H0; + dgus_screen_handler.pid_temp = DGUS_PLA_TEMP_HOTEND; + + return true; +} + +bool DGUSSetupHandler::Infos() { + dgus_screen_handler.debug_count = 0; + + return true; +} + +#endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.h b/Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.h new file mode 100644 index 0000000000..b1159ff708 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.h @@ -0,0 +1,43 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#pragma once + +namespace DGUSSetupHandler { + + #if ENABLED(SDSUPPORT) + bool Print(); + #endif + bool PrintStatus(); + bool PrintAdjust(); + bool LevelingMenu(); + bool LevelingOffset(); + bool LevelingManual(); + bool LevelingAutomatic(); + bool LevelingProbing(); + bool Filament(); + bool Move(); + bool Gcode(); + bool PID(); + bool Infos(); + +} diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.cpp b/Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.cpp new file mode 100644 index 0000000000..04362b07e8 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.cpp @@ -0,0 +1,632 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#include "../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "DGUSTxHandler.h" + +#include "DGUSScreenHandler.h" +#include "config/DGUS_Data.h" + +#include "../ui_api.h" +#include "../../../module/stepper.h" +#include "../../../module/printcounter.h" +#if ENABLED(ADVANCED_PAUSE_FEATURE) + #include "../../../feature/pause.h" +#endif + +#if ENABLED(SDSUPPORT) + void DGUSTxHandler::SetFileControlState(int file, bool state) { + DGUS_Control control; + + switch (file) { + default: return; + case 0: + control = DGUS_Control::FILE0; + break; + case 1: + control = DGUS_Control::FILE1; + break; + case 2: + control = DGUS_Control::FILE2; + break; + case 3: + control = DGUS_Control::FILE3; + break; + case 4: + control = DGUS_Control::FILE4; + break; + } + + if (state) { + dgus_display.EnableControl(DGUS_Screen::PRINT, + DGUSDisplay::RETURN_KEY_CODE, + control); + } + else { + dgus_display.DisableControl(DGUS_Screen::PRINT, + DGUSDisplay::RETURN_KEY_CODE, + control); + } + } + + void DGUSTxHandler::FileType(DGUS_VP &vp) { + // Batch send + uint16_t data[DGUS_FILE_COUNT]; + + for (int i = 0; i < DGUS_FILE_COUNT; i++) { + if (!dgus_screen_handler.filelist.seek(dgus_screen_handler.filelist_offset + i)) { + data[i] = Swap16((uint16_t)DGUS_Data::SDType::NONE); + + SetFileControlState(i, false); + continue; + } + + data[i] = dgus_screen_handler.filelist.isDir() ? + Swap16((uint16_t)DGUS_Data::SDType::DIRECTORY) + : Swap16((uint16_t)DGUS_Data::SDType::FILE); + + SetFileControlState(i, true); + } + + dgus_display.Write((uint16_t)vp.addr, data, sizeof(*data) * DGUS_FILE_COUNT); + } + + void DGUSTxHandler::FileName(DGUS_VP &vp) { + uint8_t offset; + + switch (vp.addr) { + default: return; + case DGUS_Addr::SD_FileName0: + offset = 0; + break; + case DGUS_Addr::SD_FileName1: + offset = 1; + break; + case DGUS_Addr::SD_FileName2: + offset = 2; + break; + case DGUS_Addr::SD_FileName3: + offset = 3; + break; + case DGUS_Addr::SD_FileName4: + offset = 4; + break; + } + + if (dgus_screen_handler.filelist.seek(dgus_screen_handler.filelist_offset + offset)) { + dgus_display.WriteString((uint16_t)vp.addr, dgus_screen_handler.filelist.filename(), vp.size); + } + else { + dgus_display.WriteStringPGM((uint16_t)vp.addr, NUL_STR, vp.size); + } + } + + void DGUSTxHandler::ScrollIcons(DGUS_VP &vp) { + uint16_t icons = 0; + + if (!dgus_screen_handler.filelist.isAtRootDir()) { + icons |= (uint16_t)DGUS_Data::ScrollIcon::GO_BACK; + + dgus_display.EnableControl(DGUS_Screen::PRINT, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::GO_BACK); + } + else { + dgus_display.DisableControl(DGUS_Screen::PRINT, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::GO_BACK); + } + + if (dgus_screen_handler.filelist_offset > 0) { + icons |= (uint16_t)DGUS_Data::ScrollIcon::UP; + + dgus_display.EnableControl(DGUS_Screen::PRINT, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::SCROLL_UP); + } + else { + dgus_display.DisableControl(DGUS_Screen::PRINT, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::SCROLL_UP); + } + + if (dgus_screen_handler.filelist_offset + DGUS_FILE_COUNT < dgus_screen_handler.filelist.count()) { + icons |= (uint16_t)DGUS_Data::ScrollIcon::DOWN; + + dgus_display.EnableControl(DGUS_Screen::PRINT, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::SCROLL_DOWN); + } + else { + dgus_display.DisableControl(DGUS_Screen::PRINT, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::SCROLL_DOWN); + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(icons)); + } + + void DGUSTxHandler::SelectedFileName(DGUS_VP &vp) { + if (dgus_screen_handler.filelist_selected < 0 + || !dgus_screen_handler.filelist.seek(dgus_screen_handler.filelist_selected)) { + dgus_display.WriteStringPGM((uint16_t)vp.addr, NUL_STR, vp.size); + return; + } + + dgus_display.WriteString((uint16_t)vp.addr, dgus_screen_handler.filelist.filename(), vp.size); + } +#endif // SDSUPPORT + +void DGUSTxHandler::PositionZ(DGUS_VP &vp) { + float position = ExtUI::isAxisPositionKnown(ExtUI::Z) ? + planner.get_axis_position_mm(Z_AXIS) + : 0; + + const int16_t data = dgus_display.ToFixedPoint(position); + dgus_display.Write((uint16_t)vp.addr, Swap16(data)); +} + +void DGUSTxHandler::Ellapsed(DGUS_VP &vp) { + char buffer[21]; + duration_t(print_job_timer.duration()).toString(buffer); + + dgus_display.WriteString((uint16_t)vp.addr, buffer, vp.size); +} + +void DGUSTxHandler::Percent(DGUS_VP &vp) { + uint16_t progress; + + switch (vp.addr) { + default: return; + case DGUS_Addr::STATUS_Percent: + progress = constrain(ExtUI::getProgress_percent(), 0, 100); + break; + case DGUS_Addr::STATUS_Percent_Complete: + progress = 100; + break; + } + + dgus_display.Write((uint16_t)DGUS_Addr::STATUS_Percent, Swap16(progress)); +} + +void DGUSTxHandler::StatusIcons(DGUS_VP &vp) { + uint16_t icons = 0; + + if (printingIsActive()) { + icons |= (uint16_t)DGUS_Data::StatusIcon::PAUSE; + + dgus_display.EnableControl(DGUS_Screen::PRINT_STATUS, + DGUSDisplay::POPUP_WINDOW, + DGUS_Control::PAUSE); + } + else { + dgus_display.DisableControl(DGUS_Screen::PRINT_STATUS, + DGUSDisplay::POPUP_WINDOW, + DGUS_Control::PAUSE); + } + + if (printingIsPaused()) { + icons |= (uint16_t)DGUS_Data::StatusIcon::RESUME; + + dgus_display.EnableControl(DGUS_Screen::PRINT_STATUS, + DGUSDisplay::POPUP_WINDOW, + DGUS_Control::RESUME); + } + else { + dgus_display.DisableControl(DGUS_Screen::PRINT_STATUS, + DGUSDisplay::POPUP_WINDOW, + DGUS_Control::RESUME); + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(icons)); +} + +void DGUSTxHandler::Flowrate(DGUS_VP &vp) { + int16_t flowrate; + + switch (vp.addr) { + default: return; + case DGUS_Addr::ADJUST_Flowrate_CUR: + #if EXTRUDERS > 1 + flowrate = ExtUI::getFlow_percent(ExtUI::getActiveTool()); + #else + flowrate = ExtUI::getFlow_percent(ExtUI::E0); + #endif + break; + #if EXTRUDERS > 1 + case DGUS_Addr::ADJUST_Flowrate_E0: + flowrate = ExtUI::getFlow_percent(ExtUI::E0); + break; + case DGUS_Addr::ADJUST_Flowrate_E1: + flowrate = ExtUI::getFlow_percent(ExtUI::E1); + break; + #endif + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(flowrate)); +} + +void DGUSTxHandler::TempMax(DGUS_VP &vp) { + uint16_t temp; + + switch (vp.addr) { + default: return; + case DGUS_Addr::TEMP_Max_Bed: + temp = BED_MAX_TARGET; + break; + case DGUS_Addr::TEMP_Max_H0: + temp = HEATER_0_MAXTEMP - HOTEND_OVERSHOOT; + break; + #if HOTENDS > 1 + case DGUS_Addr::TEMP_Max_H1: + temp = HEATER_1_MAXTEMP - HOTEND_OVERSHOOT; + break; + #endif + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(temp)); +} + +void DGUSTxHandler::StepperStatus(DGUS_VP &vp) { + if (X_ENABLE_READ() == X_ENABLE_ON + && Y_ENABLE_READ() == Y_ENABLE_ON + && Z_ENABLE_READ() == Z_ENABLE_ON) { + dgus_display.Write((uint16_t)vp.addr, Swap16((uint16_t)DGUS_Data::Status::ENABLED)); + } + else { + dgus_display.Write((uint16_t)vp.addr, Swap16((uint16_t)DGUS_Data::Status::DISABLED)); + } +} + +void DGUSTxHandler::StepIcons(DGUS_VP &vp) { + if (!vp.extra) return; + uint16_t icons = 0; + DGUS_Data::StepSize size = *(DGUS_Data::StepSize*)vp.extra; + + switch (size) { + case DGUS_Data::StepSize::MM10: + icons |= (uint16_t)DGUS_Data::StepIcon::MM10; + break; + case DGUS_Data::StepSize::MM1: + icons |= (uint16_t)DGUS_Data::StepIcon::MM1; + break; + case DGUS_Data::StepSize::MMP1: + icons |= (uint16_t)DGUS_Data::StepIcon::MMP1; + break; + case DGUS_Data::StepSize::MMP01: + icons |= (uint16_t)DGUS_Data::StepIcon::MMP01; + break; + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(icons)); +} + +void DGUSTxHandler::ABLDisableIcon(DGUS_VP &vp) { + uint16_t data; + + if (ExtUI::getLevelingActive()) { + data = (uint16_t)DGUS_Data::Status::ENABLED; + + dgus_display.EnableControl(DGUS_Screen::LEVELING_AUTOMATIC, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::DISABLE); + } + else { + data = (uint16_t)DGUS_Data::Status::DISABLED; + + dgus_display.DisableControl(DGUS_Screen::LEVELING_AUTOMATIC, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::DISABLE); + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(data)); +} + +void DGUSTxHandler::ABLGrid(DGUS_VP &vp) { + // Batch send + int16_t data[DGUS_LEVEL_GRID_SIZE]; + xy_uint8_t point; + int16_t fixed; + + for (int i = 0; i < DGUS_LEVEL_GRID_SIZE; i++) { + point.x = i % GRID_MAX_POINTS_X; + point.y = i / GRID_MAX_POINTS_X; + fixed = dgus_display.ToFixedPoint(ExtUI::getMeshPoint(point)); + data[i] = Swap16(fixed); + } + + dgus_display.Write((uint16_t)vp.addr, data, sizeof(*data) * DGUS_LEVEL_GRID_SIZE); +} + +void DGUSTxHandler::FilamentIcons(DGUS_VP &vp) { + uint16_t icons = 0; + + switch (dgus_screen_handler.filament_extruder) { + default: return; + case DGUS_Data::Extruder::CURRENT: + #if EXTRUDERS > 1 + switch (ExtUI::getActiveTool()) { + default: break; + case ExtUI::E0: + icons |= (uint16_t)DGUS_Data::ExtruderIcon::E0; + break; + case ExtUI::E1: + icons |= (uint16_t)DGUS_Data::ExtruderIcon::E1; + break; + } + break; + #endif + case DGUS_Data::Extruder::E0: + icons |= (uint16_t)DGUS_Data::ExtruderIcon::E0; + break; + case DGUS_Data::Extruder::E1: + icons |= (uint16_t)DGUS_Data::ExtruderIcon::E1; + break; + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(icons)); +} + +void DGUSTxHandler::BLTouch(DGUS_VP &vp) { + #if ENABLED(BLTOUCH) + dgus_display.EnableControl(DGUS_Screen::SETTINGS_MENU2, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::EXTRA2); + + dgus_display.Write((uint16_t)vp.addr, Swap16((uint16_t)DGUS_Data::Status::ENABLED)); + #else + dgus_display.DisableControl(DGUS_Screen::SETTINGS_MENU2, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::EXTRA2); + + dgus_display.Write((uint16_t)vp.addr, Swap16((uint16_t)DGUS_Data::Status::DISABLED)); + #endif +} + +void DGUSTxHandler::PIDIcons(DGUS_VP &vp) { + uint16_t icons = 0; + + switch (dgus_screen_handler.pid_heater) { + default: return; + case DGUS_Data::Heater::BED: + icons |= (uint16_t)DGUS_Data::HeaterIcon::BED; + break; + case DGUS_Data::Heater::H0: + icons |= (uint16_t)DGUS_Data::HeaterIcon::H0; + break; + case DGUS_Data::Heater::H1: + icons |= (uint16_t)DGUS_Data::HeaterIcon::H1; + break; + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(icons)); +} + +void DGUSTxHandler::PIDKp(DGUS_VP &vp) { + float value; + + switch (dgus_screen_handler.pid_heater) { + default: return; + #if ENABLED(PIDTEMPBED) + case DGUS_Data::Heater::BED: + value = ExtUI::getBedPIDValues_Kp(); + break; + #endif + #if ENABLED(PIDTEMP) + case DGUS_Data::Heater::H0: + value = ExtUI::getPIDValues_Kp(ExtUI::E0); + break; + #if HOTENDS > 1 + case DGUS_Data::Heater::H1: + value = ExtUI::getPIDValues_Kp(ExtUI::E1); + break; + #endif + #endif + } + + const int32_t data = dgus_display.ToFixedPoint(value); + dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); +} + +void DGUSTxHandler::PIDKi(DGUS_VP &vp) { + float value; + + switch (dgus_screen_handler.pid_heater) { + default: return; + #if ENABLED(PIDTEMPBED) + case DGUS_Data::Heater::BED: + value = ExtUI::getBedPIDValues_Ki(); + break; + #endif + #if ENABLED(PIDTEMP) + case DGUS_Data::Heater::H0: + value = ExtUI::getPIDValues_Ki(ExtUI::E0); + break; + #if HOTENDS > 1 + case DGUS_Data::Heater::H1: + value = ExtUI::getPIDValues_Ki(ExtUI::E1); + break; + #endif + #endif + } + + const int32_t data = dgus_display.ToFixedPoint(value); + dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); +} + +void DGUSTxHandler::PIDKd(DGUS_VP &vp) { + float value; + + switch (dgus_screen_handler.pid_heater) { + default: return; + #if ENABLED(PIDTEMPBED) + case DGUS_Data::Heater::BED: + value = ExtUI::getBedPIDValues_Kd(); + break; + #endif + #if ENABLED(PIDTEMP) + case DGUS_Data::Heater::H0: + value = ExtUI::getPIDValues_Kd(ExtUI::E0); + break; + #if HOTENDS > 1 + case DGUS_Data::Heater::H1: + value = ExtUI::getPIDValues_Kd(ExtUI::E1); + break; + #endif + #endif + } + + const int32_t data = dgus_display.ToFixedPoint(value); + dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); +} + +void DGUSTxHandler::BuildVolume(DGUS_VP &vp) { + char buffer[vp.size]; + snprintf_P(buffer, vp.size, PSTR("%dx%dx%d"), X_BED_SIZE, Y_BED_SIZE, (Z_MAX_POS - Z_MIN_POS)); + + dgus_display.WriteString((uint16_t)vp.addr, buffer, vp.size); +} + +void DGUSTxHandler::TotalPrints(DGUS_VP &vp) { + #if ENABLED(PRINTCOUNTER) + dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(print_job_timer.getStats().totalPrints)); + #else + UNUSED(vp); + #endif +} + +void DGUSTxHandler::FinishedPrints(DGUS_VP &vp) { + #if ENABLED(PRINTCOUNTER) + dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(print_job_timer.getStats().finishedPrints)); + #else + UNUSED(vp); + #endif +} + +void DGUSTxHandler::PrintTime(DGUS_VP &vp) { + #if ENABLED(PRINTCOUNTER) + char buffer[21]; + ExtUI::getTotalPrintTime_str(buffer); + + dgus_display.WriteString((uint16_t)vp.addr, buffer, vp.size); + #else + dgus_display.WriteStringPGM((uint16_t)vp.addr, DGUS_MSG_UNDEF, vp.size); + #endif +} + +void DGUSTxHandler::LongestPrint(DGUS_VP &vp) { + #if ENABLED(PRINTCOUNTER) + char buffer[21]; + ExtUI::getLongestPrint_str(buffer); + + dgus_display.WriteString((uint16_t)vp.addr, buffer, vp.size); + #else + dgus_display.WriteStringPGM((uint16_t)vp.addr, DGUS_MSG_UNDEF, vp.size); + #endif +} + +void DGUSTxHandler::FilamentUsed(DGUS_VP &vp) { + #if ENABLED(PRINTCOUNTER) + char buffer[21]; + ExtUI::getFilamentUsed_str(buffer); + + dgus_display.WriteString((uint16_t)vp.addr, buffer, vp.size); + #else + dgus_display.WriteStringPGM((uint16_t)vp.addr, DGUS_MSG_UNDEF, vp.size); + #endif +} + +void DGUSTxHandler::WaitIcons(DGUS_VP &vp) { + uint16_t icons = 0; + + if (printingIsPaused() + #if ENABLED(ADVANCED_PAUSE_FEATURE) + && did_pause_print + #endif + ) { + icons |= (uint16_t)DGUS_Data::WaitIcon::ABORT; + + dgus_display.EnableControl(DGUS_Screen::WAIT, + DGUSDisplay::POPUP_WINDOW, + DGUS_Control::ABORT); + } + else { + dgus_display.DisableControl(DGUS_Screen::WAIT, + DGUSDisplay::POPUP_WINDOW, + DGUS_Control::ABORT); + } + + if (dgus_screen_handler.wait_continue) { + icons |= (uint16_t)DGUS_Data::WaitIcon::CONTINUE; + + dgus_display.EnableControl(DGUS_Screen::WAIT, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::CONTINUE); + } + else { + dgus_display.DisableControl(DGUS_Screen::WAIT, + DGUSDisplay::RETURN_KEY_CODE, + DGUS_Control::CONTINUE); + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(icons)); +} + +void DGUSTxHandler::FanSpeed(DGUS_VP &vp) { + uint16_t fan_speed; + + switch (vp.addr) { + default: return; + case DGUS_Addr::FAN0_Speed: fan_speed = ExtUI::getTargetFan_percent(ExtUI::FAN0); break; + } + + dgus_display.Write((uint16_t)vp.addr, Swap16(fan_speed)); +} + +void DGUSTxHandler::Volume(DGUS_VP &vp) { + const uint16_t volume = dgus_display.GetVolume(); + + dgus_display.Write((uint16_t)vp.addr, Swap16(volume)); +} + +void DGUSTxHandler::Brightness(DGUS_VP &vp) { + const uint16_t brightness = dgus_display.GetBrightness(); + + dgus_display.Write((uint16_t)vp.addr, Swap16(brightness)); +} + +void DGUSTxHandler::ExtraToString(DGUS_VP &vp) { + if (!vp.size || !vp.extra) return; + + dgus_display.WriteString((uint16_t)vp.addr, vp.extra, vp.size, true, false, false); +} + +void DGUSTxHandler::ExtraPGMToString(DGUS_VP &vp) { + if (!vp.size || !vp.extra) return; + + dgus_display.WriteStringPGM((uint16_t)vp.addr, vp.extra, vp.size, true, false, false); +} + +#endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.h b/Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.h new file mode 100644 index 0000000000..5715abbedf --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.h @@ -0,0 +1,127 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#pragma once + +#include "DGUSDisplay.h" +#include "definition/DGUS_VP.h" + +namespace DGUSTxHandler { + + #if ENABLED(SDSUPPORT) + void SetFileControlState(int, bool); + void FileType(DGUS_VP &); + void FileName(DGUS_VP &); + void ScrollIcons(DGUS_VP &); + void SelectedFileName(DGUS_VP &); + #endif + + void PositionZ(DGUS_VP &); + void Ellapsed(DGUS_VP &); + void Percent(DGUS_VP &); + void StatusIcons(DGUS_VP &); + + void Flowrate(DGUS_VP &); + + void TempMax(DGUS_VP &); + + void StepperStatus(DGUS_VP &); + + void StepIcons(DGUS_VP &); + + void ABLDisableIcon(DGUS_VP &); + void ABLGrid(DGUS_VP &); + + void FilamentIcons(DGUS_VP &); + + void BLTouch(DGUS_VP &); + + void PIDIcons(DGUS_VP &); + void PIDKp(DGUS_VP &); + void PIDKi(DGUS_VP &); + void PIDKd(DGUS_VP &); + + void BuildVolume(DGUS_VP &); + void TotalPrints(DGUS_VP &); + void FinishedPrints(DGUS_VP &); + void PrintTime(DGUS_VP &); + void LongestPrint(DGUS_VP &); + void FilamentUsed(DGUS_VP &); + + void WaitIcons(DGUS_VP &); + + void FanSpeed(DGUS_VP &); + + void Volume(DGUS_VP &); + + void Brightness(DGUS_VP &); + + void ExtraToString(DGUS_VP &); + void ExtraPGMToString(DGUS_VP &); + + template + void ExtraToInteger(DGUS_VP &vp) { + if (!vp.size || !vp.extra) return; + switch (vp.size) { + default: return; + case 1: { + const uint8_t data = (uint8_t)(*(T*)vp.extra); + dgus_display.Write((uint16_t)vp.addr, data); + break; + } + case 2: { + const uint16_t data = (uint16_t)(*(T*)vp.extra); + dgus_display.Write((uint16_t)vp.addr, Swap16(data)); + break; + } + case 4: { + const uint32_t data = (uint32_t)(*(T*)vp.extra); + dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + break; + } + } + } + + template + void ExtraToFixedPoint(DGUS_VP &vp) { + if (!vp.size || !vp.extra) return; + switch (vp.size) { + default: return; + case 1: { + const uint8_t data = dgus_display.ToFixedPoint(*(T*)vp.extra); + dgus_display.Write((uint16_t)vp.addr, data); + break; + } + case 2: { + const uint16_t data = dgus_display.ToFixedPoint(*(T*)vp.extra); + dgus_display.Write((uint16_t)vp.addr, Swap16(data)); + break; + } + case 4: { + const uint32_t data = dgus_display.ToFixedPoint(*(T*)vp.extra); + dgus_display.Write((uint16_t)vp.addr, dgus_display.SwapBytes(data)); + break; + } + } + } + +} diff --git a/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Addr.h b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Addr.h new file mode 100644 index 0000000000..de64fe2b10 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Addr.h @@ -0,0 +1,173 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +constexpr uint8_t DGUS_LINE_LEN = 32; +constexpr uint8_t DGUS_STATUS_LEN = 32; +constexpr uint8_t DGUS_FILE_COUNT = 5; +constexpr uint8_t DGUS_FILENAME_LEN = 32; +constexpr uint8_t DGUS_ELLAPSED_LEN = 15; +constexpr uint8_t DGUS_LEVEL_GRID_SIZE = 25; +constexpr uint8_t DGUS_MACHINE_LEN = 24; +constexpr uint8_t DGUS_BUILDVOLUME_LEN = 24; +constexpr uint8_t DGUS_VERSION_LEN = 16; +constexpr uint8_t DGUS_PRINTTIME_LEN = 24; +constexpr uint8_t DGUS_LONGESTPRINT_LEN = 24; +constexpr uint8_t DGUS_FILAMENTUSED_LEN = 24; +constexpr uint8_t DGUS_GCODE_LEN = 32; + +enum class DGUS_Addr : uint16_t { + MESSAGE_Line1 = 0x1100, // 0x1100 - 0x111F + MESSAGE_Line2 = 0x1120, // 0x1120 - 0x113F + MESSAGE_Line3 = 0x1140, // 0x1140 - 0x115F + MESSAGE_Line4 = 0x1160, // 0x1160 - 0x117F + + // READ-ONLY VARIABLES + + SCREENCHANGE = 0x2000, // Screen change request. Data contains target screen in low byte. + SCREENCHANGE_SD = 0x2001, // Only change if SD card present. + SCREENCHANGE_Idle = 0x2002, // Only change if not printing. + SCREENCHANGE_Printing = 0x2003, // Only change if printing. + SD_SelectFile = 0x2004, // Data: file index (0-4) + SD_Scroll = 0x2005, // Data: DGUS_Data::Scroll + SD_Print = 0x2006, + STATUS_Abort = 0x2007, // Popup / Data: DGUS_Data::Popup + STATUS_Pause = 0x2008, // Popup / Data: DGUS_Data::Popup + STATUS_Resume = 0x2009, // Popup / Data: DGUS_Data::Popup + ADJUST_SetFeedrate = 0x200A, // Type: Integer (16 bits signed) + ADJUST_SetFlowrate_CUR = 0x200B, // Type: Integer (16 bits signed) + #if EXTRUDERS > 1 + ADJUST_SetFlowrate_E0 = 0x200C, // Type: Integer (16 bits signed) + ADJUST_SetFlowrate_E1 = 0x200D, // Type: Integer (16 bits signed) + #endif + ADJUST_SetBabystep = 0x200E, // Type: Fixed point, 2 decimals (16 bits signed) + ADJUST_Babystep = 0x200F, // Data: DGUS_Data::Adjust + TEMP_Preset = 0x2010, // Popup / Data: DGUS_Data::TempPreset + TEMP_SetTarget_Bed = 0x2011, // Type: Integer (16 bits signed) + TEMP_SetTarget_H0 = 0x2012, // Type: Integer (16 bits signed) + #if HOTENDS > 1 + TEMP_SetTarget_H1 = 0x2013, // Type: Integer (16 bits signed) + #endif + TEMP_Cool = 0x2014, // Data: DGUS_Data::Heater + STEPPER_Control = 0x2015, // Popup / Data: DGUS_Data::Control + LEVEL_OFFSET_Set = 0x2016, // Type: Fixed point, 2 decimals (16 bits signed) + LEVEL_OFFSET_Step = 0x2017, // Data: DGUS_Data::Adjust + LEVEL_OFFSET_SetStep = 0x2018, // Data: DGUS_Data::StepSize + LEVEL_MANUAL_Point = 0x2019, // Data: point index (1-5) + LEVEL_AUTO_Probe = 0x201A, + LEVEL_AUTO_Disable = 0x201B, + FILAMENT_Select = 0x201C, // Data: DGUS_Data::Extruder + FILAMENT_SetLength = 0x201D, // Type: Integer (16 bits unsigned) + FILAMENT_Move = 0x201E, // Data: DGUS_Data::FilamentMove + MOVE_Home = 0x201F, // Data: DGUS_Data::Axis + MOVE_SetX = 0x2020, // Type: Fixed point, 1 decimal (16 bits signed) + MOVE_SetY = 0x2021, // Type: Fixed point, 1 decimal (16 bits signed) + MOVE_SetZ = 0x2022, // Type: Fixed point, 1 decimal (16 bits signed) + MOVE_Step = 0x2023, // Data: DGUS_Data::MoveDirection + MOVE_SetStep = 0x2024, // Data: DGUS_Data::StepSize + GCODE_Clear = 0x2025, + GCODE_Execute = 0x2026, + EEPROM_Reset = 0x2027, // Popup / Data: DGUS_Data::Popup + SETTINGS2_Extra = 0x2028, // Data: DGUS_Data::Extra + PID_Select = 0x2029, // Data: DGUS_Data::Heater + PID_SetTemp = 0x202A, // Type: Integer (16 bits unsigned) + PID_Run = 0x202B, + POWERLOSS_Abort = 0x202C, // Popup / Data: DGUS_Data::Popup + POWERLOSS_Resume = 0x202D, // Popup / Data: DGUS_Data::Popup + WAIT_Abort = 0x202E, // Popup / Data: DGUS_Data::Popup + WAIT_Continue = 0x202F, + + // WRITE-ONLY VARIABLES + + MESSAGE_Status = 0x3000, // 0x3000 - 0x301F + SD_Type = 0x3020, // 0x3020 - 0x3024 / Data: DGUS_Data::SDType + SD_FileName0 = 0x3025, // 0x3025 - 0x3044 + SD_FileName1 = 0x3045, // 0x3045 - 0x3064 + SD_FileName2 = 0x3065, // 0x3065 - 0x3084 + SD_FileName3 = 0x3085, // 0x3085 - 0x30A4 + SD_FileName4 = 0x30A5, // 0x30A5 - 0x30C4 + SD_ScrollIcons = 0x30C5, // Bits: DGUS_Data::ScrollIcon + SD_SelectedFileName = 0x30C6, // 0x30C6 - 0x30E5 + STATUS_PositionZ = 0x30E6, // Type: Fixed point, 1 decimal (16 bits signed) + STATUS_Ellapsed = 0x30E7, // 0x30E7 - 0x30F5 + STATUS_Percent = 0x30F6, // Type: Integer (16 bits unsigned) + STATUS_Icons = 0x30F7, // Bits: DGUS_Data::StatusIcon + ADJUST_Feedrate = 0x30F8, // Type: Integer (16 bits signed) + ADJUST_Flowrate_CUR = 0x30F9, // Type: Integer (16 bits signed) + #if EXTRUDERS > 1 + ADJUST_Flowrate_E0 = 0x30FA, // Type: Integer (16 bits signed) + ADJUST_Flowrate_E1 = 0x30FB, // Type: Integer (16 bits signed) + #endif + TEMP_Current_Bed = 0x30FC, // Type: Integer (16 bits signed) + TEMP_Target_Bed = 0x30FD, // Type: Integer (16 bits signed) + TEMP_Max_Bed = 0x30FE, // Type: Integer (16 bits unsigned) + TEMP_Current_H0 = 0x30FF, // Type: Integer (16 bits signed) + TEMP_Target_H0 = 0x3100, // Type: Integer (16 bits signed) + TEMP_Max_H0 = 0x3101, // Type: Integer (16 bits unsigned) + #if HOTENDS > 1 + TEMP_Current_H1 = 0x3102, // Type: Integer (16 bits signed) + TEMP_Target_H1 = 0x3103, // Type: Integer (16 bits signed) + TEMP_Max_H1 = 0x3104, // Type: Integer (16 bits unsigned) + #endif + STEPPER_Status = 0x3105, // Data: DGUS_Data::Status + LEVEL_OFFSET_Current = 0x3106, // Type: Fixed point, 2 decimals (16 bits signed) + LEVEL_OFFSET_StepIcons = 0x3107, // Bits: DGUS_Data::StepIcon + LEVEL_AUTO_DisableIcon = 0x3108, // Data: DGUS_Data::Status + LEVEL_AUTO_Grid = 0x3109, // 0x3109 - 0x3121 / Type: Fixed point, 3 decimals (16 bits signed) + LEVEL_PROBING_Icons1 = 0x3122, // Type: Integer (16 bits unsigned) / Each bit represents a grid point + LEVEL_PROBING_Icons2 = 0x3123, // Type: Integer (16 bits unsigned) / Each bit represents a grid point + FILAMENT_ExtruderIcons = 0x3124, // Data: DGUS_Data::ExtruderIcon + FILAMENT_Length = 0x3125, // Type: Integer (16 bits unsigned) + MOVE_CurrentX = 0x3126, // Type: Fixed point, 1 decimal (16 bits signed) + MOVE_CurrentY = 0x3127, // Type: Fixed point, 1 decimal (16 bits signed) + MOVE_CurrentZ = 0x3128, // Type: Fixed point, 1 decimal (16 bits signed) + MOVE_StepIcons = 0x3129, // Bits: DGUS_Data::StepIcon + SETTINGS2_BLTouch = 0x312A, // Data: DGUS_Data::Status + PID_HeaterIcons = 0x312B, // Data: DGUS_Data::HeaterIcon + PID_Temp = 0x312C, // Type: Integer (16 bits unsigned) + PID_Kp = 0x312D, // Type: Fixed point, 2 decimals (32 bits signed) + PID_Ki = 0x312F, // Type: Fixed point, 2 decimals (32 bits signed) + PID_Kd = 0x3131, // Type: Fixed point, 2 decimals (32 bits signed) + INFOS_Machine = 0x3133, // 0x3133 - 0x314A + INFOS_BuildVolume = 0x314B, // 0x314B - 0x3162 + INFOS_Version = 0x3163, // 0x3163 - 0x3172 + INFOS_TotalPrints = 0x3173, // Type: Integer (16 bits unsigned) + INFOS_FinishedPrints = 0x3174, // Type: Integer (16 bits unsigned) + INFOS_PrintTime = 0x3175, // 0x3175 - 0x318C + INFOS_LongestPrint = 0x318D, // 0x318D - 0x31A4 + INFOS_FilamentUsed = 0x31A5, // 0x31A5 - 0x31BC + WAIT_Icons = 0x31BD, // Bits: DGUS_Data::WaitIcon + + // READ-WRITE VARIABLES + + FAN0_Speed = 0x4000, // Type: Integer (16 bits unsigned) / Data: fan speed as percent (0-100) + GCODE_Data = 0x4001, // 0x4001 - 0x4020 + PID_Cycles = 0x4021, // Type: Integer (16 bits unsigned) + VOLUME_Level = 0x4022, // Type: Integer (16 bits unsigned) / Data: volume as percent (0-100) + BRIGHTNESS_Level = 0x4023, // Type: Integer (16 bits unsigned) / Data: brightness as percent (0-100) + + // SPECIAL CASES + + STATUS_Percent_Complete = 0x5000, // Same as STATUS_Percent, but always 100% + INFOS_Debug = 0x5001, + +}; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Constants.h b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Constants.h new file mode 100644 index 0000000000..4047a6d6dc --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Constants.h @@ -0,0 +1,96 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +#include "../../../../inc/MarlinConfigPre.h" + +#include "DGUS_Addr.h" + +static_assert((DGUS_LEVEL_GRID_SIZE == GRID_MAX_POINTS_X * GRID_MAX_POINTS_Y), "DGUS_LEVEL_GRID_SIZE incompatible with current mesh."); + +#ifndef DGUS_DEFAULT_VOLUME + #define DGUS_DEFAULT_VOLUME 50 +#endif + +#ifndef DGUS_DEFAULT_BRIGHTNESS + #define DGUS_DEFAULT_BRIGHTNESS 100 +#endif + +#ifndef DGUS_STATUS_EXPIRATION_MS + #define DGUS_STATUS_EXPIRATION_MS 30000 +#endif + +#ifndef DGUS_PRINT_BABYSTEP + #define DGUS_PRINT_BABYSTEP 0.01f +#endif + +#ifndef DGUS_PLA_TEMP_HOTEND + #define DGUS_PLA_TEMP_HOTEND 200 +#endif + +#ifndef DGUS_PLA_TEMP_BED + #define DGUS_PLA_TEMP_BED 60 +#endif + +#ifndef DGUS_ABS_TEMP_HOTEND + #define DGUS_ABS_TEMP_HOTEND 240 +#endif + +#ifndef DGUS_ABS_TEMP_BED + #define DGUS_ABS_TEMP_BED 80 +#endif + +#ifndef DGUS_PETG_TEMP_HOTEND + #define DGUS_PETG_TEMP_HOTEND 240 +#endif + +#ifndef DGUS_PETG_TEMP_BED + #define DGUS_PETG_TEMP_BED 60 +#endif + +#ifndef DGUS_DEFAULT_FILAMENT_LEN + #define DGUS_DEFAULT_FILAMENT_LEN 10 +#endif + +#ifndef LEVEL_CORNERS_Z_HOP + #define LEVEL_CORNERS_Z_HOP 4.0 +#endif + +#ifndef LEVEL_CORNERS_HEIGHT + #define LEVEL_CORNERS_HEIGHT 0.0 +#endif + +static_assert(LEVEL_CORNERS_Z_HOP >= 0, "LEVEL_CORNERS_Z_HOP must be >= 0. Please update your configuration."); + +#ifndef DGUS_LEVEL_CENTER_X + #define DGUS_LEVEL_CENTER_X ((X_BED_SIZE) / 2) +#endif + +#ifndef DGUS_LEVEL_CENTER_Y + #define DGUS_LEVEL_CENTER_Y ((Y_BED_SIZE) / 2) +#endif + +#if ENABLED(BLTOUCH) + #ifndef DGUS_RESET_BLTOUCH + #define DGUS_RESET_BLTOUCH "M999\nM280P0S160" + #endif +#endif diff --git a/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Control.h b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Control.h new file mode 100644 index 0000000000..92d2f5ece2 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Control.h @@ -0,0 +1,50 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +enum class DGUS_Control : uint8_t { + + // PRINT + FILE0 = 1, // RETURN_KEY_CODE + FILE1 = 2, // RETURN_KEY_CODE + FILE2 = 3, // RETURN_KEY_CODE + FILE3 = 4, // RETURN_KEY_CODE + FILE4 = 5, // RETURN_KEY_CODE + GO_BACK = 6, // RETURN_KEY_CODE + SCROLL_UP = 7, // RETURN_KEY_CODE + SCROLL_DOWN = 8, // RETURN_KEY_CODE + + // PRINT_STATUS + PAUSE = 1, // POPUP_WINDOW + RESUME = 2, // POPUP_WINDOW + + // LEVELING_AUTOMATIC + DISABLE = 5, // RETURN_KEY_CODE + + // SETTINGS_MENU2 + EXTRA2 = 6, // RETURN_KEY_CODE + + // WAIT + ABORT = 1, // POPUP_WINDOW + CONTINUE = 2 // RETURN_KEY_CODE + +}; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Data.h b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Data.h new file mode 100644 index 0000000000..886109054c --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Data.h @@ -0,0 +1,148 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +#include + +namespace DGUS_Data { + + // RX constants + + enum class Scroll : uint8_t { + GO_BACK = 0, + UP = 1, + DOWN = 2 + }; + + enum class Popup : uint8_t { + CONFIRMED = 1 + }; + + enum class Adjust : uint8_t { + INCREMENT = 0, + DECREMENT = 1 + }; + + enum class TempPreset : uint8_t { + PLA = 1, + ABS = 2, + PETG = 3 + }; + + enum class Extruder : int8_t { + CURRENT = -1, + E0 = 0, + E1 = 1 + }; + + enum class Heater : int8_t { + ALL = -2, + BED = -1, + H0 = 0, + H1 = 1 + }; + + enum class Control : uint8_t { + ENABLE = 1, + DISABLE = 2 + }; + + enum class StepSize : uint8_t { + MM10 = 0, // 10mm + MM1 = 1, // 1mm + MMP1 = 2, // 0.1mm + MMP01 = 3 // 0.01mm + }; + + enum class FilamentMove : uint8_t { + RETRACT = 0, + EXTRUDE = 1 + }; + + enum class Axis : uint8_t { + X_Y_Z = 0, + X_Y = 1, + Z = 2 + }; + + enum class MoveDirection : uint8_t { + XP = 0, // X+ + XM = 1, // X- + YP = 2, // Y+ + YM = 3, // Y- + ZP = 4, // Z+ + ZM = 5 // Z- + }; + + enum class Extra : uint8_t { + BUTTON1 = 0, + BUTTON2 = 1 + }; + + // TX constants + + enum class SDType : uint16_t { + NONE = 0, + FILE = 1, + DIRECTORY = 2 + }; + + enum class ScrollIcon : uint16_t { + GO_BACK = 1U << 0, + UP = 1U << 1, + DOWN = 1U << 2 + }; + + enum class StatusIcon : uint16_t { + PAUSE = 1U << 0, + RESUME = 1U << 1 + }; + + enum class Status : uint16_t { + DISABLED = 0, + ENABLED = 1 + }; + + enum class StepIcon : uint16_t { + MM10 = 1U << 0, // 10mm + MM1 = 1U << 1, // 1mm + MMP1 = 1U << 2, // 0.1mm + MMP01 = 1U << 3 // 0.01mm + }; + + enum class ExtruderIcon : uint16_t { + E0 = 1U << 0, + E1 = 1U << 1 + }; + + enum class HeaterIcon : uint16_t { + BED = 1U << 0, + H0 = 1U << 1, + H1 = 1U << 2 + }; + + enum class WaitIcon : uint16_t { + ABORT = 1U << 0, + CONTINUE = 1U << 1 + }; + +}; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Screen.h b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Screen.h new file mode 100644 index 0000000000..b3d2ad6d3c --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Screen.h @@ -0,0 +1,52 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +enum class DGUS_Screen : uint8_t { + BOOT = 0, + HOME = 1, + PRINT = 2, + PRINT_STATUS = 3, + PRINT_ADJUST = 4, + PRINT_FINISHED = 5, + TEMP_MENU = 6, + TEMP_MANUAL = 7, + FAN = 8, + SETTINGS_MENU = 9, + LEVELING_MENU = 10, + LEVELING_OFFSET = 11, + LEVELING_MANUAL = 12, + LEVELING_AUTOMATIC = 13, + LEVELING_PROBING = 14, + FILAMENT = 15, + MOVE = 16, + GCODE = 17, + SETTINGS_MENU2 = 18, + PID = 19, + VOLUME = 20, + BRIGHTNESS = 21, + INFOS = 22, + DEBUG = 240, + POWERLOSS = 248, + WAIT = 249, + KILL = 250 +}; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.cpp b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.cpp new file mode 100644 index 0000000000..95e6444956 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.cpp @@ -0,0 +1,240 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#include "../../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "DGUS_ScreenAddrList.h" + +#include "../../ui_api.h" + +constexpr DGUS_Addr LIST_HOME[] PROGMEM = { + DGUS_Addr::TEMP_Current_H0, + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::TEMP_Current_Bed, + DGUS_Addr::TEMP_Target_Bed, + (DGUS_Addr)0 +}; + +#if ENABLED(SDSUPPORT) + constexpr DGUS_Addr LIST_PRINT[] PROGMEM = { + DGUS_Addr::SD_Type, + DGUS_Addr::SD_FileName0, + DGUS_Addr::SD_FileName1, + DGUS_Addr::SD_FileName2, + DGUS_Addr::SD_FileName3, + DGUS_Addr::SD_FileName4, + DGUS_Addr::SD_ScrollIcons, + DGUS_Addr::SD_SelectedFileName, + (DGUS_Addr)0 + }; +#endif + +constexpr DGUS_Addr LIST_PRINT_STATUS[] PROGMEM = { + DGUS_Addr::TEMP_Current_H0, + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::TEMP_Current_Bed, + DGUS_Addr::TEMP_Target_Bed, + DGUS_Addr::STATUS_PositionZ, + DGUS_Addr::STATUS_Ellapsed, + DGUS_Addr::STATUS_Percent, + DGUS_Addr::STATUS_Icons, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_PRINT_ADJUST[] PROGMEM = { + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::TEMP_Target_Bed, + DGUS_Addr::FAN0_Speed, + DGUS_Addr::ADJUST_Feedrate, + DGUS_Addr::ADJUST_Flowrate_CUR, + DGUS_Addr::LEVEL_OFFSET_Current, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_PRINT_FINISHED[] PROGMEM = { + DGUS_Addr::TEMP_Current_H0, + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::TEMP_Current_Bed, + DGUS_Addr::TEMP_Target_Bed, + DGUS_Addr::STATUS_PositionZ, + DGUS_Addr::STATUS_Ellapsed, + DGUS_Addr::STATUS_Percent_Complete, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_TEMP_MENU[] PROGMEM = { + DGUS_Addr::TEMP_Current_H0, + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::TEMP_Current_Bed, + DGUS_Addr::TEMP_Target_Bed, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_TEMP_MANUAL[] PROGMEM = { + DGUS_Addr::TEMP_Current_H0, + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::TEMP_Max_H0, + DGUS_Addr::TEMP_Current_Bed, + DGUS_Addr::TEMP_Target_Bed, + DGUS_Addr::TEMP_Max_Bed, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_FAN[] PROGMEM = { + DGUS_Addr::FAN0_Speed, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_SETTINGS_MENU[] PROGMEM = { + DGUS_Addr::STEPPER_Status, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_LEVELING_OFFSET[] PROGMEM = { + DGUS_Addr::LEVEL_OFFSET_Current, + DGUS_Addr::LEVEL_OFFSET_StepIcons, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_LEVELING_MANUAL[] PROGMEM = { + DGUS_Addr::TEMP_Current_H0, + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::TEMP_Current_Bed, + DGUS_Addr::TEMP_Target_Bed, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_LEVELING_AUTOMATIC[] PROGMEM = { + DGUS_Addr::TEMP_Current_H0, + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::TEMP_Current_Bed, + DGUS_Addr::TEMP_Target_Bed, + DGUS_Addr::LEVEL_AUTO_DisableIcon, + DGUS_Addr::LEVEL_AUTO_Grid, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_LEVELING_PROBING[] PROGMEM = { + DGUS_Addr::LEVEL_PROBING_Icons1, + DGUS_Addr::LEVEL_PROBING_Icons2, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_FILAMENT[] PROGMEM = { + DGUS_Addr::TEMP_Current_H0, + DGUS_Addr::TEMP_Target_H0, + DGUS_Addr::FILAMENT_ExtruderIcons, + DGUS_Addr::FILAMENT_Length, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_MOVE[] PROGMEM = { + DGUS_Addr::MOVE_CurrentX, + DGUS_Addr::MOVE_CurrentY, + DGUS_Addr::MOVE_CurrentZ, + DGUS_Addr::MOVE_StepIcons, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_GCODE[] PROGMEM = { + DGUS_Addr::GCODE_Data, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_SETTINGS_MENU2[] PROGMEM = { + DGUS_Addr::SETTINGS2_BLTouch, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_PID[] PROGMEM = { + DGUS_Addr::PID_HeaterIcons, + DGUS_Addr::PID_Temp, + DGUS_Addr::PID_Cycles, + DGUS_Addr::PID_Kp, + DGUS_Addr::PID_Ki, + DGUS_Addr::PID_Kd, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_VOLUME[] PROGMEM = { + DGUS_Addr::VOLUME_Level, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_BRIGHTNESS[] PROGMEM = { + DGUS_Addr::BRIGHTNESS_Level, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_INFOS[] PROGMEM = { + DGUS_Addr::INFOS_Machine, + DGUS_Addr::INFOS_BuildVolume, + DGUS_Addr::INFOS_Version, + DGUS_Addr::INFOS_TotalPrints, + DGUS_Addr::INFOS_FinishedPrints, + DGUS_Addr::INFOS_PrintTime, + DGUS_Addr::INFOS_LongestPrint, + DGUS_Addr::INFOS_FilamentUsed, + (DGUS_Addr)0 +}; + +constexpr DGUS_Addr LIST_WAIT[] PROGMEM = { + DGUS_Addr::WAIT_Icons, + (DGUS_Addr)0 +}; + +#define MAP_HELPER(SCREEN, LIST) \ + { .screen = SCREEN, \ + .addr_list = LIST } + +const struct DGUS_ScreenAddrList screen_addr_list_map[] PROGMEM = { + MAP_HELPER(DGUS_Screen::HOME, LIST_HOME), + #if ENABLED(SDSUPPORT) + MAP_HELPER(DGUS_Screen::PRINT, LIST_PRINT), + #endif + MAP_HELPER(DGUS_Screen::PRINT_STATUS, LIST_PRINT_STATUS), + MAP_HELPER(DGUS_Screen::PRINT_ADJUST, LIST_PRINT_ADJUST), + MAP_HELPER(DGUS_Screen::PRINT_FINISHED, LIST_PRINT_FINISHED), + MAP_HELPER(DGUS_Screen::TEMP_MENU, LIST_TEMP_MENU), + MAP_HELPER(DGUS_Screen::TEMP_MANUAL, LIST_TEMP_MANUAL), + MAP_HELPER(DGUS_Screen::FAN, LIST_FAN), + MAP_HELPER(DGUS_Screen::SETTINGS_MENU, LIST_SETTINGS_MENU), + MAP_HELPER(DGUS_Screen::LEVELING_OFFSET, LIST_LEVELING_OFFSET), + MAP_HELPER(DGUS_Screen::LEVELING_MANUAL, LIST_LEVELING_MANUAL), + MAP_HELPER(DGUS_Screen::LEVELING_AUTOMATIC, LIST_LEVELING_AUTOMATIC), + MAP_HELPER(DGUS_Screen::LEVELING_PROBING, LIST_LEVELING_PROBING), + MAP_HELPER(DGUS_Screen::FILAMENT, LIST_FILAMENT), + MAP_HELPER(DGUS_Screen::MOVE, LIST_MOVE), + MAP_HELPER(DGUS_Screen::GCODE, LIST_GCODE), + MAP_HELPER(DGUS_Screen::SETTINGS_MENU2, LIST_SETTINGS_MENU2), + MAP_HELPER(DGUS_Screen::PID, LIST_PID), + MAP_HELPER(DGUS_Screen::VOLUME, LIST_VOLUME), + MAP_HELPER(DGUS_Screen::BRIGHTNESS, LIST_BRIGHTNESS), + MAP_HELPER(DGUS_Screen::INFOS, LIST_INFOS), + MAP_HELPER(DGUS_Screen::WAIT, LIST_WAIT), + + MAP_HELPER((DGUS_Screen)0, nullptr) +}; + +#endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.h b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.h new file mode 100644 index 0000000000..af05c46d28 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.h @@ -0,0 +1,32 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +#include "../config/DGUS_Screen.h" +#include "../config/DGUS_Addr.h" + +struct DGUS_ScreenAddrList { + DGUS_Screen screen; + const DGUS_Addr *addr_list; +}; + +extern const struct DGUS_ScreenAddrList screen_addr_list_map[]; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.cpp b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.cpp new file mode 100644 index 0000000000..213e430334 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.cpp @@ -0,0 +1,57 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#include "../../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "DGUS_ScreenSetup.h" + +#include "../DGUSSetupHandler.h" + +#include "../../ui_api.h" + +#define SETUP_HELPER(SCREEN, SETUP) \ + { .screen = SCREEN, \ + .setup_fn = SETUP } + +const struct DGUS_ScreenSetup screen_setup_list[] PROGMEM = { + #if ENABLED(SDSUPPORT) + SETUP_HELPER(DGUS_Screen::PRINT, &DGUSSetupHandler::Print), + #endif + SETUP_HELPER(DGUS_Screen::PRINT_STATUS, &DGUSSetupHandler::PrintStatus), + SETUP_HELPER(DGUS_Screen::PRINT_ADJUST, &DGUSSetupHandler::PrintAdjust), + SETUP_HELPER(DGUS_Screen::LEVELING_MENU, &DGUSSetupHandler::LevelingMenu), + SETUP_HELPER(DGUS_Screen::LEVELING_OFFSET, &DGUSSetupHandler::LevelingOffset), + SETUP_HELPER(DGUS_Screen::LEVELING_MANUAL, &DGUSSetupHandler::LevelingManual), + SETUP_HELPER(DGUS_Screen::LEVELING_AUTOMATIC, &DGUSSetupHandler::LevelingAutomatic), + SETUP_HELPER(DGUS_Screen::LEVELING_PROBING, &DGUSSetupHandler::LevelingProbing), + SETUP_HELPER(DGUS_Screen::FILAMENT, &DGUSSetupHandler::Filament), + SETUP_HELPER(DGUS_Screen::MOVE, &DGUSSetupHandler::Move), + SETUP_HELPER(DGUS_Screen::GCODE, &DGUSSetupHandler::Gcode), + SETUP_HELPER(DGUS_Screen::PID, &DGUSSetupHandler::PID), + SETUP_HELPER(DGUS_Screen::INFOS, &DGUSSetupHandler::Infos), + + SETUP_HELPER((DGUS_Screen)0, nullptr) +}; + +#endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.h b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.h new file mode 100644 index 0000000000..3b9208e5ec --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.h @@ -0,0 +1,31 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +#include "../config/DGUS_Screen.h" + +struct DGUS_ScreenSetup { + DGUS_Screen screen; + bool (*setup_fn)(void); +}; + +extern const struct DGUS_ScreenSetup screen_setup_list[]; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VP.h b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VP.h new file mode 100644 index 0000000000..b1b6792224 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VP.h @@ -0,0 +1,40 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +#include "../config/DGUS_Addr.h" + +#define VPFLAG_NONE 0 +#define VPFLAG_AUTOUPLOAD (1U << 0) // Upload on every DGUS update +#define VPFLAG_RXSTRING (1U << 1) // Treat the received data as a string (terminated with 0xFFFF) + +struct DGUS_VP { + DGUS_Addr addr; + uint8_t size; + uint8_t flags; + void *extra; + + // Callback that will be called if the display modified the value. + // nullptr makes it readonly for the display. + void (*rx_handler)(DGUS_VP &, void *); + void (*tx_handler)(DGUS_VP &); +}; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VPList.cpp b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VPList.cpp new file mode 100644 index 0000000000..3f5690cfe7 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VPList.cpp @@ -0,0 +1,368 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +#include "../../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "DGUS_VPList.h" + +#include "../config/DGUS_Addr.h" +#include "../DGUSScreenHandler.h" +#include "../DGUSRxHandler.h" +#include "../DGUSTxHandler.h" + +#include "../../ui_api.h" +#include "../../../../module/probe.h" +#include "../../../../module/motion.h" +#include "../../../../module/temperature.h" + +const char DGUS_MACHINENAME[] PROGMEM = MACHINE_NAME; +const char DGUS_MARLINVERSION[] PROGMEM = SHORT_BUILD_VERSION; + +#define VP_HELPER(ADDR, SIZE, FLAGS, EXTRA, RXHANDLER, TXHANDLER) \ + { .addr = ADDR, \ + .size = SIZE, \ + .flags = FLAGS, \ + .extra = EXTRA, \ + .rx_handler = RXHANDLER, \ + .tx_handler = TXHANDLER } + +#define VP_HELPER_WORD(ADDR, FLAGS, EXTRA, RXHANDLER, TXHANDLER) \ + VP_HELPER(ADDR, 2, FLAGS, EXTRA, RXHANDLER, TXHANDLER) + +#define VP_HELPER_DWORD(ADDR, FLAGS, EXTRA, RXHANDLER, TXHANDLER) \ + VP_HELPER(ADDR, 4, FLAGS, EXTRA, RXHANDLER, TXHANDLER) + +#define VP_HELPER_RX(ADDR, RXHANDLER) \ + VP_HELPER_WORD(ADDR, VPFLAG_NONE, nullptr, RXHANDLER, nullptr) + +#define VP_HELPER_RX_NODATA(ADDR, RXHANDLER) \ + VP_HELPER(ADDR, 0, VPFLAG_NONE, nullptr, RXHANDLER, nullptr) + +#define VP_HELPER_TX(ADDR, TXHANDLER) \ + VP_HELPER_WORD(ADDR, VPFLAG_NONE, nullptr, nullptr, TXHANDLER) + +#define VP_HELPER_TX_SIZE(ADDR, SIZE, TXHANDLER) \ + VP_HELPER(ADDR, SIZE, VPFLAG_NONE, nullptr, nullptr, TXHANDLER) + +#define VP_HELPER_TX_EXTRA(ADDR, EXTRA, TXHANDLER) \ + VP_HELPER_WORD(ADDR, VPFLAG_NONE, EXTRA, nullptr, TXHANDLER) + +#define VP_HELPER_TX_AUTO(ADDR, EXTRA, TXHANDLER) \ + VP_HELPER_WORD(ADDR, VPFLAG_AUTOUPLOAD, EXTRA, nullptr, TXHANDLER) + +const struct DGUS_VP vp_list[] PROGMEM = { + + // READ-ONLY VARIABLES + + VP_HELPER_RX(DGUS_Addr::SCREENCHANGE, &DGUSRxHandler::ScreenChange), + VP_HELPER_RX(DGUS_Addr::SCREENCHANGE_SD, &DGUSRxHandler::ScreenChange), + VP_HELPER_RX(DGUS_Addr::SCREENCHANGE_Idle, &DGUSRxHandler::ScreenChange), + VP_HELPER_RX(DGUS_Addr::SCREENCHANGE_Printing, &DGUSRxHandler::ScreenChange), + + #if ENABLED(SDSUPPORT) + VP_HELPER_RX(DGUS_Addr::SD_SelectFile, &DGUSRxHandler::SelectFile), + VP_HELPER_RX(DGUS_Addr::SD_Scroll, &DGUSRxHandler::Scroll), + VP_HELPER_RX_NODATA(DGUS_Addr::SD_Print, &DGUSRxHandler::PrintFile), + #endif + + VP_HELPER_RX(DGUS_Addr::STATUS_Abort, &DGUSRxHandler::PrintAbort), + VP_HELPER_RX(DGUS_Addr::STATUS_Pause, &DGUSRxHandler::PrintPause), + VP_HELPER_RX(DGUS_Addr::STATUS_Resume, &DGUSRxHandler::PrintResume), + + VP_HELPER_RX(DGUS_Addr::ADJUST_SetFeedrate, &DGUSRxHandler::Feedrate), + VP_HELPER_RX(DGUS_Addr::ADJUST_SetFlowrate_CUR, &DGUSRxHandler::Flowrate), + #if EXTRUDERS > 1 + VP_HELPER_RX(DGUS_Addr::ADJUST_SetFlowrate_E0, &DGUSRxHandler::Flowrate), + VP_HELPER_RX(DGUS_Addr::ADJUST_SetFlowrate_E1, &DGUSRxHandler::Flowrate), + #endif + VP_HELPER_RX(DGUS_Addr::ADJUST_SetBabystep, &DGUSRxHandler::BabystepSet), + VP_HELPER_RX(DGUS_Addr::ADJUST_Babystep, &DGUSRxHandler::Babystep), + + VP_HELPER_RX(DGUS_Addr::TEMP_Preset, &DGUSRxHandler::TempPreset), + VP_HELPER_RX(DGUS_Addr::TEMP_SetTarget_Bed, &DGUSRxHandler::TempTarget), + VP_HELPER_RX(DGUS_Addr::TEMP_SetTarget_H0, &DGUSRxHandler::TempTarget), + #if HOTENDS > 1 + VP_HELPER_RX(DGUS_Addr::TEMP_SetTarget_H1, &DGUSRxHandler::TempTarget), + #endif + VP_HELPER_RX(DGUS_Addr::TEMP_Cool, &DGUSRxHandler::TempCool), + + VP_HELPER_RX(DGUS_Addr::STEPPER_Control, &DGUSRxHandler::Steppers), + + VP_HELPER_RX(DGUS_Addr::LEVEL_OFFSET_Set, &DGUSRxHandler::ZOffset), + VP_HELPER_RX(DGUS_Addr::LEVEL_OFFSET_Step, &DGUSRxHandler::ZOffsetStep), + VP_HELPER_RX(DGUS_Addr::LEVEL_OFFSET_SetStep, &DGUSRxHandler::ZOffsetSetStep), + + VP_HELPER_RX(DGUS_Addr::LEVEL_MANUAL_Point, &DGUSRxHandler::MoveToPoint), + + VP_HELPER_RX_NODATA(DGUS_Addr::LEVEL_AUTO_Probe, &DGUSRxHandler::Probe), + VP_HELPER_RX_NODATA(DGUS_Addr::LEVEL_AUTO_Disable, + &DGUSRxHandler::DisableABL), + + VP_HELPER_RX(DGUS_Addr::FILAMENT_Select, &DGUSRxHandler::FilamentSelect), + VP_HELPER_RX(DGUS_Addr::FILAMENT_SetLength, &DGUSRxHandler::FilamentLength), + VP_HELPER_RX(DGUS_Addr::FILAMENT_Move, &DGUSRxHandler::FilamentMove), + + VP_HELPER_RX(DGUS_Addr::MOVE_Home, &DGUSRxHandler::Home), + VP_HELPER_RX(DGUS_Addr::MOVE_SetX, &DGUSRxHandler::Move), + VP_HELPER_RX(DGUS_Addr::MOVE_SetY, &DGUSRxHandler::Move), + VP_HELPER_RX(DGUS_Addr::MOVE_SetZ, &DGUSRxHandler::Move), + VP_HELPER_RX(DGUS_Addr::MOVE_Step, &DGUSRxHandler::MoveStep), + VP_HELPER_RX(DGUS_Addr::MOVE_SetStep, &DGUSRxHandler::MoveSetStep), + + VP_HELPER_RX_NODATA(DGUS_Addr::GCODE_Clear, &DGUSRxHandler::GcodeClear), + VP_HELPER_RX_NODATA(DGUS_Addr::GCODE_Execute, &DGUSRxHandler::GcodeExecute), + + VP_HELPER_RX(DGUS_Addr::EEPROM_Reset, &DGUSRxHandler::ResetEEPROM), + + VP_HELPER_RX(DGUS_Addr::SETTINGS2_Extra, &DGUSRxHandler::SettingsExtra), + + VP_HELPER_RX(DGUS_Addr::PID_Select, &DGUSRxHandler::PIDSelect), + VP_HELPER_RX(DGUS_Addr::PID_SetTemp, &DGUSRxHandler::PIDSetTemp), + VP_HELPER_RX_NODATA(DGUS_Addr::PID_Run, &DGUSRxHandler::PIDRun), + + #if ENABLED(POWER_LOSS_RECOVERY) + VP_HELPER_RX(DGUS_Addr::POWERLOSS_Abort, &DGUSRxHandler::PowerLossAbort), + VP_HELPER_RX(DGUS_Addr::POWERLOSS_Resume, &DGUSRxHandler::PowerLossResume), + #endif + + VP_HELPER_RX(DGUS_Addr::WAIT_Abort, &DGUSRxHandler::WaitAbort), + VP_HELPER_RX_NODATA(DGUS_Addr::WAIT_Continue, &DGUSRxHandler::WaitContinue), + + // WRITE-ONLY VARIABLES + + #if ENABLED(SDSUPPORT) + VP_HELPER_TX(DGUS_Addr::SD_Type, &DGUSTxHandler::FileType), + VP_HELPER_TX_SIZE(DGUS_Addr::SD_FileName0, + DGUS_FILENAME_LEN, + &DGUSTxHandler::FileName), + VP_HELPER_TX_SIZE(DGUS_Addr::SD_FileName1, + DGUS_FILENAME_LEN, + &DGUSTxHandler::FileName), + VP_HELPER_TX_SIZE(DGUS_Addr::SD_FileName2, + DGUS_FILENAME_LEN, + &DGUSTxHandler::FileName), + VP_HELPER_TX_SIZE(DGUS_Addr::SD_FileName3, + DGUS_FILENAME_LEN, + &DGUSTxHandler::FileName), + VP_HELPER_TX_SIZE(DGUS_Addr::SD_FileName4, + DGUS_FILENAME_LEN, + &DGUSTxHandler::FileName), + VP_HELPER_TX(DGUS_Addr::SD_ScrollIcons, &DGUSTxHandler::ScrollIcons), + VP_HELPER_TX_SIZE(DGUS_Addr::SD_SelectedFileName, + DGUS_FILENAME_LEN, + &DGUSTxHandler::SelectedFileName), + #endif + + VP_HELPER_TX_AUTO(DGUS_Addr::STATUS_PositionZ, + nullptr, + &DGUSTxHandler::PositionZ), + VP_HELPER(DGUS_Addr::STATUS_Ellapsed, + DGUS_ELLAPSED_LEN, + VPFLAG_AUTOUPLOAD, + nullptr, + nullptr, + &DGUSTxHandler::Ellapsed), + VP_HELPER_TX_AUTO(DGUS_Addr::STATUS_Percent, + nullptr, + &DGUSTxHandler::Percent), + VP_HELPER_TX(DGUS_Addr::STATUS_Icons, &DGUSTxHandler::StatusIcons), + + VP_HELPER_TX_AUTO(DGUS_Addr::ADJUST_Feedrate, + &feedrate_percentage, + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_TX_AUTO(DGUS_Addr::ADJUST_Flowrate_CUR, + nullptr, + &DGUSTxHandler::Flowrate), + #if EXTRUDERS > 1 + VP_HELPER_TX_AUTO(DGUS_Addr::ADJUST_Flowrate_E0, + nullptr, + &DGUSTxHandler::Flowrate), + VP_HELPER_TX_AUTO(DGUS_Addr::ADJUST_Flowrate_E1, + nullptr, + &DGUSTxHandler::Flowrate), + #endif + + VP_HELPER_TX_AUTO(DGUS_Addr::TEMP_Current_Bed, + &thermalManager.temp_bed.celsius, + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_TX_AUTO(DGUS_Addr::TEMP_Target_Bed, + &thermalManager.temp_bed.target, + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_TX(DGUS_Addr::TEMP_Max_Bed, &DGUSTxHandler::TempMax), + VP_HELPER_TX_AUTO(DGUS_Addr::TEMP_Current_H0, + &thermalManager.temp_hotend[ExtUI::heater_t::H0].celsius, + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_TX_AUTO(DGUS_Addr::TEMP_Target_H0, + &thermalManager.temp_hotend[ExtUI::heater_t::H0].target, + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_TX(DGUS_Addr::TEMP_Max_H0, &DGUSTxHandler::TempMax), + #if HOTENDS > 1 + VP_HELPER_TX_AUTO(DGUS_Addr::TEMP_Current_H1, + &thermalManager.temp_hotend[ExtUI::heater_t::H1].celsius, + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_TX_AUTO(DGUS_Addr::TEMP_Target_H1, + &thermalManager.temp_hotend[ExtUI::heater_t::H1].target, + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_TX(DGUS_Addr::TEMP_Max_H1, &DGUSTxHandler::TempMax), + #endif + + VP_HELPER_TX_AUTO(DGUS_Addr::STEPPER_Status, + nullptr, + &DGUSTxHandler::StepperStatus), + + VP_HELPER_TX_AUTO(DGUS_Addr::LEVEL_OFFSET_Current, + &probe.offset.z, + (&DGUSTxHandler::ExtraToFixedPoint)), + VP_HELPER_TX_EXTRA(DGUS_Addr::LEVEL_OFFSET_StepIcons, + &DGUSScreenHandler::offset_steps, + &DGUSTxHandler::StepIcons), + + VP_HELPER_TX_AUTO(DGUS_Addr::LEVEL_AUTO_DisableIcon, + nullptr, + &DGUSTxHandler::ABLDisableIcon), + VP_HELPER_TX(DGUS_Addr::LEVEL_AUTO_Grid, &DGUSTxHandler::ABLGrid), + + VP_HELPER_TX_EXTRA(DGUS_Addr::LEVEL_PROBING_Icons1, + &DGUSScreenHandler::probing_icons[0], + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_TX_EXTRA(DGUS_Addr::LEVEL_PROBING_Icons2, + &DGUSScreenHandler::probing_icons[1], + &DGUSTxHandler::ExtraToInteger), + + VP_HELPER_TX(DGUS_Addr::FILAMENT_ExtruderIcons, &DGUSTxHandler::FilamentIcons), + VP_HELPER_TX_EXTRA(DGUS_Addr::FILAMENT_Length, + &DGUSScreenHandler::filament_length, + &DGUSTxHandler::ExtraToInteger), + + VP_HELPER_TX_AUTO(DGUS_Addr::MOVE_CurrentX, + ¤t_position.x, + (&DGUSTxHandler::ExtraToFixedPoint)), + VP_HELPER_TX_AUTO(DGUS_Addr::MOVE_CurrentY, + ¤t_position.y, + (&DGUSTxHandler::ExtraToFixedPoint)), + VP_HELPER_TX_AUTO(DGUS_Addr::MOVE_CurrentZ, + ¤t_position.z, + (&DGUSTxHandler::ExtraToFixedPoint)), + VP_HELPER_TX_EXTRA(DGUS_Addr::MOVE_StepIcons, + &DGUSScreenHandler::move_steps, + &DGUSTxHandler::StepIcons), + + VP_HELPER_TX(DGUS_Addr::SETTINGS2_BLTouch, &DGUSTxHandler::BLTouch), + + VP_HELPER_TX(DGUS_Addr::PID_HeaterIcons, &DGUSTxHandler::PIDIcons), + VP_HELPER_TX_EXTRA(DGUS_Addr::PID_Temp, + &DGUSScreenHandler::pid_temp, + &DGUSTxHandler::ExtraToInteger), + VP_HELPER_DWORD(DGUS_Addr::PID_Kp, + VPFLAG_AUTOUPLOAD, + nullptr, + nullptr, + &DGUSTxHandler::PIDKp), + VP_HELPER_DWORD(DGUS_Addr::PID_Ki, + VPFLAG_AUTOUPLOAD, + nullptr, + nullptr, + &DGUSTxHandler::PIDKi), + VP_HELPER_DWORD(DGUS_Addr::PID_Kd, + VPFLAG_AUTOUPLOAD, + nullptr, + nullptr, + &DGUSTxHandler::PIDKd), + + VP_HELPER(DGUS_Addr::INFOS_Machine, + DGUS_MACHINE_LEN, + VPFLAG_NONE, + (void*)DGUS_MACHINENAME, + nullptr, + &DGUSTxHandler::ExtraPGMToString), + VP_HELPER_TX_SIZE(DGUS_Addr::INFOS_BuildVolume, + DGUS_BUILDVOLUME_LEN, + &DGUSTxHandler::BuildVolume), + VP_HELPER(DGUS_Addr::INFOS_Version, + DGUS_VERSION_LEN, + VPFLAG_NONE, + (void*)DGUS_MARLINVERSION, + nullptr, + &DGUSTxHandler::ExtraPGMToString), + VP_HELPER_TX(DGUS_Addr::INFOS_TotalPrints, &DGUSTxHandler::TotalPrints), + VP_HELPER_TX(DGUS_Addr::INFOS_FinishedPrints, &DGUSTxHandler::FinishedPrints), + VP_HELPER_TX_SIZE(DGUS_Addr::INFOS_PrintTime, + DGUS_PRINTTIME_LEN, + &DGUSTxHandler::PrintTime), + VP_HELPER_TX_SIZE(DGUS_Addr::INFOS_LongestPrint, + DGUS_LONGESTPRINT_LEN, + &DGUSTxHandler::LongestPrint), + VP_HELPER_TX_SIZE(DGUS_Addr::INFOS_FilamentUsed, + DGUS_FILAMENTUSED_LEN, + &DGUSTxHandler::FilamentUsed), + + VP_HELPER_TX(DGUS_Addr::WAIT_Icons, &DGUSTxHandler::WaitIcons), + + // READ-WRITE VARIABLES + + VP_HELPER(DGUS_Addr::FAN0_Speed, + 2, + VPFLAG_AUTOUPLOAD, + nullptr, + &DGUSRxHandler::FanSpeed, + &DGUSTxHandler::FanSpeed), + + VP_HELPER(DGUS_Addr::GCODE_Data, + DGUS_GCODE_LEN, + VPFLAG_RXSTRING, + (void*)DGUSScreenHandler::gcode, + &DGUSRxHandler::StringToExtra, + &DGUSTxHandler::ExtraToString), + + VP_HELPER(DGUS_Addr::PID_Cycles, + 2, + VPFLAG_NONE, + &DGUSScreenHandler::pid_cycles, + &DGUSRxHandler::IntegerToExtra, + &DGUSTxHandler::ExtraToInteger), + + VP_HELPER(DGUS_Addr::VOLUME_Level, + 2, + VPFLAG_NONE, + nullptr, + &DGUSRxHandler::Volume, + &DGUSTxHandler::Volume), + + VP_HELPER(DGUS_Addr::BRIGHTNESS_Level, + 2, + VPFLAG_NONE, + nullptr, + &DGUSRxHandler::Brightness, + &DGUSTxHandler::Brightness), + + // SPECIAL CASES + + VP_HELPER_TX(DGUS_Addr::STATUS_Percent_Complete, &DGUSTxHandler::Percent), + VP_HELPER_RX_NODATA(DGUS_Addr::INFOS_Debug, &DGUSRxHandler::Debug), + + VP_HELPER((DGUS_Addr)0, 0, VPFLAG_NONE, nullptr, nullptr, nullptr) + +}; + +#endif // DGUS_LCD_UI_RELOADED diff --git a/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VPList.h b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VPList.h new file mode 100644 index 0000000000..d481fbab5c --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VPList.h @@ -0,0 +1,26 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ +#pragma once + +#include "DGUS_VP.h" + +extern const struct DGUS_VP vp_list[]; diff --git a/Marlin/src/lcd/extui/dgus_reloaded/dgus_reloaded_extui.cpp b/Marlin/src/lcd/extui/dgus_reloaded/dgus_reloaded_extui.cpp new file mode 100644 index 0000000000..4d57fbd7e2 --- /dev/null +++ b/Marlin/src/lcd/extui/dgus_reloaded/dgus_reloaded_extui.cpp @@ -0,0 +1,142 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2021 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 . + * + */ + +/** + * lcd/extui/dgus_reloaded/dgus_reloaded_extui.cpp + */ + +#include "../../../inc/MarlinConfigPre.h" + +#if ENABLED(DGUS_LCD_UI_RELOADED) + +#include "../ui_api.h" +#include "DGUSScreenHandler.h" + +namespace ExtUI { + + void onStartup() { dgus_screen_handler.Init(); } + + void onIdle() { + static bool processing = false; + + // Prevent recursion + if (!processing) { + processing = true; + dgus_screen_handler.Loop(); + processing = false; + } + } + + void onPrinterKilled(PGM_P error, PGM_P component) { + dgus_screen_handler.PrinterKilled(error, component); + } + + void onMediaInserted() { TERN_(SDSUPPORT, dgus_screen_handler.SDCardInserted()); } + void onMediaError() { TERN_(SDSUPPORT, dgus_screen_handler.SDCardError()); } + void onMediaRemoved() { TERN_(SDSUPPORT, dgus_screen_handler.SDCardRemoved()); } + + void onPlayTone(const uint16_t frequency, const uint16_t duration) { + dgus_screen_handler.PlayTone(frequency, duration); + } + + void onPrintTimerStarted() { + dgus_screen_handler.PrintTimerStarted(); + } + + void onPrintTimerPaused() { + dgus_screen_handler.PrintTimerPaused(); + } + + void onPrintTimerStopped() { + dgus_screen_handler.PrintTimerStopped(); + } + + void onFilamentRunout(const extruder_t extruder) { + dgus_screen_handler.FilamentRunout(extruder); + } + + void onUserConfirmRequired(const char * const msg) { + dgus_screen_handler.UserConfirmRequired(msg); + } + + void onStatusChanged(const char * const msg) { + dgus_screen_handler.SetStatusMessage(msg); + } + + void onHomingStart() {} + void onHomingComplete() {} + void onPrintFinished() {} + + void onFactoryReset() { + dgus_screen_handler.SettingsReset(); + } + + void onStoreSettings(char *buff) { + dgus_screen_handler.StoreSettings(buff); + } + + void onLoadSettings(const char *buff) { + dgus_screen_handler.LoadSettings(buff); + } + + void onPostprocessSettings() {} + + void onConfigurationStoreWritten(bool success) { + dgus_screen_handler.ConfigurationStoreWritten(success); + } + + void onConfigurationStoreRead(bool success) { + dgus_screen_handler.ConfigurationStoreRead(success); + } + + #if HAS_MESH + void onMeshLevelingStart() {} + + void onMeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval) { + dgus_screen_handler.MeshUpdate(xpos, ypos); + } + + void onMeshUpdate(const int8_t xpos, const int8_t ypos, const probe_state_t state) { + if (state == G29_POINT_FINISH) + dgus_screen_handler.MeshUpdate(xpos, ypos); + } + #endif + + #if ENABLED(POWER_LOSS_RECOVERY) + void onPowerLossResume() { + // Called on resume from power-loss + dgus_screen_handler.PowerLossResume(); + } + #endif + + #if HAS_PID_HEATING + void onPidTuning(const result_t rst) { + // Called for temperature PID tuning result + dgus_screen_handler.PidTuning(rst); + } + #endif + + void onSteppersDisabled() {} + void onSteppersEnabled() {} +} + +#endif // DGUS_LCD_UI_RELOADED diff --git a/ini/features.ini b/ini/features.ini index fa7d151938..4a1c638de2 100644 --- a/ini/features.ini +++ b/ini/features.ini @@ -78,7 +78,8 @@ HAS_MENU_TRAMMING = src_filter=+ ANYCUBIC_LCD_CHIRON = src_filter=+ ANYCUBIC_LCD_I3MEGA = src_filter=+ -HAS_DGUS_LCD = src_filter=+ +HAS_DGUS_LCD_CLASSIC = src_filter=+ +DGUS_LCD_UI_RELOADED = src_filter=+ DGUS_LCD_UI_FYSETC = src_filter=+ DGUS_LCD_UI_HIPRECY = src_filter=+ DGUS_LCD_UI_MKS = src_filter=+ diff --git a/platformio.ini b/platformio.ini index 9ee1e76a5b..55c7577e37 100644 --- a/platformio.ini +++ b/platformio.ini @@ -77,6 +77,7 @@ default_src_filter = + - - + - - - - - - - + - - - -