3DPrinting/MarlinFirmware
1
0
Fork 0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2024-11-23 02:35:31 +00:00
Code Issues Releases Wiki Activity

MKS H43 controller (#20609)

Browse Source
This commit is contained in:
Sola 2021-02-28 07:35:32 +08:00 committed by GitHub
parent e0aa9ce372
commit c76008bd6a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
33 changed files with 6314 additions and 720 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Marlin/Configuration.h
View File

@ -2349,6 +2349,7 @@
//#define DGUS_LCD_UI_ORIGIN
//#define DGUS_LCD_UI_FYSETC
//#define DGUS_LCD_UI_HIPRECY
//#define DGUS_LCD_UI_MKS
//
// Touch-screen LCD for Malyan M200/M300 printers

6
Marlin/Configuration_adv.h
View File

@ -1517,12 +1517,12 @@
#define DGUS_UPDATE_INTERVAL_MS 500 // (ms) Interval between automatic screen updates
#if EITHER(DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_HIPRECY)
#if ANY(DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_MKS, DGUS_LCD_UI_HIPRECY)
#define DGUS_PRINT_FILENAME // Display the filename during printing
#define DGUS_PREHEAT_UI // Display a preheat screen during heatup
#if ENABLED(DGUS_LCD_UI_FYSETC)
//#define DGUS_UI_MOVE_DIS_OPTION // Disabled by default for UI_FYSETC
#if EITHER(DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_MKS)
//#define DGUS_UI_MOVE_DIS_OPTION // Disabled by default for FYSETC and MKS
#else
#define DGUS_UI_MOVE_DIS_OPTION // Enabled by default for UI_HIPRECY
#endif

2
Marlin/src/HAL/STM32/eeprom_flash.cpp
View File

@ -48,7 +48,7 @@
#include "stm32_def.h"
#define DEBUG_OUT ENABLED(EEPROM_CHITCHAT)
#include "src/core/debug_out.h"
#include "../../core/debug_out.h"
#ifndef MARLIN_EEPROM_SIZE
#define MARLIN_EEPROM_SIZE 0x1000 // 4KB

2
Marlin/src/HAL/shared/cpu_exception/exception_arm.cpp
View File

@ -283,7 +283,7 @@ void CommonHandler_C(ContextStateFrame * frame, unsigned long lr, unsigned long
savedFrame.CFSR = 0;
frame->pc = (uint32_t)resume_from_fault; // Patch where to return to
frame->lr = 0xdeadbeef; // If our handler returns (it shouldn't), let's make it trigger an exception immediately
frame->lr = 0xDEADBEEF; // If our handler returns (it shouldn't), let's make it trigger an exception immediately
frame->xpsr = _BV(24); // Need to clean the PSR register to thumb II only
MinSerial::force_using_default_output = true;
return; // The CPU will resume in our handler hopefully, and we'll try to use default serial output

8
Marlin/src/HAL/shared/eeprom_if_i2c.cpp
View File

@ -32,7 +32,13 @@
#include "eeprom_if.h"
#include <Wire.h>
void eeprom_init() { Wire.begin(); }
void eeprom_init() {
Wire.begin(
#if PINS_EXIST(I2C_SCL, I2C_SDA)
uint8_t(I2C_SDA_PIN), uint8_t(I2C_SCL_PIN)
#endif
);
}
#if ENABLED(USE_SHARED_EEPROM)

5
Marlin/src/MarlinCore.cpp
View File

@ -231,6 +231,10 @@
#include "feature/password/password.h"
#endif
#if ENABLED(DGUS_LCD_UI_MKS)
#include "lcd/extui/lib/dgus/DGUSScreenHandler.h"
#endif
PGMSTR(M112_KILL_STR, "M112 Shutdown");
MarlinState marlin_state = MF_INITIALIZING;
@ -388,6 +392,7 @@ void startOrResumeJob() {
if (queue.enqueue_one_P(PSTR("M1001"))) {
marlin_state = MF_RUNNING;
TERN_(PASSWORD_AFTER_SD_PRINT_END, password.lock_machine());
TERN_(DGUS_LCD_UI_MKS, ScreenHandler.SDPrintingFinished());
}
}

15
Marlin/src/gcode/sd/M24_M25.cpp
View File

@ -41,6 +41,10 @@
#include "../../feature/powerloss.h"
#endif
#if ENABLED(DGUS_LCD_UI_MKS)
#include "../../lcd/extui/lib/dgus/DGUSDisplayDef.h"
#endif
#include "../../MarlinCore.h" // for startOrResumeJob
/**
@ -48,6 +52,11 @@
*/
void GcodeSuite::M24() {
#if ENABLED(DGUS_LCD_UI_MKS)
if ((print_job_timer.isPaused() || print_job_timer.isRunning()) && !parser.seen("ST"))
MKS_resume_print_move();
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
if (parser.seenval('S')) card.setIndex(parser.value_long());
if (parser.seenval('T')) print_job_timer.resume(parser.value_long());
@ -98,9 +107,9 @@ void GcodeSuite::M25() {
print_job_timer.pause();
#if DISABLED(DWIN_CREALITY_LCD)
ui.reset_status();
#endif
TERN_(DGUS_LCD_UI_MKS, MKS_pause_print_move());
IF_DISABLED(DWIN_CREALITY_LCD, ui.reset_status());
#if ENABLED(HOST_ACTION_COMMANDS)
TERN_(HOST_PROMPT_SUPPORT, host_prompt_open(PROMPT_PAUSE_RESUME, PSTR("Pause SD"), PSTR("Resume")));

2
Marlin/src/inc/Conditionals_LCD.h
View File

@ -451,7 +451,7 @@
#endif
// Aliases for LCD features
#if ANY(DGUS_LCD_UI_ORIGIN, DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_HIPRECY)
#if ANY(DGUS_LCD_UI_ORIGIN, DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_HIPRECY,DGUS_LCD_UI_MKS)
#define HAS_DGUS_LCD 1
#endif

2
Marlin/src/inc/SanityCheck.h
View File

@ -2324,7 +2324,7 @@ static_assert(hbm[Z_AXIS] >= 0, "HOMING_BUMP_MM.Z must be greater than or equal
+ (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) \
+ COUNT_ENABLED(DGUS_LCD_UI_ORIGIN, DGUS_LCD_UI_FYSETC, DGUS_LCD_UI_HIPRECY,DGUS_LCD_UI_MKS) \
+ COUNT_ENABLED(ENDER2_STOCKDISPLAY, CR10_STOCKDISPLAY, DWIN_CREALITY_LCD) \
+ 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) \
+ COUNT_ENABLED(LCD_SAINSMART_I2C_1602, LCD_SAINSMART_I2C_2004) \

7
Marlin/src/lcd/extui/dgus_lcd.cpp
View File

@ -21,9 +21,7 @@
*/
/**
* dgus_lcd.cpp
*
* DGUS implementation for Marlin by coldtobi, Feb-May 2019
* lcd/extui/dgus_lcd.cpp
*/
#include "../../inc/MarlinConfigPre.h"
@ -125,11 +123,10 @@ namespace ExtUI {
#if ENABLED(POWER_LOSS_RECOVERY)
void onPowerLossResume() {
// Called on resume from power-loss
ScreenHandler.GotoScreen(DGUSLCD_SCREEN_POWER_LOSS);
IF_DISABLED(DGUS_LCD_UI_MKS, ScreenHandler.GotoScreen(DGUSLCD_SCREEN_POWER_LOSS));
}
#endif
#if HAS_PID_HEATING
void onPidTuning(const result_t rst) {
// Called for temperature PID tuning result

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

@ -20,14 +20,12 @@
*
*/
/* DGUS implementation written by coldtobi in 2019 for Marlin */
#include "../../../../inc/MarlinConfigPre.h"
#if HAS_DGUS_LCD
#if HOTENDS > 2
#error "More than 2 hotends not implemented on the Display UI design."
#warning "More than 2 hotends not implemented on DGUS Display UI."
#endif
#include "../../ui_api.h"
@ -46,6 +44,8 @@
#include "DGUSVPVariable.h"
#include "DGUSDisplayDef.h"
DGUSDisplay dgusdisplay;
// Preamble... 2 Bytes, usually 0x5A 0xA5, but configurable
constexpr uint8_t DGUS_HEADER1 = 0x5A;
constexpr uint8_t DGUS_HEADER2 = 0xA5;
@ -62,8 +62,10 @@ void DGUSDisplay::InitDisplay() {
#define LCD_BAUDRATE 115200
#endif
LCD_SERIAL.begin(LCD_BAUDRATE);
if (TERN1(POWER_LOSS_RECOVERY, !recovery.valid()))
RequestScreen(TERN(SHOW_BOOTSCREEN, DGUSLCD_SCREEN_BOOT, DGUSLCD_SCREEN_MAIN));
#if BOTH(DGUS_LCD_UI_MKS, POWER_LOSS_RECOVERY)
if (!recovery.valid()) delay(LOGO_TIME_DELAY);
#endif
RequestScreen(TERN(SHOW_BOOTSCREEN, DGUSLCD_SCREEN_BOOT, DGUSLCD_SCREEN_MAIN));
}
void DGUSDisplay::WriteVariable(uint16_t adr, const void* values, uint8_t valueslen, bool isstr) {
@ -82,12 +84,12 @@ void DGUSDisplay::WriteVariable(uint16_t adr, const void* values, uint8_t values
}
void DGUSDisplay::WriteVariable(uint16_t adr, uint16_t value) {
value = (value & 0xffU) << 8U | (value >> 8U);
value = (value & 0xFFU) << 8U | (value >> 8U);
WriteVariable(adr, static_cast<const void*>(&value), sizeof(uint16_t));
}
void DGUSDisplay::WriteVariable(uint16_t adr, int16_t value) {
value = (value & 0xffU) << 8U | (value >> 8U);
value = (value & 0xFFU) << 8U | (value >> 8U);
WriteVariable(adr, static_cast<const void*>(&value), sizeof(uint16_t));
}
@ -99,15 +101,21 @@ void DGUSDisplay::WriteVariable(uint16_t adr, int8_t value) {
WriteVariable(adr, static_cast<const void*>(&value), sizeof(int8_t));
}
#if ENABLED(DGUS_LCD_UI_MKS)
void DGUSDisplay::MKS_WriteVariable(uint16_t adr, uint8_t value) {
WriteVariable(adr, static_cast<const void *>(&value), sizeof(uint8_t));
}
#endif
void DGUSDisplay::WriteVariable(uint16_t adr, long value) {
union { long l; char lb[4]; } endian;
char tmp[4];
endian.l = value;
tmp[0] = endian.lb[3];
tmp[1] = endian.lb[2];
tmp[2] = endian.lb[1];
tmp[3] = endian.lb[0];
WriteVariable(adr, static_cast<const void*>(&tmp), sizeof(long));
union { long l; char lb[4]; } endian;
char tmp[4];
endian.l = value;
tmp[0] = endian.lb[3];
tmp[1] = endian.lb[2];
tmp[2] = endian.lb[1];
tmp[3] = endian.lb[0];
WriteVariable(adr, static_cast<const void*>(&tmp), sizeof(long));
}
void DGUSDisplay::WriteVariablePGM(uint16_t adr, const void* values, uint8_t valueslen, bool isstr) {

7
Marlin/src/lcd/extui/lib/dgus/DGUSDisplay.h
View File

@ -21,7 +21,9 @@
*/
#pragma once
/* DGUS implementation written by coldtobi in 2019 for Marlin */
/**
* lcd/extui/lib/dgus/DGUSDisplay.h
*/
#include "../../../../inc/MarlinConfigPre.h"
@ -34,6 +36,7 @@
enum DGUSLCD_Screens : uint8_t;
//#define DEBUG_DGUSLCD
#define DEBUG_OUT ENABLED(DEBUG_DGUSLCD)
#include "../../../../core/debug_out.h"
@ -60,6 +63,8 @@ public:
static void WriteVariable(uint16_t adr, uint8_t value);
static void WriteVariable(uint16_t adr, int8_t value);
static void WriteVariable(uint16_t adr, long value);
static void MKS_WriteVariable(uint16_t adr, uint8_t value);
// Utility functions for bridging ui_api and dbus
template<typename T, float(*Getter)(const T), T selector, typename WireType=uint16_t>

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

@ -21,15 +21,16 @@
*/
#pragma once
/* DGUS implementation written by coldtobi in 2019 for Marlin */
/**
* lcd/extui/lib/dgus/DGUSDisplayDef.h
* Defines the interaction between Marlin and the display firmware
*/
#include "DGUSVPVariable.h"
#include <stdint.h>
// This file defines the interaction between Marlin and the display firmware.
// information on which screen which VP is displayed
// Information on which screen which VP is displayed.
// As this is a sparse table, two arrays are needed:
// one to list the VPs of one screen and one to map screens to the lists.
// (Strictly this would not be necessary, but allows to only send data the display needs and reducing load on Marlin)
@ -47,6 +48,8 @@ extern const struct DGUS_VP_Variable ListOfVP[];
#if ENABLED(DGUS_LCD_UI_ORIGIN)
#include "origin/DGUSDisplayDef.h"
#elif ENABLED(DGUS_LCD_UI_MKS)
#include "mks/DGUSDisplayDef.h"
#elif ENABLED(DGUS_LCD_UI_FYSETC)
#include "fysetc/DGUSDisplayDef.h"
#elif ENABLED(DGUS_LCD_UI_HIPRECY)

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

@ -25,46 +25,42 @@
#if HAS_DGUS_LCD
#include "DGUSScreenHandler.h"
#include "DGUSDisplay.h"
#include "DGUSVPVariable.h"
#include "DGUSDisplayDef.h"
#include "../../ui_api.h"
#include "../../../../MarlinCore.h"
#include "../../../../gcode/queue.h"
#include "../../../../libs/duration_t.h"
#include "../../../../module/settings.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../gcode/queue.h"
#include "../../../../module/planner.h"
#include "../../../../sd/cardreader.h"
#include "../../../../libs/duration_t.h"
#include "../../../../module/printcounter.h"
#include "../../../../sd/cardreader.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
DGUSScreenHandler ScreenHandler;
uint16_t DGUSScreenHandler::ConfirmVP;
#if ENABLED(SDSUPPORT)
int16_t DGUSScreenHandler::top_file = 0;
int16_t DGUSScreenHandler::file_to_print = 0;
static ExtUI::FileList filelist;
#endif
void (*DGUSScreenHandler::confirm_action_cb)() = nullptr;
//DGUSScreenHandler ScreenHandler;
DGUSLCD_Screens DGUSScreenHandler::current_screen;
DGUSLCD_Screens DGUSScreenHandler::past_screens[NUM_PAST_SCREENS];
uint8_t DGUSScreenHandler::update_ptr;
uint16_t DGUSScreenHandler::skipVP;
bool DGUSScreenHandler::ScreenComplete;
//DGUSDisplay dgusdisplay;
void (*DGUSScreenHandler::confirm_action_cb)() = nullptr;
// endianness swap
uint16_t swap16(const uint16_t value) { return (value & 0xffU) << 8U | (value >> 8U); }
#if ENABLED(SDSUPPORT)
int16_t DGUSScreenHandler::top_file = 0,
DGUSScreenHandler::file_to_print = 0;
static ExtUI::FileList filelist;
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
filament_data_t filament_data;
#endif
void DGUSScreenHandler::sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool l4inflash) {
DGUS_VP_Variable ramcopy;
@ -87,14 +83,12 @@ void DGUSScreenHandler::sendinfoscreen(const char* line1, const char* line2, con
}
void DGUSScreenHandler::HandleUserConfirmationPopUp(uint16_t VP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1, bool l2, bool l3, bool l4) {
if (current_screen == DGUSLCD_SCREEN_CONFIRM) {
// Already showing a pop up, so we need to cancel that first.
if (current_screen == DGUSLCD_SCREEN_CONFIRM) // Already showing a pop up, so we need to cancel that first.
PopToOldScreen();
}
ConfirmVP = VP;
sendinfoscreen(line1, line2, line3, line4, l1, l2, l3, l4);
ScreenHandler.GotoScreen(DGUSLCD_SCREEN_CONFIRM);
GotoScreen(DGUSLCD_SCREEN_CONFIRM);
}
void DGUSScreenHandler::setstatusmessage(const char *msg) {
@ -130,7 +124,7 @@ void DGUSScreenHandler::DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
//DEBUG_ECHOPAIR(" DGUS_LCD_SendWordValueToDisplay ", var.VP);
//DEBUG_ECHOLNPAIR(" data ", *(uint16_t *)var.memadr);
uint16_t tmp = *(uint8_t *) var.memadr +1 ; // +1 -> avoid rounding issues for the display.
uint16_t tmp = *(uint8_t *) var.memadr + 1; // +1 -> avoid rounding issues for the display.
tmp = map(tmp, 0, 255, 0, 100);
dgusdisplay.WriteVariable(var.VP, tmp);
}
@ -157,7 +151,9 @@ void DGUSScreenHandler::DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var) {
void DGUSScreenHandler::DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr) {
if (var.memadr) {
uint16_t value = swap16(*(uint16_t*)val_ptr);
DEBUG_ECHOLNPAIR("FAN value get:", value);
*(uint8_t*)var.memadr = map(constrain(value, 0, 100), 0, 100, 0, 255);
DEBUG_ECHOLNPAIR("FAN value change:", *(uint8_t*)var.memadr);
}
}
@ -234,6 +230,7 @@ void DGUSScreenHandler::DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var) {
// Send fan status value to the display.
#if HAS_FAN
void DGUSScreenHandler::DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
DEBUG_ECHOPAIR(" DGUSLCD_SendFanStatusToDisplay ", var.VP);
@ -243,6 +240,7 @@ void DGUSScreenHandler::DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var) {
dgusdisplay.WriteVariable(var.VP, data_to_send);
}
}
#endif
// Send heater status value to the display.
@ -257,6 +255,7 @@ void DGUSScreenHandler::DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var)
}
#if ENABLED(DGUS_UI_WAITING)
void DGUSScreenHandler::DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var) {
// In FYSETC UI design there are 10 statuses to loop
static uint16_t period = 0;
@ -270,6 +269,7 @@ void DGUSScreenHandler::DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var)
period = 0;
}
}
#endif
#if ENABLED(SDSUPPORT)
@ -319,7 +319,7 @@ void DGUSScreenHandler::DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var)
DEBUG_ECHOPAIR("new topfile adjusted:", top_file);
}
else if (!filelist.isAtRootDir()) {
filelist.upDir();
IF_DISABLED(DGUS_LCD_UI_MKS, filelist.upDir());
top_file = 0;
ForceCompleteUpdate();
}
@ -327,54 +327,6 @@ void DGUSScreenHandler::DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var)
if (old_top != top_file) ForceCompleteUpdate();
}
void DGUSScreenHandler::DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file;
if (touched_nr > filelist.count()) return;
if (!filelist.seek(touched_nr)) return;
if (filelist.isDir()) {
filelist.changeDir(filelist.filename());
top_file = 0;
ForceCompleteUpdate();
return;
}
#if ENABLED(DGUS_PRINT_FILENAME)
// Send print filename
dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true);
#endif
// Setup Confirmation screen
file_to_print = touched_nr;
HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true);
}
void DGUSScreenHandler::DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr) {
if (!filelist.seek(file_to_print)) return;
ExtUI::printFile(filelist.shortFilename());
ScreenHandler.GotoScreen(
#if ENABLED(DGUS_LCD_UI_ORIGIN)
DGUSLCD_SCREEN_STATUS
#else
DGUSLCD_SCREEN_SDPRINTMANIPULATION
#endif
);
}
void DGUSScreenHandler::DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
switch (swap16(*(uint16_t*)val_ptr)) {
case 0: // Resume
if (ExtUI::isPrintingFromMediaPaused()) ExtUI::resumePrint();
break;
case 1: // Pause
if (!ExtUI::isPrintingFromMediaPaused()) ExtUI::pausePrint();
break;
case 2: // Abort
ScreenHandler.HandleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true);
break;
}
}
void DGUSScreenHandler::DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr) {
ExtUI::stopPrint();
GotoScreen(DGUSLCD_SCREEN_MAIN);
@ -385,36 +337,11 @@ void DGUSScreenHandler::DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var)
GotoScreen(DGUSLCD_SCREEN_SDPRINTTUNE);
}
void DGUSScreenHandler::DGUSLCD_SD_SendFilename(DGUS_VP_Variable& var) {
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN;
if (target_line > DGUS_SD_FILESPERSCREEN) return;
char tmpfilename[VP_SD_FileName_LEN + 1] = "";
var.memadr = (void*)tmpfilename;
if (filelist.seek(top_file + target_line))
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0);
DGUSLCD_SendStringToDisplay(var);
}
void DGUSScreenHandler::SDCardInserted() {
top_file = 0;
filelist.refresh();
auto cs = ScreenHandler.getCurrentScreen();
if (cs == DGUSLCD_SCREEN_MAIN || cs == DGUSLCD_SCREEN_STATUS)
ScreenHandler.GotoScreen(DGUSLCD_SCREEN_SDFILELIST);
}
void DGUSScreenHandler::SDCardRemoved() {
if (current_screen == DGUSLCD_SCREEN_SDFILELIST
|| (current_screen == DGUSLCD_SCREEN_CONFIRM && (ConfirmVP == VP_SD_AbortPrintConfirmed || ConfirmVP == VP_SD_FileSelectConfirm))
|| current_screen == DGUSLCD_SCREEN_SDPRINTMANIPULATION
) ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN);
}
void DGUSScreenHandler::SDCardError() {
DGUSScreenHandler::SDCardRemoved();
ScreenHandler.sendinfoscreen(PSTR("NOTICE"), nullptr, PSTR("SD card error"), nullptr, true, true, true, true);
ScreenHandler.SetupConfirmAction(nullptr);
ScreenHandler.GotoScreen(DGUSLCD_SCREEN_POPUP);
sendinfoscreen(PSTR("NOTICE"), nullptr, PSTR("SD card error"), nullptr, true, true, true, true);
SetupConfirmAction(nullptr);
GotoScreen(DGUSLCD_SCREEN_POPUP);
}
#endif // SDSUPPORT
@ -428,7 +355,7 @@ void DGUSScreenHandler::ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr)
const uint16_t* DGUSLCD_FindScreenVPMapList(uint8_t screen) {
const uint16_t *ret;
const struct VPMapping *map = VPMap;
while (ret = (uint16_t*) pgm_read_ptr(&(map->VPList))) {
while ((ret = (uint16_t*) pgm_read_ptr(&(map->VPList)))) {
if (pgm_read_byte(&(map->screen)) == screen) return ret;
map++;
}
@ -455,31 +382,9 @@ void DGUSScreenHandler::ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_
}
}
void DGUSScreenHandler::ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t *tmp = (uint8_t*)val_ptr;
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
// from screen 1 (main) to 10 (temperature). DGUSLCD_SCREEN_POPUP is special,
// meaning "return to previous screen"
DGUSLCD_Screens target = (DGUSLCD_Screens)tmp[1];
if (target == DGUSLCD_SCREEN_POPUP) {
// special handling for popup is to return to previous menu
if (current_screen == DGUSLCD_SCREEN_POPUP && confirm_action_cb) confirm_action_cb();
PopToOldScreen();
return;
}
UpdateNewScreen(target);
#ifdef DEBUG_DGUSLCD
if (!DGUSLCD_FindScreenVPMapList(target)) DEBUG_ECHOLNPAIR("WARNING: No screen Mapping found for ", target);
#endif
}
void DGUSScreenHandler::HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr) {
thermalManager.disable_all_heaters();
ScreenHandler.ForceCompleteUpdate(); // hint to send all data.
ForceCompleteUpdate(); // hint to send all data.
}
void DGUSScreenHandler::HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr) {
@ -498,7 +403,7 @@ void DGUSScreenHandler::HandleTemperatureChanged(DGUS_VP_Variable &var, void *va
case VP_T_E1_Set:
thermalManager.setTargetHotend(newvalue, 1);
acceptedvalue = thermalManager.temp_hotend[1].target;
break;
break;
#endif
#if HAS_HEATED_BED
case VP_T_Bed_Set:
@ -510,7 +415,7 @@ void DGUSScreenHandler::HandleTemperatureChanged(DGUS_VP_Variable &var, void *va
// reply to display the new value to update the view if the new value was rejected by the Thermal Manager.
if (newvalue != acceptedvalue && var.send_to_display_handler) var.send_to_display_handler(var);
ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandler::HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr) {
@ -528,7 +433,7 @@ void DGUSScreenHandler::HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_p
}
planner.set_flow(target_extruder, newvalue);
ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
#else
UNUSED(var); UNUSED(val_ptr);
#endif
@ -563,97 +468,6 @@ void DGUSScreenHandler::HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr
}
#endif
void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleManualMove");
int16_t movevalue = swap16(*(uint16_t*)val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
if (movevalue) {
const uint16_t choice = *(uint16_t*)var.memadr;
movevalue = movevalue < 0 ? -choice : choice;
}
#endif
char axiscode;
unsigned int speed = 1500; //FIXME: get default feedrate for manual moves, dont hardcode.
switch (var.VP) {
default: return;
case VP_MOVE_X:
axiscode = 'X';
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
break;
case VP_MOVE_Y:
axiscode = 'Y';
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove;
break;
case VP_MOVE_Z:
axiscode = 'Z';
speed = 300; // default to 5mm/s
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove;
break;
case VP_HOME_ALL: // only used for homing
axiscode = '\0';
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
break;
}
if (!movevalue) {
// homing
DEBUG_ECHOPAIR(" homing ", axiscode);
char buf[6] = "G28 X";
buf[4] = axiscode;
//DEBUG_ECHOPAIR(" ", buf);
queue.enqueue_one_now(buf);
//DEBUG_ECHOLNPGM(" ✓");
ScreenHandler.ForceCompleteUpdate();
return;
}
else {
//movement
DEBUG_ECHOPAIR(" move ", axiscode);
bool old_relative_mode = relative_mode;
if (!relative_mode) {
//DEBUG_ECHOPGM(" G91");
queue.enqueue_now_P(PSTR("G91"));
//DEBUG_ECHOPGM(" ✓ ");
}
char buf[32]; // G1 X9999.99 F12345
unsigned int backup_speed = MMS_TO_MMM(feedrate_mm_s);
char sign[]="\0";
int16_t value = movevalue / 100;
if (movevalue < 0) { value = -value; sign[0] = '-'; }
int16_t fraction = ABS(movevalue) % 100;
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed);
//DEBUG_ECHOPAIR(" ", buf);
queue.enqueue_one_now(buf);
//DEBUG_ECHOLNPGM(" ✓ ");
if (backup_speed != speed) {
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed);
queue.enqueue_one_now(buf);
//DEBUG_ECHOPAIR(" ", buf);
}
//while (!enqueue_and_echo_command(buf)) idle();
//DEBUG_ECHOLNPGM(" ✓ ");
if (!old_relative_mode) {
//DEBUG_ECHOPGM("G90");
queue.enqueue_now_P(PSTR("G90"));
//DEBUG_ECHOPGM(" ✓ ");
}
}
ScreenHandler.ForceCompleteUpdate();
DEBUG_ECHOLNPGM("manmv done.");
return;
cannotmove:
DEBUG_ECHOLNPAIR(" cannot move ", axiscode);
return;
}
void DGUSScreenHandler::HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleMotorLockUnlock");
@ -665,22 +479,6 @@ void DGUSScreenHandler::HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_p
queue.enqueue_one_now(buf);
}
#if ENABLED(POWER_LOSS_RECOVERY)
void DGUSScreenHandler::HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t value = swap16(*(uint16_t*)val_ptr);
if (value) {
queue.inject_P(PSTR("M1000"));
ScreenHandler.GotoScreen(DGUSLCD_SCREEN_SDPRINTMANIPULATION);
}
else {
recovery.cancel();
ScreenHandler.GotoScreen(DGUSLCD_SCREEN_STATUS);
}
}
#endif
void DGUSScreenHandler::HandleSettings(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleSettings");
uint16_t value = swap16(*(uint16_t*)val_ptr);
@ -688,10 +486,11 @@ void DGUSScreenHandler::HandleSettings(DGUS_VP_Variable &var, void *val_ptr) {
default: break;
case 1:
TERN_(PRINTCOUNTER, print_job_timer.initStats());
queue.inject_P(PSTR("M502\nM500"));
settings.reset();
settings.save();
break;
case 2: queue.inject_P(PSTR("M501")); break;
case 3: queue.inject_P(PSTR("M500")); break;
case 2: settings.load(); break;
case 3: settings.save(); break;
}
}
@ -700,7 +499,7 @@ void DGUSScreenHandler::HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_
uint16_t value_raw = swap16(*(uint16_t*)val_ptr);
DEBUG_ECHOLNPAIR("value_raw:", value_raw);
float value = (float)value_raw/10;
float value = (float)value_raw / 10;
ExtUI::axis_t axis;
switch (var.VP) {
case VP_X_STEP_PER_MM: axis = ExtUI::axis_t::X; break;
@ -711,7 +510,7 @@ void DGUSScreenHandler::HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_
DEBUG_ECHOLNPAIR_F("value:", value);
ExtUI::setAxisSteps_per_mm(value, axis);
DEBUG_ECHOLNPAIR_F("value_set:", ExtUI::getAxisSteps_per_mm(axis));
ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
return;
}
@ -720,56 +519,24 @@ void DGUSScreenHandler::HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, vo
uint16_t value_raw = swap16(*(uint16_t*)val_ptr);
DEBUG_ECHOLNPAIR("value_raw:", value_raw);
float value = (float)value_raw/10;
float value = (float)value_raw / 10;
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_STEP_PER_MM: extruder = ExtUI::extruder_t::E0; break;
#endif
#if HOTENDS >= 2
case VP_E1_STEP_PER_MM: extruder = ExtUI::extruder_t::E1; break;
#endif
#if HOTENDS >= 1
case VP_E0_STEP_PER_MM: extruder = ExtUI::extruder_t::E0; break;
#endif
#if HOTENDS >= 2
case VP_E1_STEP_PER_MM: extruder = ExtUI::extruder_t::E1; break;
#endif
}
DEBUG_ECHOLNPAIR_F("value:", value);
ExtUI::setAxisSteps_per_mm(value,extruder);
ExtUI::setAxisSteps_per_mm(value, extruder);
DEBUG_ECHOLNPAIR_F("value_set:", ExtUI::getAxisSteps_per_mm(extruder));
ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
return;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#if HAS_PID_HEATING
void DGUSScreenHandler::HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr);
DEBUG_ECHOLNPAIR("V1:", rawvalue);
float value = (float)rawvalue / 10;
DEBUG_ECHOLNPAIR("V2:", value);
float newvalue = 0;
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_PID_P: newvalue = value; break;
case VP_E0_PID_I: newvalue = scalePID_i(value); break;
case VP_E0_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HOTENDS >= 2
case VP_E1_PID_P: newvalue = value; break;
case VP_E1_PID_I: newvalue = scalePID_i(value); break;
case VP_E1_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: newvalue = value; break;
case VP_BED_PID_I: newvalue = scalePID_i(value); break;
case VP_BED_PID_D: newvalue = scalePID_d(value); break;
#endif
}
DEBUG_ECHOLNPAIR_F("V3:", newvalue);
*(float *)var.memadr = newvalue;
ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandler::HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandlePIDAutotune");
@ -777,23 +544,23 @@ void DGUSScreenHandler::HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, vo
switch (var.VP) {
default: break;
#if ENABLED(PIDTEMP)
#if HOTENDS >= 1
case VP_PID_AUTOTUNE_E0: // Autotune Extruder 0
sprintf(buf, "M303 E%d C5 S210 U1", ExtUI::extruder_t::E0);
#if ENABLED(PIDTEMP)
#if HOTENDS >= 1
case VP_PID_AUTOTUNE_E0: // Autotune Extruder 0
sprintf_P(buf, PSTR("M303 E%d C5 S210 U1"), ExtUI::extruder_t::E0);
break;
#endif
#if HOTENDS >= 2
case VP_PID_AUTOTUNE_E1:
sprintf_P(buf, PSTR("M303 E%d C5 S210 U1"), ExtUI::extruder_t::E1);
break;
#endif
#endif
#if ENABLED(PIDTEMPBED)
case VP_PID_AUTOTUNE_BED:
sprintf_P(buf, PSTR("M303 E-1 C5 S70 U1"));
break;
#endif
#if HOTENDS >= 2
case VP_PID_AUTOTUNE_E1:
sprintf(buf, "M303 E%d C5 S210 U1", ExtUI::extruder_t::E1);
break;
#endif
#endif
#if ENABLED(PIDTEMPBED)
case VP_PID_AUTOTUNE_BED:
sprintf(buf, "M303 E-1 C5 S70 U1");
break;
#endif
}
if (buf[0]) queue.enqueue_one_now(buf);
@ -803,7 +570,7 @@ void DGUSScreenHandler::HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, vo
GotoScreen(DGUSLCD_SCREEN_WAITING);
#endif
}
#endif
#endif // HAS_PID_HEATING
#if HAS_BED_PROBE
void DGUSScreenHandler::HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr) {
@ -811,19 +578,7 @@ void DGUSScreenHandler::HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, vo
const float offset = float(int16_t(swap16(*(uint16_t*)val_ptr))) / 100.0f;
ExtUI::setZOffset_mm(offset);
ScreenHandler.skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
return;
}
#endif
#if ENABLED(BABYSTEPPING)
void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleLiveAdjustZ");
int16_t flag = swap16(*(uint16_t*)val_ptr);
int16_t steps = flag ? -20 : 20;
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true);
ScreenHandler.ForceCompleteUpdate();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
return;
}
#endif
@ -849,8 +604,8 @@ void DGUSScreenHandler::HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr
#if HOTENDS >= 3
case VP_E2_CONTROL:
#endif
preheat_temp = PREHEAT_1_TEMP_HOTEND;
break;
preheat_temp = PREHEAT_1_TEMP_HOTEND;
break;
case VP_BED_CONTROL:
preheat_temp = PREHEAT_1_TEMP_BED;
@ -900,149 +655,49 @@ void DGUSScreenHandler::HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_BED_PREHEAT:
thermalManager.setTargetHotend(e_temp, 0);
TERN_(HAS_HEATED_BED, thermalManager.setTargetBed(bed_temp));
break;
#endif
#if HOTENDS >= 2
case VP_E1_BED_PREHEAT:
thermalManager.setTargetHotend(e_temp, 1);
TERN_(HAS_HEATED_BED, thermalManager.setTargetBed(bed_temp));
break;
#endif
#if HOTENDS >= 1
case VP_E0_BED_PREHEAT:
thermalManager.setTargetHotend(e_temp, 0);
TERN_(HAS_HEATED_BED, thermalManager.setTargetBed(bed_temp));
break;
#endif
#if HOTENDS >= 2
case VP_E1_BED_PREHEAT:
thermalManager.setTargetHotend(e_temp, 1);
TERN_(HAS_HEATED_BED, thermalManager.setTargetBed(bed_temp));
break;
#endif
}
// Go to the preheat screen to show the heating progress
GotoScreen(DGUSLCD_SCREEN_PREHEAT);
}
#endif
#endif // DGUS_PREHEAT_UI
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
#if ENABLED(POWER_LOSS_RECOVERY)
typedef struct {
ExtUI::extruder_t extruder; // which extruder to operate
uint8_t action; // load or unload
bool heated; // heating done ?
float purge_length; // the length to extrude before unload, prevent filament jam
} filament_data_t;
static filament_data_t filament_data;
void DGUSScreenHandler::HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleFilamentOption");
uint8_t e_temp = 0;
filament_data.heated = false;
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr);
if (preheat_option <= 8) // Load filament type
filament_data.action = 1;
else if (preheat_option >= 10) { // Unload filament type
preheat_option -= 10;
filament_data.action = 2;
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH;
void DGUSScreenHandler::HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t value = swap16(*(uint16_t*)val_ptr);
if (value) {
queue.inject_P(PSTR("M1000"));
dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), 32, true);
GotoScreen(PLR_SCREEN_RECOVER);
}
else // Cancel filament operation
filament_data.action = 0;
switch (preheat_option) {
case 0: // Load PLA
#ifdef PREHEAT_1_TEMP_HOTEND
e_temp = PREHEAT_1_TEMP_HOTEND;
#endif
break;
case 1: // Load ABS
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND);
break;
case 2: // Load PET
#ifdef PREHEAT_3_TEMP_HOTEND
e_temp = PREHEAT_3_TEMP_HOTEND;
#endif
break;
case 3: // Load FLEX
#ifdef PREHEAT_4_TEMP_HOTEND
e_temp = PREHEAT_4_TEMP_HOTEND;
#endif
break;
case 9: // Cool down
default:
e_temp = 0;
break;
}
if (filament_data.action == 0) { // Go back to utility screen
#if HOTENDS >= 1
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0);
#endif
#if HOTENDS >= 2
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1);
#endif
GotoScreen(DGUSLCD_SCREEN_UTILITY);
}
else { // Go to the preheat screen to show the heating progress
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E0;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
#if HOTENDS >= 2
case VP_E1_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E1;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
}
GotoScreen(DGUSLCD_SCREEN_FILAMENT_HEATING);
else {
recovery.cancel();
GotoScreen(PLR_SCREEN_CANCEL);
}
}
void DGUSScreenHandler::HandleFilamentLoadUnload(DGUS_VP_Variable &var) {
DEBUG_ECHOLNPGM("HandleFilamentLoadUnload");
if (filament_data.action <= 0) return;
// If we close to the target temperature, we can start load or unload the filament
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) {
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME;
if (filament_data.action == 1) { // load filament
if (!filament_data.heated) {
GotoScreen(DGUSLCD_SCREEN_FILAMENT_LOADING);
filament_data.heated = true;
}
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder)+movevalue;
}
else { // unload filament
if (!filament_data.heated) {
GotoScreen(DGUSLCD_SCREEN_FILAMENT_UNLOADING);
filament_data.heated = true;
}
// Before unloading extrude to prevent jamming
if (filament_data.purge_length >= 0) {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
filament_data.purge_length -= movevalue;
}
else
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue;
}
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder);
}
}
#endif
void DGUSScreenHandler::UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup) {
DEBUG_ECHOLNPAIR("SetNewScreen: ", newscreen);
if (!popup) {
memmove(&past_screens[1], &past_screens[0], sizeof(past_screens) - 1);
past_screens[0] = current_screen;
}
current_screen = newscreen;
skipVP = 0;
ForceCompleteUpdate();
@ -1062,7 +717,7 @@ void DGUSScreenHandler::UpdateScreenVPData() {
if (!VPList) {
DEBUG_ECHOLNPAIR(" NO SCREEN FOR: ", current_screen);
ScreenComplete = true;
return; // nothing to do, likely a bug or boring screen.
return; // nothing to do, likely a bug or boring screen.
}
// Round-robin updating of all VPs.
@ -1076,14 +731,14 @@ void DGUSScreenHandler::UpdateScreenVPData() {
update_ptr = 0;
DEBUG_ECHOLNPGM(" UpdateScreenVPData done");
ScreenComplete = true;
return; // Screen completed.
return; // Screen completed.
}
if (VP == skipVP) { skipVP = 0; continue; }
DGUS_VP_Variable rcpy;
if (populate_VPVar(VP, &rcpy)) {
uint8_t expected_tx = 6 + rcpy.size; // expected overhead is 6 bytes + payload.
uint8_t expected_tx = 6 + rcpy.size; // expected overhead is 6 bytes + payload.
// Send the VP to the display, but try to avoid overrunning the Tx Buffer.
// But send at least one VP, to avoid getting stalled.
if (rcpy.send_to_display_handler && (!sent_one || expected_tx <= dgusdisplay.GetFreeTxBuffer())) {
@ -1092,11 +747,11 @@ void DGUSScreenHandler::UpdateScreenVPData() {
rcpy.send_to_display_handler(rcpy);
}
else {
//auto x=dgusdisplay.GetFreeTxBuffer();
// auto x=dgusdisplay.GetFreeTxBuffer();
//DEBUG_ECHOLNPAIR(" tx almost full: ", x);
//DEBUG_ECHOPAIR(" update_ptr ", update_ptr);
ScreenComplete = false;
return; // please call again!
return; // please call again!
}
}
@ -1108,29 +763,6 @@ void DGUSScreenHandler::GotoScreen(DGUSLCD_Screens screen, bool ispopup) {
UpdateNewScreen(screen, ispopup);
}
bool DGUSScreenHandler::loop() {
dgusdisplay.loop();
const millis_t ms = millis();
static millis_t next_event_ms = 0;
if (!IsScreenComplete() || ELAPSED(ms, next_event_ms)) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
UpdateScreenVPData();
}
#if ENABLED(SHOW_BOOTSCREEN)
static bool booted = false;
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid()))
booted = true;
if (!booted && ELAPSED(ms, BOOTSCREEN_TIMEOUT)) {
booted = true;
GotoScreen(DGUSLCD_SCREEN_MAIN);
}
#endif
return IsScreenComplete();
}
void DGUSDisplay::RequestScreen(DGUSLCD_Screens screen) {
DEBUG_ECHOLNPAIR("GotoScreen ", screen);
const unsigned char gotoscreen[] = { 0x5A, 0x01, (unsigned char) (screen >> 8U), (unsigned char) (screen & 0xFFU) };

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

@ -21,212 +21,38 @@
*/
#pragma once
#include "DGUSDisplay.h"
#include "DGUSVPVariable.h"
/**
* lcd/extui/lib/dgus/DGUSScreenHandler.h
*/
#include "../../../../inc/MarlinConfig.h"
#include "../../../../inc/MarlinConfigPre.h"
enum DGUSLCD_Screens : uint8_t;
#include "../../ui_api.h"
class DGUSScreenHandler {
public:
DGUSScreenHandler() = default;
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
static bool loop();
typedef struct {
ExtUI::extruder_t extruder; // which extruder to operate
uint8_t action; // load or unload
bool heated; // heating done ?
float purge_length; // the length to extrude before unload, prevent filament jam
} filament_data_t;
/// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
/// The bools specifing whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
extern filament_data_t filament_data;
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
#endif
/// "M117" Message -- msg is a RAM ptr.
static void setstatusmessage(const char* msg);
/// The same for messages from Flash
static void setstatusmessagePGM(PGM_P const msg);
// Callback for VP "Display wants to change screen on idle printer"
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "Screen has been changed"
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "All Heaters Off"
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change this temperature"
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change Flowrate"
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
// Hook for manual move option
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for manual move.
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr);
// Hook for manual extrude.
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr);
// Hook for motor lock and unlook
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(POWER_LOSS_RECOVERY)
// Hook for power loss recovery.
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for settings
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#if HAS_PID_HEATING
// Hook for "Change this temperature PID para"
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for PID autotune
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_BED_PROBE
// Hook for "Change probe offset z"
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(BABYSTEPPING)
// Hook for live z adjust action
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_FAN
// Hook for fan control
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for heater control
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_PREHEAT_UI)
// Hook for preheat
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
// Hook for filament load and unload filament option
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr);
// Hook for filament load and unload
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var);
#endif
// endianness swap
inline uint16_t swap16(const uint16_t value) { return (value & 0xFFU) << 8U | (value >> 8U); }
#if ENABLED(SDSUPPORT)
// Callback for VP "Display wants to change screen when there is a SD card"
static void ScreenChangeHookIfSD(DGUS_VP_Variable &var, void *val_ptr);
/// Scroll buttons on the file listing screen.
static void DGUSLCD_SD_ScrollFilelist(DGUS_VP_Variable &var, void *val_ptr);
/// File touched.
static void DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr);
/// start print after confirmation received.
static void DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr);
/// User hit the pause, resume or abort button.
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr);
/// User confirmed the abort action
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr);
/// User hit the tune button
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr);
/// Send a single filename to the display.
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var);
/// Marlin informed us that a new SD has been inserted.
static void SDCardInserted();
/// Marlin informed us that the SD Card has been removed().
static void SDCardRemoved();
/// Marlin informed us about a bad SD Card.
static void SDCardError();
#endif
// OK Button the Confirm screen.
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr);
// Update data after went to new screen (by display or by GotoScreen)
// remember: store the last-displayed screen, so it can get returned to.
// (e.g for pop up messages)
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false);
// Recall the remembered screen.
static void PopToOldScreen();
// Make the display show the screen and update all VPs in it.
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false);
static void UpdateScreenVPData();
// Helpers to convert and transfer data to the display.
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var);
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var);
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var);
#if ENABLED(PRINTCOUNTER)
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var);
#endif
#if HAS_FAN
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var);
#endif
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var);
#if ENABLED(DGUS_UI_WAITING)
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var);
#endif
/// Send a value from 0..100 to a variable with a range from 0..255
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr);
template<typename T>
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) {
if (!var.memadr) return;
union { unsigned char tmp[sizeof(T)]; T t; } x;
unsigned char *ptr = (unsigned char*)val_ptr;
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1];
*(T*)var.memadr = x.t;
}
/// Send a float value to the display.
/// Display will get a 4-byte integer scaled to the number of digits:
/// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (long)f);
}
}
/// Send a float value to the display.
/// Display will get a 2-byte integer scaled to the number of digits:
/// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
DEBUG_ECHOLNPAIR_F(" >> ", f, 6);
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (int16_t)f);
}
}
/// Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
/// Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private:
static DGUSLCD_Screens current_screen; ///< currently on screen
static constexpr uint8_t NUM_PAST_SCREENS = 4;
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; ///< LIFO with past screens for the "back" button.
static uint8_t update_ptr; ///< Last sent entry in the VPList for the actual screen.
static uint16_t skipVP; ///< When updating the screen data, skip this one, because the user is interacting with it.
static bool ScreenComplete; ///< All VPs sent to screen?
static uint16_t ConfirmVP; ///< context for confirm screen (VP that will be emulated-sent on "OK").
#if ENABLED(SDSUPPORT)
static int16_t top_file; ///< file on top of file chooser
static int16_t file_to_print; ///< touched file to be confirmed
#endif
static void (*confirm_action_cb)();
};
#if ENABLED(DGUS_LCD_UI_ORIGIN)
#include "origin/DGUSScreenHandler.h"
#elif ENABLED(DGUS_LCD_UI_MKS)
#include "mks/DGUSScreenHandler.h"
#elif ENABLED(DGUS_LCD_UI_FYSETC)
#include "fysetc/DGUSScreenHandler.h"
#elif ENABLED(DGUS_LCD_UI_HIPRECY)
#include "hiprecy/DGUSScreenHandler.h"
#endif
extern DGUSScreenHandler ScreenHandler;

418
Marlin/src/lcd/extui/lib/dgus/fysetc/DGUSScreenHandler.cpp Normal file
View File

@ -0,0 +1,418 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_FYSETC)
#include "../DGUSScreenHandler.h"
#include "../../../../../MarlinCore.h"
#include "../../../../../gcode/queue.h"
#include "../../../../../libs/duration_t.h"
#include "../../../../../module/settings.h"
#include "../../../../../module/temperature.h"
#include "../../../../../module/motion.h"
#include "../../../../../module/planner.h"
#include "../../../../../module/printcounter.h"
#include "../../../../../sd/cardreader.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
#if ENABLED(SDSUPPORT)
void DGUSScreenHandler::DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file;
if (touched_nr > filelist.count()) return;
if (!filelist.seek(touched_nr)) return;
if (filelist.isDir()) {
filelist.changeDir(filelist.filename());
top_file = 0;
ForceCompleteUpdate();
return;
}
#if ENABLED(DGUS_PRINT_FILENAME)
// Send print filename
dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true);
#endif
// Setup Confirmation screen
file_to_print = touched_nr;
HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true);
}
void DGUSScreenHandler::DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr) {
if (!filelist.seek(file_to_print)) return;
ExtUI::printFile(filelist.shortFilename());
GotoScreen(DGUSLCD_SCREEN_SDPRINTMANIPULATION);
}
void DGUSScreenHandler::DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
switch (swap16(*(uint16_t*)val_ptr)) {
case 0: { // Resume
if (ExtUI::isPrintingFromMediaPaused()) {
ExtUI::resumePrint();
}
} break;
case 1: // Pause
GotoScreen(MKSLCD_SCREEN_PAUSE);
if (!ExtUI::isPrintingFromMediaPaused()) {
ExtUI::pausePrint();
//ExtUI::mks_pausePrint();
}
break;
case 2: // Abort
HandleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true);
break;
}
}
void DGUSScreenHandler::DGUSLCD_SD_SendFilename(DGUS_VP_Variable& var) {
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN;
if (target_line > DGUS_SD_FILESPERSCREEN) return;
char tmpfilename[VP_SD_FileName_LEN + 1] = "";
var.memadr = (void*)tmpfilename;
if (filelist.seek(top_file + target_line)) {
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
}
DGUSLCD_SendStringToDisplay(var);
}
void DGUSScreenHandler::SDCardInserted() {
top_file = 0;
filelist.refresh();
auto cs = getCurrentScreen();
if (cs == DGUSLCD_SCREEN_MAIN || cs == DGUSLCD_SCREEN_STATUS)
GotoScreen(DGUSLCD_SCREEN_SDFILELIST);
}
void DGUSScreenHandler::SDCardRemoved() {
if (current_screen == DGUSLCD_SCREEN_SDFILELIST
|| (current_screen == DGUSLCD_SCREEN_CONFIRM && (ConfirmVP == VP_SD_AbortPrintConfirmed || ConfirmVP == VP_SD_FileSelectConfirm))
|| current_screen == DGUSLCD_SCREEN_SDPRINTMANIPULATION
) GotoScreen(DGUSLCD_SCREEN_MAIN);
}
#endif // SDSUPPORT
void DGUSScreenHandler::ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t *tmp = (uint8_t*)val_ptr;
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
// from screen 1 (main) to 10 (temperature). DGUSLCD_SCREEN_POPUP is special,
// meaning "return to previous screen"
DGUSLCD_Screens target = (DGUSLCD_Screens)tmp[1];
DEBUG_ECHOLNPAIR("\n DEBUG target", target);
if (target == DGUSLCD_SCREEN_POPUP) {
// Special handling for popup is to return to previous menu
if (current_screen == DGUSLCD_SCREEN_POPUP && confirm_action_cb) confirm_action_cb();
PopToOldScreen();
return;
}
UpdateNewScreen(target);
#ifdef DEBUG_DGUSLCD
if (!DGUSLCD_FindScreenVPMapList(target)) DEBUG_ECHOLNPAIR("WARNING: No screen Mapping found for ", target);
#endif
}
void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleManualMove");
int16_t movevalue = swap16(*(uint16_t*)val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
if (movevalue) {
const uint16_t choice = *(uint16_t*)var.memadr;
movevalue = movevalue < 0 ? -choice : choice;
}
#endif
char axiscode;
unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
switch (var.VP) {
default: return;
case VP_MOVE_X:
axiscode = 'X';
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
break;
case VP_MOVE_Y:
axiscode = 'Y';
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove;
break;
case VP_MOVE_Z:
axiscode = 'Z';
speed = 300; // default to 5mm/s
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove;
break;
case VP_HOME_ALL: // only used for homing
axiscode = '\0';
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
break;
}
if (!movevalue) {
// homing
DEBUG_ECHOPAIR(" homing ", axiscode);
char buf[6] = "G28 X";
buf[4] = axiscode;
//DEBUG_ECHOPAIR(" ", buf);
queue.enqueue_one_now(buf);
//DEBUG_ECHOLNPGM(" ✓");
ForceCompleteUpdate();
return;
}
else {
// movement
DEBUG_ECHOPAIR(" move ", axiscode);
bool old_relative_mode = relative_mode;
if (!relative_mode) {
//DEBUG_ECHOPGM(" G91");
queue.enqueue_now_P(PSTR("G91"));
//DEBUG_ECHOPGM(" ✓ ");
}
char buf[32]; // G1 X9999.99 F12345
unsigned int backup_speed = MMS_TO_MMM(feedrate_mm_s);
char sign[] = "\0";
int16_t value = movevalue / 100;
if (movevalue < 0) { value = -value; sign[0] = '-'; }
int16_t fraction = ABS(movevalue) % 100;
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed);
//DEBUG_ECHOPAIR(" ", buf);
queue.enqueue_one_now(buf);
//DEBUG_ECHOLNPGM(" ✓ ");
if (backup_speed != speed) {
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed);
queue.enqueue_one_now(buf);
//DEBUG_ECHOPAIR(" ", buf);
}
// while (!enqueue_and_echo_command(buf)) idle();
//DEBUG_ECHOLNPGM(" ✓ ");
if (!old_relative_mode) {
//DEBUG_ECHOPGM("G90");
queue.enqueue_now_P(PSTR("G90"));
//DEBUG_ECHOPGM(" ✓ ");
}
}
ForceCompleteUpdate();
DEBUG_ECHOLNPGM("manmv done.");
return;
cannotmove:
DEBUG_ECHOLNPAIR(" cannot move ", axiscode);
return;
}
#if HAS_PID_HEATING
void DGUSScreenHandler::HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr);
DEBUG_ECHOLNPAIR("V1:", rawvalue);
float value = (float)rawvalue / 10;
DEBUG_ECHOLNPAIR("V2:", value);
float newvalue = 0;
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_PID_P: newvalue = value; break;
case VP_E0_PID_I: newvalue = scalePID_i(value); break;
case VP_E0_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HOTENDS >= 2
case VP_E1_PID_P: newvalue = value; break;
case VP_E1_PID_I: newvalue = scalePID_i(value); break;
case VP_E1_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: newvalue = value; break;
case VP_BED_PID_I: newvalue = scalePID_i(value); break;
case VP_BED_PID_D: newvalue = scalePID_d(value); break;
#endif
}
DEBUG_ECHOLNPAIR_F("V3:", newvalue);
*(float *)var.memadr = newvalue;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // HAS_PID_HEATING
#if ENABLED(BABYSTEPPING)
void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleLiveAdjustZ");
int16_t flag = swap16(*(uint16_t*)val_ptr),
steps = flag ? -20 : 20;
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true);
ForceCompleteUpdate();
}
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
void DGUSScreenHandler::HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleFilamentOption");
uint8_t e_temp = 0;
filament_data.heated = false;
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr);
if (preheat_option <= 8) { // Load filament type
filament_data.action = 1;
}
else if (preheat_option >= 10) { // Unload filament type
preheat_option -= 10;
filament_data.action = 2;
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH;
}
else { // Cancel filament operation
filament_data.action = 0;
}
switch (preheat_option) {
case 0: // Load PLA
#ifdef PREHEAT_1_TEMP_HOTEND
e_temp = PREHEAT_1_TEMP_HOTEND;
#endif
break;
case 1: // Load ABS
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND);
break;
case 2: // Load PET
#ifdef PREHEAT_3_TEMP_HOTEND
e_temp = PREHEAT_3_TEMP_HOTEND;
#endif
break;
case 3: // Load FLEX
#ifdef PREHEAT_4_TEMP_HOTEND
e_temp = PREHEAT_4_TEMP_HOTEND;
#endif
break;
case 9: // Cool down
default:
e_temp = 0;
break;
}
if (filament_data.action == 0) { // Go back to utility screen
#if HOTENDS >= 1
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0);
#endif
#if HOTENDS >= 2
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1);
#endif
GotoScreen(DGUSLCD_SCREEN_UTILITY);
}
else { // Go to the preheat screen to show the heating progress
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E0;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
#if HOTENDS >= 2
case VP_E1_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E1;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
}
GotoScreen(DGUSLCD_SCREEN_FILAMENT_HEATING);
}
}
void DGUSScreenHandler::HandleFilamentLoadUnload(DGUS_VP_Variable &var) {
DEBUG_ECHOLNPGM("HandleFilamentLoadUnload");
if (filament_data.action <= 0) return;
// If we close to the target temperature, we can start load or unload the filament
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) {
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME;
if (filament_data.action == 1) { // load filament
if (!filament_data.heated) {
//GotoScreen(DGUSLCD_SCREEN_FILAMENT_LOADING);
filament_data.heated = true;
}
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
}
else { // unload filament
if (!filament_data.heated) {
GotoScreen(DGUSLCD_SCREEN_FILAMENT_UNLOADING);
filament_data.heated = true;
}
// Before unloading extrude to prevent jamming
if (filament_data.purge_length >= 0) {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
filament_data.purge_length -= movevalue;
}
else {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue;
}
}
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder);
}
}
#endif // DGUS_FILAMENT_LOADUNLOAD
bool DGUSScreenHandler::loop() {
dgusdisplay.loop();
const millis_t ms = millis();
static millis_t next_event_ms = 0;
if (!IsScreenComplete() || ELAPSED(ms, next_event_ms)) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
UpdateScreenVPData();
}
#if ENABLED(SHOW_BOOTSCREEN)
static bool booted = false;
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid()))
booted = true;
if (!booted && ELAPSED(ms, TERN(USE_MKS_GREEN_UI, 1000, BOOTSCREEN_TIMEOUT)))
booted = true;
#endif
return IsScreenComplete();
}
#endif // DGUS_LCD_UI_FYSETC

240
Marlin/src/lcd/extui/lib/dgus/fysetc/DGUSScreenHandler.h Normal file
View File

@ -0,0 +1,240 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplay.h"
#include "../DGUSVPVariable.h"
#include "../DGUSDisplayDef.h"
#include "../../../../../inc/MarlinConfig.h"
enum DGUSLCD_Screens : uint8_t;
class DGUSScreenHandler {
public:
DGUSScreenHandler() = default;
static bool loop();
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifing whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
// "M117" Message -- msg is a RAM ptr.
static void setstatusmessage(const char* msg);
// The same for messages from Flash
static void setstatusmessagePGM(PGM_P const msg);
// Callback for VP "Display wants to change screen on idle printer"
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "Screen has been changed"
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "All Heaters Off"
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change this temperature"
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change Flowrate"
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
// Hook for manual move option
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for manual move.
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr);
// Hook for manual extrude.
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr);
// Hook for motor lock and unlook
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(POWER_LOSS_RECOVERY)
// Hook for power loss recovery.
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for settings
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#if HAS_PID_HEATING
// Hook for "Change this temperature PID para"
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for PID autotune
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_BED_PROBE
// Hook for "Change probe offset z"
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(BABYSTEPPING)
// Hook for live z adjust action
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_FAN
// Hook for fan control
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for heater control
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_PREHEAT_UI)
// Hook for preheat
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
// Hook for filament load and unload filament option
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr);
// Hook for filament load and unload
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var);
#endif
#if ENABLED(SDSUPPORT)
// Callback for VP "Display wants to change screen when there is a SD card"
static void ScreenChangeHookIfSD(DGUS_VP_Variable &var, void *val_ptr);
// Scroll buttons on the file listing screen.
static void DGUSLCD_SD_ScrollFilelist(DGUS_VP_Variable &var, void *val_ptr);
// File touched.
static void DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr);
// start print after confirmation received.
static void DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr);
// User hit the pause, resume or abort button.
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr);
// User confirmed the abort action
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr);
// User hit the tune button
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr);
// Send a single filename to the display.
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var);
// Marlin informed us that a new SD has been inserted.
static void SDCardInserted();
// Marlin informed us that the SD Card has been removed().
static void SDCardRemoved();
// Marlin informed us about a bad SD Card.
static void SDCardError();
#endif
// OK Button the Confirm screen.
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr);
// Update data after went to new screen (by display or by GotoScreen)
// remember: store the last-displayed screen, so it can get returned to.
// (e.g for pop up messages)
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false);
// Recall the remembered screen.
static void PopToOldScreen();
// Make the display show the screen and update all VPs in it.
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false);
static void UpdateScreenVPData();
// Helpers to convert and transfer data to the display.
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var);
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var);
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var);
#if ENABLED(PRINTCOUNTER)
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var);
#endif
#if HAS_FAN
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var);
#endif
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var);
#if ENABLED(DGUS_UI_WAITING)
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var);
#endif
// Send a value from 0..100 to a variable with a range from 0..255
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr);
template<typename T>
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) {
if (!var.memadr) return;
union { unsigned char tmp[sizeof(T)]; T t; } x;
unsigned char *ptr = (unsigned char*)val_ptr;
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1];
*(T*)var.memadr = x.t;
}
// Send a float value to the display.
// Display will get a 4-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (long)f);
}
}
// Send a float value to the display.
// Display will get a 2-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
DEBUG_ECHOLNPAIR_F(" >> ", f, 6);
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (int16_t)f);
}
}
// Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
// Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private:
static DGUSLCD_Screens current_screen; //< currently on screen
static constexpr uint8_t NUM_PAST_SCREENS = 4;
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
static bool ScreenComplete; //< All VPs sent to screen?
static uint16_t ConfirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
#if ENABLED(SDSUPPORT)
static int16_t top_file; //< file on top of file chooser
static int16_t file_to_print; //< touched file to be confirmed
#endif
static void (*confirm_action_cb)();
};
#if ENABLED(POWER_LOSS_RECOVERY)
#define PLR_SCREEN_RECOVER DGUSLCD_SCREEN_SDPRINTMANIPULATION
#define PLR_SCREEN_CANCEL DGUSLCD_SCREEN_STATUS
#endif

418
Marlin/src/lcd/extui/lib/dgus/hiprecy/DGUSScreenHandler.cpp Normal file
View File

@ -0,0 +1,418 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_HYPRECY)
#include "../DGUSScreenHandler.h"
#include "../../../../../MarlinCore.h"
#include "../../../../../gcode/queue.h"
#include "../../../../../libs/duration_t.h"
#include "../../../../../module/settings.h"
#include "../../../../../module/temperature.h"
#include "../../../../../module/motion.h"
#include "../../../../../module/planner.h"
#include "../../../../../module/printcounter.h"
#include "../../../../../sd/cardreader.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
#if ENABLED(SDSUPPORT)
void DGUSScreenHandler::DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file;
if (touched_nr > filelist.count()) return;
if (!filelist.seek(touched_nr)) return;
if (filelist.isDir()) {
filelist.changeDir(filelist.filename());
top_file = 0;
ForceCompleteUpdate();
return;
}
#if ENABLED(DGUS_PRINT_FILENAME)
// Send print filename
dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true);
#endif
// Setup Confirmation screen
file_to_print = touched_nr;
HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true);
}
void DGUSScreenHandler::DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr) {
if (!filelist.seek(file_to_print)) return;
ExtUI::printFile(filelist.shortFilename());
GotoScreen(DGUSLCD_SCREEN_SDPRINTMANIPULATION);
}
void DGUSScreenHandler::DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
switch (swap16(*(uint16_t*)val_ptr)) {
case 0: { // Resume
if (ExtUI::isPrintingFromMediaPaused()) {
ExtUI::resumePrint();
}
} break;
case 1: // Pause
GotoScreen(MKSLCD_SCREEN_PAUSE);
if (!ExtUI::isPrintingFromMediaPaused()) {
ExtUI::pausePrint();
//ExtUI::mks_pausePrint();
}
break;
case 2: // Abort
HandleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true);
break;
}
}
void DGUSScreenHandler::DGUSLCD_SD_SendFilename(DGUS_VP_Variable& var) {
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN;
if (target_line > DGUS_SD_FILESPERSCREEN) return;
char tmpfilename[VP_SD_FileName_LEN + 1] = "";
var.memadr = (void*)tmpfilename;
if (filelist.seek(top_file + target_line)) {
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
}
DGUSLCD_SendStringToDisplay(var);
}
void DGUSScreenHandler::SDCardInserted() {
top_file = 0;
filelist.refresh();
auto cs = getCurrentScreen();
if (cs == DGUSLCD_SCREEN_MAIN || cs == DGUSLCD_SCREEN_STATUS)
GotoScreen(DGUSLCD_SCREEN_SDFILELIST);
}
void DGUSScreenHandler::SDCardRemoved() {
if (current_screen == DGUSLCD_SCREEN_SDFILELIST
|| (current_screen == DGUSLCD_SCREEN_CONFIRM && (ConfirmVP == VP_SD_AbortPrintConfirmed || ConfirmVP == VP_SD_FileSelectConfirm))
|| current_screen == DGUSLCD_SCREEN_SDPRINTMANIPULATION
) GotoScreen(DGUSLCD_SCREEN_MAIN);
}
#endif // SDSUPPORT
void DGUSScreenHandler::ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t *tmp = (uint8_t*)val_ptr;
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
// from screen 1 (main) to 10 (temperature). DGUSLCD_SCREEN_POPUP is special,
// meaning "return to previous screen"
DGUSLCD_Screens target = (DGUSLCD_Screens)tmp[1];
DEBUG_ECHOLNPAIR("\n DEBUG target", target);
if (target == DGUSLCD_SCREEN_POPUP) {
// Special handling for popup is to return to previous menu
if (current_screen == DGUSLCD_SCREEN_POPUP && confirm_action_cb) confirm_action_cb();
PopToOldScreen();
return;
}
UpdateNewScreen(target);
#ifdef DEBUG_DGUSLCD
if (!DGUSLCD_FindScreenVPMapList(target)) DEBUG_ECHOLNPAIR("WARNING: No screen Mapping found for ", target);
#endif
}
void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleManualMove");
int16_t movevalue = swap16(*(uint16_t*)val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
if (movevalue) {
const uint16_t choice = *(uint16_t*)var.memadr;
movevalue = movevalue < 0 ? -choice : choice;
}
#endif
char axiscode;
unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
switch (var.VP) {
default: return;
case VP_MOVE_X:
axiscode = 'X';
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
break;
case VP_MOVE_Y:
axiscode = 'Y';
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove;
break;
case VP_MOVE_Z:
axiscode = 'Z';
speed = 300; // default to 5mm/s
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove;
break;
case VP_HOME_ALL: // only used for homing
axiscode = '\0';
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
break;
}
if (!movevalue) {
// homing
DEBUG_ECHOPAIR(" homing ", axiscode);
char buf[6] = "G28 X";
buf[4] = axiscode;
//DEBUG_ECHOPAIR(" ", buf);
queue.enqueue_one_now(buf);
//DEBUG_ECHOLNPGM(" ✓");
ForceCompleteUpdate();
return;
}
else {
// movement
DEBUG_ECHOPAIR(" move ", axiscode);
bool old_relative_mode = relative_mode;
if (!relative_mode) {
//DEBUG_ECHOPGM(" G91");
queue.enqueue_now_P(PSTR("G91"));
//DEBUG_ECHOPGM(" ✓ ");
}
char buf[32]; // G1 X9999.99 F12345
unsigned int backup_speed = MMS_TO_MMM(feedrate_mm_s);
char sign[] = "\0";
int16_t value = movevalue / 100;
if (movevalue < 0) { value = -value; sign[0] = '-'; }
int16_t fraction = ABS(movevalue) % 100;
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed);
//DEBUG_ECHOPAIR(" ", buf);
queue.enqueue_one_now(buf);
//DEBUG_ECHOLNPGM(" ✓ ");
if (backup_speed != speed) {
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed);
queue.enqueue_one_now(buf);
//DEBUG_ECHOPAIR(" ", buf);
}
// while (!enqueue_and_echo_command(buf)) idle();
//DEBUG_ECHOLNPGM(" ✓ ");
if (!old_relative_mode) {
//DEBUG_ECHOPGM("G90");
queue.enqueue_now_P(PSTR("G90"));
//DEBUG_ECHOPGM(" ✓ ");
}
}
ForceCompleteUpdate();
DEBUG_ECHOLNPGM("manmv done.");
return;
cannotmove:
DEBUG_ECHOLNPAIR(" cannot move ", axiscode);
return;
}
#if HAS_PID_HEATING
void DGUSScreenHandler::HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr);
DEBUG_ECHOLNPAIR("V1:", rawvalue);
float value = (float)rawvalue / 10;
DEBUG_ECHOLNPAIR("V2:", value);
float newvalue = 0;
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_PID_P: newvalue = value; break;
case VP_E0_PID_I: newvalue = scalePID_i(value); break;
case VP_E0_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HOTENDS >= 2
case VP_E1_PID_P: newvalue = value; break;
case VP_E1_PID_I: newvalue = scalePID_i(value); break;
case VP_E1_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: newvalue = value; break;
case VP_BED_PID_I: newvalue = scalePID_i(value); break;
case VP_BED_PID_D: newvalue = scalePID_d(value); break;
#endif
}
DEBUG_ECHOLNPAIR_F("V3:", newvalue);
*(float *)var.memadr = newvalue;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // HAS_PID_HEATING
#if ENABLED(BABYSTEPPING)
void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleLiveAdjustZ");
int16_t flag = swap16(*(uint16_t*)val_ptr),
steps = flag ? -20 : 20;
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true);
ForceCompleteUpdate();
}
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
void DGUSScreenHandler::HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleFilamentOption");
uint8_t e_temp = 0;
filament_data.heated = false;
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr);
if (preheat_option <= 8) { // Load filament type
filament_data.action = 1;
}
else if (preheat_option >= 10) { // Unload filament type
preheat_option -= 10;
filament_data.action = 2;
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH;
}
else { // Cancel filament operation
filament_data.action = 0;
}
switch (preheat_option) {
case 0: // Load PLA
#ifdef PREHEAT_1_TEMP_HOTEND
e_temp = PREHEAT_1_TEMP_HOTEND;
#endif
break;
case 1: // Load ABS
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND);
break;
case 2: // Load PET
#ifdef PREHEAT_3_TEMP_HOTEND
e_temp = PREHEAT_3_TEMP_HOTEND;
#endif
break;
case 3: // Load FLEX
#ifdef PREHEAT_4_TEMP_HOTEND
e_temp = PREHEAT_4_TEMP_HOTEND;
#endif
break;
case 9: // Cool down
default:
e_temp = 0;
break;
}
if (filament_data.action == 0) { // Go back to utility screen
#if HOTENDS >= 1
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0);
#endif
#if HOTENDS >= 2
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1);
#endif
GotoScreen(DGUSLCD_SCREEN_UTILITY);
}
else { // Go to the preheat screen to show the heating progress
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E0;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
#if HOTENDS >= 2
case VP_E1_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E1;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
}
GotoScreen(DGUSLCD_SCREEN_FILAMENT_HEATING);
}
}
void DGUSScreenHandler::HandleFilamentLoadUnload(DGUS_VP_Variable &var) {
DEBUG_ECHOLNPGM("HandleFilamentLoadUnload");
if (filament_data.action <= 0) return;
// If we close to the target temperature, we can start load or unload the filament
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) {
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME;
if (filament_data.action == 1) { // load filament
if (!filament_data.heated) {
//GotoScreen(DGUSLCD_SCREEN_FILAMENT_LOADING);
filament_data.heated = true;
}
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
}
else { // unload filament
if (!filament_data.heated) {
GotoScreen(DGUSLCD_SCREEN_FILAMENT_UNLOADING);
filament_data.heated = true;
}
// Before unloading extrude to prevent jamming
if (filament_data.purge_length >= 0) {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
filament_data.purge_length -= movevalue;
}
else {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue;
}
}
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder);
}
}
#endif // DGUS_FILAMENT_LOADUNLOAD
bool DGUSScreenHandler::loop() {
dgusdisplay.loop();
const millis_t ms = millis();
static millis_t next_event_ms = 0;
if (!IsScreenComplete() || ELAPSED(ms, next_event_ms)) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
UpdateScreenVPData();
}
#if ENABLED(SHOW_BOOTSCREEN)
static bool booted = false;
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid()))
booted = true;
if (!booted && ELAPSED(ms, TERN(USE_MKS_GREEN_UI, 1000, BOOTSCREEN_TIMEOUT)))
booted = true;
#endif
return IsScreenComplete();
}
#endif // DGUS_LCD_UI_HYPRECY

240
Marlin/src/lcd/extui/lib/dgus/hiprecy/DGUSScreenHandler.h Normal file
View File

@ -0,0 +1,240 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplay.h"
#include "../DGUSVPVariable.h"
#include "../DGUSDisplayDef.h"
#include "../../../../../inc/MarlinConfig.h"
enum DGUSLCD_Screens : uint8_t;
class DGUSScreenHandler {
public:
DGUSScreenHandler() = default;
static bool loop();
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifing whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
// "M117" Message -- msg is a RAM ptr.
static void setstatusmessage(const char* msg);
// The same for messages from Flash
static void setstatusmessagePGM(PGM_P const msg);
// Callback for VP "Display wants to change screen on idle printer"
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "Screen has been changed"
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "All Heaters Off"
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change this temperature"
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change Flowrate"
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
// Hook for manual move option
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for manual move.
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr);
// Hook for manual extrude.
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr);
// Hook for motor lock and unlook
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(POWER_LOSS_RECOVERY)
// Hook for power loss recovery.
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for settings
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#if HAS_PID_HEATING
// Hook for "Change this temperature PID para"
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for PID autotune
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_BED_PROBE
// Hook for "Change probe offset z"
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(BABYSTEPPING)
// Hook for live z adjust action
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_FAN
// Hook for fan control
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for heater control
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_PREHEAT_UI)
// Hook for preheat
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
// Hook for filament load and unload filament option
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr);
// Hook for filament load and unload
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var);
#endif
#if ENABLED(SDSUPPORT)
// Callback for VP "Display wants to change screen when there is a SD card"
static void ScreenChangeHookIfSD(DGUS_VP_Variable &var, void *val_ptr);
// Scroll buttons on the file listing screen.
static void DGUSLCD_SD_ScrollFilelist(DGUS_VP_Variable &var, void *val_ptr);
// File touched.
static void DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr);
// start print after confirmation received.
static void DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr);
// User hit the pause, resume or abort button.
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr);
// User confirmed the abort action
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr);
// User hit the tune button
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr);
// Send a single filename to the display.
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var);
// Marlin informed us that a new SD has been inserted.
static void SDCardInserted();
// Marlin informed us that the SD Card has been removed().
static void SDCardRemoved();
// Marlin informed us about a bad SD Card.
static void SDCardError();
#endif
// OK Button the Confirm screen.
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr);
// Update data after went to new screen (by display or by GotoScreen)
// remember: store the last-displayed screen, so it can get returned to.
// (e.g for pop up messages)
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false);
// Recall the remembered screen.
static void PopToOldScreen();
// Make the display show the screen and update all VPs in it.
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false);
static void UpdateScreenVPData();
// Helpers to convert and transfer data to the display.
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var);
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var);
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var);
#if ENABLED(PRINTCOUNTER)
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var);
#endif
#if HAS_FAN
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var);
#endif
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var);
#if ENABLED(DGUS_UI_WAITING)
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var);
#endif
// Send a value from 0..100 to a variable with a range from 0..255
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr);
template<typename T>
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) {
if (!var.memadr) return;
union { unsigned char tmp[sizeof(T)]; T t; } x;
unsigned char *ptr = (unsigned char*)val_ptr;
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1];
*(T*)var.memadr = x.t;
}
// Send a float value to the display.
// Display will get a 4-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (long)f);
}
}
// Send a float value to the display.
// Display will get a 2-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
DEBUG_ECHOLNPAIR_F(" >> ", f, 6);
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (int16_t)f);
}
}
// Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
// Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private:
static DGUSLCD_Screens current_screen; //< currently on screen
static constexpr uint8_t NUM_PAST_SCREENS = 4;
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
static bool ScreenComplete; //< All VPs sent to screen?
static uint16_t ConfirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
#if ENABLED(SDSUPPORT)
static int16_t top_file; //< file on top of file chooser
static int16_t file_to_print; //< touched file to be confirmed
#endif
static void (*confirm_action_cb)();
};
#if ENABLED(POWER_LOSS_RECOVERY)
#define PLR_SCREEN_RECOVER DGUSLCD_SCREEN_SDPRINTMANIPULATION
#define PLR_SCREEN_CANCEL DGUSLCD_SCREEN_STATUS
#endif

795
Marlin/src/lcd/extui/lib/dgus/mks/DGUSDisplayDef.cpp Normal file
View File

@ -0,0 +1,795 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_MKS)
#include "DGUSDisplayDef.h"
#include "../DGUSDisplay.h"
#include "../DGUSScreenHandler.h"
#include "../../../../../module/temperature.h"
#include "../../../../../module/motion.h"
#include "../../../../../module/planner.h"
#include "../../../ui_api.h"
#include "../../../../marlinui.h"
#if ENABLED(HAS_STEALTHCHOP)
#include "../../../../module/stepper/trinamic.h"
#endif
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
uint16_t distanceToMove = 10;
#endif
uint16_t distanceMove = 1;
float distanceFilament = 10;
uint16_t FilamentSpeed = 25;
float ZOffset_distance = 0.1;
float mesh_adj_distance = 0.1;
float Z_distance = 0.1;
int16_t level_1_x_point = 20;
int16_t level_1_y_point = 20;
int16_t level_2_x_point = 20;
int16_t level_2_y_point = 20;
int16_t level_3_x_point = 20;
int16_t level_3_y_point = 20;
int16_t level_4_x_point = 20;
int16_t level_4_y_point = 20;
int16_t level_5_x_point = X_MAX_POS / 2;
int16_t level_5_y_point = Y_MAX_POS / 2;
uint16_t tim_h;
uint16_t tim_m;
uint16_t tim_s;
uint16_t x_park_pos = 20;
uint16_t y_park_pos = 20;
uint16_t z_park_pos = 10;
xyz_pos_t position_before_pause;
void MKS_pause_print_move() {
planner.synchronize();
position_before_pause = current_position;
do_blocking_move_to(X_MIN_POS + x_park_pos, Y_MIN_POS + y_park_pos, current_position.z + z_park_pos);
}
void MKS_resume_print_move() { do_blocking_move_to(position_before_pause); }
uint16_t min_ex_temp = 0;
float z_offset_add = 0;
#if ENABLED(SENSORLESS_HOMING)
uint16_t tmc_x_step = 0;
uint16_t tmc_y_step = 0;
uint16_t tmc_z_step = 0;
#else
uint16_t tmc_x_step = 0;
uint16_t tmc_y_step = 0;
uint16_t tmc_z_step = 0;
#endif
uint16_t lcd_default_light = 50;
EX_FILAMENT_DEF ex_filament;
RUNOUT_MKS_DEF runout_mks;
NOZZLE_PARK_DEF nozzle_park_mks;
const uint16_t VPList_Boot[] PROGMEM = {
VP_MARLIN_VERSION,
0x0000
};
#define MKSLIST_E_ITEM(N) VP_T_E##N##_Is, VP_T_E##N##_Set,
const uint16_t VPList_Main[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded.
#if HOTENDS >= 1
MKSLIST_E_ITEM(0) VP_E0_STATUS,
#endif
#if HOTENDS >= 2
MKSLIST_E_ITEM(1)
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set, VP_BED_STATUS,
#endif
#if HAS_FAN
VP_Fan0_Percentage, VP_FAN0_STATUS,
#endif
VP_XPos, VP_YPos, VP_ZPos,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
#if ENABLED(LCD_SET_PROGRESS_MANUALLY)
VP_PrintProgress_Percentage,
#endif
0x0000
};
const uint16_t MKSList_Home[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Language
// VP_HOME_Dis,
0x0000
};
const uint16_t MKSList_Setting[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Language
VP_Setting_Dis,
0x0000
};
const uint16_t MKSList_Tool[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Language
VP_Tool_Dis,
// LCD BLK
VP_LCD_BLK,
0x0000
};
const uint16_t MKSList_EXTRUE[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
VP_Filament_distance,
VP_Filament_speed,
0x0000
};
const uint16_t MKSList_LEVEL[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
0x0000
};
const uint16_t MKSList_MOVE[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
0x0000
};
const uint16_t MKSList_Print[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Print Percent
VP_PrintProgress_Percentage,
VP_PrintTime,
VP_Flowrate_E0,
VP_Flowrate_E1,
VP_Feedrate_Percentage,
VP_PrintTime_H,
VP_PrintTime_M,
VP_PrintTime_S,
VP_XPos,
VP_YPos,
VP_ZPos,
0x0000
};
const uint16_t MKSList_SD_File[] PROGMEM = {
VP_SD_FileName0, VP_SD_FileName1,
VP_SD_FileName2, VP_SD_FileName3,
VP_SD_FileName4, VP_SD_FileName5,
VP_SD_FileName6, VP_SD_FileName7,
VP_SD_FileName8, VP_SD_FileName9,
0x0000
};
const uint16_t MKSList_TempOnly[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// LCD BLK
VP_LCD_BLK,
0x0000
};
const uint16_t MKSList_Pluse[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Pluse
VP_X_STEP_PER_MM,
VP_Y_STEP_PER_MM,
VP_Z_STEP_PER_MM,
VP_E0_STEP_PER_MM,
VP_E1_STEP_PER_MM,
0x0000
};
const uint16_t MKSList_MaxSpeed[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Pluse
VP_X_MAX_SPEED,
VP_Y_MAX_SPEED,
VP_Z_MAX_SPEED,
VP_E0_MAX_SPEED,
VP_E1_MAX_SPEED,
0x0000
};
const uint16_t MKSList_MaxAcc[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// ACC
VP_ACC_SPEED,
VP_X_ACC_MAX_SPEED,
VP_Y_ACC_MAX_SPEED,
VP_Z_ACC_MAX_SPEED,
VP_E0_ACC_MAX_SPEED,
VP_E1_ACC_MAX_SPEED,
0x0000
};
const uint16_t MKSList_PID[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// PID
VP_E0_PID_P,
VP_E0_PID_I,
VP_E0_PID_D,
0x0000
};
const uint16_t MKSList_Level_Point[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Level Point
VP_Level_Point_One_X,
VP_Level_Point_One_Y,
VP_Level_Point_Two_X,
VP_Level_Point_Two_Y,
VP_Level_Point_Three_X,
VP_Level_Point_Three_Y,
VP_Level_Point_Four_X,
VP_Level_Point_Four_Y,
VP_Level_Point_Five_X,
VP_Level_Point_Five_Y,
0x0000
};
const uint16_t MKSList_Level_PrintConfig[] PROGMEM = {
VP_T_E0_Set,
VP_T_E1_Set,
VP_T_Bed_Set,
VP_Flowrate_E0,
VP_Flowrate_E1,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
0x0000
};
const uint16_t MKSList_PrintPauseConfig[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
VP_X_PARK_POS,
VP_Y_PARK_POS,
VP_Z_PARK_POS,
0x0000
};
const uint16_t MKSList_MotoConfig[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
VP_TRAVEL_SPEED,
VP_FEEDRATE_MIN_SPEED,
VP_T_F_SPEED,
0x0000
};
const uint16_t MKSList_EX_Config[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
VP_MIN_EX_T,VP_Min_EX_T_E,
0x0000
};
const uint16_t MKSTMC_Config[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
VP_MIN_EX_T,
VP_TMC_X_STEP,
VP_TMC_Y_STEP,
VP_TMC_Z_STEP,
VP_TMC_X1_Current,
VP_TMC_Y1_Current,
VP_TMC_X_Current,
VP_TMC_Y_Current,
VP_TMC_Z_Current,
VP_TMC_E0_Current,
VP_TMC_E1_Current,
VP_TMC_Z1_Current,
0x0000
};
const uint16_t MKSAuto_Level[] PROGMEM = {
VP_MESH_LEVEL_POINT_DIS,
VP_ZPos,
0x0000
};
const uint16_t MKSOffset_Config[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
VP_OFFSET_X,
VP_OFFSET_Y,
VP_OFFSET_Z,
0x0000
};
const uint16_t MKSBabyStep[] PROGMEM = {
VP_ZOffset_DE_DIS,
0x0000
};
const uint16_t MKSList_About[] PROGMEM = {
// Marlin version
VP_MARLIN_VERSION,
// H43 Version
VP_MKS_H43_VERSION,
VP_MKS_H43_UpdataVERSION,
0x0000
};
// Page data updata
const struct VPMapping VPMap[] PROGMEM = {
{ MKSLCD_SCREEN_BOOT, VPList_Boot }, // Boot Page to show logo 0
{ MKSLCD_SCREEN_HOME, MKSList_Home }, // Home, Page 1
{ MKSLCD_SCREEN_SETTING, MKSList_Setting }, // Setting, Page 2
{ MKSLCD_SCREEM_TOOL, MKSList_Tool }, // Page 3
{ MKSLCD_SCREEN_EXTRUDE_P1, MKSList_EXTRUE }, // Page 4
{ MKSLCD_SCREEN_EXTRUDE_P2, MKSList_EXTRUE }, // Page 11
{ MKSLCD_PAUSE_SETTING_EX, MKSList_EXTRUE }, // Page 57
{ MKSLCD_PAUSE_SETTING_EX2, MKSList_EXTRUE }, // Page 61
{ MKSLCD_SCREEN_LEVEL, MKSList_LEVEL }, // Page 5
{ MKSLCD_SCREEN_MOVE, MKSList_MOVE }, // Page 6
{ MKSLCD_SCREEN_PRINT, MKSList_Print }, // Page 7
{ MKSLCD_SCREEN_PAUSE, MKSList_Print }, // Page 26
{ MKSLCD_SCREEN_CHOOSE_FILE, MKSList_SD_File }, // Page 15
{ MKSLCD_SCREEN_MOTOR_PLUSE, MKSList_Pluse }, // Page 51
{ MKSLCD_SCREEN_MOTOR_SPEED, MKSList_MaxSpeed }, // Page 55
{ MKSLCD_SCREEN_MOTOR_ACC_MAX, MKSList_MaxAcc }, // Page 53
{ MKSLCD_SCREEN_LEVEL_DATA, MKSList_Level_Point }, // Page 48
{ MKSLCD_PrintPause_SET, MKSList_PrintPauseConfig }, // Page 49
{ MKSLCD_FILAMENT_DATA, MKSList_SD_File }, // Page 50
{ MKSLCD_SCREEN_Config, MKSList_TempOnly }, // Page 46
{ MKSLCD_SCREEN_Config_MOTOR, MKSList_MotoConfig }, // Page 47
{ MKSLCD_PID, MKSList_PID }, // Page 56
{ MKSLCD_ABOUT, MKSList_About }, // Page 36
{ MKSLCD_SCREEN_PRINT_CONFIG, MKSList_Level_PrintConfig }, // Page 60
{ MKSLCD_SCREEN_EX_CONFIG, MKSList_EX_Config }, // Page 65
{ MKSLCD_SCREEN_TMC_Config, MKSTMC_Config }, // Page 70
{ MKSLCD_AUTO_LEVEL, MKSAuto_Level }, // Page 73
{ MKSLCD_Screen_Offset_Config, MKSOffset_Config }, // Page 30
{ MKSLCD_Screen_PMove, MKSList_MOVE }, // Page 64
{ MKSLCD_Screen_Baby, MKSBabyStep }, // Page 71
//{ MKSLCD_SCREEN_LEVEL_DATA, MKSList_SD_File},
//{ MKSLCD_SCREEN_HOME, VPList_Boot },
{ 0, nullptr } // List is terminated with an nullptr as table entry.
};
const char MarlinVersion[] PROGMEM = SHORT_BUILD_VERSION;
const char H43Version[] PROGMEM = "MKS H43_V1.30";
const char Updata_Time[] PROGMEM = STRING_DISTRIBUTION_DATE;
// Helper to define a DGUS_VP_Variable for common use cases.
#define VPHELPER(VPADR, VPADRVAR, RXFPTR, TXFPTR) \
{ \
.VP = VPADR, .memadr = VPADRVAR, .size = sizeof(VPADRVAR), \
.set_by_display_handler = RXFPTR, .send_to_display_handler = TXFPTR \
}
// Helper to define a DGUS_VP_Variable when the sizeo of the var cannot be determined automaticalyl (eg. a string)
#define VPHELPER_STR(VPADR, VPADRVAR, STRLEN, RXFPTR, TXFPTR) \
{ \
.VP = VPADR, .memadr = VPADRVAR, .size = STRLEN, \
.set_by_display_handler = RXFPTR, .send_to_display_handler = TXFPTR \
}
const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
// Helper to detect touch events
VPHELPER(VP_SCREENCHANGE, nullptr, ScreenHandler.ScreenChangeHook, nullptr),
VPHELPER(VP_SCREENCHANGE_ASK, nullptr, ScreenHandler.ScreenChangeHookIfIdle, nullptr),
#if ENABLED(SDSUPPORT)
VPHELPER(VP_SCREENCHANGE_WHENSD, nullptr, ScreenHandler.ScreenChangeHookIfSD, nullptr),
#endif
VPHELPER(VP_CONFIRMED, nullptr, ScreenHandler.ScreenConfirmedOK, nullptr),
// Back Button
VPHELPER(VP_BACK_PAGE, nullptr, &ScreenHandler.ScreenBackChange, nullptr),
VPHELPER(VP_TEMP_ALL_OFF, nullptr, &ScreenHandler.HandleAllHeatersOff, nullptr),
VPHELPER(VP_MOVE_X, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_MOVE_Y, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_MOVE_Z, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_HOME_ALL, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_X_HOME, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_Y_HOME, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_Z_HOME, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_MOVE_DISTANCE, &distanceMove, &ScreenHandler.GetManualMovestep, nullptr),
VPHELPER(VP_MOTOR_LOCK_UNLOK, nullptr, &ScreenHandler.HandleManualMove, nullptr),
VPHELPER(VP_LEVEL_POINT, nullptr, &ScreenHandler.ManualAssistLeveling, nullptr),
#if ENABLED(POWER_LOSS_RECOVERY)
VPHELPER(VP_POWER_LOSS_RECOVERY, nullptr, &ScreenHandler.HandlePowerLossRecovery, nullptr),
#endif
VPHELPER(VP_SETTINGS, nullptr, &ScreenHandler.HandleSettings, nullptr),
#if ENABLED(SINGLE_Z_CALIBRATION)
VPHELPER(VP_Z_CALIBRATE, nullptr, &ScreenHandler.HandleZCalibration, nullptr),
#endif
#if ENABLED(FIRST_LAYER_CAL)
VPHELPER(VP_Z_FIRST_LAYER_CAL, nullptr, &ScreenHandler.HandleFirstLayerCal, nullptr),
#endif
{.VP = VP_MARLIN_VERSION, .memadr = (void *)MarlinVersion, .size = VP_MARLIN_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
// M117 LCD String (We don't need the string in memory but "just" push it to the display on demand, hence the nullptr
{.VP = VP_M117, .memadr = nullptr, .size = VP_M117_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay},
{.VP = VP_MKS_H43_VERSION, .memadr = (void *)H43Version, .size = VP_MKS_H43_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
{.VP = VP_MKS_H43_UpdataVERSION, .memadr = (void *)Updata_Time, .size = VP_MKS_H43_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
// Temperature Data
#if HOTENDS >= 1
VPHELPER(VP_T_E0_Is, &thermalManager.temp_hotend[0].celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E0_Set, &thermalManager.temp_hotend[0].target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Flowrate_E0, &planner.flow_percentage[ExtUI::extruder_t::E0], ScreenHandler.HandleFlowRateChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_EPos, &destination.e, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_MOVE_E0, nullptr, &ScreenHandler.HandleManualExtrude, nullptr),
VPHELPER(VP_E0_CONTROL, &thermalManager.temp_hotend[0].target, &ScreenHandler.HandleHeaterControl, nullptr),
VPHELPER(VP_E0_STATUS, &thermalManager.temp_hotend[0].target, nullptr, &ScreenHandler.DGUSLCD_SendHeaterStatusToDisplay),
#if ENABLED(DGUS_PREHEAT_UI)
VPHELPER(VP_E0_BED_PREHEAT, nullptr, &ScreenHandler.HandlePreheat, nullptr),
#endif
#if ENABLED(PIDTEMP)
VPHELPER(VP_E0_PID_P, &thermalManager.temp_hotend[0].pid.Kp, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID),
VPHELPER(VP_E0_PID_I, &thermalManager.temp_hotend[0].pid.Ki, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID),
VPHELPER(VP_E0_PID_D, &thermalManager.temp_hotend[0].pid.Kd, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_E0, nullptr, &ScreenHandler.HandlePIDAutotune, nullptr),
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
VPHELPER(VP_LOAD_Filament, nullptr, &ScreenHandler.MKS_FilamentLoad, nullptr),
VPHELPER(VP_UNLOAD_Filament, nullptr, &ScreenHandler.MKS_FilamentUnLoad, nullptr),
VPHELPER(VP_Filament_distance, &distanceFilament, &ScreenHandler.GetManualFilament, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Filament_speed, &FilamentSpeed, &ScreenHandler.GetManualFilamentSpeed, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#endif
#if HOTENDS >= 2
VPHELPER(VP_T_E1_Is, &thermalManager.temp_hotend[1].celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E1_Set, &thermalManager.temp_hotend[1].target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Flowrate_E1, &planner.flow_percentage[ExtUI::extruder_t::E1], ScreenHandler.HandleFlowRateChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_MOVE_E1, nullptr, &ScreenHandler.HandleManualExtrude, nullptr),
VPHELPER(VP_E1_CONTROL, &thermalManager.temp_hotend[1].target, &ScreenHandler.HandleHeaterControl, nullptr),
VPHELPER(VP_E1_STATUS, &thermalManager.temp_hotend[1].target, nullptr, &ScreenHandler.DGUSLCD_SendHeaterStatusToDisplay),
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
VPHELPER(VP_Filament_distance, &distanceFilament, &ScreenHandler.GetManualFilament, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Filament_speed, &FilamentSpeed, &ScreenHandler.GetManualFilamentSpeed, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if ENABLED(PIDTEMP)
VPHELPER(VP_PID_AUTOTUNE_E1, nullptr, &ScreenHandler.HandlePIDAutotune, nullptr),
#endif
VPHELPER(VP_E1_FILAMENT_LOAD_UNLOAD, nullptr, &ScreenHandler.HandleFilamentOption, &ScreenHandler.HandleFilamentLoadUnload),
#endif
#if HAS_HEATED_BED
VPHELPER(VP_T_Bed_Is, &thermalManager.temp_bed.celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_Bed_Set, &thermalManager.temp_bed.target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_BED_CONTROL, &thermalManager.temp_bed.target, &ScreenHandler.HandleHeaterControl, nullptr),
VPHELPER(VP_BED_STATUS, &thermalManager.temp_bed.target, nullptr, &ScreenHandler.DGUSLCD_SendHeaterStatusToDisplay),
#if ENABLED(PIDTEMPBED)
VPHELPER(VP_BED_PID_P, &thermalManager.temp_bed.pid.Kp, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID),
VPHELPER(VP_BED_PID_I, &thermalManager.temp_bed.pid.Ki, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID),
VPHELPER(VP_BED_PID_D, &thermalManager.temp_bed.pid.Kd, ScreenHandler.HandleTemperaturePIDChanged, ScreenHandler.DGUSLCD_SendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_BED, nullptr, &ScreenHandler.HandlePIDAutotune, nullptr),
#endif
#endif
// Fan Data
#if HAS_FAN
#define FAN_VPHELPER(N) \
VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], ScreenHandler.DGUSLCD_SetUint8, &ScreenHandler.DGUSLCD_SendFanToDisplay), \
VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], &ScreenHandler.HandleFanControl, nullptr), \
VPHELPER(VP_FAN##N##_STATUS, &thermalManager.fan_speed[N], nullptr, &ScreenHandler.DGUSLCD_SendFanStatusToDisplay),
REPEAT(FAN_COUNT, FAN_VPHELPER)
#endif
// Feedrate
VPHELPER(VP_Feedrate_Percentage, &feedrate_percentage, ScreenHandler.DGUSLCD_SetValueDirectly<int16_t>, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
// Position Data
VPHELPER(VP_XPos, &current_position.x, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_YPos, &current_position.y, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_ZPos, &current_position.z, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
// Level Point Set
VPHELPER(VP_Level_Point_One_X, &level_1_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_One_Y, &level_1_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Two_X, &level_2_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Two_Y, &level_2_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Three_X, &level_3_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Three_Y, &level_3_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Four_X, &level_4_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Four_Y, &level_4_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Five_X, &level_5_x_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Level_Point_Five_Y, &level_5_y_point, ScreenHandler.HandleChangeLevelPoint_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
// Print Progress
VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, ScreenHandler.DGUSLCD_SendPrintProgressToDisplay),
//LCD Control
VPHELPER(VP_LCD_BLK, &lcd_default_light, &ScreenHandler.LCD_BLK_Adjust, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
// Print Time
VPHELPER_STR(VP_PrintTime, nullptr, VP_PrintTime_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintTimeToDisplay_MKS),
#if ENABLED(PRINTCOUNTER)
VPHELPER_STR(VP_PrintAccTime, nullptr, VP_PrintAccTime_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintAccTimeToDisplay),
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintsTotalToDisplay),
#endif
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], ScreenHandler.HandleStepPerMMChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], ScreenHandler.HandleStepPerMMChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], ScreenHandler.HandleStepPerMMChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_X_MAX_SPEED, &planner.settings.max_feedrate_mm_s[X_AXIS], ScreenHandler.HandleMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Y_MAX_SPEED, &planner.settings.max_feedrate_mm_s[Y_AXIS], ScreenHandler.HandleMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Z_MAX_SPEED, &planner.settings.max_feedrate_mm_s[Z_AXIS], ScreenHandler.HandleMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
#if HOTENDS >= 1
VPHELPER(VP_E0_MAX_SPEED, &planner.settings.max_feedrate_mm_s[E0_AXIS], ScreenHandler.HandleExtruderMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
#endif
#if HOTENDS >= 2
VPHELPER(VP_E1_MAX_SPEED, &planner.settings.max_feedrate_mm_s[E1_AXIS], ScreenHandler.HandleExtruderMaxSpeedChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
#endif
VPHELPER(VP_X_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[X_AXIS], ScreenHandler.HandleMaxAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Y_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[Y_AXIS], ScreenHandler.HandleMaxAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Z_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[Z_AXIS], ScreenHandler.HandleMaxAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#if HOTENDS >= 1
VPHELPER(VP_E0_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[E0_AXIS], ScreenHandler.HandleExtruderAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if HOTENDS >= 2
VPHELPER(VP_E1_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[E1_AXIS], ScreenHandler.HandleExtruderAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
VPHELPER(VP_TRAVEL_SPEED, (uint16_t *)&planner.settings.travel_acceleration, ScreenHandler.HandleTravelAccChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_FEEDRATE_MIN_SPEED, (uint16_t *)&planner.settings.min_feedrate_mm_s, ScreenHandler.HandleFeedRateMinChange_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_T_F_SPEED, (uint16_t *)&planner.settings.min_travel_feedrate_mm_s, ScreenHandler.HandleMin_T_F_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_ACC_SPEED, (uint16_t *)&planner.settings.acceleration, ScreenHandler.HandleAccChange_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_X_PARK_POS, &x_park_pos, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Y_PARK_POS, &y_park_pos, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_Z_PARK_POS, &z_park_pos, ScreenHandler.GetParkPos_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_MIN_EX_T, &thermalManager.extrude_min_temp, ScreenHandler.HandleGetExMinTemp_MKS, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#if ENABLED(SENSORLESS_HOMING) // TMC SENSORLESS Setting
#if AXIS_HAS_STEALTHCHOP(X)
VPHELPER(VP_TMC_X_STEP, &tmc_x_step, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
#endif
#if AXIS_HAS_STEALTHCHOP(Y)
VPHELPER(VP_TMC_Y_STEP, &tmc_y_step, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
#endif
#if AXIS_HAS_STEALTHCHOP(Z)
VPHELPER(VP_TMC_Z_STEP, &tmc_z_step, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendTMCStepValue),
#endif
#endif
#if HAS_TRINAMIC_CONFIG // TMC Current Setting
#if AXIS_IS_TMC(X)
VPHELPER(VP_TMC_X_Current, &stepperX.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(Y)
VPHELPER(VP_TMC_Y_Current, &stepperY.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(Z)
VPHELPER(VP_TMC_Z_Current, &stepperZ.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(E0)
VPHELPER(VP_TMC_E0_Current, &stepperE0.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(E1)
VPHELPER(VP_TMC_E1_Current, &stepperE1.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(X2)
VPHELPER(VP_TMC_X1_Current, &stepperX2.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(Y2)
VPHELPER(VP_TMC_Y1_Current, &stepperY2.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(Z2)
VPHELPER(VP_TMC_Z1_Current, &stepperZ2.val_mA, ScreenHandler.TMC_ChangeConfig, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
#endif
#endif
VPHELPER(VP_EEPROM_CTRL, nullptr, ScreenHandler.EEPROM_CTRL, nullptr),
VPHELPER(VP_LEVEL_BUTTON, nullptr, ScreenHandler.Level_Ctrl_MKS, nullptr),
VPHELPER(VP_LANGUAGE_CHANGE, nullptr, ScreenHandler.LanguageChange_MKS, nullptr),
//VPHELPER(VP_SD_Print_LiveAdjustZ, nullptr, ScreenHandler.HandleLiveAdjustZ, nullptr),
VPHELPER(VP_SD_Print_LiveAdjustZ_Confirm, nullptr, ScreenHandler.ZoffsetConfirm, nullptr),
VPHELPER(VP_ZOffset_Distance,nullptr ,ScreenHandler.GetZoffsetDistance, nullptr),
VPHELPER(VP_MESH_LEVEL_ADJUST, nullptr, ScreenHandler.MeshLevelDistanceConfig, nullptr),
VPHELPER(VP_MESH_LEVEL_POINT,nullptr, ScreenHandler.MeshLevel,nullptr),
VPHELPER(VP_Min_EX_T_E, &thermalManager.extrude_min_temp, &ScreenHandler.GetMinExtrudeTemp, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
VPHELPER(VP_AutoTurnOffSw, nullptr, &ScreenHandler.GetTurnOffCtrl, nullptr),
#if HOTENDS >= 1
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], ScreenHandler.HandleStepPerMMExtruderChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
#endif
#if HOTENDS >= 2
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], ScreenHandler.HandleStepPerMMExtruderChanged_MKS, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
#endif
// SDCard File listing
#if ENABLED(SDSUPPORT)
VPHELPER(VP_SD_ScrollEvent, nullptr, ScreenHandler.DGUSLCD_SD_ScrollFilelist, nullptr),
VPHELPER(VP_SD_FileSelected, nullptr, ScreenHandler.DGUSLCD_SD_FileSelected, nullptr),
VPHELPER(VP_SD_FileSelectConfirm, nullptr, ScreenHandler.DGUSLCD_SD_StartPrint, nullptr),
VPHELPER_STR(VP_SD_FileName0, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName1, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName2, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName3, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName4, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName5, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName6, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName7, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName8, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER_STR(VP_SD_FileName9, nullptr, VP_SD_FileName_LEN, nullptr, ScreenHandler.DGUSLCD_SD_SendFilename),
VPHELPER(VP_SD_ResumePauseAbort, nullptr, ScreenHandler.DGUSLCD_SD_ResumePauseAbort, nullptr),
VPHELPER(VP_SD_AbortPrintConfirmed, nullptr, ScreenHandler.DGUSLCD_SD_ReallyAbort, nullptr),
VPHELPER(VP_SD_Print_Setting, nullptr, ScreenHandler.DGUSLCD_SD_PrintTune, nullptr),
#if ENABLED(BABYSTEPPING)
VPHELPER(VP_SD_Print_LiveAdjustZ,nullptr, ScreenHandler.HandleLiveAdjustZ, &ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<2>),
VPHELPER(VP_ZOffset_DE_DIS,&z_offset_add,nullptr, &ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
#endif
#if HAS_BED_PROBE
VPHELPER(VP_OFFSET_X, &probe.offset.x, ScreenHandler.GetOffsetValue,ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_OFFSET_Y, &probe.offset.y, ScreenHandler.GetOffsetValue,ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_OFFSET_Z, &probe.offset.z, ScreenHandler.GetOffsetValue,ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
#endif
#endif
#if ENABLED(DGUS_UI_WAITING)
VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, ScreenHandler.DGUSLCD_SendWaitingStatusToDisplay),
#endif
// Messages for the User, shared by the popup and the kill screen. They cant be autouploaded as we do not buffer content.
//{.VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
//{.VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
//{.VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
//{.VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplayPGM},
{.VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay_Language_MKS},
{.VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay_Language_MKS},
{.VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay_Language_MKS},
{.VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = &ScreenHandler.DGUSLCD_SendStringToDisplay_Language_MKS},
VPHELPER(0, 0, 0, 0) // must be last entry.
};
#endif // DGUS_LCD_UI_MKS

908
Marlin/src/lcd/extui/lib/dgus/mks/DGUSDisplayDef.h Normal file
View File

@ -0,0 +1,908 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplayDef.h"
//#define USE_MKS_GREEN_UI
//#define DGUS_MKS_RUNOUT_SENSOR
#define LOGO_TIME_DELAY TERN(USE_MKS_GREEN_UI, 5000, 1500)
#if ENABLED(DGUS_MKS_RUNOUT_SENSOR)
#define MT_DET_1_PIN 1
#define MT_DET_2_PIN 2
#define MT_DET_PIN_INVERTING false
#endif
#define MKS_FINSH
extern uint16_t distanceMove;
extern float distanceFilament;
extern uint16_t FilamentSpeed;
extern float ZOffset_distance;
extern float mesh_adj_distance;
extern float Z_distance;
extern int16_t level_1_x_point;
extern int16_t level_1_y_point;
extern int16_t level_2_x_point;
extern int16_t level_2_y_point;
extern int16_t level_3_x_point;
extern int16_t level_3_y_point;
extern int16_t level_4_x_point;
extern int16_t level_4_y_point;
extern int16_t level_5_x_point;
extern int16_t level_5_y_point;
extern uint16_t tim_h;
extern uint16_t tim_m;
extern uint16_t tim_s;
extern uint16_t x_park_pos;
extern uint16_t y_park_pos;
extern uint16_t z_park_pos;
extern xyz_pos_t position_before_pause;
void MKS_pause_print_move();
void MKS_resume_print_move();
extern uint16_t min_ex_temp;
extern float z_offset_add;
extern uint16_t tmc_x_step;
extern uint16_t tmc_y_step;
extern uint16_t tmc_z_step;
extern uint16_t lcd_default_light;
#if AXIS_HAS_STEALTHCHOP(X)
extern uint16_t tmc_x_current;
#endif
#if AXIS_HAS_STEALTHCHOP(Y)
extern uint16_t tmc_y_current;
#endif
#if AXIS_HAS_STEALTHCHOP(Z)
extern uint16_t tmc_z_current;
#endif
#if AXIS_HAS_STEALTHCHOP(E0)
extern uint16_t tmc_e0_current;
#endif
#if AXIS_HAS_STEALTHCHOP(E1)
extern uint16_t tmc_e1_current;
#endif
typedef enum {
EX_HEATING,
EX_HEAT_STARUS,
EX_CHANGING,
EX_CHANGE_STATUS,
EX_NONE,
} EX_STATUS_DEF;
typedef struct {
//uint8_t ex_change_flag:1;
//uint8_t ex_heat_flag:1;
uint8_t ex_load_unload_flag:1; //0:unload 1:load
EX_STATUS_DEF ex_status;
uint32_t ex_tick_start;
uint32_t ex_tick_end;
uint32_t ex_speed;
uint32_t ex_length;
uint32_t ex_need_time;
} EX_FILAMENT_DEF;
extern EX_FILAMENT_DEF ex_filament;
typedef enum {
UNRUNOUT_STATUS,
RUNOUT_STATUS,
RUNOUT_WAITTING_STATUS,
RUNOUT_BEGIN_STATUS,
} RUNOUT_MKS_STATUS_DEF;
typedef struct {
RUNOUT_MKS_STATUS_DEF runout_status;
uint8_t pin_status;
uint8_t de_count;
uint8_t de_times;
} RUNOUT_MKS_DEF;
extern RUNOUT_MKS_DEF runout_mks;
typedef struct {
uint8_t print_pause_start_flag:1;
uint8_t runout_flag:1;
bool blstatus;
uint16_t x_pos;
uint16_t y_pos;
uint16_t z_pos;
} NOZZLE_PARK_DEF;
extern NOZZLE_PARK_DEF nozzle_park_mks;
enum DGUSLCD_Screens : uint8_t {
#if ENABLED(USE_MKS_GREEN_UI)
DGUSLCD_SCREEN_BOOT = 33,
DGUSLCD_SCREEN_MAIN = 60,
DGUSLCD_SCREEN_STATUS = 60,
DGUSLCD_SCREEN_STATUS2 = 60,
DGUSLCD_SCREEN_PREHEAT = 18,
DGUSLCD_SCREEN_POWER_LOSS = 100,
DGUSLCD_SCREEN_MANUALMOVE = 192,
DGUSLCD_SCREEN_UTILITY = 120,
DGUSLCD_SCREEN_FILAMENT_UNLOADING = 158,
DGUSLCD_SCREEN_SDFILELIST = 15,
DGUSLCD_SCREEN_SDPRINTMANIPULATION = 15,
DGUSLCD_SCREEN_SDPRINTTUNE = 17,
MKSLCD_SCREEN_BOOT = 33,
MKSLCD_SCREEN_HOME = 60, // MKS main page
MKSLCD_SCREEN_SETTING = 62, // MKS Setting page / no wifi whit
MKSLCD_SCREEM_TOOL = 64, // MKS Tool page
MKSLCD_SCREEN_EXTRUDE_P1 = 75,
MKSLCD_SCREEN_EXTRUDE_P2 = 77,
MKSLCD_SCREEN_LEVEL = 73,
MKSLCD_AUTO_LEVEL = 81,
MKSLCD_SCREEN_MOVE = 66,
MKSLCD_SCREEN_PRINT = 68,
MKSLCD_SCREEN_PAUSE = 70,
MKSLCD_SCREEN_CHOOSE_FILE = 87,
MKSLCD_SCREEN_NO_CHOOSE_FILE = 88,
MKSLCD_SCREEN_Config = 101,
MKSLCD_SCREEN_Config_MOTOR = 103,
MKSLCD_SCREEN_MOTOR_PLUSE = 104,
MKSLCD_SCREEN_MOTOR_SPEED = 102,
MKSLCD_SCREEN_MOTOR_ACC_MAX = 105,
MKSLCD_SCREEN_PRINT_CONFIG = 72,
MKSLCD_SCREEN_LEVEL_DATA = 106,
MKSLCD_PrintPause_SET = 107,
//MKSLCD_FILAMENT_DATA = 50,
MKSLCD_ABOUT = 83,
MKSLCD_PID = 108,
MKSLCD_PAUSE_SETTING_MOVE = 98,
MKSLCD_PAUSE_SETTING_EX = 96,
MKSLCD_PAUSE_SETTING_EX2 = 97,
MKSLCD_SCREEN_PRINT_CONFIRM = 94,
MKSLCD_SCREEN_EX_CONFIG = 112,
MKSLCD_SCREEN_EEP_Config = 89,
MKSLCD_SCREEN_PrintDone = 92,
MKSLCD_SCREEN_TMC_Config = 111,
MKSLCD_Screen_Offset_Config = 109,
MKSLCD_Screen_PMove = 98,
MKSLCD_Screen_Baby = 79,
#else
DGUSLCD_SCREEN_BOOT = 120,
DGUSLCD_SCREEN_MAIN = 1,
DGUSLCD_SCREEN_STATUS = 1,
DGUSLCD_SCREEN_STATUS2 = 1,
DGUSLCD_SCREEN_PREHEAT = 18,
DGUSLCD_SCREEN_POWER_LOSS = 100,
DGUSLCD_SCREEN_MANUALMOVE = 192,
DGUSLCD_SCREEN_UTILITY = 120,
DGUSLCD_SCREEN_FILAMENT_UNLOADING = 158,
DGUSLCD_SCREEN_SDFILELIST = 15,
DGUSLCD_SCREEN_SDPRINTMANIPULATION = 15,
DGUSLCD_SCREEN_SDPRINTTUNE = 17,
MKSLCD_SCREEN_BOOT = 0,
MKSLCD_SCREEN_HOME = 1, // MKS main page
MKSLCD_SCREEN_SETTING = 2, // MKS Setting page / no wifi whit
MKSLCD_SCREEM_TOOL = 3, // MKS Tool page
MKSLCD_SCREEN_EXTRUDE_P1 = 4,
MKSLCD_SCREEN_EXTRUDE_P2 = 11,
MKSLCD_SCREEN_LEVEL = 5,
MKSLCD_AUTO_LEVEL = 73,
MKSLCD_SCREEN_LEVEL_PRESS = 9,
MKSLCD_SCREEN_MOVE = 6,
MKSLCD_SCREEN_PRINT = 7,
MKSLCD_SCREEN_PRINT_PRESS = 13,
MKSLCD_SCREEN_PAUSE = 26,
MKSLCD_SCREEN_PAUSE_PRESS = 26,
MKSLCD_SCREEN_CHOOSE_FILE = 15,
MKSLCD_SCREEN_NO_CHOOSE_FILE = 17,
MKSLCD_SCREEN_Config = 46,
MKSLCD_SCREEN_Config_MOTOR = 47,
MKSLCD_SCREEN_MOTOR_PLUSE = 51,
MKSLCD_SCREEN_MOTOR_SPEED = 55,
MKSLCD_SCREEN_MOTOR_ACC_MAX = 53,
MKSLCD_SCREEN_PRINT_CONFIG = 60,
MKSLCD_SCREEN_LEVEL_DATA = 48,
MKSLCD_PrintPause_SET = 49,
MKSLCD_FILAMENT_DATA = 50,
MKSLCD_ABOUT = 36,
MKSLCD_PID = 56,
MKSLCD_PAUSE_SETTING_MOVE = 58,
MKSLCD_PAUSE_SETTING_EX = 57,
MKSLCD_PAUSE_SETTING_EX2 = 61,
MKSLCD_SCREEN_NO_FILE = 42,
MKSLCD_SCREEN_PRINT_CONFIRM = 43,
MKSLCD_SCREEN_EX_CONFIG = 65,
MKSLCD_SCREEN_EEP_Config = 20,
MKSLCD_SCREEN_PrintDone = 25,
MKSLCD_SCREEN_TMC_Config = 70,
MKSLCD_Screen_Offset_Config = 30,
MKSLCD_Screen_PMove = 64,
MKSLCD_Screen_Baby = 71,
#endif
DGUSLCD_SCREEN_CONFIRM = 240,
DGUSLCD_SCREEN_KILL = 250, ///< Kill Screen. Must always be 250 (to be able to display "Error wrong LCD Version")
DGUSLCD_SCREEN_WAITING = 251,
DGUSLCD_SCREEN_POPUP = 252, ///< special target, popup screen will also return this code to say "return to previous screen"
DGUSLDC_SCREEN_UNUSED = 255
};
// Display Memory layout used (T5UID)
// Except system variables this is arbitrary, just to organize stuff....
// 0x0000 .. 0x0FFF -- System variables and reserved by the display
// 0x1000 .. 0x1FFF -- Variables to never change location, regardless of UI Version
// 0x2000 .. 0x2FFF -- Controls (VPs that will trigger some action)
// 0x3000 .. 0x4FFF -- Marlin Data to be displayed
// 0x5000 .. -- SPs (if we want to modify display elements, e.g change color or like) -- currently unused
// As there is plenty of space (at least most displays have >8k RAM), we do not pack them too tight,
// so that we can keep variables nicely together in the address space.
// UI Version always on 0x1000...0x1002 so that the firmware can check this and bail out.
// constexpr uint16_t VP_UI_VERSION_MAJOR = 0x1000; // Major -- incremented when incompatible
// constexpr uint16_t VP_UI_VERSION_MINOR = 0x1001; // Minor -- incremented on new features, but compatible
// constexpr uint16_t VP_UI_VERSION_PATCH = 0x1002; // Patch -- fixed which do not change functionality.
// constexpr uint16_t VP_UI_FLAVOUR = 0x1010; // lets reserve 16 bytes here to determine if UI is suitable for this Marlin. tbd.
// Storage space for the Killscreen messages. 0x1100 - 0x1200 . Reused for the popup.
// constexpr uint16_t VP_MSGSTR1 = 0x1100;
// constexpr uint8_t VP_MSGSTR1_LEN = 0x20; // might be more place for it...
// constexpr uint16_t VP_MSGSTR2 = 0x1140;
// constexpr uint8_t VP_MSGSTR2_LEN = 0x20;
// constexpr uint16_t VP_MSGSTR3 = 0x1180;
// constexpr uint8_t VP_MSGSTR3_LEN = 0x20;
// constexpr uint16_t VP_MSGSTR4 = 0x11C0;
// constexpr uint8_t VP_MSGSTR4_LEN = 0x20;
// Screenchange request for screens that only make sense when printer is idle.
// e.g movement is only allowed if printer is not printing.
// Marlin must confirm by setting the screen manually.
// constexpr uint16_t VP_SCREENCHANGE_ASK = 0x2000;
// constexpr uint16_t VP_SCREENCHANGE = 0x2001; // Key-Return button to new menu pressed. Data contains target screen in low byte and info in high byte.
// constexpr uint16_t VP_TEMP_ALL_OFF = 0x2002; // Turn all heaters off. Value arbitrary ;)=
// constexpr uint16_t VP_SCREENCHANGE_WHENSD = 0x2003; // "Print" Button touched -- go only there if there is an SD Card.
// constexpr uint16_t VP_CONFIRMED = 0x2010; // OK on confirm screen.
// // Buttons on the SD-Card File listing.
// constexpr uint16_t VP_SD_ScrollEvent = 0x2020; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
// constexpr uint16_t VP_SD_FileSelected = 0x2022; // Number of file field selected.
// constexpr uint16_t VP_SD_FileSelectConfirm = 0x2024; // (This is a virtual VP and emulated by the Confirm Screen when a file has been confirmed)
// constexpr uint16_t VP_SD_ResumePauseAbort = 0x2026; // Resume(Data=0), Pause(Data=1), Abort(Data=2) SD Card prints
// constexpr uint16_t VP_SD_AbortPrintConfirmed = 0x2028; // Abort print confirmation (virtual, will be injected by the confirm dialog)
// constexpr uint16_t VP_SD_Print_Setting = 0x2040;
// constexpr uint16_t VP_SD_Print_LiveAdjustZ = 0x2050; // Data: 0 down, 1 up
// Controls for movement (we can't use the incremental / decremental feature of the display at this feature works only with 16 bit values
// (which would limit us to 655.35mm, which is likely not a problem for common setups, but i don't want to rule out hangprinters support)
// A word about the coding: The VP will be per axis and the return code will be an signed 16 bit value in 0.01 mm resolution, telling us
// the relative travel amount t he user wants to do. So eg. if the display sends us VP=2100 with value 100, the user wants us to move X by +1 mm.
// constexpr uint16_t VP_MOVE_X = 0x2100;
// constexpr uint16_t VP_MOVE_Y = 0x2102;
// constexpr uint16_t VP_MOVE_Z = 0x2104;
// constexpr uint16_t VP_MOVE_E0 = 0x2110;
// constexpr uint16_t VP_MOVE_E1 = 0x2112;
// //constexpr uint16_t VP_MOVE_E2 = 0x2114;
// //constexpr uint16_t VP_MOVE_E3 = 0x2116;
// //constexpr uint16_t VP_MOVE_E4 = 0x2118;
// //constexpr uint16_t VP_MOVE_E5 = 0x211A;
// constexpr uint16_t VP_HOME_ALL = 0x2120;
// constexpr uint16_t VP_MOTOR_LOCK_UNLOK = 0x2130;
// constexpr uint16_t VP_XYZ_HOME = 0x2132;
// Power loss recovery
// constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x2180;
// // Fan Control Buttons , switch between "off" and "on"
// constexpr uint16_t VP_FAN0_CONTROL = 0x2200;
// constexpr uint16_t VP_FAN1_CONTROL = 0x2202;
// constexpr uint16_t VP_FAN2_CONTROL = 0x2204;
// constexpr uint16_t VP_FAN3_CONTROL = 0x2206;
// // Heater Control Buttons , triged between "cool down" and "heat PLA" state
// constexpr uint16_t VP_E0_CONTROL = 0x2210;
// constexpr uint16_t VP_E1_CONTROL = 0x2212;
// //constexpr uint16_t VP_E2_CONTROL = 0x2214;
// //constexpr uint16_t VP_E3_CONTROL = 0x2216;
// //constexpr uint16_t VP_E4_CONTROL = 0x2218;
// //constexpr uint16_t VP_E5_CONTROL = 0x221A;
// constexpr uint16_t VP_BED_CONTROL = 0x221C;
// // Preheat
// constexpr uint16_t VP_E0_BED_PREHEAT = 0x2220;
// constexpr uint16_t VP_E1_BED_PREHEAT = 0x2222;
// //constexpr uint16_t VP_E2_BED_PREHEAT = 0x2224;
// //constexpr uint16_t VP_E3_BED_PREHEAT = 0x2226;
// //constexpr uint16_t VP_E4_BED_PREHEAT = 0x2228;
// //constexpr uint16_t VP_E5_BED_PREHEAT = 0x222A;
// // Filament load and unload
// // constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x2300;
// // constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x2302;
// // Settings store , reset
// // PID autotune
// constexpr uint16_t VP_PID_AUTOTUNE_E0 = 0x2410;
// constexpr uint16_t VP_PID_AUTOTUNE_E1 = 0x2412;
// //constexpr uint16_t VP_PID_AUTOTUNE_E2 = 0x2414;
// //constexpr uint16_t VP_PID_AUTOTUNE_E3 = 0x2416;
// //constexpr uint16_t VP_PID_AUTOTUNE_E4 = 0x2418;
// //constexpr uint16_t VP_PID_AUTOTUNE_E5 = 0x241A;
// constexpr uint16_t VP_PID_AUTOTUNE_BED = 0x2420;
// // Calibrate Z
// constexpr uint16_t VP_Z_CALIBRATE = 0x2430;
// First layer cal
// constexpr uint16_t VP_Z_FIRST_LAYER_CAL = 0x2500; // Data: 0 - Cancel first layer cal progress, >0 filament type have loaded
// Firmware version on the boot screen.
// constexpr uint16_t VP_MARLIN_VERSION = 0x3000;
// constexpr uint8_t VP_MARLIN_VERSION_LEN = 16; // there is more space on the display, if needed.
// Place for status messages.
constexpr uint16_t VP_M117 = 0x7020;
constexpr uint8_t VP_M117_LEN = 0x20;
// // Temperatures.
// constexpr uint16_t VP_T_E0_Is = 0x3060; // 4 Byte Integer
// constexpr uint16_t VP_T_E0_Set = 0x3062; // 2 Byte Integer
// constexpr uint16_t VP_T_E1_Is = 0x3064; // 4 Byte Integer
// // reserved to support up to 6 Extruders:
// constexpr uint16_t VP_T_E1_Set = 0x3066; // 2 Byte Integer
// constexpr uint16_t VP_T_E2_Is = 0x3068; // 4 Byte Integer
// constexpr uint16_t VP_T_E2_Set = 0x306A; // 2 Byte Integer
// constexpr uint16_t VP_T_E3_Is = 0x306C; // 4 Byte Integer
// constexpr uint16_t VP_T_E3_Set = 0x306E; // 2 Byte Integer
// constexpr uint16_t VP_T_E4_Is = 0x3070; // 4 Byte Integer
// constexpr uint16_t VP_T_E4_Set = 0x3072; // 2 Byte Integer
// constexpr uint16_t VP_T_E5_Is = 0x3074; // 4 Byte Integer
// constexpr uint16_t VP_T_E5_Set = 0x3076; // 2 Byte Integer
// constexpr uint16_t VP_T_E6_Is = 0x3078; // 4 Byte Integer
// constexpr uint16_t VP_T_E6_Set = 0x307A; // 2 Byte Integer
// constexpr uint16_t VP_T_E7_Is = 0x3078; // 4 Byte Integer
// constexpr uint16_t VP_T_E7_Set = 0x307A; // 2 Byte Integer
// constexpr uint16_t VP_T_Bed_Is = 0x3080; // 4 Byte Integer
// constexpr uint16_t VP_T_Bed_Set = 0x3082; // 2 Byte Integer
// constexpr uint16_t VP_Flowrate_E0 = 0x3090; // 2 Byte Integer
// constexpr uint16_t VP_Flowrate_E1 = 0x3092; // 2 Byte Integer
// // reserved for up to 6 Extruders:
// constexpr uint16_t VP_Flowrate_E2 = 0x3094;
// constexpr uint16_t VP_Flowrate_E3 = 0x3096;
// constexpr uint16_t VP_Flowrate_E4 = 0x3098;
// constexpr uint16_t VP_Flowrate_E5 = 0x309A;
// constexpr uint16_t VP_Fan0_Percentage = 0x3100; // 2 Byte Integer (0..100)
// constexpr uint16_t VP_Fan1_Percentage = 0x3102; // 2 Byte Integer (0..100)
// constexpr uint16_t VP_Fan2_Percentage = 0x3104; // 2 Byte Integer (0..100)
// constexpr uint16_t VP_Fan3_Percentage = 0x3106; // 2 Byte Integer (0..100)
// constexpr uint16_t VP_Feedrate_Percentage = 0x3108; // 2 Byte Integer (0..100)
// Actual Position
// constexpr uint16_t VP_XPos = 0x3110; // 4 Byte Fixed point number; format xxx.yy
// constexpr uint16_t VP_YPos = 0x3112; // 4 Byte Fixed point number; format xxx.yy
// constexpr uint16_t VP_ZPos = 0x3114; // 4 Byte Fixed point number; format xxx.yy
// constexpr uint16_t VP_EPos = 0x3120; // 4 Byte Fixed point number; format xxx.yy
// constexpr uint16_t VP_PrintProgress_Percentage = 0x3130; // 2 Byte Integer (0..100)
// constexpr uint16_t VP_PrintTime = 0x3140;
// constexpr uint16_t VP_PrintTime_LEN = 32;
// constexpr uint16_t VP_PrintAccTime = 0x3160;
// constexpr uint16_t VP_PrintAccTime_LEN = 32;
// constexpr uint16_t VP_PrintsTotal = 0x3180;
// constexpr uint16_t VP_PrintsTotal_LEN = 16;
// // SDCard File Listing
// constexpr uint16_t VP_SD_FileName_LEN = 32; // LEN is shared for all entries.
// constexpr uint16_t DGUS_SD_FILESPERSCREEN = 8; // FIXME move that info to the display and read it from there.
// constexpr uint16_t VP_SD_FileName0 = 0x3200;
// constexpr uint16_t VP_SD_FileName1 = 0x3220;
// constexpr uint16_t VP_SD_FileName2 = 0x3240;
// constexpr uint16_t VP_SD_FileName3 = 0x3260;
// constexpr uint16_t VP_SD_FileName4 = 0x3280;
// constexpr uint16_t VP_SD_FileName5 = 0x32A0;
// constexpr uint16_t VP_SD_FileName6 = 0x32C0;
// constexpr uint16_t VP_SD_FileName7 = 0x32E0;
// Heater status
constexpr uint16_t VP_E0_STATUS = 0x3410;
constexpr uint16_t VP_E1_STATUS = 0x3412;
//constexpr uint16_t VP_E2_STATUS = 0x3414;
//constexpr uint16_t VP_E3_STATUS = 0x3416;
//constexpr uint16_t VP_E4_STATUS = 0x3418;
//constexpr uint16_t VP_E5_STATUS = 0x341A;
constexpr uint16_t VP_MOVE_OPTION = 0x3500;
// // PIDs
// constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , 2 byte unsigned int , 0~1638.4
// constexpr uint16_t VP_E0_PID_I = 0x3702;
// constexpr uint16_t VP_E0_PID_D = 0x3704;
// constexpr uint16_t VP_E1_PID_P = 0x3706; // at the moment , 2 byte unsigned int , 0~1638.4
// constexpr uint16_t VP_E1_PID_I = 0x3708;
// constexpr uint16_t VP_E1_PID_D = 0x370A;
// constexpr uint16_t VP_BED_PID_P = 0x3710;
// constexpr uint16_t VP_BED_PID_I = 0x3712;
// constexpr uint16_t VP_BED_PID_D = 0x3714;
// Wating screen status
constexpr uint16_t VP_WAITING_STATUS = 0x3800;
// SPs for certain variables...
// located at 0x5000 and up
// Not used yet!
// This can be used e.g to make controls / data display invisible
constexpr uint16_t SP_T_E0_Is = 0x5000;
constexpr uint16_t SP_T_E0_Set = 0x5010;
constexpr uint16_t SP_T_E1_Is = 0x5020;
constexpr uint16_t SP_T_Bed_Is = 0x5030;
constexpr uint16_t SP_T_Bed_Set = 0x5040;
/*************************************************************************************************************************
*************************************************************************************************************************
* DGUS for MKS Mem layout
************************************************************************************************************************
************************************************************************************************************************/
#if ENABLED(MKS_FINSH)
/* -------------------------------0x1000-0x1FFF------------------------------- */
constexpr uint16_t VP_MSGSTR1 = 0x1100;
constexpr uint8_t VP_MSGSTR1_LEN = 0x20; // might be more place for it...
constexpr uint16_t VP_MSGSTR2 = 0x1140;
constexpr uint8_t VP_MSGSTR2_LEN = 0x20;
constexpr uint16_t VP_MSGSTR3 = 0x1180;
constexpr uint8_t VP_MSGSTR3_LEN = 0x20;
constexpr uint16_t VP_MSGSTR4 = 0x11C0;
constexpr uint8_t VP_MSGSTR4_LEN = 0x20;
constexpr uint16_t VP_MARLIN_VERSION = 0x1A00;
constexpr uint8_t VP_MARLIN_VERSION_LEN = 16; // there is more space on the display, if needed.
constexpr uint16_t VP_SCREENCHANGE_ASK = 0x1500;
constexpr uint16_t VP_SCREENCHANGE = 0x1501; // Key-Return button to new menu pressed. Data contains target screen in low byte and info in high byte.
constexpr uint16_t VP_TEMP_ALL_OFF = 0x1502; // Turn all heaters off. Value arbitrary ;)=
constexpr uint16_t VP_SCREENCHANGE_WHENSD = 0x1503; // "Print" Button touched -- go only there if there is an SD Card.
constexpr uint16_t VP_CONFIRMED = 0x1510; // OK on confirm screen.
constexpr uint16_t VP_BACK_PAGE = 0x1600;
constexpr uint16_t VP_SETTINGS = 0x1620;
// Power loss recovery
constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x1680;
/* -------------------------------0x2000-0x2FFF------------------------------- */
// Temperatures.
constexpr uint16_t VP_T_E0_Is = 0x2000; // 4 Byte Integer
constexpr uint16_t VP_T_E0_Set = 0x2004; // 2 Byte Integer
constexpr uint16_t VP_T_E1_Is = 0x2008; // 4 Byte Integer
constexpr uint16_t VP_T_E1_Set = 0x200B; // 2 Byte Integer
constexpr uint16_t VP_T_E2_Is = 0x2010; // 4 Byte Integer
constexpr uint16_t VP_T_E2_Set = 0x2014; // 2 Byte Integer
constexpr uint16_t VP_T_E3_Is = 0x2018; // 4 Byte Integer
constexpr uint16_t VP_T_E3_Set = 0x201B; // 2 Byte Integer
constexpr uint16_t VP_T_E4_Is = 0x2020; // 4 Byte Integer
constexpr uint16_t VP_T_E4_Set = 0x2024; // 2 Byte Integer
constexpr uint16_t VP_T_E5_Is = 0x2028; // 4 Byte Integer
constexpr uint16_t VP_T_E5_Set = 0x202B; // 2 Byte Integer
constexpr uint16_t VP_T_E6_Is = 0x2030; // 4 Byte Integer
constexpr uint16_t VP_T_E6_Set = 0x2034; // 2 Byte Integer
constexpr uint16_t VP_T_E7_Is = 0x2038; // 4 Byte Integer
constexpr uint16_t VP_T_E7_Set = 0x203B; // 2 Byte Integer
constexpr uint16_t VP_T_Bed_Is = 0x2040; // 4 Byte Integer
constexpr uint16_t VP_T_Bed_Set = 0x2044; // 2 Byte Integer
constexpr uint16_t VP_Min_EX_T_E = 0x2100;
constexpr uint16_t VP_Flowrate_E0 = 0x2200; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E1 = 0x2202; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E2 = 0x2204;
constexpr uint16_t VP_Flowrate_E3 = 0x2206;
constexpr uint16_t VP_Flowrate_E4 = 0x2208;
constexpr uint16_t VP_Flowrate_E5 = 0x220A;
constexpr uint16_t VP_Flowrate_E6 = 0x220C;
constexpr uint16_t VP_Flowrate_E7 = 0x220E;
// Move
constexpr uint16_t VP_MOVE_X = 0x2300;
constexpr uint16_t VP_MOVE_Y = 0x2302;
constexpr uint16_t VP_MOVE_Z = 0x2304;
constexpr uint16_t VP_MOVE_E0 = 0x2310;
constexpr uint16_t VP_MOVE_E1 = 0x2312;
constexpr uint16_t VP_MOVE_E2 = 0x2314;
constexpr uint16_t VP_MOVE_E3 = 0x2316;
constexpr uint16_t VP_MOVE_E4 = 0x2318;
constexpr uint16_t VP_MOVE_E5 = 0x231A;
constexpr uint16_t VP_MOVE_E6 = 0x231C;
constexpr uint16_t VP_MOVE_E7 = 0x231E;
constexpr uint16_t VP_HOME_ALL = 0x2320;
constexpr uint16_t VP_MOTOR_LOCK_UNLOK = 0x2330;
constexpr uint16_t VP_MOVE_DISTANCE = 0x2334;
constexpr uint16_t VP_X_HOME = 0x2336;
constexpr uint16_t VP_Y_HOME = 0x2338;
constexpr uint16_t VP_Z_HOME = 0x233A;
// Fan Control Buttons , switch between "off" and "on"
constexpr uint16_t VP_FAN0_CONTROL = 0x2350;
constexpr uint16_t VP_FAN1_CONTROL = 0x2352;
constexpr uint16_t VP_FAN2_CONTROL = 0x2354;
constexpr uint16_t VP_FAN3_CONTROL = 0x2356;
constexpr uint16_t VP_FAN4_CONTROL = 0x2358;
constexpr uint16_t VP_FAN5_CONTROL = 0x235A;
constexpr uint16_t VP_LANGUAGE_CHANGE = 0x2380;
constexpr uint16_t VP_LANGUAGE_CHANGE1 = 0x2382;
constexpr uint16_t VP_LANGUAGE_CHANGE2 = 0x2384;
constexpr uint16_t VP_LANGUAGE_CHANGE3 = 0x2386;
constexpr uint16_t VP_LANGUAGE_CHANGE4 = 0x2388;
constexpr uint16_t VP_LANGUAGE_CHANGE5 = 0x238A;
// LEVEL
constexpr uint16_t VP_LEVEL_POINT = 0x2400;
constexpr uint16_t VP_MESH_LEVEL_POINT = 0x2410;
constexpr uint16_t VP_MESH_LEVEL_ADJUST = 0x2412;
constexpr uint16_t VP_MESH_LEVEL_DIP = 0x2414;
constexpr uint16_t VP_MESH_LEVEL_POINT_X = 0x2416;
constexpr uint16_t VP_MESH_LEVEL_POINT_Y = 0x2418;
constexpr uint16_t VP_LEVEL_BUTTON = 0x2420;
constexpr uint16_t VP_MESH_LEVEL_POINT_DIS = 0x2422;
constexpr uint16_t VP_MESH_LEVEL_BACK = 0x2424;
constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x2500;
constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x2504;
constexpr uint16_t VP_LOAD_Filament = 0x2508;
// constexpr uint16_t VP_LOAD_UNLOAD_Cancle = 0x250A;
constexpr uint16_t VP_UNLOAD_Filament = 0x250B;
constexpr uint16_t VP_Filament_distance = 0x2600;
constexpr uint16_t VP_Filament_speed = 0x2604;
constexpr uint16_t VP_MIN_EX_T = 0x2606;
constexpr uint16_t VP_E1_Filament_distance = 0x2614;
constexpr uint16_t VP_E1_Filament_speed = 0x2616;
constexpr uint16_t VP_E1_MIN_EX_T = 0x2618;
constexpr uint16_t VP_Fan0_Percentage = 0x2700; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan1_Percentage = 0x2702; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan2_Percentage = 0x2704; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan3_Percentage = 0x2706; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Feedrate_Percentage = 0x2708; // 2 Byte Integer (0..100)
// Fan status
constexpr uint16_t VP_FAN0_STATUS = 0x2710;
constexpr uint16_t VP_FAN1_STATUS = 0x2712;
constexpr uint16_t VP_FAN2_STATUS = 0x2714;
constexpr uint16_t VP_FAN3_STATUS = 0x2716;
// Step per mm
constexpr uint16_t VP_X_STEP_PER_MM = 0x2900; // at the moment , 2 byte unsigned int , 0~1638.4
constexpr uint16_t VP_Y_STEP_PER_MM = 0x2904;
constexpr uint16_t VP_Z_STEP_PER_MM = 0x2908;
constexpr uint16_t VP_E0_STEP_PER_MM = 0x2910;
constexpr uint16_t VP_E1_STEP_PER_MM = 0x2912;
constexpr uint16_t VP_E2_STEP_PER_MM = 0x2914;
constexpr uint16_t VP_E3_STEP_PER_MM = 0x2916;
constexpr uint16_t VP_E4_STEP_PER_MM = 0x2918;
constexpr uint16_t VP_E5_STEP_PER_MM = 0x291A;
constexpr uint16_t VP_E6_STEP_PER_MM = 0x291C;
constexpr uint16_t VP_E7_STEP_PER_MM = 0x291E;
constexpr uint16_t VP_X_MAX_SPEED = 0x2A00;
constexpr uint16_t VP_Y_MAX_SPEED = 0x2A04;
constexpr uint16_t VP_Z_MAX_SPEED = 0x2A08;
constexpr uint16_t VP_E0_MAX_SPEED = 0x2A0C;
constexpr uint16_t VP_E1_MAX_SPEED = 0x2A10;
constexpr uint16_t VP_X_ACC_MAX_SPEED = 0x2A28;
constexpr uint16_t VP_Y_ACC_MAX_SPEED = 0x2A2C;
constexpr uint16_t VP_Z_ACC_MAX_SPEED = 0x2A30;
constexpr uint16_t VP_E0_ACC_MAX_SPEED = 0x2A34;
constexpr uint16_t VP_E1_ACC_MAX_SPEED = 0x2A38;
constexpr uint16_t VP_TRAVEL_SPEED = 0x2A3C;
constexpr uint16_t VP_FEEDRATE_MIN_SPEED = 0x2A40;
constexpr uint16_t VP_T_F_SPEED = 0x2A44;
constexpr uint16_t VP_ACC_SPEED = 0x2A48;
/* -------------------------------0x3000-0x3FFF------------------------------- */
// Buttons on the SD-Card File listing.
constexpr uint16_t VP_SD_ScrollEvent = 0x3020; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
constexpr uint16_t VP_SD_FileSelected = 0x3022; // Number of file field selected.
constexpr uint16_t VP_SD_FileSelectConfirm = 0x3024; // (This is a virtual VP and emulated by the Confirm Screen when a file has been confirmed)
constexpr uint16_t VP_SD_ResumePauseAbort = 0x3026; // Resume(Data=0), Pause(Data=1), Abort(Data=2) SD Card prints
constexpr uint16_t VP_SD_AbortPrintConfirmed = 0x3028; // Abort print confirmation (virtual, will be injected by the confirm dialog)
constexpr uint16_t VP_SD_Print_Setting = 0x3040;
constexpr uint16_t VP_SD_Print_LiveAdjustZ = 0x3050; // Data: 0 down, 1 up
constexpr uint16_t VP_SD_Print_LiveAdjustZ_Confirm = 0x3060;
constexpr uint16_t VP_ZOffset_Distance = 0x3070;
constexpr uint16_t VP_ZOffset_DE_DIS = 0x3080;
// SDCard File Listing
constexpr uint16_t VP_SD_FileName_LEN = 32; // LEN is shared for all entries.
constexpr uint16_t DGUS_SD_FILESPERSCREEN = 10; // FIXME move that info to the display and read it from there.
constexpr uint16_t VP_SD_FileName0 = 0x3100;
constexpr uint16_t VP_SD_FileName1 = 0x3120;
constexpr uint16_t VP_SD_FileName2 = 0x3140;
constexpr uint16_t VP_SD_FileName3 = 0x3160;
constexpr uint16_t VP_SD_FileName4 = 0x3180;
constexpr uint16_t VP_SD_FileName5 = 0x31A0;
constexpr uint16_t VP_SD_FileName6 = 0x31C0;
constexpr uint16_t VP_SD_FileName7 = 0x31E0;
constexpr uint16_t VP_SD_FileName8 = 0x3200;
constexpr uint16_t VP_SD_FileName9 = 0x3220;
constexpr uint16_t VP_SD_Print_ProbeOffsetZ = 0x32A0;
constexpr uint16_t VP_SD_Print_Baby = 0x32B0;
constexpr uint16_t VP_SD_Print_Filename = 0x32C0;
// X Y Z Point
constexpr uint16_t VP_XPos = 0x3300; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_YPos = 0x3302; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_ZPos = 0x3304; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_EPos = 0x3306; // 4 Byte Fixed point number; format xxx.yy
// Print
constexpr uint16_t VP_PrintProgress_Percentage = 0x3330; // 2 Byte Integer (0..100)
constexpr uint16_t VP_PrintTime = 0x3340;
constexpr uint16_t VP_PrintTime_LEN = 32;
constexpr uint16_t VP_PrintAccTime = 0x3360;
constexpr uint16_t VP_PrintAccTime_LEN = 32;
constexpr uint16_t VP_PrintsTotal = 0x3380;
constexpr uint16_t VP_PrintsTotal_LEN = 16;
constexpr uint16_t VP_File_Pictutr0 = 0x3400;
constexpr uint16_t VP_File_Pictutr1 = 0x3402;
constexpr uint16_t VP_File_Pictutr2 = 0x3404;
constexpr uint16_t VP_File_Pictutr3 = 0x3406;
constexpr uint16_t VP_File_Pictutr4 = 0x3408;
constexpr uint16_t VP_File_Pictutr5 = 0x340A;
constexpr uint16_t VP_File_Pictutr6 = 0x340C;
constexpr uint16_t VP_File_Pictutr7 = 0x340E;
constexpr uint16_t VP_File_Pictutr8 = 0x3410;
constexpr uint16_t VP_File_Pictutr9 = 0x3412;
constexpr uint16_t VP_BED_STATUS = 0x341C;
constexpr uint16_t VP_TMC_X_STEP = 0x3430;
constexpr uint16_t VP_TMC_Y_STEP = 0x3432;
constexpr uint16_t VP_TMC_Z_STEP = 0x3434;
constexpr uint16_t VP_TMC_X1_Current = 0x3436;
constexpr uint16_t VP_TMC_Y1_Current = 0x3438;
constexpr uint16_t VP_TMC_X_Current = 0x343A;
constexpr uint16_t VP_TMC_Y_Current = 0x343C;
constexpr uint16_t VP_TMC_Z_Current = 0x343E;
constexpr uint16_t VP_TMC_E0_Current = 0x3440;
constexpr uint16_t VP_TMC_E1_Current = 0x3442;
constexpr uint16_t VP_TMC_Z1_Current = 0x3444;
constexpr uint16_t VP_PrintTime_H = 0x3500;
constexpr uint16_t VP_PrintTime_M = 0x3502;
constexpr uint16_t VP_PrintTime_S = 0x3504;
// PIDs
constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , 2 byte unsigned int , 0~1638.4
constexpr uint16_t VP_E0_PID_I = 0x3702;
constexpr uint16_t VP_E0_PID_D = 0x3704;
constexpr uint16_t VP_E1_PID_P = 0x3706; // at the moment , 2 byte unsigned int , 0~1638.4
constexpr uint16_t VP_E1_PID_I = 0x3708;
constexpr uint16_t VP_E1_PID_D = 0x370A;
constexpr uint16_t VP_BED_PID_P = 0x3710;
constexpr uint16_t VP_BED_PID_I = 0x3712;
constexpr uint16_t VP_BED_PID_D = 0x3714;
constexpr uint16_t VP_EEPROM_CTRL = 0x3720;
constexpr uint16_t VP_OFFSET_X = 0x3724;
constexpr uint16_t VP_OFFSET_Y = 0x3728;
constexpr uint16_t VP_OFFSET_Z = 0x372B;
// PID autotune
constexpr uint16_t VP_PID_AUTOTUNE_E0 = 0x3800;
constexpr uint16_t VP_PID_AUTOTUNE_E1 = 0x3802;
constexpr uint16_t VP_PID_AUTOTUNE_E2 = 0x3804;
constexpr uint16_t VP_PID_AUTOTUNE_E3 = 0x3806;
constexpr uint16_t VP_PID_AUTOTUNE_E4 = 0x3808;
constexpr uint16_t VP_PID_AUTOTUNE_E5 = 0x380A;
constexpr uint16_t VP_PID_AUTOTUNE_BED = 0x380C;
// Calibrate Z
constexpr uint16_t VP_Z_CALIBRATE = 0x3810;
constexpr uint16_t VP_AutoTurnOffSw = 0x3812;
constexpr uint16_t VP_LCD_BLK = 0x3814;
constexpr uint16_t VP_X_PARK_POS = 0x3900;
constexpr uint16_t VP_Y_PARK_POS = 0x3902;
constexpr uint16_t VP_Z_PARK_POS = 0x3904;
/* -------------------------------0x4000-0x4FFF------------------------------- */
// Heater Control Buttons , triged between "cool down" and "heat PLA" state
constexpr uint16_t VP_E0_CONTROL = 0x4010;
constexpr uint16_t VP_E1_CONTROL = 0x4012;
//constexpr uint16_t VP_E2_CONTROL = 0x2214;
//constexpr uint16_t VP_E3_CONTROL = 0x2216;
//constexpr uint16_t VP_E4_CONTROL = 0x2218;
//constexpr uint16_t VP_E5_CONTROL = 0x221A;
constexpr uint16_t VP_BED_CONTROL = 0x401C;
// Preheat
constexpr uint16_t VP_E0_BED_PREHEAT = 0x4020;
constexpr uint16_t VP_E1_BED_PREHEAT = 0x4022;
//constexpr uint16_t VP_E2_BED_PREHEAT = 0x4024;
//constexpr uint16_t VP_E3_BED_PREHEAT = 0x4026;
//constexpr uint16_t VP_E4_BED_PREHEAT = 0x4028;
//constexpr uint16_t VP_E5_BED_PREHEAT = 0x402A;
// Filament load and unload
// constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x4030;
// constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x4032;
// Settings store , reset
// Level data
constexpr uint16_t VP_Level_Point_One_X = 0x4100;
constexpr uint16_t VP_Level_Point_One_Y = 0x4102;
constexpr uint16_t VP_Level_Point_Two_X = 0x4104;
constexpr uint16_t VP_Level_Point_Two_Y = 0x4106;
constexpr uint16_t VP_Level_Point_Three_X = 0x4108;
constexpr uint16_t VP_Level_Point_Three_Y = 0x410A;
constexpr uint16_t VP_Level_Point_Four_X = 0x410C;
constexpr uint16_t VP_Level_Point_Four_Y = 0x410E;
constexpr uint16_t VP_Level_Point_Five_X = 0x4110;
constexpr uint16_t VP_Level_Point_Five_Y = 0x4112;
/* H43 Version */
constexpr uint16_t VP_MKS_H43_VERSION = 0x4A00; // MKS H43 V1.0.0
constexpr uint16_t VP_MKS_H43_VERSION_LEN = 16;
constexpr uint16_t VP_MKS_H43_UpdataVERSION = 0x4A10; // MKS H43 V1.0.0
constexpr uint16_t VP_MKS_H43_UpdataVERSION_LEN = 16;
/* -------------------------------0x5000-0xFFFF------------------------------- */
constexpr uint16_t VP_HOME_Dis = 0x5000;
constexpr uint16_t VP_Setting_Dis = 0x5010;
constexpr uint16_t VP_Tool_Dis = 0x5020;
constexpr uint16_t VP_Printing_Dis = 0x5030;
constexpr uint16_t VP_Language_Dis = 0x5080;
constexpr uint16_t VP_LossPoint_Dis = 0x5090;
constexpr uint16_t VP_PrintPauseConfig_Dis = 0x5120;
constexpr uint16_t VP_MotorPluse_Dis = 0x5140;
constexpr uint16_t VP_MotorMaxSpeed_Dis = 0x5150;
constexpr uint16_t VP_MotorMaxAcc_Dis = 0x5160;
constexpr uint16_t VP_X_Pluse_Dis = 0x5170;
constexpr uint16_t VP_Y_Pluse_Dis = 0x5180;
constexpr uint16_t VP_Z_Pluse_Dis = 0x5190;
constexpr uint16_t VP_E0_Pluse_Dis = 0x51A0;
constexpr uint16_t VP_E1_Pluse_Dis = 0x51B0;
constexpr uint16_t VP_X_Max_Speed_Dis = 0x5280;
constexpr uint16_t VP_Y_Max_Speed_Dis = 0x5290;
constexpr uint16_t VP_Z_Max_Speed_Dis = 0x52A0;
constexpr uint16_t VP_E0_Max_Speed_Dis = 0x52B0;
constexpr uint16_t VP_E1_Max_Speed_Dis = 0x52C0;
constexpr uint16_t VP_X_Max_Acc_Speed_Dis = 0x51E0;
constexpr uint16_t VP_Y_Max_Acc_Speed_Dis = 0x51F0;
constexpr uint16_t VP_Z_Max_Acc_Speed_Dis = 0x5200;
constexpr uint16_t VP_E0_Max_Acc_Speed_Dis = 0x5210;
constexpr uint16_t VP_E1_Max_Acc_Speed_Dis = 0x5220;
constexpr uint16_t VP_PrintTime_Dis = 0x5470;
constexpr uint16_t VP_E0_Temp_Dis = 0x5310;
constexpr uint16_t VP_E1_Temp_Dis = 0x5320;
constexpr uint16_t VP_HB_Temp_Dis = 0x5330;
constexpr uint16_t VP_Feedrate_Dis = 0x5350;
constexpr uint16_t VP_PrintAcc_Dis = 0x5340;
constexpr uint16_t VP_Fan_Speed_Dis = 0x5360;
constexpr uint16_t VP_Min_Ex_Temp_Dis = 0x5380;
constexpr uint16_t VP_X_PARK_POS_Dis = 0x53E0;
constexpr uint16_t VP_Y_PARK_POS_Dis = 0x53F0;
constexpr uint16_t VP_Z_PARK_POS_Dis = 0x5400;
constexpr uint16_t VP_TravelAcc_Dis = 0x5440;
constexpr uint16_t VP_FeedRateMin_Dis = 0x5450;
constexpr uint16_t VP_TravelFeeRateMin_Dis = 0x5460;
constexpr uint16_t VP_ACC_Dis = 0x5480;
constexpr uint16_t VP_Extrusion_Dis = 0x5230;
constexpr uint16_t VP_HeatBed_Dis = 0x5240;
constexpr uint16_t VP_Printting_Dis = 0x5430;
constexpr uint16_t VP_FactoryDefaults_Dis = 0x54C0;
constexpr uint16_t VP_StoreSetting_Dis = 0x54B0;
constexpr uint16_t VP_Info_EEPROM_2_Dis = 0x54D0;
constexpr uint16_t VP_Info_EEPROM_1_Dis = 0x54E0;
constexpr uint16_t VP_AutoLevel_1_Dis = 0x55F0;
constexpr uint16_t VP_TMC_X_Step_Dis = 0x5530;
constexpr uint16_t VP_TMC_Y_Step_Dis = 0x5540;
constexpr uint16_t VP_TMC_Z_Step_Dis = 0x5550;
constexpr uint16_t VP_TMC_X1_Current_Dis = 0x5560;
constexpr uint16_t VP_TMC_Y1_Current_Dis = 0x5570;
constexpr uint16_t VP_TMC_X_Current_Dis = 0x5580;
constexpr uint16_t VP_TMC_Y_Current_Dis = 0x5590;
constexpr uint16_t VP_TMC_Z_Current_Dis = 0x55A0;
constexpr uint16_t VP_TMC_E0_Current_Dis = 0x55B0;
constexpr uint16_t VP_TMC_E1_Current_Dis = 0x55C0;
constexpr uint16_t VP_TMC_Z1_Current_Dis = 0x55E0;
constexpr uint16_t VP_AutoLEVEL_INFO1 = 0x5600;
constexpr uint16_t VP_EX_TEMP_INFO1_Dis = 0x5610;
constexpr uint16_t VP_EX_TEMP_INFO2_Dis = 0x5620;
constexpr uint16_t VP_EX_TEMP_INFO3_Dis = 0x5630;
constexpr uint16_t VP_LCD_BLK_Dis = 0x56A0;
constexpr uint16_t VP_Info_PrinfFinsh_1_Dis = 0x5C00;
constexpr uint16_t VP_Info_PrinfFinsh_2_Dis = 0x5C10;
constexpr uint16_t VP_Length_Dis = 0x5B00;
constexpr uint16_t VP_PrintConfrim_Info_Dis = 0x5B90;
constexpr uint16_t VP_StopPrintConfrim_Info_Dis = 0x5B80;
constexpr uint16_t VP_Point_One_Dis = 0x5BA0;
constexpr uint16_t VP_Point_Two_Dis = 0x5BB0;
constexpr uint16_t VP_Point_Three_Dis = 0x5BC0;
constexpr uint16_t VP_Point_Four_Dis = 0x5BD0;
constexpr uint16_t VP_Point_Five_Dis = 0x5BE0;
constexpr uint16_t VP_Print_Dis = 0x5250;
constexpr uint16_t VP_About_Dis = 0x5A00;
constexpr uint16_t VP_Config_Dis = 0x5A10;
constexpr uint16_t VP_Filament_Dis = 0x5A20;
constexpr uint16_t VP_Move_Dis = 0x5A30;
constexpr uint16_t VP_Level_Dis = 0x5A50;
constexpr uint16_t VP_Speed_Dis = 0x5A70;
constexpr uint16_t VP_InOut_Dis = 0x5A80;
constexpr uint16_t VP_MotorConfig_Dis = 0x5100;
constexpr uint16_t VP_LevelConfig_Dis = 0x5110;
constexpr uint16_t VP_Advance_Dis = 0x5130;
constexpr uint16_t VP_TemperatureConfig_Dis = 0x5390;
#endif // MKS_FINSH

2109
Marlin/src/lcd/extui/lib/dgus/mks/DGUSScreenHandler.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

307
Marlin/src/lcd/extui/lib/dgus/mks/DGUSScreenHandler.h Normal file
View File

@ -0,0 +1,307 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplay.h"
#include "../DGUSVPVariable.h"
#include "../DGUSDisplayDef.h"
#include "../../../../../inc/MarlinConfig.h"
enum DGUSLCD_Screens : uint8_t;
class DGUSScreenHandler {
public:
DGUSScreenHandler() = default;
static bool loop();
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifing whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static void sendinfoscreen_ch_mks(const uint16_t* line1, const uint16_t* line2, const uint16_t* line3, const uint16_t* line4);
static void sendinfoscreen_en_mks(const char* line1, const char* line2, const char* line3, const char* line4) ;
static void sendinfoscreen_mks(const void* line1, const void* line2, const void* line3, const void* line4,uint16_t language);
// "M117" Message -- msg is a RAM ptr.
static void setstatusmessage(const char* msg);
// The same for messages from Flash
static void setstatusmessagePGM(PGM_P const msg);
// Callback for VP "Display wants to change screen on idle printer"
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "Screen has been changed"
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr);
static void ScreenBackChange(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "All Heaters Off"
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change this temperature"
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change Flowrate"
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
// Hook for manual move option
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr);
#endif
static void EEPROM_CTRL(DGUS_VP_Variable &var, void *val_ptr);
static void LanguageChange_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void GetOffsetValue(DGUS_VP_Variable &var, void *val_ptr);
static void Level_Ctrl_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void MeshLevel(DGUS_VP_Variable &var, void *val_ptr);
static void MeshLevelDistanceConfig(DGUS_VP_Variable &var, void *val_ptr);
static void ManualAssistLeveling(DGUS_VP_Variable &var, void *val_ptr);
static void ZoffsetConfirm(DGUS_VP_Variable &var, void *val_ptr);
static void Z_offset_select(DGUS_VP_Variable &var, void *val_ptr);
static void GetManualMovestep(DGUS_VP_Variable &var, void *val_ptr);
static void GetZoffsetDistance(DGUS_VP_Variable &var, void *val_ptr);
static void GetMinExtrudeTemp(DGUS_VP_Variable &var, void *val_ptr);
static void GetParkPos_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleGetExMinTemp_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void DGUS_LanguageDisplay(uint8_t var);
static void TMC_ChangeConfig(DGUS_VP_Variable &var, void *val_ptr);
static void GetTurnOffCtrl(DGUS_VP_Variable &var, void *val_ptr);
static void LanguagePInit(void);
static void DGUS_Runout_Idle(void);
static void DGUS_RunoutInit(void);
static void DGUS_ExtrudeLoadInit(void);
static void LCD_BLK_Adjust(DGUS_VP_Variable &var, void *val_ptr);
// Hook for manual move.
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr);
// Hook for manual extrude.
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr);
// Hook for motor lock and unlook
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(POWER_LOSS_RECOVERY)
// Hook for power loss recovery.
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for settings
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMChanged_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMExtruderChanged_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleMaxSpeedChange_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleExtruderMaxSpeedChange_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleMaxAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleExtruderAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleChangeLevelPoint_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleTravelAccChange_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleFeedRateMinChange_MKS(DGUS_VP_Variable &var, void *val_ptr);
static void HandleMin_T_F_MKS(DGUS_VP_Variable &var, void *val_ptr);
#if HAS_PID_HEATING
// Hook for "Change this temperature PID para"
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for PID autotune
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_BED_PROBE
// Hook for "Change probe offset z"
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(BABYSTEPPING)
// Hook for live z adjust action
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_FAN
// Hook for fan control
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for heater control
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_PREHEAT_UI)
// Hook for preheat
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
// Hook for filament load and unload filament option
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr);
// Hook for filament load and unload
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var);
static void MKS_FilamentLoad(DGUS_VP_Variable &var, void *val_ptr);
static void MKS_FilamentUnLoad(DGUS_VP_Variable &var, void *val_ptr);
static void MKS_LOAD_UNLOAD_IDLE();
static void MKS_LOAD_Cancle(DGUS_VP_Variable &var, void *val_ptr);
static void GetManualFilament(DGUS_VP_Variable &var, void *val_ptr);
static void GetManualFilamentSpeed(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(SDSUPPORT)
// Callback for VP "Display wants to change screen when there is a SD card"
static void ScreenChangeHookIfSD(DGUS_VP_Variable &var, void *val_ptr);
// Scroll buttons on the file listing screen.
static void DGUSLCD_SD_ScrollFilelist(DGUS_VP_Variable &var, void *val_ptr);
// File touched.
static void DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr);
// start print after confirmation received.
static void DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr);
// User hit the pause, resume or abort button.
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr);
// User confirmed the abort action
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr);
// User hit the tune button
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr);
// Send a single filename to the display.
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var);
// Marlin informed us that a new SD has been inserted.
static void SDCardInserted();
// Marlin informed us that the SD Card has been removed().
static void SDCardRemoved();
// Marlin informed us about a bad SD Card.
static void SDCardError();
// Marlin informed us about SD print completion.
static void SDPrintingFinished();
#endif
// OK Button the Confirm screen.
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr);
// Update data after went to new screen (by display or by GotoScreen)
// remember: store the last-displayed screen, so it can get returned to.
// (e.g for pop up messages)
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false);
// Recall the remembered screen.
static void PopToOldScreen();
// Make the display show the screen and update all VPs in it.
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false);
static void UpdateScreenVPData();
// Helpers to convert and transfer data to the display.
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var);
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var);
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintTimeToDisplay_MKS(DGUS_VP_Variable &var);
static void DGUSLCD_SendBabyStepToDisplay_MKS(DGUS_VP_Variable &var);
static void DGUSLCD_SendFanToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendGbkToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplay_Language_MKS(DGUS_VP_Variable &var);
static void DGUSLCD_SendTMCStepValue(DGUS_VP_Variable &var);
#if ENABLED(PRINTCOUNTER)
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var);
#endif
#if HAS_FAN
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var);
#endif
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var);
#if ENABLED(DGUS_UI_WAITING)
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var);
#endif
// Send a value from 0..100 to a variable with a range from 0..255
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr);
static void DGUSLCD_SetUint8(DGUS_VP_Variable &var, void *val_ptr);
template<typename T>
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) {
if (!var.memadr) return;
union { unsigned char tmp[sizeof(T)]; T t; } x;
unsigned char *ptr = (unsigned char*)val_ptr;
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1];
*(T*)var.memadr = x.t;
}
// Send a float value to the display.
// Display will get a 4-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (long)f);
}
}
// Send a float value to the display.
// Display will get a 2-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
DEBUG_ECHOLNPAIR_F(" >> ", f, 6);
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (int16_t)f);
}
}
// Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
// Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private:
static DGUSLCD_Screens current_screen; //< currently on screen
static constexpr uint8_t NUM_PAST_SCREENS = 4;
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
static bool ScreenComplete; //< All VPs sent to screen?
static uint16_t ConfirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
#if ENABLED(SDSUPPORT)
static int16_t top_file; //< file on top of file chooser
static int16_t file_to_print; //< touched file to be confirmed
#endif
static void (*confirm_action_cb)();
};
#define MKS_Language_Choose 0x00
#define MKS_Language_NoChoose 0x01
#define MKS_SimpleChinese 0
#define MKS_English 1
extern uint8_t DGUSLanguageSwitch;
extern bool DGUSAutoTurnOff;
#if ENABLED(POWER_LOSS_RECOVERY)
#define PLR_SCREEN_RECOVER MKSLCD_SCREEN_PRINT
#define PLR_SCREEN_CANCEL MKSLCD_SCREEN_HOME
#endif

6
Marlin/src/lcd/extui/lib/dgus/origin/DGUSDisplayDef.cpp
View File

@ -20,7 +20,9 @@
*
*/
/* DGUS implementation written by coldtobi in 2019 for Marlin */
/**
* lcd/extui/lib/dgus/origin/DGUSDisplayDef.cpp
*/
#include "../../../../../inc/MarlinConfigPre.h"
@ -87,7 +89,7 @@ const uint16_t VPList_Status[] PROGMEM = {
};
const uint16_t VPList_Status2[] PROGMEM = {
/* VP_M117, for completeness, but it cannot be auto-uploaded */
// VP_M117, for completeness, but it cannot be auto-uploaded
#if HOTENDS >= 1
VP_Flowrate_E0,
#endif

418
Marlin/src/lcd/extui/lib/dgus/origin/DGUSScreenHandler.cpp Normal file
View File

@ -0,0 +1,418 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_ORIGIN)
#include "../DGUSScreenHandler.h"
#include "../../../../../MarlinCore.h"
#include "../../../../../gcode/queue.h"
#include "../../../../../libs/duration_t.h"
#include "../../../../../module/settings.h"
#include "../../../../../module/temperature.h"
#include "../../../../../module/motion.h"
#include "../../../../../module/planner.h"
#include "../../../../../module/printcounter.h"
#include "../../../../../sd/cardreader.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
#if ENABLED(SDSUPPORT)
void DGUSScreenHandler::DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file;
if (touched_nr > filelist.count()) return;
if (!filelist.seek(touched_nr)) return;
if (filelist.isDir()) {
filelist.changeDir(filelist.filename());
top_file = 0;
ForceCompleteUpdate();
return;
}
#if ENABLED(DGUS_PRINT_FILENAME)
// Send print filename
dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true);
#endif
// Setup Confirmation screen
file_to_print = touched_nr;
HandleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true);
}
void DGUSScreenHandler::DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr) {
if (!filelist.seek(file_to_print)) return;
ExtUI::printFile(filelist.shortFilename());
GotoScreen(DGUSLCD_SCREEN_STATUS);
}
void DGUSScreenHandler::DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
switch (swap16(*(uint16_t*)val_ptr)) {
case 0: { // Resume
if (ExtUI::isPrintingFromMediaPaused()) {
ExtUI::resumePrint();
}
} break;
case 1: // Pause
GotoScreen(MKSLCD_SCREEN_PAUSE);
if (!ExtUI::isPrintingFromMediaPaused()) {
ExtUI::pausePrint();
//ExtUI::mks_pausePrint();
}
break;
case 2: // Abort
HandleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true);
break;
}
}
void DGUSScreenHandler::DGUSLCD_SD_SendFilename(DGUS_VP_Variable& var) {
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN;
if (target_line > DGUS_SD_FILESPERSCREEN) return;
char tmpfilename[VP_SD_FileName_LEN + 1] = "";
var.memadr = (void*)tmpfilename;
if (filelist.seek(top_file + target_line)) {
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
}
DGUSLCD_SendStringToDisplay(var);
}
void DGUSScreenHandler::SDCardInserted() {
top_file = 0;
filelist.refresh();
auto cs = getCurrentScreen();
if (cs == DGUSLCD_SCREEN_MAIN || cs == DGUSLCD_SCREEN_STATUS)
GotoScreen(DGUSLCD_SCREEN_SDFILELIST);
}
void DGUSScreenHandler::SDCardRemoved() {
if (current_screen == DGUSLCD_SCREEN_SDFILELIST
|| (current_screen == DGUSLCD_SCREEN_CONFIRM && (ConfirmVP == VP_SD_AbortPrintConfirmed || ConfirmVP == VP_SD_FileSelectConfirm))
|| current_screen == DGUSLCD_SCREEN_SDPRINTMANIPULATION
) GotoScreen(DGUSLCD_SCREEN_MAIN);
}
#endif // SDSUPPORT
void DGUSScreenHandler::ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t *tmp = (uint8_t*)val_ptr;
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
// from screen 1 (main) to 10 (temperature). DGUSLCD_SCREEN_POPUP is special,
// meaning "return to previous screen"
DGUSLCD_Screens target = (DGUSLCD_Screens)tmp[1];
DEBUG_ECHOLNPAIR("\n DEBUG target", target);
if (target == DGUSLCD_SCREEN_POPUP) {
// Special handling for popup is to return to previous menu
if (current_screen == DGUSLCD_SCREEN_POPUP && confirm_action_cb) confirm_action_cb();
PopToOldScreen();
return;
}
UpdateNewScreen(target);
#ifdef DEBUG_DGUSLCD
if (!DGUSLCD_FindScreenVPMapList(target)) DEBUG_ECHOLNPAIR("WARNING: No screen Mapping found for ", target);
#endif
}
void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleManualMove");
int16_t movevalue = swap16(*(uint16_t*)val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
if (movevalue) {
const uint16_t choice = *(uint16_t*)var.memadr;
movevalue = movevalue < 0 ? -choice : choice;
}
#endif
char axiscode;
unsigned int speed = 1500; // FIXME: get default feedrate for manual moves, dont hardcode.
switch (var.VP) {
default: return;
case VP_MOVE_X:
axiscode = 'X';
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
break;
case VP_MOVE_Y:
axiscode = 'Y';
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove;
break;
case VP_MOVE_Z:
axiscode = 'Z';
speed = 300; // default to 5mm/s
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove;
break;
case VP_HOME_ALL: // only used for homing
axiscode = '\0';
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
break;
}
if (!movevalue) {
// homing
DEBUG_ECHOPAIR(" homing ", axiscode);
char buf[6] = "G28 X";
buf[4] = axiscode;
//DEBUG_ECHOPAIR(" ", buf);
queue.enqueue_one_now(buf);
//DEBUG_ECHOLNPGM(" ✓");
ForceCompleteUpdate();
return;
}
else {
// movement
DEBUG_ECHOPAIR(" move ", axiscode);
bool old_relative_mode = relative_mode;
if (!relative_mode) {
//DEBUG_ECHOPGM(" G91");
queue.enqueue_now_P(PSTR("G91"));
//DEBUG_ECHOPGM(" ✓ ");
}
char buf[32]; // G1 X9999.99 F12345
unsigned int backup_speed = MMS_TO_MMM(feedrate_mm_s);
char sign[] = "\0";
int16_t value = movevalue / 100;
if (movevalue < 0) { value = -value; sign[0] = '-'; }
int16_t fraction = ABS(movevalue) % 100;
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed);
//DEBUG_ECHOPAIR(" ", buf);
queue.enqueue_one_now(buf);
//DEBUG_ECHOLNPGM(" ✓ ");
if (backup_speed != speed) {
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed);
queue.enqueue_one_now(buf);
//DEBUG_ECHOPAIR(" ", buf);
}
// while (!enqueue_and_echo_command(buf)) idle();
//DEBUG_ECHOLNPGM(" ✓ ");
if (!old_relative_mode) {
//DEBUG_ECHOPGM("G90");
queue.enqueue_now_P(PSTR("G90"));
//DEBUG_ECHOPGM(" ✓ ");
}
}
ForceCompleteUpdate();
DEBUG_ECHOLNPGM("manmv done.");
return;
cannotmove:
DEBUG_ECHOLNPAIR(" cannot move ", axiscode);
return;
}
#if HAS_PID_HEATING
void DGUSScreenHandler::HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr);
DEBUG_ECHOLNPAIR("V1:", rawvalue);
float value = (float)rawvalue / 10;
DEBUG_ECHOLNPAIR("V2:", value);
float newvalue = 0;
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_PID_P: newvalue = value; break;
case VP_E0_PID_I: newvalue = scalePID_i(value); break;
case VP_E0_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HOTENDS >= 2
case VP_E1_PID_P: newvalue = value; break;
case VP_E1_PID_I: newvalue = scalePID_i(value); break;
case VP_E1_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: newvalue = value; break;
case VP_BED_PID_I: newvalue = scalePID_i(value); break;
case VP_BED_PID_D: newvalue = scalePID_d(value); break;
#endif
}
DEBUG_ECHOLNPAIR_F("V3:", newvalue);
*(float *)var.memadr = newvalue;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // HAS_PID_HEATING
#if ENABLED(BABYSTEPPING)
void DGUSScreenHandler::HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleLiveAdjustZ");
int16_t flag = swap16(*(uint16_t*)val_ptr),
steps = flag ? -20 : 20;
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true);
ForceCompleteUpdate();
}
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
void DGUSScreenHandler::HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) {
DEBUG_ECHOLNPGM("HandleFilamentOption");
uint8_t e_temp = 0;
filament_data.heated = false;
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr);
if (preheat_option <= 8) { // Load filament type
filament_data.action = 1;
}
else if (preheat_option >= 10) { // Unload filament type
preheat_option -= 10;
filament_data.action = 2;
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH;
}
else { // Cancel filament operation
filament_data.action = 0;
}
switch (preheat_option) {
case 0: // Load PLA
#ifdef PREHEAT_1_TEMP_HOTEND
e_temp = PREHEAT_1_TEMP_HOTEND;
#endif
break;
case 1: // Load ABS
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND);
break;
case 2: // Load PET
#ifdef PREHEAT_3_TEMP_HOTEND
e_temp = PREHEAT_3_TEMP_HOTEND;
#endif
break;
case 3: // Load FLEX
#ifdef PREHEAT_4_TEMP_HOTEND
e_temp = PREHEAT_4_TEMP_HOTEND;
#endif
break;
case 9: // Cool down
default:
e_temp = 0;
break;
}
if (filament_data.action == 0) { // Go back to utility screen
#if HOTENDS >= 1
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0);
#endif
#if HOTENDS >= 2
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1);
#endif
GotoScreen(DGUSLCD_SCREEN_UTILITY);
}
else { // Go to the preheat screen to show the heating progress
switch (var.VP) {
default: return;
#if HOTENDS >= 1
case VP_E0_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E0;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
#if HOTENDS >= 2
case VP_E1_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E1;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
}
GotoScreen(DGUSLCD_SCREEN_FILAMENT_HEATING);
}
}
void DGUSScreenHandler::HandleFilamentLoadUnload(DGUS_VP_Variable &var) {
DEBUG_ECHOLNPGM("HandleFilamentLoadUnload");
if (filament_data.action <= 0) return;
// If we close to the target temperature, we can start load or unload the filament
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) {
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME;
if (filament_data.action == 1) { // load filament
if (!filament_data.heated) {
//GotoScreen(DGUSLCD_SCREEN_FILAMENT_LOADING);
filament_data.heated = true;
}
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
}
else { // unload filament
if (!filament_data.heated) {
GotoScreen(DGUSLCD_SCREEN_FILAMENT_UNLOADING);
filament_data.heated = true;
}
// Before unloading extrude to prevent jamming
if (filament_data.purge_length >= 0) {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
filament_data.purge_length -= movevalue;
}
else {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue;
}
}
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder);
}
}
#endif // DGUS_FILAMENT_LOADUNLOAD
bool DGUSScreenHandler::loop() {
dgusdisplay.loop();
const millis_t ms = millis();
static millis_t next_event_ms = 0;
if (!IsScreenComplete() || ELAPSED(ms, next_event_ms)) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
UpdateScreenVPData();
}
#if ENABLED(SHOW_BOOTSCREEN)
static bool booted = false;
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid()))
booted = true;
if (!booted && ELAPSED(ms, TERN(USE_MKS_GREEN_UI, 1000, BOOTSCREEN_TIMEOUT)))
booted = true;
#endif
return IsScreenComplete();
}
#endif // DGUS_LCD_UI_ORIGIN

240
Marlin/src/lcd/extui/lib/dgus/origin/DGUSScreenHandler.h Normal file
View File

@ -0,0 +1,240 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplay.h"
#include "../DGUSVPVariable.h"
#include "../DGUSDisplayDef.h"
#include "../../../../../inc/MarlinConfig.h"
enum DGUSLCD_Screens : uint8_t;
class DGUSScreenHandler {
public:
DGUSScreenHandler() = default;
static bool loop();
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifing whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static void HandleUserConfirmationPopUp(uint16_t ConfirmVP, const char* line1, const char* line2, const char* line3, const char* line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
// "M117" Message -- msg is a RAM ptr.
static void setstatusmessage(const char* msg);
// The same for messages from Flash
static void setstatusmessagePGM(PGM_P const msg);
// Callback for VP "Display wants to change screen on idle printer"
static void ScreenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "Screen has been changed"
static void ScreenChangeHook(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "All Heaters Off"
static void HandleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change this temperature"
static void HandleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change Flowrate"
static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
// Hook for manual move option
static void HandleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for manual move.
static void HandleManualMove(DGUS_VP_Variable &var, void *val_ptr);
// Hook for manual extrude.
static void HandleManualExtrude(DGUS_VP_Variable &var, void *val_ptr);
// Hook for motor lock and unlook
static void HandleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(POWER_LOSS_RECOVERY)
// Hook for power loss recovery.
static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for settings
static void HandleSettings(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#if HAS_PID_HEATING
// Hook for "Change this temperature PID para"
static void HandleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for PID autotune
static void HandlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_BED_PROBE
// Hook for "Change probe offset z"
static void HandleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(BABYSTEPPING)
// Hook for live z adjust action
static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_FAN
// Hook for fan control
static void HandleFanControl(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for heater control
static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_PREHEAT_UI)
// Hook for preheat
static void HandlePreheat(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
// Hook for filament load and unload filament option
static void HandleFilamentOption(DGUS_VP_Variable &var, void *val_ptr);
// Hook for filament load and unload
static void HandleFilamentLoadUnload(DGUS_VP_Variable &var);
#endif
#if ENABLED(SDSUPPORT)
// Callback for VP "Display wants to change screen when there is a SD card"
static void ScreenChangeHookIfSD(DGUS_VP_Variable &var, void *val_ptr);
// Scroll buttons on the file listing screen.
static void DGUSLCD_SD_ScrollFilelist(DGUS_VP_Variable &var, void *val_ptr);
// File touched.
static void DGUSLCD_SD_FileSelected(DGUS_VP_Variable &var, void *val_ptr);
// start print after confirmation received.
static void DGUSLCD_SD_StartPrint(DGUS_VP_Variable &var, void *val_ptr);
// User hit the pause, resume or abort button.
static void DGUSLCD_SD_ResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr);
// User confirmed the abort action
static void DGUSLCD_SD_ReallyAbort(DGUS_VP_Variable &var, void *val_ptr);
// User hit the tune button
static void DGUSLCD_SD_PrintTune(DGUS_VP_Variable &var, void *val_ptr);
// Send a single filename to the display.
static void DGUSLCD_SD_SendFilename(DGUS_VP_Variable &var);
// Marlin informed us that a new SD has been inserted.
static void SDCardInserted();
// Marlin informed us that the SD Card has been removed().
static void SDCardRemoved();
// Marlin informed us about a bad SD Card.
static void SDCardError();
#endif
// OK Button the Confirm screen.
static void ScreenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr);
// Update data after went to new screen (by display or by GotoScreen)
// remember: store the last-displayed screen, so it can get returned to.
// (e.g for pop up messages)
static void UpdateNewScreen(DGUSLCD_Screens newscreen, bool popup=false);
// Recall the remembered screen.
static void PopToOldScreen();
// Make the display show the screen and update all VPs in it.
static void GotoScreen(DGUSLCD_Screens screen, bool ispopup = false);
static void UpdateScreenVPData();
// Helpers to convert and transfer data to the display.
static void DGUSLCD_SendWordValueToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var);
static void DGUSLCD_SendTemperaturePID(DGUS_VP_Variable &var);
static void DGUSLCD_SendPercentageToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintProgressToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintTimeToDisplay(DGUS_VP_Variable &var);
#if ENABLED(PRINTCOUNTER)
static void DGUSLCD_SendPrintAccTimeToDisplay(DGUS_VP_Variable &var);
static void DGUSLCD_SendPrintsTotalToDisplay(DGUS_VP_Variable &var);
#endif
#if HAS_FAN
static void DGUSLCD_SendFanStatusToDisplay(DGUS_VP_Variable &var);
#endif
static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var);
#if ENABLED(DGUS_UI_WAITING)
static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var);
#endif
// Send a value from 0..100 to a variable with a range from 0..255
static void DGUSLCD_PercentageToUint8(DGUS_VP_Variable &var, void *val_ptr);
template<typename T>
static void DGUSLCD_SetValueDirectly(DGUS_VP_Variable &var, void *val_ptr) {
if (!var.memadr) return;
union { unsigned char tmp[sizeof(T)]; T t; } x;
unsigned char *ptr = (unsigned char*)val_ptr;
LOOP_L_N(i, sizeof(T)) x.tmp[i] = ptr[sizeof(T) - i - 1];
*(T*)var.memadr = x.t;
}
// Send a float value to the display.
// Display will get a 4-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (long)f);
}
}
// Send a float value to the display.
// Display will get a 2-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<unsigned int decimals>
static void DGUSLCD_SendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
DEBUG_ECHOLNPAIR_F(" >> ", f, 6);
f *= cpow(10, decimals);
dgusdisplay.WriteVariable(var.VP, (int16_t)f);
}
}
// Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
// Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private:
static DGUSLCD_Screens current_screen; //< currently on screen
static constexpr uint8_t NUM_PAST_SCREENS = 4;
static DGUSLCD_Screens past_screens[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
static bool ScreenComplete; //< All VPs sent to screen?
static uint16_t ConfirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
#if ENABLED(SDSUPPORT)
static int16_t top_file; //< file on top of file chooser
static int16_t file_to_print; //< touched file to be confirmed
#endif
static void (*confirm_action_cb)();
};
#if ENABLED(POWER_LOSS_RECOVERY)
#define PLR_SCREEN_RECOVER DGUSLCD_SCREEN_SDPRINTMANIPULATION
#define PLR_SCREEN_CANCEL DGUSLCD_SCREEN_STATUS
#endif

2
Marlin/src/lcd/extui/lib/mks_ui/draw_manuaLevel.cpp
View File

@ -29,6 +29,8 @@
#include "../../../../gcode/queue.h"
#include "../../../../inc/MarlinConfig.h"
extern const char G28_STR[];
extern lv_group_t *g;
static lv_obj_t *scr;

14
Marlin/src/lcd/extui/lib/mks_ui/draw_move_motor.cpp
View File

@ -38,8 +38,6 @@ static lv_task_t *updatePosTask;
static char cur_label = 'Z';
static float cur_pos = 0;
void disp_cur_pos();
enum {
ID_M_X_P = 1,
ID_M_X_N,
@ -51,6 +49,12 @@ enum {
ID_M_RETURN
};
void disp_cur_pos() {
char str_1[16];
sprintf_P(public_buf_l, PSTR("%c:%s mm"), cur_label, dtostrf(cur_pos, 1, 1, str_1));
if (labelP) lv_label_set_text(labelP, public_buf_l);
}
static void event_handler(lv_obj_t *obj, lv_event_t event) {
char str_1[16];
if (event != LV_EVENT_RELEASED) return;
@ -125,12 +129,6 @@ void lv_draw_move_motor() {
disp_cur_pos();
}
void disp_cur_pos() {
char str_1[16];
sprintf_P(public_buf_l, PSTR("%c:%s mm"), cur_label, dtostrf(cur_pos, 1, 1, str_1));
if (labelP) lv_label_set_text(labelP, public_buf_l);
}
void disp_move_dist() {
if ((int)(10 * uiCfg.move_dist) == 1)
lv_imgbtn_set_src_both(buttonV, "F:/bmp_step_move0_1.bin");

12
Marlin/src/lcd/extui/lib/mks_ui/draw_ready_print.cpp
View File

@ -152,9 +152,9 @@ void lv_draw_ready_print() {
limit_info = lv_label_create_empty(scr);
lv_style_copy(&limit_style, &lv_style_scr);
limit_style.body.main_color.full = 0X0000;
limit_style.body.grad_color.full = 0X0000;
limit_style.text.color.full = 0Xffff;
limit_style.body.main_color.full = 0x0000;
limit_style.body.grad_color.full = 0x0000;
limit_style.text.color.full = 0xffff;
lv_obj_set_style(limit_info, &limit_style);
lv_obj_set_pos(limit_info, 20, 120);
@ -163,9 +163,9 @@ void lv_draw_ready_print() {
det_info = lv_label_create_empty(scr);
lv_style_copy(&det_style, &lv_style_scr);
det_style.body.main_color.full = 0X0000;
det_style.body.grad_color.full = 0X0000;
det_style.text.color.full = 0Xffff;
det_style.body.main_color.full = 0x0000;
det_style.body.grad_color.full = 0x0000;
det_style.text.color.full = 0xffff;
lv_obj_set_style(det_info, &det_style);
lv_obj_set_pos(det_info, 20, 145);

2
Marlin/src/lcd/extui/lib/mks_ui/pic_manager.h
View File

@ -116,7 +116,7 @@
#endif
// Flash flag
#define REFLSHE_FLGA_ADD (0X800000-32)
#define REFLSHE_FLGA_ADD (0x800000-32)
// SD card information first addr
#define VAR_INF_ADDR 0x000000

8
Marlin/src/lcd/extui/lib/mks_ui/wifi_module.cpp
View File

@ -1231,13 +1231,13 @@ void utf8_2_unicode(uint8_t *source, uint8_t Len) {
while (1) {
char_byte_num = source[i] & 0xF0;
if (source[i] < 0X80) {
if (source[i] < 0x80) {
//ASCII --1byte
FileName_unicode[char_i] = source[i];
i += 1;
char_i += 1;
}
else if (char_byte_num == 0XC0 || char_byte_num == 0XD0) {
else if (char_byte_num == 0xC0 || char_byte_num == 0xD0) {
//--2byte
u16_h = (((uint16_t)source[i] << 8) & 0x1F00) >> 2;
u16_l = ((uint16_t)source[i + 1] & 0x003F);
@ -1247,7 +1247,7 @@ void utf8_2_unicode(uint8_t *source, uint8_t Len) {
i += 2;
char_i += 2;
}
else if (char_byte_num == 0XE0) {
else if (char_byte_num == 0xE0) {
//--3byte
u16_h = (((uint16_t)source[i] << 8) & 0x0F00) << 4;
u16_m = (((uint16_t)source[i + 1] << 8) & 0x3F00) >> 2;
@ -1258,7 +1258,7 @@ void utf8_2_unicode(uint8_t *source, uint8_t Len) {
i += 3;
char_i += 2;
}
else if (char_byte_num == 0XF0) {
else if (char_byte_num == 0xF0) {
//--4byte
i += 4;
//char_i += 3;

2
Marlin/src/pins/stm32f4/pins_MKS_ROBIN_NANO_V3.h
View File

@ -42,6 +42,8 @@
//#define FLASH_EEPROM_EMULATION // Use Flash-based EEPROM emulation
#define I2C_EEPROM
#define MARLIN_EEPROM_SIZE 0x1000 // 4KB
#define I2C_SCL_PIN PB6
#define I2C_SDA_PIN PB7
//
// Release PB4 (Z_DIR_PIN) from JTAG NRST role

5
platformio.ini
View File

@ -53,6 +53,7 @@ default_src_filter = +<src/*> -<src/config> -<src/HAL> +<src/HAL/shared>
-<src/lcd/menu/menu_ubl.cpp>
-<src/lcd/extui/lib/mks_ui>
-<src/lcd/extui/lib/dgus> -<src/lcd/extui/dgus_lcd.cpp>
-<src/lcd/extui/lib/dgus/fysetc> -<src/lcd/extui/lib/dgus/hiprecy> -<src/lcd/extui/lib/dgus/mks> -<src/lcd/extui/lib/dgus/origin>
-<src/lcd/extui/example.cpp>
-<src/lcd/extui/malyan_lcd.cpp>
-<src/lcd/extui/lib/ftdi_eve_touch_ui>
@ -287,6 +288,10 @@ HAS_MENU_UBL = src_filter=+<src/lcd/menu/menu_ubl.cpp>
ANYCUBIC_LCD_CHIRON = src_filter=+<src/lcd/extui/anycubic_chiron_lcd.cpp> +<src/lcd/extui/lib/anycubic_chiron>
ANYCUBIC_LCD_I3MEGA = src_filter=+<src/lcd/extui/anycubic_i3mega_lcd.cpp> +<src/lcd/extui/lib/anycubic_i3mega>
HAS_DGUS_LCD = src_filter=+<src/lcd/extui/lib/dgus> +<src/lcd/extui/dgus_lcd.cpp>
DGUS_LCD_UI_FYSETC = src_filter=+<src/lcd/extui/lib/dgus/fysetc>
DGUS_LCD_UI_HIPRECY = src_filter=+<src/lcd/extui/lib/dgus/hiprecy>
DGUS_LCD_UI_MKS = src_filter=+<src/lcd/extui/lib/dgus/mks>
DGUS_LCD_UI_ORIGIN = src_filter=+<src/lcd/extui/lib/dgus/origin>
TOUCH_UI_FTDI_EVE = src_filter=+<src/lcd/extui/lib/ftdi_eve_touch_ui>
EXTUI_EXAMPLE = src_filter=+<src/lcd/extui/example.cpp>
MALYAN_LCD = src_filter=+<src/lcd/extui/malyan_lcd.cpp>