Update Configuration.h

tweaks
Fix icons
2024-02-26 14:26:27 -05:00 · 2024-01-30 10:27:36 -05:00 · 2024-01-29 14:57:11 -05:00 · 2024-01-28 18:18:06 -05:00 · 2024-01-28 13:57:17 -05:00 · 2024-01-27 21:08:09 -05:00
211 changed files with 17846 additions and 1178 deletions
@@ -16,7 +16,7 @@
 * 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/>.
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 #pragma once
@@ -28,25 +28,179 @@
 /**
 * Marlin release version identifier
 */
-//#define SHORT_BUILD_VERSION "bugfix-2.1.x"
+#define SHORT_BUILD_VERSION "DW7.4.9"

 /**
 * Verbose version identifier which should contain a reference to the location
 * from where the binary was downloaded or the source code was compiled.
 */
-//#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION
+
+#if(ENABLED(MachineMini))
+  #define VerChar1 "M"
+#elif(ENABLED(MachineEnder2))
+  #define VerChar1 "E2"
+#elif(ENABLED(MachineEnder2Pro))
+  #define VerChar1 "E2P"
+#elif(ENABLED(MachineEnder3))
+  #define VerChar1 "E3"
+#elif ENABLED(MachineEnder3V2)
+  #define VerChar1 "E3V2"
+#elif ENABLED(MachineEnder3S1)
+  #define VerChar1 "E3S1"
+#elif ENABLED(MachineEnder3Max)
+  #define VerChar1 "E3M"
+#elif(ENABLED(MachineEnder4))
+  #define VerChar1 "E4"
+#elif(ENABLED(MachineEnder5))
+  #define VerChar1 "E5"
+#elif(ENABLED(MachineEnder6))
+  #define VerChar1 "E6"
+#elif(ENABLED(MachineEnder7))
+  #define VerChar1 "E7"
+#elif(ENABLED(MachineSermoonD1))
+  #define VerChar1 "D1"
+#elif(ENABLED(MachineEnder5Plus))
+  #define VerChar1 "E5P"
+#elif(ENABLED(MachineCR20))
+  #define VerChar1 "2"
+#elif(ENABLED(MachineCR10Orig))
+  #define VerChar1 "O"
+#elif(ENABLED(MachineCR10Std))
+  #define VerChar1 "S"
+#elif(ENABLED(MachineCRX))
+  #define VerChar1 "X"
+#elif(ENABLED(MachineCR6))
+  #define VerChar1 "CR6"
+#elif(ENABLED(MachineCR5))
+  #define VerChar1 "CR5"
+#elif(ENABLED(MachineCR6Max))
+  #define VerChar1 "CR6M"
+#elif(ENABLED(MachineS4))
+  #define VerChar1 "4"
+#elif(ENABLED(MachineS5) || ENABLED(MachineCR10Max))
+  #define VerChar1 "5"
+#elif ENABLED(MachineCR2020)
+  #define VerChar1 "20"
+#elif(ENABLED(MachineCR30))
+  #define VerChar1 "CR30"
+#endif
+
+#if(ENABLED(HotendStock))
+#define VerChar2 "S"
+#elif(ENABLED(HotendE3D))
+#define VerChar2 "E"
+#elif ENABLED(HotendMosquito)
+#define VerChar2 "M"
+#endif
+
+#if(ENABLED(HotendAllMetal))
+#define VerChar3 "M"
+#else
+#define VerChar3 "S"
+#endif
+
+
+#if(ENABLED(BedAC))
+#define VerChar4 "A"
+#elif(ENABLED(BedDC))
+#define VerChar4 "D"
+#else
+#define VerChar4 "N"
+#endif
+
+#if(ENABLED(ABL_EZABL))
+#define VerChar5 "A"
+#elif(ENABLED(ABL_BLTOUCH))
+#define VerChar5 "B"
+#else
+#define VerChar5 "N"
+#endif
+
+#if(ENABLED(ABL_UBL))
+#define VerChar6 "U"
+#elif(ENABLED(ABL_BI))
+#define VerChar6 "B"
+#else
+#define VerChar6 "N"
+#endif
+
+#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION " FL " VerChar1 VerChar2 VerChar3 VerChar4 VerChar5 VerChar6

 /**
 * The STRING_DISTRIBUTION_DATE represents when the binary file was built,
 * here we define this default string as the date where the latest release
 * version was tagged.
 */
-//#define STRING_DISTRIBUTION_DATE "2023-08-04"
+#define STRING_DISTRIBUTION_DATE "2023-08-04"

 /**
 * Defines a generic printer name to be output to the LCD after booting Marlin.
 */
-//#define MACHINE_NAME "3D Printer"
+#if ENABLED(MACHINE_PRO)
+  #define MACHINEPRO " Pro"
+#else
+  #define MACHINEPRO ""
+#endif
+
+#if(ENABLED(MachineMini))
+  #define CUSTOM_MACHINE_NAME "Mini SuPeR"
+#elif(ENABLED(MachineCR10Smart))
+  #define CUSTOM_MACHINE_NAME "CR10Smart"
+#elif(ENABLED(MachineCR10SmartPro))
+  #define CUSTOM_MACHINE_NAME "CR10SmartPro"
+#elif(ENABLED(MachineEnder2))
+  #define CUSTOM_MACHINE_NAME "Ender2"
+#elif(ENABLED(MachineEnder2Pro))
+  #define CUSTOM_MACHINE_NAME "Ender2 Pro"
+#elif(ENABLED(MachineEnder3))
+  #define CUSTOM_MACHINE_NAME "Ender3" MACHINEPRO
+#elif(ENABLED(MachineEnder3Max))
+  #define CUSTOM_MACHINE_NAME "E3Max"
+#elif(ENABLED(MachineEnder6))
+  #define CUSTOM_MACHINE_NAME "Ender6"
+#elif(ENABLED(MachineEnder7))
+  #define CUSTOM_MACHINE_NAME "Ender7"
+#elif(ENABLED(MachineEnder3V2))
+  #define CUSTOM_MACHINE_NAME "Ender3V2"
+#elif(ENABLED(MachineEnder3S1))
+  #define CUSTOM_MACHINE_NAME "Ender3S1"
+#elif(ENABLED(MachineEnder4))
+  #define CUSTOM_MACHINE_NAME "Ender4"
+#elif(ENABLED(MachineEnder5))
+  #define CUSTOM_MACHINE_NAME "Ender5" MACHINEPRO
+#elif(ENABLED(MachineEnder5Plus))
+  #define CUSTOM_MACHINE_NAME "E5 Plus"
+#elif(ENABLED(MachineCR20))
+  #define CUSTOM_MACHINE_NAME "CR-20"
+#elif(ENABLED(MachineCR10Orig))
+  #define CUSTOM_MACHINE_NAME "CR-10"
+#elif(ENABLED(MachineCRX))
+  #define CUSTOM_MACHINE_NAME "CR-X"
+#elif ENABLED(MachineCR10SProV2)
+  #define CUSTOM_MACHINE_NAME "10SProV2"
+#elif(ENABLED(MachineCR10SPro))
+  #define CUSTOM_MACHINE_NAME "10S Pro"
+#elif(ENABLED(MachineCR10Max))
+  #define CUSTOM_MACHINE_NAME "CR10Max"
+#elif(ENABLED(MachineCR10SV3))
+  #define CUSTOM_MACHINE_NAME "CR10V3"
+#elif(ENABLED(MachineCR10SV2))
+  #define CUSTOM_MACHINE_NAME "CR10V2"
+#elif(ENABLED(MachineCR10Std))
+  #define CUSTOM_MACHINE_NAME "CR10300"
+#elif(ENABLED(MachineS4))
+  #define CUSTOM_MACHINE_NAME "CR10400"
+#elif(ENABLED(MachineS5))
+  #define CUSTOM_MACHINE_NAME "CR10500"
+#elif ENABLED(MachineCR2020)
+  #define CUSTOM_MACHINE_NAME "CR2020"
+#elif ENABLED(MachineSermoonD1)
+  #define CUSTOM_MACHINE_NAME "SermoonD1"
+#elif ENABLED(MachineCR5)
+  #define CUSTOM_MACHINE_NAME "CR5 Pro"
+#elif ENABLED(MachineCR30)
+  #define CUSTOM_MACHINE_NAME "CR30 Printmill"
+#endif

 /**
 * The SOURCE_CODE_URL is the location where users will find the Marlin Source
@@ -54,7 +208,7 @@
 * has a distinct Github fork— the Source Code URL should just be the main
 * Marlin repository.
 */
-//#define SOURCE_CODE_URL "github.com/MarlinFirmware/Marlin"
+#define SOURCE_CODE_URL "https://github.com/InsanityAutomation/Marlin/tree/CrealityDwin_2.0"

 /**
 * Default generic printer UUID.
@@ -65,12 +219,12 @@
 * The WEBSITE_URL is the location where users can get more information such as
 * documentation about a specific Marlin release.
 */
-//#define WEBSITE_URL "marlinfw.org"
+#define WEBSITE_URL "https://www.amazon.com/s?k=F1RST+LAYER"

 /**
 * Set the vendor info the serial USB interface, if changable
 * Currently only supported by DUE platform
 */
-//#define USB_DEVICE_VENDOR_ID           0x0000
-//#define USB_DEVICE_PRODUCT_ID          0x0000
-//#define USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
+//#define  USB_DEVICE_VENDOR_ID           0x0000
+//#define  USB_DEVICE_PRODUCT_ID          0x0000
+//#define  USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
@@ -0,0 +1,93 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Custom Bitmap for splashscreen
+ *
+ * You may use one of the following tools to generate the C++ bitmap array from
+ * a black and white image:
+ *
+ *  - http://www.marlinfw.org/tools/u8glib/converter.html
+ *  - http://www.digole.com/tools/PicturetoC_Hex_converter.php
+ */
+
+#define CUSTOM_BOOTSCREEN_TIMEOUT   2500
+#define CUSTOM_BOOTSCREEN_BMPWIDTH  128
+#define CUSTOM_BOOTSCREEN_INVERTED
+
+const unsigned char custom_start_bmp[] PROGMEM = {
+  B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,
+  B11111110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,
+  B11111100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
+  B11111100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
+  B11111100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000000,B00000001,B11110000,B00111111,
+  B11111110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000000,B00000010,B00001000,B00011111,
+  B11111100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000000,B00000101,B00000100,B00111111,
+  B11111110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000000,B00001010,B00000010,B00011111,
+  B11111100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000000,B00010101,B00000001,B00111111,
+  B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
+  B11111100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000000,B00010100,B00000001,B00111111,
+  B11111110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
+  B11111100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B00010101,B00000001,B00111111,
+  B11111110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101010,B00001010,B00000010,B00011111,
+  B11111100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010001,B00000101,B00000100,B00111111,
+  B11111110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100001,B00000010,B10001000,B00011111,
+  B11111100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010001,B00000001,B11110000,B00111111,
+  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101010,B00000000,B00000000,B00011111,
+  B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00000000,B00000000,B00111111,
+  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
+  B11111100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
+  B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
+  B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
+  B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11100000,B00101110,B11111011,B01111101,B11111011,B11111011,B11001111,B11000001,B11011111,B10111011,B00111110,B11000000,B11100001,B11111110,B00111100,B00011111,
+  B11111101,B11101110,B01111011,B00111001,B11111001,B11110011,B11001111,B10011110,B11011111,B10111011,B00111110,B11011111,B11011110,B11111100,B11011101,B11100111,
+  B11111101,B11101110,B00111011,B10111011,B11111001,B11101011,B11010111,B10111111,B01011111,B10111011,B01011110,B11011111,B11011110,B11111101,B11101101,B11110111,
+  B11111101,B11101110,B10111011,B11010011,B11111010,B11101011,B10110111,B00111111,B11011111,B10111011,B01001110,B11011111,B11011111,B11111111,B11001101,B11110011,
+  B11111101,B11101110,B11011011,B11000111,B11111010,B11101011,B10111011,B01111111,B11000000,B00111011,B01101110,B11000000,B11100011,B11111111,B00011101,B11110011,
+  B11111101,B11101110,B11001011,B11101111,B11111010,B11011011,B10111011,B01111111,B11011111,B10111011,B01100110,B11011111,B11111000,B11111111,B11001101,B11110011,
+  B11111101,B11101110,B11101011,B11101111,B11111011,B01011011,B00000011,B00111111,B01011111,B10111011,B01110110,B11011111,B11111110,B01111111,B11101101,B11110011,
+  B11111101,B11101110,B11110011,B11101111,B11111011,B01011011,B01111001,B10111110,B11011111,B10111011,B01111010,B11011111,B11011110,B01111101,B11101101,B11110111,
+  B11111101,B11101110,B11110011,B11101111,B11111011,B10111010,B11111101,B10011110,B11011111,B10111011,B01111100,B11011111,B11011110,B11111101,B11001101,B11100111,
+  B11111101,B11101110,B11111011,B11101111,B11111011,B10111010,B11111101,B11000001,B11011111,B10111011,B01111110,B11000000,B11100000,B11111110,B00011100,B00011111
+};
@@ -0,0 +1,74 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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 <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Custom Status Screen bitmap
+ *
+ * Place this file in the root with your configuration files
+ * and enable CUSTOM_STATUS_SCREEN_IMAGE in Configuration.h.
+ *
+ * Use the Marlin Bitmap Converter to make your own:
+ * http://marlinfw.org/tools/u8glib/converter.html
+ */
+
+//
+// Status Screen Logo bitmap
+//
+#define STATUS_LOGO_Y            3
+#define STATUS_LOGO_WIDTH       24
+
+const unsigned char status_logo_bmp[] PROGMEM = {
+  B11111111,B11111111,B11111111,
+  B10000000,B00000000,B00000001,
+  B10001110,B00000000,B11100001,
+  B10011111,B00000001,B11110001,
+  B10010011,B10000001,B00111001,
+  B10011111,B10000001,B11111001,
+  B10011111,B10000001,B11111001,
+  B10011111,B10111001,B11111001,
+  B10001111,B00101000,B11110001,
+  B10000000,B00111000,B00000001,
+  B10000000,B00000000,B00000001,
+  B10011111,B11111111,B11111001,
+  B10010001,B01110100,B10011001,
+  B10011011,B00000110,B10101001,
+  B10011011,B01010100,B10101001,
+  B10011011,B01010110,B10101001,
+  B10011011,B01010100,B10011001,
+  B10011111,B11111111,B11111001,
+  B11111111,B11111111,B11111111
+};
+
+//
+// Use default bitmaps
+//
+#define STATUS_HOTEND_ANIM
+#define STATUS_BED_ANIM
+#if HOTENDS < 2
+  #define STATUS_LOGO_X          8
+  #define STATUS_HEATERS_X      40
+  #define STATUS_BED_X          72
+#else
+  #define STATUS_LOGO_X          0
+  #define STATUS_HEATERS_X      32
+  #define STATUS_BED_X          80
+#endif
@@ -139,8 +139,8 @@ typedef Servo hal_servo_t;
    #error "LCD_SERIAL_PORT must be from 0 to 3."
  #endif
  #define LCD_SERIAL lcdSerial
-  #if HAS_DGUS_LCD
-    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
+    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
  #endif
 #endif

@@ -629,7 +629,7 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
  template class MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> >;
  MSerialLCD lcdSerial(MSerialLCD::HasEmergencyParser);

-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
    template<typename Cfg>
    typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::get_tx_buffer_free() {
      const ring_buffer_pos_t t = tx_buffer.tail,  // next byte to send.
@@ -209,7 +209,7 @@
    static ring_buffer_pos_t available();
    static void write(const uint8_t c);
    static void flushTX();
-    #if HAS_DGUS_LCD
+    #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
      static ring_buffer_pos_t get_tx_buffer_free();
    #endif

@@ -280,7 +280,7 @@
    static constexpr bool DROPPED_RX        = false;
    static constexpr bool RX_FRAMING_ERRORS = false;
    static constexpr bool MAX_RX_QUEUED     = false;
-    static constexpr bool RX_OVERRUNS       = ALL(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
+    static constexpr bool RX_OVERRUNS       = (ANY(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS) || ENABLED(DWINOS_4));
  };

  typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialLCD;
@@ -100,7 +100,7 @@ extern DefaultSerial1 USBSerial;
  #else
    #error "LCD_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
  #endif
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DWINOS_4)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.available()
  #endif
 #endif
@@ -113,7 +113,7 @@
  #else
    #error "LCD_SERIAL_PORT must be from 1 to 9, or -1 for Native USB."
  #endif
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)  || ENABLED(DWINOS_4)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif
@@ -40,6 +40,7 @@ struct MarlinSerial : public HardwareSerial {
  inline void begin(unsigned long baud) { begin(baud, SERIAL_8N1); }

  void _rx_complete_irq(serial_t *obj);
+  FORCE_INLINE static uint8_t buffer_overruns() { return 0; }

 protected:
  usart_rx_callback_t _rx_callback;
@@ -139,7 +139,7 @@
    #define LCD_SERIAL MSERIAL(1) // dummy port
    static_assert(false, "LCD_SERIAL_PORT must be from 1 to " STRINGIFY(NUM_UARTS) ". You can also use -1 if the board supports Native USB.")
  #endif
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(DWINOS_4)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif
@@ -197,7 +197,7 @@ void HostUI::action(FSTR_P const fstr, const bool eol) {
            #endif
            #if HAS_FILAMENT_SENSOR
              if (runout.filament_ran_out) {                      // Disable a triggered sensor
-                runout.enabled = false;
+                runout.enabled[active_extruder] = false;
                runout.reset();
              }
            #endif
@@ -136,7 +136,7 @@ void MMU2::reset() {
 int8_t MMU2::get_current_tool() { return extruder == MMU2_NO_TOOL ? -1 : extruder; }

 #if ANY(HAS_PRUSA_MMU2S, MMU_EXTRUDER_SENSOR)
-  #define FILAMENT_PRESENT() (READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE)
+  #define FILAMENT_PRESENT() (READ(FIL_RUNOUT1_PIN) != runout.out_state())
 #else
  #define FILAMENT_PRESENT() true
 #endif
@@ -212,12 +212,21 @@ bool load_filament(const_float_t slow_load_length/*=0*/, const_float_t fast_load
      impatient_beep(max_beep_count);
      #if ALL(FILAMENT_CHANGE_RESUME_ON_INSERT, FILAMENT_RUNOUT_SENSOR)
        #if MULTI_FILAMENT_SENSOR
-          #define _CASE_INSERTED(N) case N-1: if (READ(FIL_RUNOUT##N##_PIN) != FIL_RUNOUT##N##_STATE) wait_for_user = false; break;
-          switch (active_extruder) {
-            REPEAT_1(NUM_RUNOUT_SENSORS, _CASE_INSERTED)
+          LOOP_S_LE_N(i, 1, NUM_RUNOUT_SENSORS) {
+            pin_t pin;
+            switch (i) {
+              default: continue;
+              #define _CASE_RUNOUT(N) case N: pin = FIL_RUNOUT##N##_PIN; break;
+              REPEAT_1(NUM_RUNOUT_SENSORS, _CASE_RUNOUT)
+              #undef _CASE_RUNOUT
+            }
+            const RunoutMode rm = runout.mode[i - 1];
+            if (rm != RM_NONE && rm != RM_MOTION_SENSOR && extDigitalRead(pin) != runout.out_state(i - 1))
+              wait_for_user = false;
          }
        #else
-          if (READ(FIL_RUNOUT_PIN) != FIL_RUNOUT_STATE) wait_for_user = false;
+          if (READ(FIL_RUNOUT_PIN) != runout.out_state(active_extruder))
+            wait_for_user = false;
        #endif
      #endif
      idle_no_sleep();
@@ -286,7 +295,7 @@ bool load_filament(const_float_t slow_load_length/*=0*/, const_float_t fast_load
          // Show "Purge More" / "Resume" menu and wait for reply
          KEEPALIVE_STATE(PAUSED_FOR_USER);
          wait_for_user = false;
-          #if ANY(HAS_MARLINUI_MENU, DWIN_LCD_PROUI)
+          #if ANY(HAS_MARLINUI_MENU, DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI, EXTENSIBLE_UI)
            ui.pause_show_message(PAUSE_MESSAGE_OPTION); // Also sets PAUSE_RESPONSE_WAIT_FOR
          #else
            pause_menu_response = PAUSE_RESPONSE_WAIT_FOR;
@@ -678,7 +687,7 @@ void resume_print(const_float_t slow_load_length/*=0*/, const_float_t fast_load_
  #endif

  // If resume_position is negative
-  if (resume_position.e < 0) unscaled_e_move(resume_position.e, feedRate_t(PAUSE_PARK_RETRACT_FEEDRATE));
+  //if (resume_position.e < 0) unscaled_e_move(resume_position.e, feedRate_t(PAUSE_PARK_RETRACT_FEEDRATE));
  #ifdef ADVANCED_PAUSE_RESUME_PRIME
    if (ADVANCED_PAUSE_RESUME_PRIME != 0)
      unscaled_e_move(ADVANCED_PAUSE_RESUME_PRIME, feedRate_t(ADVANCED_PAUSE_PURGE_FEEDRATE));
@@ -687,7 +696,7 @@ void resume_print(const_float_t slow_load_length/*=0*/, const_float_t fast_load_
  // Now all extrusion positions are resumed and ready to be confirmed
  // Set extruder to saved position
  planner.set_e_position_mm((destination.e = current_position.e = resume_position.e));
-
+  sync_plan_position_e();
  ui.pause_show_message(PAUSE_MESSAGE_STATUS);

  #ifdef ACTION_ON_RESUMED
@@ -98,11 +98,12 @@ void Power::power_on() {
 * Processes any PSU_POWEROFF_GCODE and makes a PS_OFF_SOUND if enabled.
 */
 void Power::power_off() {
-  SERIAL_ECHOLNPGM(STR_POWEROFF);
+

  TERN_(HAS_SUICIDE, suicide());

  if (!psu_on) return;
+  SERIAL_ECHOLNPGM(STR_POWEROFF);

  #ifdef PSU_POWEROFF_GCODE
    gcode.process_subcommands_now(F(PSU_POWEROFF_GCODE));
@@ -32,9 +32,9 @@

 FilamentMonitor runout;

-bool FilamentMonitorBase::enabled = true,
-     FilamentMonitorBase::filament_ran_out;  // = false
-
+bool FilamentMonitorBase::enabled[NUM_RUNOUT_SENSORS], // Initialized by settings.load
+     FilamentMonitorBase::filament_ran_out; // = false
+RunoutMode FilamentMonitorBase::mode[NUM_RUNOUT_SENSORS]; // Initialized by settings.load
 #if ENABLED(HOST_ACTION_COMMANDS)
  bool FilamentMonitorBase::host_handling; // = false
 #endif
@@ -45,15 +45,10 @@ bool FilamentMonitorBase::enabled = true,
  #include "../core/debug_out.h"
 #endif

-#if HAS_FILAMENT_RUNOUT_DISTANCE
-  float RunoutResponseDelayed::runout_distance_mm = FILAMENT_RUNOUT_DISTANCE_MM;
-  countdown_t RunoutResponseDelayed::mm_countdown;
-  #if ENABLED(FILAMENT_MOTION_SENSOR)
-    uint8_t FilamentSensorEncoder::motion_detected;
-  #endif
-#else
-  int8_t RunoutResponseDebounced::runout_count[NUM_RUNOUT_SENSORS]; // = 0
-#endif
+float RunoutResponseDelayed::runout_distance_mm[NUM_RUNOUT_SENSORS]; // Initialized by settings.load
+countdown_t RunoutResponseDelayed::mm_countdown;
+uint8_t FilamentSensorCore::motion_detected;
+int8_t RunoutResponseDelayed::runout_count[NUM_RUNOUT_SENSORS]; // = 0

 //
 // Filament Runout event handler
@@ -44,12 +44,6 @@
  #define FILAMENT_RUNOUT_THRESHOLD 5
 #endif

-#if ENABLED(FILAMENT_MOTION_SENSOR)
-  #define HAS_FILAMENT_MOTION 1
-#endif
-#if DISABLED(FILAMENT_MOTION_SENSOR) || ENABLED(FILAMENT_SWITCH_AND_MOTION)
-  #define HAS_FILAMENT_SWITCH 1
-#endif

 typedef Flags<
          #if NUM_MOTION_SENSORS > NUM_RUNOUT_SENSORS
@@ -64,24 +58,37 @@ inline bool should_monitor_runout() { return did_pause_print || printingIsActive

 template<class RESPONSE_T, class SENSOR_T>
 class TFilamentMonitor;
-class FilamentSensor;
+class FilamentSensorCore;
 class RunoutResponseDelayed;
-class RunoutResponseDebounced;

 /********************************* TEMPLATE SPECIALIZATION *********************************/

 typedef TFilamentMonitor<
-          TERN(HAS_FILAMENT_RUNOUT_DISTANCE, RunoutResponseDelayed, RunoutResponseDebounced),
-          FilamentSensor
+          RunoutResponseDelayed,
+          FilamentSensorCore
        > FilamentMonitor;

 extern FilamentMonitor runout;

 /*******************************************************************************************/

+enum RunoutMode : uint8_t {
+  RM_NONE,
+  RM_OUT_ON_LOW,
+  RM_OUT_ON_HIGH,
+  RM_RESERVED3,
+  RM_RESERVED4,
+  RM_RESERVED5,
+  RM_RESERVED6,
+  RM_MOTION_SENSOR
+};
+
 class FilamentMonitorBase {
  public:
-    static bool enabled, filament_ran_out;
+    static bool enabled[NUM_RUNOUT_SENSORS], filament_ran_out;
+    static RunoutMode mode[NUM_RUNOUT_SENSORS];
+
+    static uint8_t out_state(const uint8_t e=0) { return mode[e] == RM_OUT_ON_HIGH ? HIGH : LOW; }

    #if ENABLED(HOST_ACTION_COMMANDS)
      static bool host_handling;
@@ -111,24 +118,14 @@ class TFilamentMonitor : public FilamentMonitorBase {

    // Call this method when filament is present,
    // so the response can reset its counter.
-    static void filament_present(const uint8_t extruder) {
-      response.filament_present(extruder);
-    }
-    #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-      static void filament_motion_present(const uint8_t extruder) {
-        response.filament_motion_present(extruder);
-      }
-    #endif
-
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      static float& runout_distance() { return response.runout_distance_mm; }
-      static void set_runout_distance(const_float_t mm) { response.runout_distance_mm = mm; }
-    #endif
+    static void filament_present(const uint8_t e) { response.filament_present(e); }
+    static float& runout_distance(const uint8_t e=0) { return response.runout_distance_mm[e]; }
+    static void set_runout_distance(const_float_t mm, const uint8_t e=0) { response.runout_distance_mm[e] = mm; }

    // Handle a block completion. RunoutResponseDelayed uses this to
    // add up the length of filament moved while the filament is out.
    static void block_completed(const block_t * const b) {
-      if (enabled) {
+      if (enabled[active_extruder]) {
        response.block_completed(b);
        sensor.block_completed(b);
      }
@@ -137,11 +134,11 @@ class TFilamentMonitor : public FilamentMonitorBase {
    // Give the response a chance to update its counter.
    static void run() {
      if (enabled && !filament_ran_out && should_monitor_runout()) {
-        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, cli()); // Prevent RunoutResponseDelayed::block_completed from accumulating here
+        cli(); // Prevent RunoutResponseDelayed::block_completed from accumulating here
        response.run();
        sensor.run();
        const runout_flags_t runout_flags = response.has_run_out();
-        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, sei());
+        sei();
        #if MULTI_FILAMENT_SENSOR
          #if ENABLED(WATCH_ALL_RUNOUT_SENSORS)
            const bool ran_out = bool(runout_flags);  // any sensor triggers
@@ -182,27 +179,40 @@ class FilamentSensorBase {
    static void filament_present(const uint8_t extruder) {
      runout.filament_present(extruder); // ...which calls response.filament_present(extruder)
    }
-    #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-      static void filament_motion_present(const uint8_t extruder) {
-        runout.filament_motion_present(extruder); // ...which calls response.filament_motion_present(extruder)
-      }
-    #endif

  public:
    static void setup() {
-      #define _INIT_RUNOUT_PIN(P,S,U,D) do{ if (ENABLED(U)) SET_INPUT_PULLUP(P); else if (ENABLED(D)) SET_INPUT_PULLDOWN(P); else SET_INPUT(P); }while(0);
-      #define  INIT_RUNOUT_PIN(N) _INIT_RUNOUT_PIN(FIL_RUNOUT##N##_PIN, FIL_RUNOUT##N##_STATE, FIL_RUNOUT##N##_PULLUP, FIL_RUNOUT##N##_PULLDOWN);
-      REPEAT_1(NUM_RUNOUT_SENSORS, INIT_RUNOUT_PIN)
-      #undef INIT_RUNOUT_PIN
-
-      #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-        #define INIT_MOTION_PIN(N) _INIT_RUNOUT_PIN(FIL_MOTION##N##_PIN, FIL_MOTION##N##_STATE, FIL_MOTION##N##_PULLUP, FIL_MOTION##N##_PULLDOWN);
-        REPEAT_1(NUM_MOTION_SENSORS, INIT_MOTION_PIN)
-        #undef  INIT_MOTION_PIN
+      #define _INIT_RUNOUT_PIN(P,S,U,D) do{ if (ENABLED(U)) SET_INPUT_PULLUP(P); else if (ENABLED(D)) SET_INPUT_PULLDOWN(P); else SET_INPUT(P); }while(0)
+      #define  INIT_RUNOUT_PIN(N) _INIT_RUNOUT_PIN(FIL_RUNOUT##N##_PIN, FIL_RUNOUT##N##_STATE, FIL_RUNOUT##N##_PULLUP, FIL_RUNOUT##N##_PULLDOWN)
+      #if NUM_RUNOUT_SENSORS >= 1
+        INIT_RUNOUT_PIN(1);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 2
+        INIT_RUNOUT_PIN(2);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 3
+        INIT_RUNOUT_PIN(3);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 4
+        INIT_RUNOUT_PIN(4);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 5
+        INIT_RUNOUT_PIN(5);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 6
+        INIT_RUNOUT_PIN(6);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 7
+        INIT_RUNOUT_PIN(7);
+      #endif
+      #if NUM_RUNOUT_SENSORS >= 8
+        INIT_RUNOUT_PIN(8);
      #endif
      #undef _INIT_RUNOUT_PIN
+      #undef  INIT_RUNOUT_PIN
    }

+
    // Return a bitmask of runout pin states
    static uint8_t poll_runout_pins() {
      #define _OR_RUNOUT(N) | (READ(FIL_RUNOUT##N##_PIN) ? _BV((N) - 1) : 0)
@@ -212,7 +222,7 @@ class FilamentSensorBase {

    // Return a bitmask of runout flag states (1 bits always indicates runout)
    static uint8_t poll_runout_states() {
-      #define _INVERT_BIT(N) | (FIL_RUNOUT##N##_STATE ? 0 : _BV(N - 1))
+      #define _INVERT_BIT(N) | (runout.out_state(N-1) ? 0 : _BV(N-1))
      return poll_runout_pins() ^ uint8_t(0 REPEAT_1(NUM_RUNOUT_SENSORS, _INVERT_BIT));
      #undef _INVERT_BIT
    }
@@ -234,17 +244,21 @@ class FilamentSensorBase {
    #endif
 };

-#if HAS_FILAMENT_MOTION
+class FilamentSensorCore : public FilamentSensorBase {
+  private:
+    static uint8_t motion_detected;

-  /**
-   * This sensor uses a magnetic encoder disc and a Hall effect
-   * sensor (or a slotted disc and optical sensor). The state
-   * will toggle between 0 and 1 on filament movement. It can detect
-   * filament runout and stripouts or jams.
-   */
-  class FilamentSensorEncoder : public FilamentSensorBase {
-    private:
-      static uint8_t motion_detected;
+    static bool poll_runout_state(const uint8_t extruder) {
+        const uint8_t runout_states = poll_runout_states();
+        #if MULTI_FILAMENT_SENSOR
+          if ( !TERN0(DUAL_X_CARRIAGE, idex_is_duplicating())
+            && !TERN0(MULTI_NOZZLE_DUPLICATION, extruder_duplication_enabled)
+          ) return TEST(runout_states, extruder); // A specific extruder ran out
+        #else
+          UNUSED(extruder);
+        #endif
+        return !!runout_states;                   // Any extruder ran out
+      }

      static void poll_motion_sensor() {
        static uint8_t old_state;
@@ -252,17 +266,17 @@ class FilamentSensorBase {
                      change    = old_state ^ new_state;
        old_state = new_state;

-        #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
-          if (change) {
-            SERIAL_ECHOPGM("Motion detected:");
-            for (uint8_t e = 0; e < TERN(FILAMENT_SWITCH_AND_MOTION, NUM_MOTION_SENSORS, NUM_RUNOUT_SENSORS); ++e)
-              if (TEST(change, e)) SERIAL_CHAR(' ', '0' + e);
-            SERIAL_EOL();
-          }
-        #endif
+      #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
+        if (change) {
+          SERIAL_ECHOPGM("Motion detected:");
+          for(uint8_t e = 0; e < NUM_RUNOUT_SENSORS; ++e)
+            if (TEST(change, e)) SERIAL_CHAR(' ', '0' + e);
+          SERIAL_EOL();
+        }
+      #endif

-        motion_detected |= change;
-      }
+      motion_detected |= change;
+    }

    public:
      static void block_completed(const block_t * const b) {
@@ -275,36 +289,12 @@ class FilamentSensorBase {
        motion_detected = 0;
      }

-      static void run() { poll_motion_sensor(); }
-  };
-
-#endif // HAS_FILAMENT_MOTION
-
-#if HAS_FILAMENT_SWITCH
-
-  /**
-   * This is a simple endstop switch in the path of the filament.
-   * It can detect filament runout, but not stripouts or jams.
-   */
-  class FilamentSensorSwitch : public FilamentSensorBase {
-    private:
-      static bool poll_runout_state(const uint8_t extruder) {
-        const uint8_t runout_states = poll_runout_states();
-        #if MULTI_FILAMENT_SENSOR
-          if ( !TERN0(DUAL_X_CARRIAGE, idex_is_duplicating())
-            && !TERN0(MULTI_NOZZLE_DUPLICATION, extruder_duplication_enabled)
-          ) return TEST(runout_states, extruder); // A specific extruder ran out
-        #else
-          UNUSED(extruder);
-        #endif
-        return !!runout_states;                   // Any extruder ran out
+    static void run() {
+      if (runout.mode[active_extruder] == RM_MOTION_SENSOR) {
+        poll_motion_sensor();
      }
-
-    public:
-      static void block_completed(const block_t * const) {}
-
-      static void run() {
-        for (uint8_t s = 0; s < NUM_RUNOUT_SENSORS; ++s) {
+      else if (runout.mode[active_extruder] != RM_NONE) {
+        for(uint8_t s = 0; s < NUM_RUNOUT_SENSORS; ++s) {
          const bool out = poll_runout_state(s);
          if (!out) filament_present(s);
          #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
@@ -316,37 +306,13 @@ class FilamentSensorBase {
          #endif
        }
      }
-  };
-
- #endif // HAS_FILAMENT_SWITCH
-
-  /**
-   * This is a simple endstop switch in the path of the filament.
-   * It can detect filament runout, but not stripouts or jams.
-   */
-  class FilamentSensor : public FilamentSensorBase {
-    private:
-      TERN_(HAS_FILAMENT_MOTION, static FilamentSensorEncoder encoder_sensor);
-      TERN_(HAS_FILAMENT_SWITCH, static FilamentSensorSwitch switch_sensor);
-
-    public:
-      static void block_completed(const block_t * const b) {
-        TERN_(HAS_FILAMENT_MOTION, encoder_sensor.block_completed(b));
-        TERN_(HAS_FILAMENT_SWITCH, switch_sensor.block_completed(b));
-      }
-
-      static void run() {
-        TERN_(HAS_FILAMENT_MOTION, encoder_sensor.run());
-        TERN_(HAS_FILAMENT_SWITCH, switch_sensor.run());
-      }
-  };
+    }
+};


 /********************************* RESPONSE TYPE *********************************/

-#if HAS_FILAMENT_RUNOUT_DISTANCE
-
-  typedef struct {
+typedef struct {
    float runout[NUM_RUNOUT_SENSORS];
    Flags<NUM_RUNOUT_SENSORS> runout_reset;    // Reset runout later
    #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
@@ -355,15 +321,16 @@ class FilamentSensorBase {
    #endif
  } countdown_t;

-  // RunoutResponseDelayed triggers a runout event only if the length
-  // of filament specified by FILAMENT_RUNOUT_DISTANCE_MM has been fed
-  // during a runout condition.
-  class RunoutResponseDelayed {
-    private:
-      static countdown_t mm_countdown;
+// RunoutResponseDelayed triggers a runout event only if the length
+// of filament specified by FIL_RUNOUT_DISTANCE_MM has been fed
+// during a runout condition.
+class RunoutResponseDelayed {
+  private:
+    static countdown_t mm_countdown;

-    public:
-      static float runout_distance_mm;
+  public:
+    static float runout_distance_mm[NUM_RUNOUT_SENSORS];
+    static int8_t runout_count[NUM_RUNOUT_SENSORS];

      static void reset() {
        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) filament_present(i);
@@ -372,116 +339,33 @@ class FilamentSensorBase {
        #endif
      }

-      static void run() {
-        #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
-          static millis_t t = 0;
-          const millis_t ms = millis();
-          if (ELAPSED(ms, t)) {
-            t = millis() + 1000UL;
-            for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i)
-              SERIAL_ECHO(i ? F(", ") : F("Runout remaining mm: "), mm_countdown.runout[i]);
+    static void run() {
+      #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
+        static millis_t t = 0;
+        const millis_t ms = millis();
+        if (ELAPSED(ms, t)) {
+          t = millis() + 1000UL;
+          for(uint8_t i; i < NUM_RUNOUT_SENSORS; ++i)
+            SERIAL_ECHO(i ? F(", ") : F("Remaining mm: "), mm_countdown[i]);
            #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
              for (uint8_t i = 0; i < NUM_MOTION_SENSORS; ++i)
                SERIAL_ECHO(i ? F(", ") : F("Motion remaining mm: "), mm_countdown.motion[i]);
            #endif
-            SERIAL_EOL();
-          }
-        #endif
-      }
-
-      static runout_flags_t has_run_out() {
-        runout_flags_t runout_flags{0};
-        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) if (mm_countdown.runout[i] < 0) runout_flags.set(i);
-        #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-          for (uint8_t i = 0; i < NUM_MOTION_SENSORS; ++i) if (mm_countdown.motion[i] < 0) runout_flags.set(i);
-        #endif
-        return runout_flags;
-      }
-
-      static void filament_present(const uint8_t extruder) {
-        if (mm_countdown.runout[extruder] < runout_distance_mm || did_pause_print) {
-          // Reset runout only if it is smaller than runout_distance or printing is paused.
-          // On Bowden systems retract may be larger than runout_distance_mm, so if retract
-          // was added leave it in place, or the following unretract will cause runout event.
-          mm_countdown.runout[extruder] = runout_distance_mm;
-          mm_countdown.runout_reset.clear(extruder);
-        }
-        else {
-          // If runout is larger than runout distance, we cannot reset right now, as Bowden and retract
-          // distance larger than runout_distance_mm leads to negative runout right after unretract.
-          // But we cannot ignore filament_present event. After unretract, runout will become smaller
-          // than runout_distance_mm and should be reset after that. So activate delayed reset.
-          mm_countdown.runout_reset.set(extruder);
-        }
-      }
-
-      #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-        static void filament_motion_present(const uint8_t extruder) {
-          // Same logic as filament_present
-          if (mm_countdown.motion[extruder] < runout_distance_mm || did_pause_print) {
-            mm_countdown.motion[extruder] = runout_distance_mm;
-            mm_countdown.motion_reset.clear(extruder);
-          }
-          else
-            mm_countdown.motion_reset.set(extruder);
+          SERIAL_EOL();
        }
      #endif
+    }

-      static void block_completed(const block_t * const b) {
-        const int32_t esteps = b->steps.e;
-        if (!esteps) return;
-
-        // No calculation unless paused or printing
-        if (!should_monitor_runout()) return;
-
-        // No need to ignore retract/unretract movement since they complement each other
-        const uint8_t e = b->extruder;
-        const float mm = (b->direction_bits.e ? esteps : -esteps) * planner.mm_per_step[E_AXIS_N(e)];
-
-        if (e < NUM_RUNOUT_SENSORS) {
-          mm_countdown.runout[e] -= mm;
-          if (mm_countdown.runout_reset[e]) filament_present(e);          // Reset pending. Try to reset.
-        }
-
-        #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-          if (e < NUM_MOTION_SENSORS) {
-            mm_countdown.motion[e] -= mm;
-            if (mm_countdown.motion_reset[e]) filament_motion_present(e); // Reset pending. Try to reset.
-          }
-        #endif
-      }
-  };
-
-#else // !HAS_FILAMENT_RUNOUT_DISTANCE
-
-  // RunoutResponseDebounced triggers a runout event after a runout
-  // condition has been detected runout_threshold times in a row.
-
-  class RunoutResponseDebounced {
-    private:
-      static constexpr int8_t runout_threshold = FILAMENT_RUNOUT_THRESHOLD;
-      static int8_t runout_count[NUM_RUNOUT_SENSORS];
-
-    public:
-      static void reset() {
-        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) filament_present(i);
-      }
-
-      static void run() {
-        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) if (runout_count[i] >= 0) runout_count[i]--;
-      }
-
-      static runout_flags_t has_run_out() {
-        runout_flags_t runout_flags{0};
+    static runout_flags_t has_run_out() {
+      runout_flags_t runout_flags{0};
        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) if (runout_count[i] < 0) runout_flags.set(i);
        return runout_flags;
-      }
+    }

      static void block_completed(const block_t * const) { }

      static void filament_present(const uint8_t extruder) {
-        runout_count[extruder] = runout_threshold;
+        runout_count[extruder] = runout_distance_mm[extruder];
      }
  };

-#endif // !HAS_FILAMENT_RUNOUT_DISTANCE
@@ -995,6 +995,9 @@ G29_TYPE GcodeSuite::G29() {
    process_subcommands_now(F(Z_PROBE_END_SCRIPT));
  #endif

+  TERN_(HAS_DWIN_E3V2_BASIC, DWIN_LevelingDone());
+  TERN_(EXTENSIBLE_UI, ExtUI::onLevelingDone());
+  TERN_(HAS_MULTI_HOTEND, if (active_extruder != 0) tool_change(0));
  probe.use_probing_tool(false);

  report_current_position();
@@ -94,7 +94,7 @@ void GcodeSuite::M600() {
                                   // In this case, for duplicating modes set DXC_ext to the extruder that ran out.
      #if MULTI_FILAMENT_SENSOR
        if (idex_is_duplicating())
-          DXC_ext = (READ(FIL_RUNOUT2_PIN) == FIL_RUNOUT2_STATE) ? 1 : 0;
+          DXC_ext = (READ(FIL_RUNOUT2_PIN) == runout.out_state(1)) ? 1 : 0;
      #else
        DXC_ext = active_extruder;
      #endif
@@ -28,36 +28,46 @@
 #include "../../../feature/runout.h"

 /**
- * M412: Enable / Disable filament runout detection
+ * M591: Configure filament runout detection
 *
 * Parameters
 *  R         : Reset the runout sensor
 *  S<bool>   : Reset and enable/disable the runout sensor
 *  H<bool>   : Enable/disable host handling of filament runout
- *  D<linear> : Extra distance to continue after runout is triggered
+ *  L<linear> : Extra distance to continue after runout is triggered or motion interval
+ *  D<linear> : Alias for L
+ *  P<index>  : Mode 0 = NONE
+ *                   1 = Switch NO (HIGH = filament present)
+ *                   2 = Switch NC (LOW = filament present)
+ *                   3 = Encoder / Motion Sensor
 */
-void GcodeSuite::M412() {
-  if (parser.seen("RS"
-    TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, "D")
-    TERN_(HOST_ACTION_COMMANDS, "H")
-  )) {
+void GcodeSuite::M591() {
+  if (parser.seen("RSDP" TERN_(HOST_ACTION_COMMANDS, "H"))) {
    #if ENABLED(HOST_ACTION_COMMANDS)
      if (parser.seen('H')) runout.host_handling = parser.value_bool();
    #endif
    const bool seenR = parser.seen_test('R'), seenS = parser.seen('S');
    if (seenR || seenS) runout.reset();
-    if (seenS) runout.enabled = parser.value_bool();
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      if (parser.seenval('D')) runout.set_runout_distance(parser.value_linear_units());
-    #endif
+    const uint8_t tool = TERN0(MULTI_FILAMENT_SENSOR, parser.ushortval('E', active_extruder));
+    if (seenS) runout.enabled[tool] = parser.value_bool();
+    if (parser.seen('D') || parser.seen('L')) runout.set_runout_distance(parser.value_linear_units(), tool);
+    if (parser.seen('P')) {
+      const RunoutMode tmp_mode = (RunoutMode)parser.value_int();
+      switch (tmp_mode) {
+        case RM_NONE ... RM_OUT_ON_HIGH:
+        case RM_MOTION_SENSOR:
+          runout.mode[tool] = tmp_mode;
+          runout.setup();
+        default: break;
+      }
+    }
  }
  else {
    SERIAL_ECHO_START();
    SERIAL_ECHOPGM("Filament runout ");
-    serialprint_onoff(runout.enabled);
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(), "mm");
-    #endif
+    serialprint_onoff(runout.enabled[active_extruder]);
+    SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(active_extruder), "mm");
+    SERIAL_ECHOPGM(" ; Mode ", runout.mode[active_extruder]);
    #if ENABLED(HOST_ACTION_COMMANDS)
      SERIAL_ECHOPGM(" ; Host handling ");
      serialprint_onoff(runout.host_handling);
@@ -66,16 +76,18 @@ void GcodeSuite::M412() {
  }
 }

-void GcodeSuite::M412_report(const bool forReplay/*=true*/) {
+void GcodeSuite::M591_report(const bool forReplay/*=true*/) {
  report_heading_etc(forReplay, F(STR_FILAMENT_RUNOUT_SENSOR));
-  SERIAL_ECHOPGM(
-    "  M412 S", runout.enabled
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      , " D", LINEAR_UNIT(runout.runout_distance())
-    #endif
-    , " ; Sensor "
-  );
-  serialprintln_onoff(runout.enabled);
+  for(int e=0; e < NUM_RUNOUT_SENSORS; e++)
+    SERIAL_ECHOLNPGM(
+      "  M591"
+      #if MULTI_FILAMENT_SENSOR
+        " E", e,
+      #endif
+        " S", runout.enabled[e]
+      , " D", LINEAR_UNIT(runout.runout_distance(e))
+      , " P", runout.mode[e]
+    );
 }

 #endif // HAS_FILAMENT_SENSOR
@@ -857,10 +857,6 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
        case 407: M407(); break;                                  // M407: Display measured filament diameter
      #endif

-      #if HAS_FILAMENT_SENSOR
-        case 412: M412(); break;                                  // M412: Enable/Disable filament runout detection
-      #endif
-
      #if HAS_MULTI_LANGUAGE
        case 414: M414(); break;                                  // M414: Select multi language menu
      #endif
@@ -935,6 +931,11 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
        case 575: M575(); break;                                  // M575: Set serial baudrate
      #endif

+      #if HAS_FILAMENT_SENSOR
+        case 412: M412(); break;                                  // Alias to M591
+        case 591: M591(); break;                                  // M591 Configure filament runout detection
+      #endif
+
      #if HAS_ZV_SHAPING
        case 593: M593(); break;                                  // M593: Input Shaping control
      #endif
@@ -234,7 +234,6 @@
 * M406 - Disable Filament Sensor flow control. (Requires FILAMENT_WIDTH_SENSOR)
 * M407 - Display measured filament diameter in millimeters. (Requires FILAMENT_WIDTH_SENSOR)
 * M410 - Quickstop. Abort all planned moves.
- * M412 - Enable / Disable Filament Runout Detection. (Requires FILAMENT_RUNOUT_SENSOR)
 * M413 - Enable / Disable Power-Loss Recovery. (Requires POWER_LOSS_RECOVERY)
 * M414 - Set language by index. (Requires LCD_LANGUAGE_2...)
 * M420 - Enable/Disable Leveling (with current values) S1=enable S0=disable (Requires MESH_BED_LEVELING or ABL)
@@ -259,6 +258,7 @@
 * M554 - Get or set IP gateway. (Requires enabled Ethernet port)
 * M569 - Enable stealthChop on an axis. (Requires at least one _DRIVER_TYPE to be TMC2130/2160/2208/2209/5130/5160)
 * M575 - Change the serial baud rate. (Requires BAUD_RATE_GCODE)
+ * M591 - Configure Filament Runout Detection. (Requires FILAMENT_RUNOUT_SENSOR)
 * M593 - Get or set input shaping parameters. (Requires INPUT_SHAPING_[XY])
 * M600 - Pause for filament change: "M600 X<pos> Y<pos> Z<raise> E<first_retract> L<later_retract>". (Requires ADVANCED_PAUSE_FEATURE)
 * M603 - Configure filament change: "M603 T<tool> U<unload_length> L<load_length>". (Requires ADVANCED_PAUSE_FEATURE)
@@ -1023,8 +1023,9 @@ private:
  #endif

  #if HAS_FILAMENT_SENSOR
-    static void M412();
-    static void M412_report(const bool forReplay=true);
+    static void M412() { M591(); }
+    static void M591();
+    static void M591_report(const bool forReplay=true);
  #endif

  #if HAS_MULTI_LANGUAGE
@@ -128,7 +128,7 @@ void GcodeSuite::M115() {
    // AUTOLEVEL (G29)
    cap_line(F("AUTOLEVEL"), ENABLED(HAS_AUTOLEVEL));

-    // RUNOUT (M412, M600)
+    // RUNOUT (M591, M600)
    cap_line(F("RUNOUT"), ENABLED(FILAMENT_RUNOUT_SENSOR));

    // Z_PROBE (G30)
@@ -361,6 +361,8 @@ void plan_arc(
        planner.apply_leveling(raw);
      #endif

+      hints.curve_radius = i > 1 ? radius : 0;
+
      // calculate safe speed for stopping by the end of the arc
      arc_mm_remaining -= segment_mm;
      hints.safe_exit_speed_sqr = _MIN(limiting_speed_sqr, 2 * limiting_accel * arc_mm_remaining);
@@ -87,7 +87,7 @@ void GcodeSuite::G30() {
        F(  " Z:"), p_float_t(measured_z, 2)
      );
      msg.echoln();
-      #if ANY(DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI)
+      #if ANY(DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI, EXTENSIBLE_UI)
        ui.set_status(msg);
      #endif
    }
@@ -489,7 +489,7 @@
 #endif

 // Extensible UI serial touch screens. (See src/lcd/extui)
-#if ANY(HAS_DGUS_LCD, MALYAN_LCD, ANYCUBIC_LCD_I3MEGA, ANYCUBIC_LCD_CHIRON, NEXTION_TFT, TOUCH_UI_FTDI_EVE)
+#if ANY(HAS_DGUS_LCD, MALYAN_LCD, TOUCH_UI_FTDI_EVE, ANYCUBIC_LCD_I3MEGA, ANYCUBIC_LCD_CHIRON, NEXTION_TFT, DGUS_LCD_UI_CREALITY_TOUCH)
  #define IS_EXTUI 1
  #define EXTENSIBLE_UI
 #endif
@@ -1172,10 +1172,14 @@
 * Fill in undefined Filament Sensor options
 */
 #if ENABLED(FILAMENT_RUNOUT_SENSOR)
+  #define HAS_FILAMENT_SENSOR 1
+  #ifndef NUM_RUNOUT_SENSORS
+    #define NUM_RUNOUT_SENSORS E_STEPPERS
+  #endif
+  #if ENABLED(MIXING_EXTRUDER)
+    #define WATCH_ALL_RUNOUT_SENSORS
+  #endif
  #if NUM_RUNOUT_SENSORS >= 1
-    #ifndef FIL_RUNOUT1_STATE
-      #define FIL_RUNOUT1_STATE FIL_RUNOUT_STATE
-    #endif
    #ifndef FIL_RUNOUT1_PULLUP
      #define FIL_RUNOUT1_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1184,9 +1188,7 @@
    #endif
  #endif
  #if NUM_RUNOUT_SENSORS >= 2
-    #ifndef FIL_RUNOUT2_STATE
-      #define FIL_RUNOUT2_STATE FIL_RUNOUT_STATE
-    #endif
+    #define MULTI_FILAMENT_SENSOR 1
    #ifndef FIL_RUNOUT2_PULLUP
      #define FIL_RUNOUT2_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1195,9 +1197,6 @@
    #endif
  #endif
  #if NUM_RUNOUT_SENSORS >= 3
-    #ifndef FIL_RUNOUT3_STATE
-      #define FIL_RUNOUT3_STATE FIL_RUNOUT_STATE
-    #endif
    #ifndef FIL_RUNOUT3_PULLUP
      #define FIL_RUNOUT3_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1206,9 +1205,6 @@
    #endif
  #endif
  #if NUM_RUNOUT_SENSORS >= 4
-    #ifndef FIL_RUNOUT4_STATE
-      #define FIL_RUNOUT4_STATE FIL_RUNOUT_STATE
-    #endif
    #ifndef FIL_RUNOUT4_PULLUP
      #define FIL_RUNOUT4_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1217,9 +1213,6 @@
    #endif
  #endif
  #if NUM_RUNOUT_SENSORS >= 5
-    #ifndef FIL_RUNOUT5_STATE
-      #define FIL_RUNOUT5_STATE FIL_RUNOUT_STATE
-    #endif
    #ifndef FIL_RUNOUT5_PULLUP
      #define FIL_RUNOUT5_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1228,9 +1221,6 @@
    #endif
  #endif
  #if NUM_RUNOUT_SENSORS >= 6
-    #ifndef FIL_RUNOUT6_STATE
-      #define FIL_RUNOUT6_STATE FIL_RUNOUT_STATE
-    #endif
    #ifndef FIL_RUNOUT6_PULLUP
      #define FIL_RUNOUT6_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1239,9 +1229,6 @@
    #endif
  #endif
  #if NUM_RUNOUT_SENSORS >= 7
-    #ifndef FIL_RUNOUT7_STATE
-      #define FIL_RUNOUT7_STATE FIL_RUNOUT_STATE
-    #endif
    #ifndef FIL_RUNOUT7_PULLUP
      #define FIL_RUNOUT7_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1250,9 +1237,6 @@
    #endif
  #endif
  #if NUM_RUNOUT_SENSORS >= 8
-    #ifndef FIL_RUNOUT8_STATE
-      #define FIL_RUNOUT8_STATE FIL_RUNOUT_STATE
-    #endif
    #ifndef FIL_RUNOUT8_PULLUP
      #define FIL_RUNOUT8_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1843,6 +1827,30 @@
  #define NEOPIXEL_BKGD_INDEX_LAST NEOPIXEL_BKGD_INDEX_FIRST
 #endif

+/*** TEMPORARY COMPATIBILITY ***/
+
+#if HAS_FILAMENT_SENSOR
+  #ifndef FIL_RUNOUT_ENABLED
+    #if FIL_RUNOUT_ENABLED_DEFAULT
+      #define FIL_RUNOUT_ENABLED ARRAY_N_1(NUM_RUNOUT_SENSORS, true)
+    #else
+      #define FIL_RUNOUT_ENABLED ARRAY_N_1(NUM_RUNOUT_SENSORS, false)
+    #endif
+  #endif
+  #ifndef FIL_RUNOUT_MODE
+    #if FIL_RUNOUT_STATE
+      #define FIL_RUNOUT_MODE ARRAY_N_1(NUM_RUNOUT_SENSORS, 1)
+    #else
+      #define FIL_RUNOUT_MODE ARRAY_N_1(NUM_RUNOUT_SENSORS, 2)
+    #endif
+  #endif
+  #ifndef FIL_RUNOUT_DISTANCE_MM
+    #define FIL_RUNOUT_DISTANCE_MM ARRAY_N_1(NUM_RUNOUT_SENSORS, 10)
+  #endif
+  #undef FIL_RUNOUT_ENABLED_DEFAULT
+  #undef FIL_RUNOUT_STATE
+  #undef FILAMENT_RUNOUT_DISTANCE_MM
+#endif
 #if ALL(SPI_FLASH, HAS_MEDIA, MARLIN_DEV_MODE)
  #define SPI_FLASH_BACKUP 1
 #endif
@@ -2893,7 +2893,7 @@
  #define HAS_TEMPERATURE 1
 #endif

-#if HAS_TEMPERATURE && ANY(HAS_MARLINUI_MENU, HAS_DWIN_E3V2, HAS_DGUS_LCD_CLASSIC)
+#if HAS_TEMPERATURE && ANY(HAS_MARLINUI_MENU, HAS_DWIN_E3V2, HAS_DGUS_LCD_CLASSIC, DGUS_LCD_UI_CREALITY_TOUCH)
  #ifdef PREHEAT_10_LABEL
    #define PREHEAT_COUNT 10
  #elif defined(PREHEAT_9_LABEL)
@@ -543,10 +543,71 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
    #error "You can't enable FIL_RUNOUT7_PULLUP and FIL_RUNOUT7_PULLDOWN at the same time."
  #elif ALL(FIL_RUNOUT8_PULLUP, FIL_RUNOUT8_PULLDOWN)
    #error "You can't enable FIL_RUNOUT8_PULLUP and FIL_RUNOUT8_PULLDOWN at the same time."
-  #elif FILAMENT_RUNOUT_DISTANCE_MM < 0
-    #error "FILAMENT_RUNOUT_DISTANCE_MM must be greater than or equal to zero."
-  #elif DISABLED(ADVANCED_PAUSE_FEATURE) && defined(FILAMENT_RUNOUT_SCRIPT)
+  #elif DISABLED(ADVANCED_PAUSE_FEATURE)
    static_assert(nullptr == strstr(FILAMENT_RUNOUT_SCRIPT, "M600"), "ADVANCED_PAUSE_FEATURE is required to use M600 with FILAMENT_RUNOUT_SENSOR.");
+  #elif defined(FIL_RUNOUT_ENABLED_DEFAULT)
+    #error "FIL_RUNOUT_ENABLED_DEFAULT is now set with the FILAMENT_RUNOUT_ENABLED array."
+  #elif defined(FILAMENT_RUNOUT_DISTANCE_MM)
+    #error "FILAMENT_RUNOUT_DISTANCE_MM is now set with the FIL_RUNOUT_DISTANCE_MM array."
+  #elif defined(FIL_RUNOUT_STATE) || defined(FIL_RUNOUT2_STATE) || defined(FIL_RUNOUT3_STATE) || defined(FIL_RUNOUT4_STATE) || defined(FIL_RUNOUT5_STATE) || defined(FIL_RUNOUT6_STATE) || defined(FIL_RUNOUT7_STATE) || defined(FIL_RUNOUT8_STATE)
+    #ifdef FIL_RUNOUT_STATE
+      #if FIL_RUNOUT_STATE
+        #error "FIL_RUNOUT_STATE HIGH is now set with FIL_RUNOUT_MODE { 2 ... }."
+      #else
+        #error "FIL_RUNOUT_STATE LOW is now set with FIL_RUNOUT_MODE { 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT2_STATE
+      #if FIL_RUNOUT2_STATE
+        #error "FIL_RUNOUT2_STATE HIGH is now set with FIL_RUNOUT_MODE { n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT2_STATE LOW is now set with FIL_RUNOUT_MODE { n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT3_STATE
+      #if FIL_RUNOUT3_STATE
+        #error "FIL_RUNOUT3_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT3_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT4_STATE
+      #if FIL_RUNOUT4_STATE
+        #error "FIL_RUNOUT4_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT4_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT5_STATE
+      #if FIL_RUNOUT5_STATE
+        #error "FIL_RUNOUT5_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT5_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT6_STATE
+      #if FIL_RUNOUT6_STATE
+        #error "FIL_RUNOUT6_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT6_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT7_STATE
+      #if FIL_RUNOUT7_STATE
+        #error "FIL_RUNOUT7_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT7_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, n, n, n, 1 ... }."
+      #endif
+    #endif
+    #ifdef FIL_RUNOUT8_STATE
+      #if FIL_RUNOUT8_STATE
+        #error "FIL_RUNOUT8_STATE HIGH is now set with FIL_RUNOUT_MODE { n, n, n, n, n, n, n, 2 ... }."
+      #else
+        #error "FIL_RUNOUT8_STATE LOW is now set with FIL_RUNOUT_MODE { n, n, n, n, n, n, n, 1 ... }."
+      #endif
+    #endif
+  #elif ENABLED(FILAMENT_MOTION_SENSOR)
+    #error "FILAMENT_MOTION_SENSOR is now set with FIL_RUNOUT_MODE { 7 ... }."
  #endif
 #endif

@@ -1476,14 +1537,16 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
 #endif

 #if ENABLED(LCD_BED_TRAMMING)
-  #ifndef BED_TRAMMING_INSET_LFRB
-    #error "LCD_BED_TRAMMING requires BED_TRAMMING_INSET_LFRB values."
-  #elif ENABLED(BED_TRAMMING_USE_PROBE)
+  #if ENABLED(BED_TRAMMING_USE_PROBE)
    #if !HAS_BED_PROBE
      #error "BED_TRAMMING_USE_PROBE requires a real probe."
    #elif ENABLED(SENSORLESS_PROBING)
      #error "BED_TRAMMING_USE_PROBE is incompatible with SENSORLESS_PROBING."
    #endif
+  #else
+    #ifndef BED_TRAMMING_INSET_LFRB
+      #error "LCD_BED_TRAMMING requires BED_TRAMMING_INSET_LFRB values."
+    #endif
  #endif
 #endif

@@ -2583,7 +2646,7 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
  + COUNT_ENABLED(ANYCUBIC_LCD_I3MEGA, ANYCUBIC_LCD_CHIRON, ANYCUBIC_TFT35, ANYCUBIC_LCD_VYPER) \
  + DGUS_UI_IS(ORIGIN) + DGUS_UI_IS(FYSETC) + DGUS_UI_IS(HIPRECY) + DGUS_UI_IS(MKS) + DGUS_UI_IS(RELOADED) + DGUS_UI_IS(IA_CREALITY) \
  + COUNT_ENABLED(ENDER2_STOCKDISPLAY, CR10_STOCKDISPLAY) \
-  + COUNT_ENABLED(DWIN_CREALITY_LCD, DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI, DWIN_MARLINUI_PORTRAIT, DWIN_MARLINUI_LANDSCAPE) \
+  + COUNT_ENABLED(DWIN_CREALITY_LCD, DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI, DWIN_MARLINUI_PORTRAIT, DWIN_MARLINUI_LANDSCAPE, DGUS_LCD_UI_CREALITY_TOUCH) \
  + COUNT_ENABLED(FYSETC_MINI_12864_X_X, FYSETC_MINI_12864_1_2, FYSETC_MINI_12864_2_0, FYSETC_GENERIC_12864_1_1) \
  + COUNT_ENABLED(LCD_SAINSMART_I2C_1602, LCD_SAINSMART_I2C_2004) \
  + COUNT_ENABLED(MKS_12864OLED, MKS_12864OLED_SSD1306) \
@@ -3453,9 +3516,9 @@ static_assert(_PLUS_TEST(3), "DEFAULT_MAX_ACCELERATION values must be positive."
  #error "LED_CONTROL_MENU requires an LCD controller that implements the menu."
 #endif

-#if ENABLED(CUSTOM_MENU_MAIN) && NONE(HAS_MARLINUI_MENU, TOUCH_UI_FTDI_EVE, TFT_LVGL_UI)
-  #error "CUSTOM_MENU_MAIN requires an LCD controller that implements the menu."
-#endif
+//#if ENABLED(CUSTOM_MENU_MAIN) && NONE(HAS_MARLINUI_MENU, TOUCH_UI_FTDI_EVE, TFT_LVGL_UI)
+  //#error "CUSTOM_MENU_MAIN requires an LCD controller that implements the menu."
+//#endif

 #if ENABLED(CASE_LIGHT_USE_NEOPIXEL) && DISABLED(NEOPIXEL_LED)
  #error "CASE_LIGHT_USE_NEOPIXEL requires NEOPIXEL_LED."
@@ -2935,7 +2935,11 @@ void hmiControl() {
  void hmiLeveling() {
    popupWindowLeveling();
    dwinUpdateLCD();
-    queue.inject(F("G28O\nG29"));
+    #if defined(MAIN_MENU_ITEM_1_GCODE)
+      queue.inject(F(MAIN_MENU_ITEM_1_GCODE));
+    #else
+      queue.inject(F("G28O\nG29\nG28\nG1Z0"));
+    #endif
  }
 #endif

@@ -4053,8 +4057,8 @@ void hmiInit() {
  hmiSDCardInit();

  for (uint16_t t = 0; t <= 100; t += 2) {
-    dwinIconShow(ICON, ICON_Bar, 15, 260);
-    dwinDrawRectangle(1, COLOR_BG_BLACK, 15 + t * 242 / 100, 260, 257, 280);
+    dwinIconShow(ICON, ICON_Bar, 15, 450);
+    dwinDrawRectangle(1, COLOR_BG_BLACK, 15 + t * 242 / 100, 450, 257, 470);
    dwinUpdateLCD();
    delay(20);
  }
@@ -48,6 +48,7 @@ void dwinStartup() {
  dwinFrameClear(COLOR_BG_BLACK); // MarlinUI handles the bootscreen so just clear here
  dwinJPGShowAndCache(3);
  dwinUpdateLCD();
+  dwinJPGShowAndCache(3);
 }

 /*---------------------------------------- Picture related functions ----------------------------------------*/
@@ -108,8 +108,8 @@ void MarlinUI::clear_lcd() {
      #define INFO_CENTER ((LCD_PIXEL_WIDTH) - 200 / 2)
      #define VERSION_Y   84
    #endif
-
-    dwinDrawString(false, font10x20, COLOR_YELLOW, COLOR_BG_BLACK, INFO_CENTER - (dwin_string.length * 10) / 2, VERSION_Y, S(dwin_string.string()));
+    dwinJPGShowAndCache(0); // Ensure DACAI stays on boot screen
+    dwinDrawString(false, font10x20, COLOR_YELLOW, COLOR_BG_BLACK, INFO_CENTER - (dwin_string.length * 10) / 2, 230, S(dwin_string.string()));
    TERN_(SHOW_CUSTOM_BOOTSCREEN, safe_delay(CUSTOM_BOOTSCREEN_TIMEOUT));
    clear_lcd();

@@ -199,7 +199,7 @@ typedef struct {
 } select_t;
 select_t select_page{0}, select_print{0};

-#if ENABLED(LCD_BED_TRAMMING)
+#if ENABLED(LCD_BED_TRAMMING) && DISABLED(BED_TRAMMING_USE_PROBE)
  constexpr float bed_tramming_inset_lfbr[] = BED_TRAMMING_INSET_LFRB;
 #endif

@@ -2220,12 +2220,12 @@ void setMoveZ() { hmiValue.axis = Z_AXIS; setPFloatOnClick(Z_MIN_POS, Z_MAX_POS,
 #if HAS_FILAMENT_SENSOR
  void setRunoutEnable() {
    runout.reset();
-    toggleCheckboxLine(runout.enabled);
+    runout.enabled[0] = !runout.enabled[0];
+    Draw_Chkb_Line(CurrentMenu->line(), runout.enabled[0]);
+    DWIN_UpdateLCD();
  }
-  #if HAS_FILAMENT_RUNOUT_DISTANCE
-    void applyRunoutDistance() { runout.set_runout_distance(menuData.value / MINUNITMULT); }
-    void setRunoutDistance() { setFloatOnClick(0, 999, UNITFDIGITS, runout.runout_distance(), applyRunoutDistance); }
-  #endif
+  void ApplyRunoutDistance() { runout.set_runout_distance(MenuData.Value / MINUNITMULT); }
+  void SetRunoutDistance() { SetFloatOnClick(0, 999, UNITFDIGITS, runout.runout_distance(), ApplyRunoutDistance); }
 #endif

 #if ENABLED(ADVANCED_PAUSE_FEATURE)
@@ -2290,6 +2290,11 @@ void setFlow() { setPIntOnClick(MIN_PRINT_FLOW, MAX_PRINT_FLOW, []{ planner.refr
 #if ENABLED(LCD_BED_TRAMMING)

  void tramXY(const uint8_t point, float &x, float &y) {
+    #if ENABLED(BED_TRAMMING_USE_PROBE)
+      float bed_tramming_inset_lfbr[] = {X_MIN_BED + probe.min_x() + 0.01f, Y_MIN_BED + probe.min_y() + 0.01f,
+             X_MAX_BED - probe.max_x() - 0.01f, Y_MAX_BED - probe.max_y() - 0.01f };
+    #endif
+
    switch (point) {
      case 0:
        LCD_MESSAGE(MSG_TRAM_FL);
@@ -83,7 +83,7 @@ void ESDiag::update() {
  TERN_(USE_X_MIN, ES_REPORT(X_MIN)); TERN_(USE_X_MAX, ES_REPORT(X_MAX));
  TERN_(USE_Y_MIN, ES_REPORT(Y_MIN)); TERN_(USE_Y_MAX, ES_REPORT(Y_MAX));
  TERN_(USE_Z_MIN, ES_REPORT(Z_MIN)); TERN_(USE_Z_MAX, ES_REPORT(Z_MAX));
-  TERN_(HAS_FILAMENT_SENSOR, draw_es_state(READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE));
+  TERN_(HAS_FILAMENT_SENSOR, draw_es_state(READ(FIL_RUNOUT1_PIN) != runout.out_state());
  dwinUpdateLCD();
 }

@@ -0,0 +1,357 @@
+/**
+ * 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/>.
+ *
+ */
+
+/* DGUS implementation written by coldtobi in 2019 for Marlin */
+
+#include "../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+
+#define DEBUG_ECHOLNPAIR DEBUG_ECHOLNPGM
+
+#if HOTENDS > 2
+  #error "More than 2 hotends not implemented on the Display UI design."
+#endif
+
+#include "../ui_api.h"
+
+#include "../../../MarlinCore.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"
+#if ENABLED(POWER_LOSS_RECOVERY)
+  #include "../../../feature/powerloss.h"
+#endif
+
+#include "DGUSDisplay.h"
+#include "DGUSVPVariable.h"
+#include "DGUSDisplayDef.h"
+
+// Preamble... 2 Bytes, usually 0x5A 0xA5, but configurable
+constexpr uint8_t DGUS_HEADER1 = 0x5A;
+constexpr uint8_t DGUS_HEADER2 = 0xA5;
+
+constexpr uint8_t DGUS_CMD_WRITEVAR = 0x82;
+constexpr uint8_t DGUS_CMD_READVAR = 0x83;
+
+#if ENABLED(DEBUG_DGUSLCD)
+  bool dguslcd_local_debug; // = false;
+#endif
+
+#define dgusserial LCD_SERIAL
+
+void DGUSDisplay::InitDisplay() {
+  dgusserial.begin(LCD_BAUDRATE);
+
+  /*delay(500); // Attempt to fix possible handshake error
+
+  ResetDisplay(); // Reset for firmware update
+
+  delay(500); // Attempt to fix possible handshake error
+*/
+  if (true
+    #if ENABLED(POWER_LOSS_RECOVERY)
+      && !recovery.valid()
+    #endif
+  )
+    RequestScreen(
+      #if ENABLED(SHOW_BOOTSCREEN)
+        DGUSLCD_SCREEN_BOOT
+      #else
+        DGUSLCD_SCREEN_MAIN
+      #endif
+    );
+}
+
+void DGUSDisplay::ResetDisplay() {
+  SERIAL_ECHOLN("ResetDisplay");
+  const unsigned char resetCommand[] = { 0x55, 0xAA, 0x5A, 0xA5 };
+  WriteVariable(0x04, resetCommand, sizeof(resetCommand));
+}
+
+void DGUSDisplay::ReadVariable(uint16_t adr) {
+  WriteHeader(adr, DGUS_CMD_READVAR, sizeof(uint8_t));
+
+  // Specify to read one byte
+  dgusserial.write(static_cast<uint8_t>(1));
+}
+
+void DGUSDisplay::WriteVariable(uint16_t adr, const void* values, uint8_t valueslen, bool isstr, char fillChar) {
+  const char* myvalues = static_cast<const char*>(values);
+  bool strend = !myvalues;
+  WriteHeader(adr, DGUS_CMD_WRITEVAR, valueslen);
+  while (valueslen--) {
+    char x;
+    if (!strend) x = *myvalues++;
+    if ((isstr && !x) || strend) {
+      strend = true;
+      x = fillChar;
+    }
+    dgusserial.write(x);
+  }
+}
+
+void DGUSDisplay::WriteVariable(uint16_t adr, uint16_t value) {
+  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) {
+  union { int16_t l; char lb[2]; } endian;
+  char tmp[2];
+  endian.l = value;
+  tmp[0] = endian.lb[1];
+  tmp[1] = endian.lb[0];
+
+  WriteVariable(adr, static_cast<const void*>(&tmp), sizeof(int16_t));
+}
+
+void DGUSDisplay::WriteVariable(uint16_t adr, uint8_t value) {
+  WriteVariable(adr, static_cast<const void*>(&value), sizeof(uint8_t));
+}
+
+void DGUSDisplay::WriteVariable(uint16_t adr, int8_t value) {
+  WriteVariable(adr, static_cast<const void*>(&value), sizeof(int8_t));
+}
+
+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));
+}
+
+void DGUSDisplay::WriteVariable(uint16_t adr, float value) {
+    static_assert(sizeof(float) == 4);
+
+    union { float 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(float));
+}
+
+void DGUSDisplay::WriteVariablePGM(uint16_t adr, const void* values, uint8_t valueslen, bool isstr, char fillChar) {
+  const char* myvalues = static_cast<const char*>(values);
+  bool strend = !myvalues;
+  WriteHeader(adr, DGUS_CMD_WRITEVAR, valueslen);
+  while (valueslen--) {
+    char x;
+    if (!strend) x = pgm_read_byte(myvalues++);
+    if ((isstr && !x) || strend) {
+      strend = true;
+      x = fillChar;
+    }
+    dgusserial.write(x);
+  }
+}
+
+void DGUSDisplay::SetVariableDisplayColor(uint16_t sp, uint16_t color) {
+  WriteVariable(sp + 0x03, color);
+}
+
+void DGUSDisplay::ProcessRx() {
+
+  #if ENABLED(DGUS_SERIAL_STATS_RX_BUFFER_OVERRUNS)
+    if (!dgusserial.available() && dgusserial.buffer_overruns()) {
+      // Overrun, but reset the flag only when the buffer is empty
+      // We want to extract as many as valid datagrams possible...
+      DEBUG_ECHOPGM("OVFL");
+      rx_datagram_state = DGUS_IDLE;
+      //dgusserial.reset_rx_overun();
+      dgusserial.flush();
+    }
+  #endif
+
+  uint8_t receivedbyte;
+  while (dgusserial.available()) {
+    switch (rx_datagram_state) {
+
+      case DGUS_IDLE: // Waiting for the first header byte
+        receivedbyte = dgusserial.read();
+        //DEBUGLCDCOMM_ECHOPAIR("< ",receivedbyte);
+        if (DGUS_HEADER1 == receivedbyte) rx_datagram_state = DGUS_HEADER1_SEEN;
+        break;
+
+      case DGUS_HEADER1_SEEN: // Waiting for the second header byte
+        receivedbyte = dgusserial.read();
+        //DEBUGLCDCOMM_ECHOPAIR(" ", receivedbyte);
+        rx_datagram_state = (DGUS_HEADER2 == receivedbyte) ? DGUS_HEADER2_SEEN : DGUS_IDLE;
+        break;
+
+      case DGUS_HEADER2_SEEN: // Waiting for the length byte
+        rx_datagram_len = dgusserial.read();
+        //DEBUGLCDCOMM_ECHOPAIR(" (", rx_datagram_len, ") ");
+
+        // Telegram min len is 3 (command and one word of payload)
+        rx_datagram_state = WITHIN(rx_datagram_len, 3, DGUS_RX_BUFFER_SIZE) ? DGUS_WAIT_TELEGRAM : DGUS_IDLE;
+        break;
+
+      case DGUS_WAIT_TELEGRAM: // wait for complete datagram to arrive.
+        if (dgusserial.available() < rx_datagram_len) return;
+
+        Initialized = true; // We've talked to it, so we defined it as initialized.
+        uint8_t command = dgusserial.read();
+
+       // DEBUGLCDCOMM_ECHOPAIR("# ", command);
+
+        uint8_t readlen = rx_datagram_len - 1;  // command is part of len.
+        unsigned char tmp[rx_datagram_len - 1];
+        unsigned char *ptmp = tmp;
+        while (readlen--) {
+          receivedbyte = dgusserial.read();
+          //DEBUGLCDCOMM_ECHOPAIR(" ", receivedbyte);
+          *ptmp++ = receivedbyte;
+        }
+        //DEBUGLCDCOMM_ECHOPGM(" # ");
+        // mostly we'll get this: 5A A5 03 82 4F 4B -- ACK on 0x82, so discard it.
+        if (command == DGUS_CMD_WRITEVAR && 'O' == tmp[0] && 'K' == tmp[1]) {
+          //DEBUG_ECHOLNPGM(">");
+          rx_datagram_state = DGUS_IDLE;
+          break;
+        }
+
+        /* AutoUpload, (and answer to) Command 0x83 :
+        |      tmp[0  1  2  3  4 ... ]
+        | Example 5A A5 06 83 20 01 01 78 01 ……
+        |          / /  |  |   \ /   |  \     \
+        |        Header |  |    |    |   \_____\_ DATA (Words!)
+        |     DatagramLen  /  VPAdr  |
+        |           Command          DataLen (in Words) */
+        if (command == DGUS_CMD_READVAR) {
+          const uint16_t vp = tmp[0] << 8 | tmp[1];
+
+          //const uint8_t dlen = tmp[2] << 1;  // Convert to Bytes. (Display works with words)
+          //DEBUG_ECHOPAIR(" vp=", vp, " dlen=", dlen);
+          DGUS_VP_Variable ramcopy;
+          DEBUG_ECHOLNPAIR("VP received: ", vp , " - val ", tmp[3]);
+          if (populate_VPVar(vp, &ramcopy)) {
+            if (ramcopy.set_by_display_handler)
+              ramcopy.set_by_display_handler(ramcopy, &tmp[3]);
+            else
+              DEBUG_ECHOLNPGM(" VPVar found, no handler.");
+          }
+          else
+            DEBUG_ECHOLNPAIR(" VPVar not found:", vp);
+
+          rx_datagram_state = DGUS_IDLE;
+          break;
+        }
+
+      // discard anything else
+      rx_datagram_state = DGUS_IDLE;
+    }
+  }
+}
+
+size_t DGUSDisplay::GetFreeTxBuffer() { return SERIAL_GET_TX_BUFFER_FREE(); }
+
+void DGUSDisplay::WriteHeader(uint16_t adr, uint8_t cmd, uint8_t payloadlen) {
+  dgusserial.write(DGUS_HEADER1);
+  dgusserial.write(DGUS_HEADER2);
+  dgusserial.write(payloadlen + 3);
+  dgusserial.write(cmd);
+  dgusserial.write(adr >> 8);
+  dgusserial.write(adr & 0xFF);
+}
+
+void DGUSDisplay::WritePGM(const char str[], uint8_t len) {
+  while (len--) dgusserial.write(pgm_read_byte(str++));
+}
+
+void DGUSDisplay::loop() {
+  // protect against recursion… ProcessRx() may indirectly call idle() when injecting gcode commands.
+  if (!no_reentrance) {
+    no_reentrance = true;
+    ProcessRx();
+    //Because crappy VPHELPER macros cant take calcs or functions, process updated value here. If we handle only in button handler code, we will miss changes over M290
+    dgusdisplay.WriteVariable(VP_Z_OFFSET, (int16_t)(100*ExtUI::getZOffset_mm()));
+
+    no_reentrance = false;
+  }
+}
+
+void DGUSDisplay::RequestScreen(DGUSLCD_Screens screen) {
+  displayRequest = screen;
+
+  DEBUG_ECHOLNPAIR("GotoScreen ", screen);
+  const unsigned char gotoscreen[] = { 0x5A, 0x01, (unsigned char) (screen >> 8U), (unsigned char) (screen & 0xFFU) };
+  WriteVariable(0x84, gotoscreen, sizeof(gotoscreen));
+}
+
+void DGUSDisplay::SetTouchScreenConfiguration(bool enable_standby, bool enable_sound, uint8_t standby_brightness, uint8_t brightness, uint16_t standbyTimeSeconds) {
+  // Main configuration (System_Config)
+  unsigned char cfg_bits = 0x0;
+  cfg_bits |= 1UL << 5; // 5: load 22 touch file
+  cfg_bits |= 1UL << 4; // 4: auto-upload should always be enabled
+  if (enable_sound) cfg_bits |= 1UL << 3; // 3: audio
+  if (enable_standby) cfg_bits |= 1UL << 2; // 2: backlight on standby
+  cfg_bits |= 1UL << 1; // 1 & 0: 270 degrees orientation of display
+  cfg_bits |= 1UL << 0;
+
+  DEBUG_ECHOLNPAIR("Update touch screen config - standby ", enable_standby);
+  DEBUG_ECHOLNPAIR("Update touch screen config - sound ", enable_sound);
+
+  const unsigned char config_set[] = { 0x5A, 0x00, (unsigned char) (cfg_bits >> 8U), (unsigned char) (cfg_bits & 0xFFU) };
+  WriteVariable(0x80 /*System_Config*/, config_set, sizeof(config_set));
+
+  // Standby brightness (LED_Config)
+  uint16_t dwinStandbyTimeSeconds = 100 * standbyTimeSeconds;  /* milliseconds, but divided by 10 (not 5 like the docs say) */
+  const unsigned char brightness_set[] = {
+    brightness /*% active*/,
+    standby_brightness /*% standby*/,
+    static_cast<uint8_t>(dwinStandbyTimeSeconds >> 8),
+    static_cast<uint8_t>(dwinStandbyTimeSeconds)
+  };
+  WriteVariable(0x82 /*LED_Config*/, brightness_set, sizeof(brightness_set));
+}
+
+rx_datagram_state_t DGUSDisplay::rx_datagram_state = DGUS_IDLE;
+uint8_t DGUSDisplay::rx_datagram_len = 0;
+bool DGUSDisplay::Initialized = false;
+bool DGUSDisplay::no_reentrance = false;
+DGUSLCD_Screens DGUSDisplay::displayRequest = DGUSLCD_SCREEN_BOOT;
+
+// A SW memory barrier, to ensure GCC does not overoptimize loops
+#define sw_barrier() asm volatile("": : :"memory");
+
+bool populate_VPVar(const uint16_t VP, DGUS_VP_Variable * const ramcopy) {
+  //DEBUG_ECHOLNPAIR("populate_VPVar ", VP);
+  const DGUS_VP_Variable *pvp = DGUSLCD_FindVPVar(VP);
+  // DEBUG_ECHOLNPAIR(" pvp ", (uint16_t )pvp);
+  if (!pvp) return false;
+  memcpy_P(ramcopy, pvp, sizeof(DGUS_VP_Variable));
+  return true;
+}
+
+#endif // HAS_DGUS_LCD
@@ -0,0 +1,136 @@
+/**
+ * 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
+
+//#define DEBUG_DGUSLCD
+//#define DEBUG_DGUSLCD_OUTGOING_COMM
+
+
+/* Creality DGUS implementation written by Sebastiaan Dammann in 2020 for Marlin */
+
+#include "../../../inc/MarlinConfigPre.h"
+
+#include "../../../MarlinCore.h"
+#if HAS_BED_PROBE
+  #include "../../../module/probe.h"
+#endif
+
+#include "DGUSVPVariable.h"
+
+enum DGUSLCD_Screens : uint8_t;
+
+#ifndef DEBUG_OUT
+#define DEBUG_OUT ENABLED(DEBUG_DGUSLCD)
+#endif
+
+#include "../../../core/debug_out.h"
+
+
+typedef enum : uint8_t {
+  DGUS_IDLE,           //< waiting for DGUS_HEADER1.
+  DGUS_HEADER1_SEEN,   //< DGUS_HEADER1 received
+  DGUS_HEADER2_SEEN,   //< DGUS_HEADER2 received
+  DGUS_WAIT_TELEGRAM,  //< LEN received, Waiting for to receive all bytes.
+} rx_datagram_state_t;
+
+typedef void (*UPDATE_CURRENT_SCREEN_CALLBACK)(DGUSLCD_Screens screen);
+
+// Low-Level access to the display.
+class DGUSDisplay {
+public:
+
+  DGUSDisplay() = default;
+
+  static void InitDisplay();
+  static void ResetDisplay();
+
+  // Variable access.
+  static void WriteVariable(uint16_t adr, const void* values, uint8_t valueslen, bool isstr=false, char fillChar = ' ');
+  static void WriteVariablePGM(uint16_t adr, const void* values, uint8_t valueslen, bool isstr=false, char fillChar = ' ');
+  static void WriteVariable(uint16_t adr, int16_t value);
+  static void WriteVariable(uint16_t adr, uint16_t value);
+  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 WriteVariable(uint16_t adr, float value);
+
+  static void SetVariableDisplayColor(uint16_t sp, uint16_t color);
+
+  static void ReadVariable(uint16_t adr);
+
+  // Utility functions for bridging ui_api and dgus
+  template<typename T, float(*Getter)(const T), T selector, typename WireType=uint16_t>
+  static void SetVariable(DGUS_VP_Variable &var) {
+    WriteVariable(var.VP, (WireType)Getter(selector));
+  }
+
+  template<typename T, void(*Setter)(const float V, const T), T selector>
+  static void GetVariable(DGUS_VP_Variable &var, void *val_ptr) {
+    uint16_t newvalue = swap16(*(uint16_t*)val_ptr);
+    Setter(newvalue, selector);
+  }
+
+  // Force display into another screen.
+  // (And trigger update of containing VPs)
+  // (to implement a pop up message, which may not be nested)
+  static void RequestScreen(DGUSLCD_Screens screen);
+
+  static void SetTouchScreenConfiguration(bool enable_standby, bool enable_sound, uint8_t standby_brightness, uint8_t active_brightness, uint16_t standbyTimeSeconds);
+
+  // Periodic tasks, eg. Rx-Queue handling.
+  static void loop();
+
+public:
+  // Helper for users of this class to estimate if an interaction would be blocking.
+  static size_t GetFreeTxBuffer();
+
+  // Checks two things: Can we confirm the presence of the display and has we initiliazed it.
+  // (both boils down that the display answered to our chatting)
+  static inline bool isInitialized() { return Initialized; }
+
+private:
+  static void WriteHeader(uint16_t adr, uint8_t cmd, uint8_t payloadlen);
+  static void WritePGM(const char str[], uint8_t len);
+  static void ProcessRx();
+
+  static inline uint16_t swap16(const uint16_t value) { return (value & 0xffU) << 8U | (value >> 8U); }
+  static rx_datagram_state_t rx_datagram_state;
+  static uint8_t rx_datagram_len;
+  static bool Initialized, no_reentrance;
+
+  static DGUSLCD_Screens displayRequest;
+};
+
+#define GET_VARIABLE(f, t, V...) (&DGUSDisplay::GetVariable<decltype(t), f, t, ##V>)
+#define SET_VARIABLE(f, t, V...) (&DGUSDisplay::SetVariable<decltype(t), f, t, ##V>)
+
+extern DGUSDisplay dgusdisplay;
+
+// compile-time x^y
+template<typename T>
+constexpr T cpow(const T x, const int y) { return y == 0 ? 1.0 : x * cpow(x, y - 1); }
+
+/// Find the flash address of a DGUS_VP_Variable for the VP.
+const DGUS_VP_Variable* DGUSLCD_FindVPVar(const uint16_t vp);
+
+/// Helper to populate a DGUS_VP_Variable for a given VP. Return false if not found.
+bool populate_VPVar(const uint16_t VP, DGUS_VP_Variable * const ramcopy);
@@ -0,0 +1,53 @@
+/**
+ * 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
+
+/* DGUS implementation written by Sebastiaan Dammann in 2020 for Marlin */
+
+#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
+// 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)
+struct VPMapping {
+  const uint8_t screen;
+  const uint16_t *VPList;  // The list is null-terminated.
+};
+
+extern const struct VPMapping VPMap[];
+
+// List of VPs handled by Marlin / The Display.
+extern const struct DGUS_VP_Variable ListOfVP[];
+
+#define DWIN_DEFAULT_FILLER_CHAR ' '
+#define DWIN_SCROLLER_FILLER_CHAR 0x0
+
+#include "../../../inc/MarlinConfig.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+  #include "creality_touch/DGUSDisplayDef.h"
+#endif
@@ -0,0 +1,471 @@
+/**
+ * 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 "../../../inc/MarlinConfig.h"
+
+#include "../../../module/motion.h"
+
+#if HAS_COLOR_LEDS
+  #include "../../../feature/leds/leds.h"
+
+  #if ENABLED(PRINTER_EVENT_LEDS)
+    #define HAS_COLOR_LEDS_PREFERENCES 1
+  #endif
+#endif
+
+#include "../../../module/motion.h"
+
+enum DGUSLCD_Screens : uint8_t;
+
+struct creality_dwin_settings_t {
+  size_t settings_size;
+  uint8_t settings_version;
+
+  bool led_state;
+  bool display_standby;
+  bool display_sound;
+  int16_t standby_screen_brightness;
+  int16_t screen_brightness;
+  int16_t standby_time_seconds;
+
+  #if HAS_COLOR_LEDS_PREFERENCES
+  LEDColor LastLEDColor;
+  #endif
+};
+
+class DGUSScreenHandler {
+public:
+  DGUSScreenHandler() = default;
+
+  static bool loop();
+
+  static void Init();
+  static void DefaultSettings();
+  static void LoadSettings(const char* buff);
+  static void StoreSettings(char* buff);
+  static void SetTouchScreenConfiguration();
+  static void KillScreenCalled();
+
+  static void OnPowerlossResume();
+
+  static void RequestSaveSettings();
+
+  // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
+  // The bools specifying 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 inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
+    sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash);
+  }
+  static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
+    sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, 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 HandleDevelopmentTestButton(DGUS_VP_Variable &var, void *val_ptr);
+
+  /// "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);
+  static void HandleFanSpeedChanged(DGUS_VP_Variable &var, void *val_ptr);
+  // Hook for "Change Flowrate"
+  static void HandleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr);
+  // Hook for manual extrude.
+  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)
+    static void TogglePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr);
+
+    // Hook for power loss recovery.
+    static void HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr);
+  #endif
+
+  // Version sanity check
+  static void HandleScreenVersion(DGUS_VP_Variable &var, void *val_ptr);
+
+  // Hook for settings
+  static void HandleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
+  static void HandleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
+  static void HandleFadeHeight(DGUS_VP_Variable &var, void *val_ptr);
+
+  // Hook for move to position
+  static void HandlePositionChange(DGUS_VP_Variable &var, void *val_ptr);
+
+  static void HandleToggleTouchScreenMute(DGUS_VP_Variable &var, void *val_ptr);
+  static void HandleToggleTouchScreenStandbySetting(DGUS_VP_Variable &var, void *val_ptr);
+  static void HandleTouchScreenBrightnessSetting(DGUS_VP_Variable &var, void *val_ptr);
+  static void HandleTouchScreenStandbyBrightnessSetting(DGUS_VP_Variable &var, void *val_ptr);
+  static void HandleTouchScreenStandbyTimeSetting(DGUS_VP_Variable &var, void *val_ptr);
+
+  #if HAS_PROBE_SETTINGS
+  static void HandleToggleProbeHeaters(DGUS_VP_Variable &var, void *val_ptr);
+  static void HandleToggleProbeTemperatureStabilization(DGUS_VP_Variable &var, void *val_ptr);
+  static void HandleToggleProbePreheatTemp(DGUS_VP_Variable &var, void *val_ptr);
+  #endif
+
+  #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
+
+
+  static void HandleZoffsetChange(DGUS_VP_Variable &var, void *val_ptr);
+
+  #if HAS_MESH
+    // Hook for "Change probe offset z"
+
+    static void OnMeshLevelingStart();
+
+    static void OnMeshLevelingUpdate(const int8_t x, const int8_t y, const float z);
+
+    static void InitMeshValues();
+
+    static void ResetMeshValues();
+
+    static void UpdateMeshValue(const int8_t x, const int8_t y, const float z);
+
+    static void HandleMeshPoint(DGUS_VP_Variable &var, void *val_ptr);
+  #endif
+
+  // LED
+  #if HAS_COLOR_LEDS
+    static void HandleLED(DGUS_VP_Variable &var, void *val_ptr);
+    static void SendLEDToDisplay(DGUS_VP_Variable &var);
+  #endif
+
+  // Hook for live z adjust action
+  static void HandleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr);
+
+  // Hook for heater control
+  static void HandleHeaterControl(DGUS_VP_Variable &var, void *val_ptr);
+  #if ENABLED(DGUS_PREHEAT_UI)
+    // 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);
+    /// 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();
+
+    static void SetPrintingFromHost();
+  #endif
+
+  static void HandleLEDToggle();
+
+  static void HandleFanToggle();
+
+  static void FilamentRunout();
+
+  static void OnFactoryReset();
+
+#if HAS_BUZZER || ENABLED(SPEAKER)
+  static void Buzzer(const uint16_t frequency, const uint16_t duration);
+#endif
+
+  static void OnHomingStart();
+  static void OnHomingComplete();
+  static void OnPrintFinished();
+
+  // 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 save_current_screen=true);
+
+  // Recall the remembered screen.
+  static void PopToOldScreen();
+  static void OnBackButton(DGUS_VP_Variable &var, void *val_ptr);
+
+  // Make the display show the screen and update all VPs in it.
+  static void GotoScreen(DGUSLCD_Screens screen, bool save_current_screen = true);
+
+  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_SendScrollingStringToDisplay(DGUS_VP_Variable &var);
+  static void DGUSLCD_SendStringToDisplayPGM(DGUS_VP_Variable &var);
+  static void DGUSLCD_SendScrollingStringToDisplayPGM(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_SendPrintTimeWithRemainingToDisplay(DGUS_VP_Variable &var);
+  static void DGUSLCD_SendPrintTimeRemainingToDisplay(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);
+    static void DGUSLCD_SendFanSpeedToDisplay(DGUS_VP_Variable &var);
+  #endif
+  static void DGUSLCD_SendHeaterStatusToDisplay(DGUS_VP_Variable &var);
+  #if ENABLED(DGUS_UI_WAITING)
+    static void DGUSLCD_SendWaitingStatusToDisplay(DGUS_VP_Variable &var);
+  #endif
+
+  static void DGUSLCD_SendAboutFirmwareWebsite(DGUS_VP_Variable &var);
+  static void DGUSLCD_SendAboutFirmwareVersion(DGUS_VP_Variable &var);
+  static void DGUSLCD_SendAboutPrintSize(DGUS_VP_Variable &var);
+
+  /// 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;
+  }
+
+  template<DGUSLCD_Screens TPage>
+  static void DGUSLCD_NavigateToPage(DGUS_VP_Variable &var, void *val_ptr) {
+    GotoScreen(TPage);
+  }
+
+  template<DGUSLCD_Screens TPage, typename Handler>
+  static void DGUSLCD_NavigateToPage(DGUS_VP_Variable &var, void *val_ptr) {
+    GotoScreen(TPage);
+    Handler::Init();
+  }
+
+  /// Send a float value to the display.
+  /// Display will get a 4-byte integer scaled to the number of digits:
+  /// Tell the display the number of digits and it cheats by displaying a dot between...
+  template<unsigned int decimals>
+  static void DGUSLCD_SendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) {
+    if (var.memadr) {
+      double d = static_cast<double>(*(float *)var.memadr);
+      d *= cpow(10, decimals);
+
+      // Round - truncated values look like skipped numbers
+      static_assert(sizeof(long) == 4, "Assuming long is 4 bytes");
+      long roundedValue = static_cast<long>(round(d));
+      dgusdisplay.WriteVariable(var.VP, roundedValue);
+    }
+  }
+
+  // Receive a float from the display - Display will send a 2-byte integer scaled to the number of digits
+  template<unsigned int decimals>
+  static void DGUSLCD_SetFloatAsIntFromDisplay(DGUS_VP_Variable &var, void *val_ptr) {
+    if (var.memadr) {
+      uint16_t value_raw = swap16(*(uint16_t*)val_ptr);
+
+      float value = static_cast<float>(static_cast<double>(value_raw) /cpow(10, decimals));
+      *(float *)var.memadr = value;
+    }
+  }
+
+  // Receive a float from the display - Display will send a 4-byte integer scaled to the number of digits
+  template<unsigned int decimals>
+  static void DGUSLCD_SetFloatAsLongFromDisplay(DGUS_VP_Variable &var, void *val_ptr) {
+    if (var.memadr) {
+      uint32_t value_raw = uInt32Value(*(uint32_t*)val_ptr);
+
+      float value = static_cast<float>(static_cast<double>(value_raw) /cpow(10, decimals));
+      *(float *)var.memadr = value;
+    }
+  }
+
+   static void DGUSLCD_SendULongToDisplay(DGUS_VP_Variable &var) {
+    if (var.memadr) {
+      // Round - truncated values look like skipped numbers
+      long roundedValue = *(uint32_t *) var.memadr;
+      dgusdisplay.WriteVariable(var.VP, roundedValue);
+    }
+  }
+
+  static void DGUSLCD_ReceiveULongFromDisplay(DGUS_VP_Variable &var, void* val_ptr) {
+    if (var.memadr) {
+      // Round - truncated values look like skipped numbers
+      uint32_t incomingValue = *(uint32_t *) val_ptr;
+
+      *(uint32_t*)var.memadr = uInt32Value(incomingValue);
+    }
+  }
+
+  // Toggle a boolean at the specified memory address
+  static void DGUSLCD_ToggleBoolean(DGUS_VP_Variable &var, void *val_ptr) {
+    if (var.memadr) {
+      SERIAL_ECHOLNPGM("Toggle boolean - ", var.VP);
+
+      bool* val = (bool *)var.memadr;
+      *val = !*val;
+    }
+  }
+
+  // Send an icon to the display, depending on whether it is true or false
+  template<unsigned int value_if_true, unsigned int value_if_false>
+  static void DGUSLCD_SendIconValue(DGUS_VP_Variable &var) {
+    if (var.memadr) {
+      bool value = *(bool *)var.memadr;
+      uint16_t valueToSend = value ? value_if_true : value_if_false;
+      dgusdisplay.WriteVariable(var.VP, valueToSend);
+    }
+  }
+
+  /// 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) {
+      double d = static_cast<double>(*(float *)var.memadr);
+      d *= cpow(10, decimals);
+
+      // Round - truncated values look like skipped numbers
+      int16_t roundedValue = static_cast<int16_t>(round(d));
+      dgusdisplay.WriteVariable(var.VP, roundedValue);
+    }
+  }
+
+  template<AxisEnum Axis>
+  static void SendAxisTrustValue(DGUS_VP_Variable &var) {
+    bool trust = axis_is_trusted(Axis);
+
+    uint16_t color = trust ? 0xFFFF /*White*/ : 0XF800 /*Red*/;
+    dgusdisplay.SetVariableDisplayColor(var.VP, color);
+  }
+
+  /// 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 bool HandlePendingUserConfirmation();
+
+  static void SetSynchronousOperationStart();
+  static void SetSynchronousOperationFinish();
+  static bool HasCurrentSynchronousOperation() { return HasSynchronousOperation; }
+  static void SendBusyState(DGUS_VP_Variable &var);
+
+  static void SetViewMeshLevelState();
+
+  static bool fwretract_available;
+
+private:
+  static void HandleScreenVersionMismatchLEDFlash();
+
+  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").
+
+  static uint8_t MeshLevelIndex;
+  static uint8_t MeshLevelIconIndex;
+  static bool SaveSettingsRequested;
+  static bool HasScreenVersionMismatch;
+  static bool HasSynchronousOperation;
+
+  #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
+
+private:
+  FORCE_INLINE static DGUSLCD_Screens GetPreviousScreen() {
+    return past_screens[0];
+  }
+
+public: // Needed for VP auto-upload
+  static bool HasRGBSettings;
+  static creality_dwin_settings_t Settings;
+};
+
+extern DGUSScreenHandler ScreenHandler;
+
+struct DGUSSynchronousOperation {
+  private:
+    bool is_running;
+
+  public:
+    DGUSSynchronousOperation() : is_running(false) {}
+
+    // Don't allow this to be created on the stack
+    void* operator new (std::size_t size) = delete;
+
+    void start() {
+      is_running = true;
+      ScreenHandler.SetSynchronousOperationStart();
+    }
+
+    void done() {
+      is_running = false;
+      ScreenHandler.SetSynchronousOperationFinish();
+    }
+
+    ~DGUSSynchronousOperation() {
+      if (is_running) {
+        ScreenHandler.SetSynchronousOperationFinish();
+      }
+    }
+};
@@ -0,0 +1,67 @@
+/**
+ * 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 <stdint.h>
+
+/**
+ * DGUSVPVariable.h
+ *
+ *  Created on: Feb 9, 2019
+ *      Author: tobi
+ */
+
+struct DGUS_VP_Variable {
+  uint16_t VP;
+  void*    memadr;  // If nullptr, the value cannot be uploaded to the display.
+  uint8_t  size;
+
+  // Callback that will be called if the display modified the value.
+  // nullptr makes it readonly for the display.
+  void (*set_by_display_handler)(DGUS_VP_Variable &var, void *val_ptr);
+  void (*send_to_display_handler)(DGUS_VP_Variable &var);
+
+  template<typename T>
+  DGUS_VP_Variable& operator =(T &o) {
+    *(T*)memadr = o;  // warning this is not typesafe.
+    // TODO: Call out the display or mark as dirty for the next update.
+    return *this;
+  }
+};
+
+// endianness swap
+FORCE_INLINE uint16_t swap16(const uint16_t value) { return (value & 0xffU) << 8U | (value >> 8U); }
+
+FORCE_INLINE int16_t swap16(const int16_t value) { 
+  union { int16_t l; char lb[2]; } endian;
+  
+  endian.l = value;
+  char tmp = endian.lb[1];
+  endian.lb[1] = endian.lb[0];
+  endian.lb[0] = tmp;
+
+  return endian.l; 
+}
+
+FORCE_INLINE uint32_t uInt32Value(const uint32_t value) { return ((value>>24)&0xff) |  ((value<<8)&0xff0000) | ((value>>8)&0xff00) | ((value<<24)&0xff000000); }
+
+FORCE_INLINE uint16_t uInt16Value(void *val_ptr) { return swap16(*static_cast<uint16_t*>(val_ptr)); }
@@ -0,0 +1,230 @@
+
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+
+#include "../DGUSDisplayDef.h"
+#include "../DGUSDisplay.h"
+#include "../DGUSScreenHandler.h"
+
+#include "EstepsHandler.h"
+#include "AxisSettingsHandler.h"
+
+#include "../../ui_api.h"
+#include "../../../marlinui.h"
+
+#include "../../../../module/temperature.h"
+#include "../../../../module/settings.h"
+#include "../../../../module/planner.h"
+#include "../../../../gcode/gcode.h"
+
+#if HAS_TRINAMIC_CONFIG
+#include "../../../../feature/tmc_util.h"
+#include "../../../../module/stepper/indirection.h"
+#endif
+
+AxisEnum AxisSettingsHandler::current_axis;
+uint16_t AxisSettingsHandler::axis_settings_title_icon = ICON_AXIS_SETTINGS_TITLE_X;
+
+float AxisSettingsHandler::axis_steps_mm;
+uint16_t AxisSettingsHandler::max_acceleration_mm_per_s2;
+float AxisSettingsHandler::jerk;
+feedRate_t AxisSettingsHandler::max_feedrate;
+
+#if HAS_TRINAMIC_CONFIG
+bool AxisSettingsHandler::has_tmc_settings = true;
+#else 
+bool AxisSettingsHandler::has_tmc_settings = false;
+#endif
+
+uint16_t AxisSettingsHandler::tmc_current;
+bool AxisSettingsHandler::stealthchop;
+uint32_t AxisSettingsHandler::hybrid_threshold;
+
+void AxisSettingsHandler::HandleNavigation(DGUS_VP_Variable &var, void *val_ptr) {
+    switch (uInt16Value(val_ptr)) {
+        case AXIS_SETTINGS_NAV_BUTTON_VAL_X:
+            current_axis = X_AXIS;
+            axis_settings_title_icon = ICON_AXIS_SETTINGS_TITLE_X;
+            break;
+
+        case AXIS_SETTINGS_NAV_BUTTON_VAL_Y:
+            current_axis = Y_AXIS;
+            axis_settings_title_icon = ICON_AXIS_SETTINGS_TITLE_Y;
+            break;
+
+        case AXIS_SETTINGS_NAV_BUTTON_VAL_Z:
+            current_axis = Z_AXIS;
+            axis_settings_title_icon = ICON_AXIS_SETTINGS_TITLE_Z;
+            break;
+
+        case AXIS_SETTINGS_NAV_BUTTON_VAL_E:
+            current_axis = E_AXIS;
+            axis_settings_title_icon = ICON_AXIS_SETTINGS_TITLE_E;
+            break;
+    }
+
+    // Load settings for axis
+    axis_steps_mm = planner.settings.axis_steps_per_mm[current_axis];
+    max_acceleration_mm_per_s2 = static_cast<uint16_t>(planner.settings.max_acceleration_mm_per_s2[current_axis]);
+    IF_ENABLED(CLASSIC_JERK, jerk = planner.max_jerk[current_axis]);
+    max_feedrate = planner.settings.max_feedrate_mm_s[current_axis];
+
+    #if HAS_TRINAMIC_CONFIG
+    switch (current_axis){
+        #if AXIS_IS_TMC(X)
+        case X_AXIS:
+            tmc_current = stepperX.getMilliamps();
+
+            #if AXIS_HAS_STEALTHCHOP(X)
+            stealthchop = stepperX.get_stored_stealthChop();
+
+            #if ENABLED(HYBRID_THRESHOLD)
+            hybrid_threshold = static_cast<uint32_t>(stepperX.get_pwm_thrs());
+            #endif
+            #endif
+            break;
+        #endif
+
+        #if AXIS_IS_TMC(Y)
+        case Y_AXIS:
+            tmc_current = stepperY.getMilliamps();
+
+            #if AXIS_HAS_STEALTHCHOP(Y)
+            stealthchop = stepperY.get_stored_stealthChop();
+
+            #if ENABLED(HYBRID_THRESHOLD)
+            hybrid_threshold = static_cast<uint32_t>(stepperY.get_pwm_thrs());
+            #endif
+            #endif
+            break;
+        #endif
+
+        #if AXIS_IS_TMC(Z)
+        case Z_AXIS:
+            tmc_current = stepperZ.getMilliamps();
+
+            #if AXIS_HAS_STEALTHCHOP(Z)
+            stealthchop = stepperZ.get_stored_stealthChop();
+
+            #if ENABLED(HYBRID_THRESHOLD)
+            hybrid_threshold = static_cast<uint32_t>(stepperZ.get_pwm_thrs());
+            #endif
+            #endif
+            break;
+        #endif
+
+        #if AXIS_IS_TMC(E0)
+        case E_AXIS:
+            tmc_current = stepperE0.getMilliamps();
+
+            #if AXIS_HAS_STEALTHCHOP(E0)
+            stealthchop = stepperE0.get_stored_stealthChop();
+
+            #if ENABLED(HYBRID_THRESHOLD)
+            hybrid_threshold = static_cast<uint32_t>(stepperE0.get_pwm_thrs());
+            #endif
+            #endif
+            break;
+        #endif
+
+        default:
+        // Too bad
+        break;
+    }
+    #endif
+
+    // Nav
+    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_AXIS_SETTINGS_AXIS);
+}
+
+void AxisSettingsHandler::HandleBackNavigation(DGUS_VP_Variable &var, void *val_ptr) {
+    // Save settings for axis
+    planner.settings.axis_steps_per_mm[current_axis] = axis_steps_mm;
+    planner.settings.max_acceleration_mm_per_s2[current_axis] = max_acceleration_mm_per_s2;
+    IF_ENABLED(CLASSIC_JERK, planner.max_jerk[current_axis] = jerk);
+    planner.settings.max_feedrate_mm_s[current_axis] = max_feedrate;
+
+    // If we're handling the E-axis, the back button might end on that screen. Show that we didn't forget the settings.
+    if (current_axis == E_AXIS) {
+        EstepsHandler::set_esteps = axis_steps_mm;
+        EstepsHandler::calculated_esteps = axis_steps_mm;
+    }
+
+    #if HAS_TRINAMIC_CONFIG
+    switch (current_axis){
+        #if AXIS_IS_TMC(X)
+        case X_AXIS:
+            stepperX.rms_current(tmc_current);
+
+            #if AXIS_HAS_STEALTHCHOP(X)
+            stepperX.set_stealthChop(stealthchop);
+
+            #if ENABLED(HYBRID_THRESHOLD)
+            stepperX.set_pwm_thrs(hybrid_threshold);
+            #endif
+            #endif
+            break;
+        #endif
+
+        #if AXIS_IS_TMC(Y)
+        case Y_AXIS:
+            stepperY.rms_current(tmc_current);
+
+            #if AXIS_HAS_STEALTHCHOP(Y)
+            stepperY.set_stealthChop(stealthchop);
+
+            #if ENABLED(HYBRID_THRESHOLD)
+            stepperY.set_pwm_thrs(hybrid_threshold);
+            #endif
+            #endif
+            break;
+        #endif
+
+        #if AXIS_IS_TMC(Z)
+        case Z_AXIS:
+            stepperZ.rms_current(tmc_current);
+
+            #if AXIS_HAS_STEALTHCHOP(Z)
+            stepperZ.set_stealthChop(stealthchop);
+
+            #if ENABLED(HYBRID_THRESHOLD)
+            stepperZ.set_pwm_thrs(hybrid_threshold);
+            #endif
+            #endif
+            break;
+        #endif
+
+        #if AXIS_IS_TMC(E0)
+            case E_AXIS:
+            stepperE0.rms_current(tmc_current);
+
+            #if AXIS_HAS_STEALTHCHOP(E0)
+            stepperE0.set_stealthChop(stealthchop);
+
+            #if ENABLED(HYBRID_THRESHOLD)
+            stepperE0.set_pwm_thrs(hybrid_threshold);
+            #endif
+            #endif
+            break;
+        #endif
+
+        default:
+        // Too bad
+        break;
+    }
+    #endif
+
+    // Save and pop
+    ScreenHandler.PopToOldScreen();
+
+    settings.save();
+}
+
+void AxisSettingsHandler::HandleTMCNavigation(DGUS_VP_Variable &var, void *val_ptr) {
+    #if HAS_TRINAMIC_CONFIG
+    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_AXIS_SETTINGS_TMC);
+    #endif
+}
+
+#endif
@@ -0,0 +1,26 @@
+#include <cstdint>
+
+class AxisSettingsHandler {
+    private:
+        static AxisEnum current_axis;
+
+    public:
+        static uint16_t axis_settings_title_icon;
+
+        static float axis_steps_mm;
+        static uint16_t max_acceleration_mm_per_s2;
+
+        static float jerk;
+        static feedRate_t max_feedrate;
+
+        static bool has_tmc_settings;
+        static uint16_t tmc_current;
+        static bool stealthchop;
+        static uint32_t hybrid_threshold;
+
+    public:
+        static void HandleNavigation(DGUS_VP_Variable &var, void *val_ptr);
+        static void HandleBackNavigation(DGUS_VP_Variable &var, void *val_ptr);
+        static void HandleTMCNavigation(DGUS_VP_Variable &var, void *val_ptr);
+};
+
@@ -0,0 +1,796 @@
+/**
+ * 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/>.
+ *
+ */
+
+/* DGUS implementation written by Sebastiaan Dammann in 2020 for Marlin */
+
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+
+#include "../DGUSDisplayDef.h"
+#include "../DGUSDisplay.h"
+#include "../DGUSScreenHandler.h"
+#include "AxisSettingsHandler.h"
+#include "EstepsHandler.h"
+#include "FilamentLoadUnloadHandler.h"
+#include "PIDHandler.h"
+#include "MeshValidationHandler.h"
+
+#include "../../../../module/temperature.h"
+#include "../../../../module/motion.h"
+#include "../../../../module/planner.h"
+
+#include "../../../../feature/caselight.h"
+#if ENABLED(BABYSTEPPING)
+  #include "../../../../feature/babystep.h"
+#endif
+
+#if ENABLED(FWRETRACT)
+  #include "../../../../feature/fwretract.h"
+#endif
+
+#if HAS_COLOR_LEDS
+  #include "../../../../feature/leds/leds.h"
+#endif
+
+#if ENABLED(POWER_LOSS_RECOVERY)
+  #include "../../../../feature/powerloss.h"
+#endif
+
+#if ENABLED(FILAMENT_RUNOUT_SENSOR)
+#include "../../../../feature/runout.h"
+#endif
+
+#include "../../ui_api.h"
+#include "../../../marlinui.h"
+
+#include "PageHandlers.h"
+
+#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
+  uint16_t distanceToMove = 10;
+#endif
+using namespace ExtUI;
+
+
+const char MarlinVersion[] PROGMEM = SHORT_BUILD_VERSION;
+
+// ----- Common var lists
+#if HOTENDS >= 1
+#define VPList_HeatHotend VP_T_E0_Is, VP_T_E0_Set,
+#else
+#define VPList_HeatHotend
+#endif
+
+#if HAS_HEATED_BED
+#define VPList_HeatBed  VP_T_Bed_Is, VP_T_Bed_Set,
+#else
+#define VPList_HeatBed
+#endif
+
+#define VPList_Common VP_BACK_BUTTON_STATE, VP_Z_OFFSET, VP_BUTTON_BEDLEVELKEY
+#define VPList_CommonWithStatus VPList_HeatHotend VPList_HeatBed VP_Z_OFFSET, VP_Feedrate_Percentage, VP_BACK_BUTTON_STATE
+#define VPList_CommonWithHeatOnly VPList_HeatHotend VPList_HeatBed VP_BACK_BUTTON_STATE, VP_Z_OFFSET
+
+// ----- Which variables to auto-update on which screens
+const uint16_t VPList_None[] PROGMEM = {
+  VPList_Common,
+
+  0x0000
+};
+
+const uint16_t VPList_DialogStop[] PROGMEM = {
+  VPList_Common,
+
+  0x0000
+};
+
+const uint16_t VPList_Main[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  0x0000
+};
+
+const uint16_t VPList_SDFileList[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_SD_FileName0,
+  VP_SD_FileName1,
+  VP_SD_FileName2,
+  VP_SD_FileName3,
+  VP_SD_FileName4,
+  VP_SD_FileName5,
+
+  0x0000
+};
+
+const uint16_t VPList_Control[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_LED_TOGGLE,
+  VP_MUTE_ICON,
+
+  0x0000
+};
+
+const uint16_t VPList_Feed[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_FILCHANGE_NOZZLE_TEMP,
+  VP_FILCHANGE_LENGTH,
+
+  0x0000
+};
+
+const uint16_t VPList_Temp[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_FAN_TOGGLE,
+
+  0x0000
+};
+
+
+const uint16_t VPList_PreheatPLASettings[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_PREHEAT_PLA_HOTEND_TEMP,
+  VP_PREHEAT_PLA_BED_TEMP,
+
+  0x0000
+};
+
+const uint16_t VPList_PreheatABSSettings[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_PREHEAT_ABS_HOTEND_TEMP,
+  VP_PREHEAT_ABS_BED_TEMP,
+
+  0x0000
+};
+
+
+const uint16_t VPList_PrintPausingError[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_X_POSITION,
+  VP_Y_POSITION,
+  VP_Z_POSITION_PRECISION,
+  VP_Z_OFFSET,
+  VP_Fan0_Percentage,
+  VP_Feedrate_Percentage,
+
+  VP_PrintProgress_Percentage,
+  VP_PrintTimeProgressBar,
+  VP_PrintTime,
+  VP_PrintTimeWithRemainingVisible,
+  VP_PrintTimeRemaining,
+  VP_LINEAR_ADVANCE_FACTOR,
+
+  0x0000
+};
+
+const uint16_t VPList_PrintScreen[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_X_POSITION, VP_Y_POSITION, VP_Z_POSITION, VP_Z_POSITION_PRECISION,
+  SP_X_POSITION, SP_Y_POSITION, SP_Z_POSITION,
+
+  VP_Flowrate_E0,
+  VP_Fan0_Percentage,
+
+  VP_PrintProgress_Percentage,
+  VP_PrintTimeProgressBar,
+  VP_PrintTime,
+  VP_PrintTimeWithRemainingVisible,
+  VP_PrintTimeRemaining,
+  VP_LINEAR_ADVANCE_FACTOR,
+
+  VP_FWRETRACT_INDICATOR_ICON,
+
+  0x0000
+};
+
+const uint16_t VPList_Leveling[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_MESH_LEVEL_TEMP,
+
+  0x0000
+};
+
+const uint16_t VPList_ZOffsetLevel[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  0x0000
+};
+
+const uint16_t VPList_TuneScreen[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_PrintTime,
+
+  VP_Flowrate_E0,
+
+  VP_LED_TOGGLE,
+  VP_FAN_TOGGLE,
+  VP_Fan0_Percentage,
+
+  0x0000
+};
+
+
+const uint16_t VPList_TuneExtraScreen[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_LINEAR_ADVANCE_FACTOR,
+  VP_RGB_NAV_BUTTON_ICON,
+
+  0x0000
+};
+
+
+const uint16_t VPList_Prepare[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_PrintTime,
+
+  0x0000
+};
+
+const uint16_t VPList_Info[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_PrintTime,
+
+  VP_PRINTER_BEDSIZE,
+  VP_MARLIN_WEBSITE,
+  VP_MARLIN_VERSION,
+
+  0x0000
+};
+
+const uint16_t VPList_EstepsCalibration[] PROGMEM = {
+  VPList_CommonWithHeatOnly,
+
+  VP_ESTEPS_CURRENT,
+  VP_ESTEPS_CALIBRATION_TEMP,
+  VP_ESTEPS_CALIBRATION_LENGTH,
+  VP_ESTEPS_CALIBRATION_LEFTOVER_LENGTH,
+  VP_ESTEPS_CALIBRATION_MARK_LENGTH,
+  VP_ESTEPS_CALCULATED_ESTEPS,
+
+  0x0000
+};
+
+const uint16_t VPList_PidTune[] PROGMEM = {
+  VPList_CommonWithHeatOnly,
+
+  VP_PIDTUNE_TARGET_TEMP,
+  VP_PIDTUNE_FAN_TOGGLE_ICON,
+  VP_PIDTUNE_CYCLES,
+
+  0x0000
+};
+
+const uint16_t VPList_FWRetractTune[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_FWRETRACT_RETRACT_LENGTH,
+  VP_FWRETRACT_RETRACT_FEEDRATE,
+  VP_FWRETRACT_RETRACT_ZHOP,
+  VP_FWRETRACT_RESTART_LENGTH,
+  VP_FWRETRACT_RESTART_FEEDRATE,
+
+  VP_FWRETRACT_TOGGLE_BUTTON_ICON,
+
+  0x0000
+};
+
+const uint16_t VPList_LevelingSettings[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  VP_TOGGLE_PROBING_HEATERS_OFF_ONOFF_ICON,
+  VP_TOGGLE_PROBE_PREHEAT_HOTEND_TEMP,
+  VP_TOGGLE_PROBE_PREHEAT_BED_TEMP,
+  VP_TOGGLE_POST_PROBING_TEMPERATURE_STABILIZATION_ICON,
+  VP_LEVELING_FADE_HEIGHT,
+
+  0x0000
+};
+
+const uint16_t VPList_AxisSettingsNav[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  0x0000
+};
+
+const uint16_t VPList_AxisSettingsAxis[] PROGMEM = {
+  VPList_CommonWithHeatOnly,
+
+  VP_AXIS_SETTINGS_TITLE_ICON,
+
+  VP_AXIS_SETTINGS_AXIS_STEPSMM,
+  VP_AXIS_SETTINGS_AXIS_MAX_ACCEL,
+  VP_AXIS_SETTINGS_AXIS_JERK,
+  VP_AXIS_SETTINGS_AXIS_FEEDRATE,
+
+  VP_AXIS_TMC_NAV_ICON,
+
+  0x0000
+};
+
+const uint16_t VPList_AxisSettingsTMC[] PROGMEM = {
+  VPList_CommonWithHeatOnly,
+
+  VP_AXIS_SETTINGS_AXIS_TMCCURRENT,
+  VP_AXIS_SETTINGS_AXIS_TMCSTEALTHCHOP_ICON,
+  VP_AXIS_SETTINGS_AXIS_TMCHYBRIDTHRESHOLD,
+
+  0x0000
+};
+
+const uint16_t VPList_AdvMovementSettings[] PROGMEM = {
+  VPList_CommonWithHeatOnly,
+
+  VP_MOV_MINIMUM_SEGMENT_TIME,
+  VP_MOV_MINIMUM_FEEDRATE,
+  VP_MOV_NORMAL_ACCELERATION,
+  VP_MOV_RETRACT_ACCELERATION,
+
+  VP_MOV_MINIMUM_TRAVEL_FEEDRATE,
+  VP_MOV_MINIMUM_TRAVEL_ACCELERATION,
+
+  0x0000
+};
+
+const uint16_t VPList_MiscSettings[] PROGMEM = {
+  VPList_CommonWithHeatOnly,
+
+  VP_FILAMENTRUNOUT_SENSOR_TOGGLE_ICON,
+
+  VP_PLR_TOGGLE_ICON,
+
+  VP_STANDBY_BACKLIGHT_ICON,
+  VP_SCREEN_BACKLIGHT_STANDBY,
+  VP_SCREEN_BACKLIGHT,
+  VP_SCREEN_STANDBY_TIME,
+  VP_RGB_NAV_BUTTON_ICON,
+
+  0x0000
+};
+
+const uint16_t VPList_MeshValidation[] PROGMEM = {
+  VPList_CommonWithHeatOnly,
+
+  VP_MESHPATTERN_NOZZLE_TEMP,
+  VP_MESHPATTERN_BED_TEMP,
+
+  VP_MESHPATTERN_BUTTON_ICON,
+
+  0x0000
+};
+
+const uint16_t VPList_Calibrate[] PROGMEM = {
+  VPList_CommonWithStatus,
+
+  0x0000
+};
+
+const uint16_t VPList_RGB[] PROGMEM = {
+  VPList_CommonWithHeatOnly,
+
+  VP_RGB_CONTROL_R,
+  VP_RGB_CONTROL_G,
+  VP_RGB_CONTROL_B,
+  VP_RGB_CONTROL_W,
+  VP_RGB_CONTROL_I,
+
+  0x0000
+};
+
+
+// -- Mapping from screen to variable list
+const struct VPMapping VPMap[] PROGMEM = {
+  { DGUSLCD_SCREEN_BOOT, VPList_None },
+  { DGUSLCD_SCREEN_MAIN, VPList_Main },
+
+  { DGUSLCD_SCREEN_SDFILELIST, VPList_SDFileList },
+
+  { DGUSLCD_SCREEN_FILAMENTRUNOUT1, VPList_PrintPausingError },
+  { DGUSLCD_SCREEN_FILAMENTRUNOUT2, VPList_PrintPausingError },
+
+  { DGUSLCD_SCREEN_PRINT_FINISH, VPList_PrintScreen },
+  { DGUSLCD_SCREEN_PRINT_RUNNING, VPList_PrintScreen },
+  { DGUSLCD_SCREEN_PRINT_PAUSED, VPList_PrintScreen },
+
+  { DGUSLCD_SCREEN_TUNING, VPList_TuneScreen },
+  { DGUSLCD_SCREEN_TUNING_EXTRA, VPList_TuneExtraScreen },
+  { DGUSLCD_SCREEN_PREPARE, VPList_Prepare },
+
+  { DGUSLCD_SCREEN_INFO, VPList_Info },
+
+  { DGUSLCD_SCREEN_MOVE1MM, VPList_PrintScreen },
+  { DGUSLCD_SCREEN_MOVE10MM, VPList_PrintScreen },
+  { DGUSLCD_SCREEN_MOVE01MM, VPList_PrintScreen },
+
+  { DGUSLCD_SCREEN_FEED, VPList_Feed },
+  { DGUSLCD_SCREEN_SETUP, VPList_Control },
+
+  { DGUSLCD_SCREEN_TEMP, VPList_Temp },
+  { DGUSLCD_SCREEN_TEMP_PLA, VPList_PreheatPLASettings },
+  { DGUSLCD_SCREEN_TEMP_ABS, VPList_PreheatABSSettings },
+
+  { DGUSLCD_SCREEN_INFO, VPList_PrintScreen },
+  { DGUSLCD_SCREEN_ZOFFSET_LEVEL, VPList_ZOffsetLevel },
+  { DGUSLCD_SCREEN_LEVELING, VPList_Leveling },
+
+  { DGUSLCD_SCREEN_POWER_LOSS, VPList_None },
+  { DGUSLCD_SCREEN_THERMAL_RUNAWAY, VPList_None },
+  { DGUSLCD_SCREEN_HEATING_FAILED, VPList_None },
+  { DGUSLCD_SCREEN_THERMISTOR_ERROR, VPList_None },
+
+  { DGUSLCD_SCREEN_AUTOHOME, VPList_PrintScreen },
+
+  { DGUSLCD_SCREEN_DIALOG_PAUSE, VPList_None },
+  { DGUSLCD_SCREEN_DIALOG_STOP, VPList_DialogStop },
+
+  { DGUSLCD_SCREEN_CONFIRM, VPList_None },
+  { DGUSLCD_SCREEN_POPUP, VPList_None },
+
+  { DGUSLCD_SCREEN_ESTEPS_CALIBRATION, VPList_EstepsCalibration },
+  { DGUSLCD_SCREEN_PIDTUNE_CALIBRATION, VPList_PidTune },
+
+  { DGUSLCD_SCREEN_TUNEFWRETRACT, VPList_FWRetractTune },
+
+  { DGUSLCD_SCREEN_ESTEPS_CALIBRATION_RESULTS, VPList_EstepsCalibration },
+  { DGUSLCD_SCREEN_LEVELING_SETTINGS, VPList_LevelingSettings },
+
+  { DGUSLCD_SCREEN_AXIS_SETTINGS_NAV, VPList_AxisSettingsNav },
+  { DGUSLCD_SCREEN_AXIS_SETTINGS_AXIS , VPList_AxisSettingsAxis },
+  { DGUSLCD_SCREEN_AXIS_SETTINGS_TMC, VPList_AxisSettingsTMC },
+  { DGUSLCD_SCREEN_ADV_MOV_SETTINGS, VPList_AdvMovementSettings },
+
+  { DGUSLCD_SCREEN_MISC_SETTINGS, VPList_MiscSettings },
+  { DGUSLCD_SCREEN_MESH_VALIDATION, VPList_MeshValidation },
+
+  { DGUSLCD_SCREEN_CALIBRATE, VPList_Calibrate },
+  { DGUSLCD_SCREEN_RGB, VPList_RGB},
+
+  { 0 , nullptr } // List is terminated with an nullptr as table entry.
+};
+
+// 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 = {
+  // Back button state
+  VPHELPER(VP_BACK_BUTTON_STATE, nullptr, nullptr, ScreenHandler.SendBusyState),
+
+  // Screen version
+  VPHELPER(VP_UI_VERSION_MAJOR, nullptr, ScreenHandler.HandleScreenVersion, nullptr),
+
+  #if HOTENDS >= 1
+    VPHELPER(VP_Flowrate_E0, &planner.flow_percentage[ExtUI::extruder_t::E0], ScreenHandler.HandleFlowRateChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+    VPHELPER(VP_T_E0_Is, &thermalManager.temp_hotend[0].celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
+    VPHELPER(VP_T_E0_Set, &thermalManager.temp_hotend[0].target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  #endif
+
+  #if HAS_HEATED_BED
+    VPHELPER(VP_T_Bed_Is, &thermalManager.temp_bed.celsius, nullptr, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<0>),
+    VPHELPER(VP_T_Bed_Set, &thermalManager.temp_bed.target, ScreenHandler.HandleTemperatureChanged, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  #endif
+
+  VPHELPER(VP_MESH_LEVEL_TEMP, &thermalManager.temp_hotend[0].target, nullptr, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+
+  // Feedrate
+  VPHELPER(VP_Feedrate_Percentage, &feedrate_percentage, ScreenHandler.DGUSLCD_SetValueDirectly<int16_t>, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+
+  VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, ScreenHandler.DGUSLCD_SendPrintProgressToDisplay),
+  VPHELPER(VP_PrintTimeProgressBar, nullptr, nullptr, ScreenHandler.DGUSLCD_SendPrintProgressToDisplay),
+
+  // Calibration
+  // ... e-steps
+  VPHELPER(VP_ESTEPS_CURRENT, &EstepsHandler::set_esteps, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_ESTEPS_CALIBRATION_TEMP, &EstepsHandler::calibration_temperature, ScreenHandler.DGUSLCD_SetValueDirectly<uint16_t>, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_ESTEPS_CALIBRATION_LENGTH, &EstepsHandler::filament_to_extrude, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_ESTEPS_CALIBRATION_MARK_LENGTH, &EstepsHandler::mark_filament_mm, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_ESTEPS_CALIBRATION_LEFTOVER_LENGTH, &EstepsHandler::remaining_filament, EstepsHandler::HandleRemainingFilament, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_ESTEPS_CALCULATED_ESTEPS, &EstepsHandler::calculated_esteps, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+
+  VPHELPER(VP_ESTEPS_CALIBRATESTART_BUTTON, nullptr, EstepsHandler::HandleStartButton, nullptr),
+  VPHELPER(VP_ESTEPS_APPLY_BUTTON, nullptr, EstepsHandler::HandleApplyButton, nullptr),
+  VPHELPER(VP_ESTEPS_BACK_BUTTON, nullptr, EstepsHandler::HandleBackButton, nullptr),
+
+  VPHELPER(VP_ESTEP_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_ESTEPS_CALIBRATION, EstepsHandler>), nullptr),
+
+  // ... PID
+  VPHELPER(VP_PIDTUNE_TARGET_TEMP, &PIDHandler::calibration_temperature, ScreenHandler.DGUSLCD_SetValueDirectly<uint16_t>, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_PIDTUNE_CYCLES, &PIDHandler::cycles, ScreenHandler.DGUSLCD_SetValueDirectly<uint16_t>, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_PIDTUNE_FAN_TOGGLE, &PIDHandler::fan_on, ScreenHandler.DGUSLCD_ToggleBoolean, nullptr),
+  VPHELPER(VP_PIDTUNE_FAN_TOGGLE_ICON, &PIDHandler::fan_on, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_TOGGLE_ON, ICON_TOGGLE_OFF>)),
+
+  VPHELPER(VP_PIDTUNE_START_BUTTON, nullptr, PIDHandler::HandleStartButton, nullptr),
+
+  VPHELPER(VP_PIDTUNE_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_PIDTUNE_CALIBRATION, PIDHandler>), nullptr),
+
+  VPHELPER(VP_GENERIC_BACK_BUTTON, nullptr, ScreenHandler.OnBackButton, nullptr),
+
+  #if HAS_MESH
+    // ... Mesh validation
+    VPHELPER(VP_MESHPATTERN_NOZZLE_TEMP, &MeshValidationHandler::nozzle_temperature, MeshValidationHandler::HandleTemperature, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+    VPHELPER(VP_MESHPATTERN_BED_TEMP, &MeshValidationHandler::bed_temperature, MeshValidationHandler::HandleTemperature, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+
+    VPHELPER(VP_MESHPATTERN_BUTTON_ICON, &MeshValidationHandler::is_running,  nullptr, (ScreenHandler.DGUSLCD_SendIconValue<MESHPATTERN_BUTTON_CANCEL, MESHPATTERN_BUTTON_START>)),
+
+    VPHELPER(VP_MESHPATTERN_START_BUTTON, nullptr, MeshValidationHandler::HandleStartOrCancelButton, nullptr),
+    VPHELPER(VP_MESHPATTERN_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_MESH_VALIDATION, MeshValidationHandler>), nullptr),
+  #endif
+
+  // Axis settings
+  VPHELPER(VP_AXIS_SETTINGS_NAV_BUTTON, nullptr, AxisSettingsHandler::HandleNavigation, nullptr),
+  VPHELPER(VP_AXIS_SETTINGS_TITLE_ICON, &AxisSettingsHandler::axis_settings_title_icon, nullptr, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+
+  VPHELPER(VP_AXIS_SETTINGS_AXIS_STEPSMM, &AxisSettingsHandler::axis_steps_mm, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_AXIS_SETTINGS_AXIS_MAX_ACCEL, &AxisSettingsHandler::max_acceleration_mm_per_s2, ScreenHandler.DGUSLCD_SetValueDirectly<uint16_t>, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+
+  VPHELPER(VP_AXIS_SETTINGS_AXIS_JERK, &AxisSettingsHandler::jerk, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_AXIS_SETTINGS_AXIS_FEEDRATE, &AxisSettingsHandler::max_feedrate, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+
+  VPHELPER(VP_AXIS_SETTINGS_AXIS_TMCCURRENT, &AxisSettingsHandler::tmc_current, ScreenHandler.DGUSLCD_SetValueDirectly<uint16_t>, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_AXIS_SETTINGS_AXIS_TMCSTEALTHCHOP_BUTTON, &AxisSettingsHandler::stealthchop, ScreenHandler.DGUSLCD_ToggleBoolean, nullptr),
+  VPHELPER(VP_AXIS_SETTINGS_AXIS_TMCSTEALTHCHOP_ICON, &AxisSettingsHandler::stealthchop, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_TOGGLE_ON, ICON_TOGGLE_OFF>)),
+  VPHELPER(VP_AXIS_SETTINGS_AXIS_TMCHYBRIDTHRESHOLD, &AxisSettingsHandler::hybrid_threshold, ScreenHandler.DGUSLCD_ReceiveULongFromDisplay, ScreenHandler.DGUSLCD_SendULongToDisplay),
+
+  VPHELPER(VP_AXIS_TMC_NAV_ICON, &AxisSettingsHandler::has_tmc_settings,  nullptr, (ScreenHandler.DGUSLCD_SendIconValue<AXIS_TMC_NAV_ICON_SHOWING, AXIS_TMC_NAV_ICON_HIDING>)),
+
+  VPHELPER(VP_AXIS_SETTINGS_NAV_BACKBUTTON, nullptr, AxisSettingsHandler::HandleBackNavigation, nullptr),
+
+  VPHELPER(VP_AXIS_TUNING_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_AXIS_SETTINGS_NAV>), nullptr),
+  VPHELPER(VP_AXIS_TMC_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_AXIS_SETTINGS_TMC>), nullptr),
+
+  // Advanced movement settings
+  VPHELPER(VP_MOV_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_ADV_MOV_SETTINGS>), nullptr),
+
+  VPHELPER(VP_MOV_MINIMUM_SEGMENT_TIME, &planner.settings.min_segment_time_us, ScreenHandler.DGUSLCD_SetValueDirectly<uint16_t>, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+
+  VPHELPER(VP_MOV_MINIMUM_FEEDRATE, &planner.settings.min_feedrate_mm_s, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_MOV_NORMAL_ACCELERATION, &planner.settings.acceleration, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_MOV_RETRACT_ACCELERATION, &planner.settings.retract_acceleration, ScreenHandler.DGUSLCD_SetFloatAsLongFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<1>),
+
+  VPHELPER(VP_MOV_MINIMUM_TRAVEL_FEEDRATE, &planner.settings.min_travel_feedrate_mm_s, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_MOV_MINIMUM_TRAVEL_ACCELERATION, &planner.settings.travel_acceleration, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+
+  // Misc settings
+  VPHELPER(VP_MISCSETTINGS_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_MISC_SETTINGS>), nullptr),
+
+#if ENABLED(FILAMENT_RUNOUT_SENSOR)
+  VPHELPER(VP_FILAMENTRUNOUT_SENSOR_TOGGLE_BUTTON, &runout.enabled, ScreenHandler.DGUSLCD_ToggleBoolean, nullptr),
+  VPHELPER(VP_FILAMENTRUNOUT_SENSOR_TOGGLE_ICON, &runout.enabled,  nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_TOGGLE_ON, ICON_TOGGLE_OFF>)),
+#endif
+
+#if ENABLED(POWER_LOSS_RECOVERY)
+  VPHELPER(VP_PLR_TOGGLE_BUTTON, nullptr, ScreenHandler.TogglePowerLossRecovery, nullptr),
+  VPHELPER(VP_PLR_TOGGLE_ICON, &PrintJobRecovery::enabled,  nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_TOGGLE_ON, ICON_TOGGLE_OFF>)),
+#endif
+
+  // Preheat settings
+  #ifdef PREHEAT_1_LABEL
+  VPHELPER(VP_PREHEAT_PLA_HOTEND_TEMP, &ui.material_preset[0].hotend_temp, ScreenHandler.DGUSLCD_SetValueDirectly<int16_t>, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_PREHEAT_PLA_BED_TEMP, &ui.material_preset[0].bed_temp, ScreenHandler.DGUSLCD_SetValueDirectly<int16_t>, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  #endif
+
+  #ifdef PREHEAT_2_LABEL
+  VPHELPER(VP_PREHEAT_ABS_HOTEND_TEMP, &ui.material_preset[1].hotend_temp, ScreenHandler.DGUSLCD_SetValueDirectly<int16_t>, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_PREHEAT_ABS_BED_TEMP, &ui.material_preset[1].bed_temp, ScreenHandler.DGUSLCD_SetValueDirectly<int16_t>, &ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  #endif
+
+  // About info
+  VPHELPER_STR(VP_MARLIN_WEBSITE, nullptr, VP_MARLIN_WEBSITE_LEN, nullptr, ScreenHandler.DGUSLCD_SendAboutFirmwareWebsite),
+  VPHELPER_STR(VP_MARLIN_VERSION, nullptr, VP_MARLIN_VERSION_LEN, nullptr, ScreenHandler.DGUSLCD_SendAboutFirmwareVersion),
+  VPHELPER_STR(VP_PRINTER_BEDSIZE, nullptr, VP_PRINTER_BEDSIZE_LEN, nullptr, ScreenHandler.DGUSLCD_SendAboutPrintSize),
+
+  // Position Data
+  VPHELPER(VP_X_POSITION, &current_position.x, ScreenHandler.HandlePositionChange, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_Y_POSITION, &current_position.y, ScreenHandler.HandlePositionChange, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_Z_POSITION, &current_position.z, ScreenHandler.HandlePositionChange, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_Z_POSITION_PRECISION, &current_position.z, nullptr, ScreenHandler.DGUSLCD_SendFloatAsLongValueToDisplay<2>),
+
+  VPHELPER(SP_X_POSITION, nullptr, nullptr, ScreenHandler.SendAxisTrustValue<X_AXIS>),
+  VPHELPER(SP_Y_POSITION, nullptr, nullptr, ScreenHandler.SendAxisTrustValue<Y_AXIS>),
+  VPHELPER(SP_Z_POSITION, nullptr, nullptr, ScreenHandler.SendAxisTrustValue<Z_AXIS>),
+
+  #if HAS_BED_PROBE
+    VPHELPER(VP_Z_OFFSET, &probe.offset.z, ScreenHandler.HandleZoffsetChange, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<2>),
+  #elif ENABLED(BABYSTEP_DISPLAY_TOTAL)
+    VPHELPER(VP_Z_OFFSET, nullptr, ScreenHandler.HandleZoffsetChange, nullptr),
+  #endif
+
+
+  VPHELPER(VP_FAN_TOGGLE, &thermalManager.fan_speed[0], nullptr, ScreenHandler.DGUSLCD_SendFanStatusToDisplay),
+  VPHELPER(VP_Fan0_Percentage, &thermalManager.fan_speed[0], ScreenHandler.HandleFanSpeedChanged, ScreenHandler.DGUSLCD_SendFanSpeedToDisplay),
+
+  #if ENABLED(POWER_LOSS_RECOVERY)
+    VPHELPER(VP_POWER_LOSS_RECOVERY, nullptr, &ScreenHandler.HandlePowerLossRecovery, nullptr),
+  #endif
+
+  VPHELPER_STR(VP_PrintTime, nullptr, VP_PrintTime_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintTimeToDisplay),
+  VPHELPER_STR(VP_PrintTimeWithRemainingVisible, nullptr, VP_PrintTime_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintTimeWithRemainingToDisplay),
+  VPHELPER_STR(VP_PrintTimeRemaining, nullptr, VP_PrintTimeRemaining_LEN, nullptr, ScreenHandler.DGUSLCD_SendPrintTimeRemainingToDisplay),
+  VPHELPER(VP_SCREENCHANGE, nullptr, ScreenHandler.ScreenChangeHook, nullptr),
+  VPHELPER(VP_CONFIRMED, nullptr, ScreenHandler.ScreenConfirmedOK, nullptr),
+
+  #if HAS_PROBE_SETTINGS
+    VPHELPER(VP_TOGGLE_PROBING_HEATERS_OFF_ONOFF_BUTTON, nullptr, ScreenHandler.HandleToggleProbeHeaters, nullptr),
+    VPHELPER(VP_TOGGLE_PROBING_HEATERS_OFF_ONOFF_ICON, &probe.settings.turn_heaters_off, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_ACCURACY_TOGGLE_ON, ICON_ACCURACY_TOGGLE_OFF>)),
+
+    VPHELPER(VP_TOGGLE_POST_PROBING_TEMPERATURE_STABILIZATION_BUTTON, nullptr, ScreenHandler.HandleToggleProbeTemperatureStabilization, nullptr),
+    VPHELPER(VP_TOGGLE_POST_PROBING_TEMPERATURE_STABILIZATION_ICON, &probe.settings.stabilize_temperatures_after_probing, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_POST_PROBE_TEMP_STABILIZATION_TOGGLE_ON, ICON_POST_PROBE_TEMP_STABILIZATION_TOGGLE_OFF>)),
+
+    VPHELPER(VP_TOGGLE_PROBE_PREHEAT_HOTEND_TEMP, &probe.settings.preheat_hotend_temp, ScreenHandler.HandleToggleProbePreheatTemp, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+    VPHELPER(VP_TOGGLE_PROBE_PREHEAT_BED_TEMP, &probe.settings.preheat_bed_temp, ScreenHandler.HandleToggleProbePreheatTemp, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  #endif
+
+  #if HAS_MESH
+    VPHELPER(VP_LEVELING_FADE_HEIGHT, &planner.z_fade_height, ScreenHandler.HandleFadeHeight, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  #endif
+
+  VPHELPER(VP_LEVELING_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_ZOFFSET_LEVEL>), nullptr),
+  VPHELPER(VP_LEVELING_EDIT_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_LEVELING>), nullptr),
+  VPHELPER(VP_TOGGLE_PROBE_SETTINGS_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_LEVELING_SETTINGS>), nullptr),
+
+
+  // Creality has the same button ID mapped all over the place, so let the generic handler figure it out
+  VPHELPER(VP_BUTTON_MAINENTERKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_ADJUSTENTERKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_PREPAREENTERKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_RESUMEPRINTKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_SELECTFILEKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_STARTPRINTKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_STOPPRINTKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_PAUSEPRINTKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_COOLDOWN, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_TEMPCONTROL, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_BEDLEVELKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_HEATLOADSTARTKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+  VPHELPER(VP_BUTTON_MOVEKEY, nullptr, DGUSCrealityDisplay_HandleReturnKeyEvent, nullptr),
+
+  // File listing
+  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),
+
+  // Firmware retract
+  VPHELPER(VP_FWRETRACT_NAV_BUTTON, nullptr, ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_TUNEFWRETRACT>, nullptr),
+
+  VPHELPER(VP_FWRETRACT_RETRACT_LENGTH, &fwretract.settings.retract_length, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_FWRETRACT_RETRACT_FEEDRATE, &fwretract.settings.retract_feedrate_mm_s, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_FWRETRACT_RETRACT_ZHOP, &fwretract.settings.retract_zraise, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+
+  VPHELPER(VP_FWRETRACT_RESTART_LENGTH, &fwretract.settings.retract_recover_extra, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_FWRETRACT_RESTART_FEEDRATE, &fwretract.settings.retract_recover_feedrate_mm_s, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+
+  VPHELPER(VP_FWRETRACT_INDICATOR_ICON, &fwretract.autoretract_enabled, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_FWRETRACT_AUTO_ENGAGED, ICON_FWRETRACT_AUTO_DISENGAGED>)),
+  VPHELPER(VP_FWRETRACT_TOGGLE_BUTTON_ICON, &fwretract.autoretract_enabled, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_FWRETRACT_AUTO_TOGGLE_ON, ICON_FWRETRACT_AUTO_TOGGLE_OFF>)),
+  VPHELPER(VP_FWRETRACT_TOGGLE_BUTTON, &fwretract.autoretract_enabled, ScreenHandler.DGUSLCD_ToggleBoolean, nullptr),
+
+  // Other tuning
+#if ENABLED(LIN_ADVANCE)
+  VPHELPER(VP_LINEAR_ADVANCE_FACTOR, &planner.extruder_advance_K[0], ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<2>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<2>),
+#endif
+
+  VPHELPER(VP_OTHER_TUNE_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_TUNING_EXTRA>), nullptr),
+
+
+  // Additional buttons
+  VPHELPER(VP_MUTE_TOGGLE, nullptr, ScreenHandler.HandleToggleTouchScreenMute, nullptr),
+  VPHELPER(VP_STANDBY_BACKLIGHT_TOGGLE, nullptr, ScreenHandler.HandleToggleTouchScreenStandbySetting, nullptr),
+
+  // Additional settings
+  VPHELPER(VP_SCREEN_BACKLIGHT_STANDBY, &ScreenHandler.Settings.standby_screen_brightness, ScreenHandler.HandleTouchScreenStandbyBrightnessSetting, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_SCREEN_BACKLIGHT, &ScreenHandler.Settings.screen_brightness, ScreenHandler.HandleTouchScreenBrightnessSetting, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_SCREEN_STANDBY_TIME, &ScreenHandler.Settings.standby_time_seconds, ScreenHandler.HandleTouchScreenStandbyTimeSetting, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+
+  // RGB
+  VPHELPER(VP_RGB_NAV_BUTTON_ICON, &ScreenHandler.HasRGBSettings, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_RGB_SETTINGS_AVAILABLE, ICON_RGB_SETTINGS_UNAVAILABLE>)),
+
+  #if HAS_COLOR_LEDS
+    VPHELPER(VP_RGB_NAV_BUTTON, nullptr, ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_RGB>, nullptr),
+
+    VPHELPER(VP_RGB_CONTROL_R, &leds.color.r, ScreenHandler.HandleLED, ScreenHandler.SendLEDToDisplay),
+    VPHELPER(VP_RGB_CONTROL_G, &leds.color.g, ScreenHandler.HandleLED, ScreenHandler.SendLEDToDisplay),
+    VPHELPER(VP_RGB_CONTROL_B, &leds.color.b, ScreenHandler.HandleLED, ScreenHandler.SendLEDToDisplay),
+
+    #if EITHER(RGBW_LED, NEOPIXEL_LED)
+      VPHELPER(VP_RGB_CONTROL_W, &leds.color.w, ScreenHandler.HandleLED, ScreenHandler.SendLEDToDisplay),
+
+      #if ENABLED(NEOPIXEL_LED)
+        VPHELPER(VP_RGB_CONTROL_I, &leds.color.i, ScreenHandler.HandleLED, ScreenHandler.SendLEDToDisplay),
+      #endif
+    #endif
+  #endif
+
+  // Filament load/unload
+  VPHELPER(VP_FILCHANGE_NAV_BUTTON, nullptr, (ScreenHandler.DGUSLCD_NavigateToPage<DGUSLCD_SCREEN_FEED, FilamentLoadUnloadHandler>), nullptr),
+
+  VPHELPER(VP_FILCHANGE_LENGTH, &FilamentLoadUnloadHandler::length, ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>, ScreenHandler.DGUSLCD_SendFloatAsIntValueToDisplay<1>),
+  VPHELPER(VP_FILCHANGE_NOZZLE_TEMP, &FilamentLoadUnloadHandler::nozzle_temperature, FilamentLoadUnloadHandler::HandleTemperature, ScreenHandler.DGUSLCD_SendWordValueToDisplay),
+  VPHELPER(VP_FILCHANGE_ACTION_BUTTON, nullptr, FilamentLoadUnloadHandler::HandleLoadUnloadButton, nullptr),
+
+  // Icons
+  #if ENABLED(CASE_LIGHT_ENABLE)
+    VPHELPER(VP_LED_TOGGLE, &caselight.on, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_LED_TOGGLE_ON, ICON_LED_TOGGLE_OFF>)),
+  #endif
+  VPHELPER(VP_STANDBY_BACKLIGHT_ICON, &ScreenHandler.Settings.display_standby, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_TOGGLE_ON, ICON_TOGGLE_OFF>)),
+  VPHELPER(VP_MUTE_ICON, &ScreenHandler.Settings.display_sound, nullptr, (ScreenHandler.DGUSLCD_SendIconValue<ICON_SOUND_TOGGLE_ON, ICON_SOUND_TOGGLE_OFF>)),
+
+  // Development test button
+  VPHELPER(VP_DEVELOPMENT_HELPER_BUTTON, nullptr, ScreenHandler.HandleDevelopmentTestButton, nullptr),
+
+  // Mesh override input
+#if MESH_INPUT_SUPPORTED_SIZE == GRID_MAX_POINTS && HAS_MESH
+  //#define _VPHELPER_GP(N) VPHELPER((VP_MESH_INPUT_X0_Y0 + ( ##N## * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  //REPEAT(MESH_INPUT_SUPPORTED_SIZE, _VPHELPER_GP)
+
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 0 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 1 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 2 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 3 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 4 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 5 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 6 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 7 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 8 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 9 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 10 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 11 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 12 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 13 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 14 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+  VPHELPER((VP_MESH_INPUT_X0_Y0 + ( 15 * MESH_INPUT_DATA_SIZE)), nullptr, ScreenHandler.HandleMeshPoint, nullptr),
+#endif
+
+  // 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_M117_STATIC, .memadr = nullptr, .size = VP_M117_STATIC_LEN, .set_by_display_handler = nullptr, .send_to_display_handler =&ScreenHandler.DGUSLCD_SendStringToDisplay },
+
+  // 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 },
+
+  VPHELPER(0, 0, 0, 0)  // must be last entry.
+};
+
+#endif // DGUS_LCD_UI_ORIGIN
@@ -0,0 +1,562 @@
+/**
+ * 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
+
+enum DGUSLCD_Screens : uint8_t {
+  DGUSLCD_SCREEN_BOOT = 0,
+
+  DGUSLCD_SCREEN_MAIN = 28,
+
+  DGUSLCD_SCREEN_CONFIRM = 66,
+  DGUSLCD_SCREEN_SDPRINTMANIPULATION = 37 ,
+  DGUSLCD_SCREEN_SDPRINTTUNE = 41,
+  DGUSLCD_SCREEN_SDFILELIST = 67,
+
+  DGUSLCD_SCREEN_FILAMENTRUNOUT1 = 34, // DWINTouchPage::ERR_FILAMENTRUNOUT_HOTEND_COLD
+  DGUSLCD_SCREEN_FILAMENTRUNOUT2 = 35, // DWINTouchPage::ERR_FILAMENTRUNOUT_FILAMENT_LOADED
+
+  DGUSLCD_SCREEN_PRINT_FINISH = 36,    // DWINTouchPage::PRINT_FINISHED
+  DGUSLCD_SCREEN_PRINT_RUNNING = 37,   // DWINTouchPage::PRINT_PROGRESS_RUNNING
+  DGUSLCD_SCREEN_PRINT_PAUSED = 39,    // DWINTouchPage::PRINT_PROGRESS_PAUSED
+
+  DGUSLCD_SCREEN_DIALOG_PAUSE = 38,    // DWINTouchPage::DIALOG_PAUSE_PRINTING
+  DGUSLCD_SCREEN_DIALOG_STOP = 40,     // DWINTouchPage::DIALOG_STOP_PRINTING
+
+  DGUSLCD_SCREEN_TUNING = 41,          // DWINTouchPage::MENU_TUNING
+  DGUSLCD_SCREEN_TUNING_EXTRA = 79,    // (this is a new page)
+  DGUSLCD_SCREEN_PREPARE = 42,         // DWINTouchPage::MENU_PREPARE
+
+  DGUSLCD_SCREEN_MOVE10MM = 43,         // DWINTouchPage::MOVE_1MM
+  DGUSLCD_SCREEN_MOVE1MM = 44,          // DWINTouchPage::MOVE_10MM
+  DGUSLCD_SCREEN_MOVE01MM = 45,         // DWINTouchPage::MOVE_01MM
+
+  DGUSLCD_SCREEN_FEED = 46,            // DWINTouchPage::FEED
+  DGUSLCD_SCREEN_SETUP = 47,         // DWINTouchPage::MENU_CONTROL
+
+  DGUSLCD_SCREEN_TEMP = 48,            // DWINTouchPage::MENU_TEMP
+  DGUSLCD_SCREEN_TEMP_PLA = 49,        // DWINTouchPage::MENU_PLA_TEMP
+  DGUSLCD_SCREEN_TEMP_ABS = 50,        // DWINTouchPage::MENU_ABS_TEMP
+
+  DGUSLCD_SCREEN_INFO = 51,            // DWINTouchPage::MENU_ABOUT
+
+  DGUSLCD_SCREEN_ZOFFSET_LEVEL = 52,   // DWINTouchPage::MENU_ZOFFSET_LEVELING
+  DGUSLCD_SCREEN_LEVELING = 53,        // DWINTouchPage::LEVELING
+
+  DGUSLCD_SCREEN_POWER_LOSS = 54,       // DWINTouchPage::DIALOG_POWER_FAILURE
+  DGUSLCD_SCREEN_THERMAL_RUNAWAY = 57,  // DWINTouchPage::ERR_THERMAL_RUNAWAY
+  DGUSLCD_SCREEN_HEATING_FAILED = 58,   // DWINTouchPage::ERR_HEATING_FAILED
+  DGUSLCD_SCREEN_THERMISTOR_ERROR = 59, // DWINTouchPage::ERR_THERMISTOR
+
+  DGUSLCD_SCREEN_AUTOHOME = 61,         // DWINTouchPage::AUTOHOME_IN_PROGRESS
+
+  DGUSLCD_SCREEN_POPUP = 63,           // NEW - does not exist in original display
+  DGUSLCD_SCREEN_KILL = 64,            // NEW - does not exist in original display
+
+  DGUSLCD_SCREEN_PIDTUNE_CALIBRATION = 68,
+  DGUSLCD_SCREEN_ESTEPS_CALIBRATION = 69,
+
+  DGUSLCD_SCREEN_TUNEFWRETRACT = 70,
+
+  DGUSLCD_SCREEN_ESTEPS_CALIBRATION_RESULTS = 71,
+  DGUSLCD_SCREEN_LEVELING_SETTINGS = 72,
+
+  DGUSLCD_SCREEN_AXIS_SETTINGS_NAV = 73,
+  DGUSLCD_SCREEN_AXIS_SETTINGS_AXIS = 74,
+  DGUSLCD_SCREEN_AXIS_SETTINGS_TMC = 75,
+
+  DGUSLCD_SCREEN_ADV_MOV_SETTINGS = 76,
+  DGUSLCD_SCREEN_MISC_SETTINGS = 77,
+  DGUSLCD_SCREEN_MESH_VALIDATION = 78,
+
+  DGUSLCD_SCREEN_CALIBRATE = 80,
+  DGUSLCD_SCREEN_RGB = 81
+};
+
+// Version checks
+constexpr uint16_t VP_UI_VERSION_MAJOR = 0xFFFA;
+constexpr uint16_t EXPECTED_UI_VERSION_MAJOR = 61;
+constexpr uint16_t VERSION_MISMATCH_BUZZ_AMOUNT = 5;
+constexpr uint16_t VERSION_MISMATCH_LED_FLASH_DELAY = 1000;
+
+#define VP_STARTPROGRESSBAR           0x1000
+
+// // Storage space for the Killscreen messages. Reused for the popup.
+constexpr uint16_t VP_MSGSTR1 = 0x2010;
+constexpr uint8_t VP_MSGSTR1_LEN = 0x20;  // might be more place for it...
+constexpr uint16_t VP_MSGSTR2 = 0x2030;
+constexpr uint8_t VP_MSGSTR2_LEN = 0x40;
+constexpr uint16_t VP_MSGSTR3 = 0x2070;
+constexpr uint8_t VP_MSGSTR3_LEN = 0x40;
+constexpr uint16_t VP_MSGSTR4 = 0x2080;
+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 = 0x219f;   // 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 = 0x219E; // 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;
+
+// // 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_CONTROL = 0x2222;
+// //constexpr uint16_t VP_E2_BED_CONTROL = 0x2224;
+// //constexpr uint16_t VP_E3_BED_CONTROL = 0x2226;
+// //constexpr uint16_t VP_E4_BED_CONTROL = 0x2228;
+// //constexpr uint16_t VP_E5_BED_CONTROL = 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
+// constexpr uint16_t VP_SETTINGS = 0x2400;
+
+// // 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;
+
+// // Firmware version on the boot screen.
+constexpr uint16_t VP_PRINTER_BEDSIZE = 0x1074;
+constexpr uint16_t VP_PRINTER_BEDSIZE_LEN = 12;
+constexpr uint16_t VP_MARLIN_VERSION = 0x2222;
+constexpr uint8_t VP_MARLIN_VERSION_LEN = 32;
+
+constexpr uint16_t VP_MARLIN_WEBSITE = 0x2242;
+constexpr uint8_t VP_MARLIN_WEBSITE_LEN = 32;
+
+constexpr uint16_t VP_STANDBY_BACKLIGHT_ICON = 0x2280;
+constexpr uint16_t VP_STANDBY_BACKLIGHT_TOGGLE = 0x2282;
+
+constexpr uint16_t VP_MUTE_ICON = 0x2284;
+constexpr uint16_t VP_MUTE_TOGGLE = 0x2286;
+
+constexpr uint16_t VP_SCREEN_BACKLIGHT_STANDBY = 0x228D;
+constexpr uint16_t VP_SCREEN_BACKLIGHT = 0x2384;
+
+constexpr uint16_t VP_SCREEN_STANDBY_TIME = 0x2386;
+
+// Material preheat settings
+constexpr uint16_t VP_PREHEAT_PLA_HOTEND_TEMP = 0x1102;
+constexpr uint16_t VP_PREHEAT_PLA_BED_TEMP = 0x1104;
+
+constexpr uint16_t VP_PREHEAT_ABS_HOTEND_TEMP = 0x1108;
+constexpr uint16_t VP_PREHEAT_ABS_BED_TEMP = 0x110a;
+
+// Place for status messages.
+
+// ... We have memory space for scrolling messages
+constexpr uint16_t VP_M117 = 0x3000 + (3 * 1);  // Text Variable Pointer. First three VP must be reserved [a VP is two bytes red.]. Text is saved after the 3rd VP and ended with 0x00 or 0x0F.
+constexpr uint8_t VP_M117_LEN = 100;
+
+// ... And memory space for static (short) messages. Note this VPAddr is also the VP of the 5 beta and alpha 4 touch screens.
+constexpr uint8_t M117_STATIC_DISPLAY_LEN = 28; // Fits "TFT flashed incorrectly v0" exactly
+constexpr uint16_t VP_M117_STATIC = 0x21B3;
+constexpr uint8_t VP_M117_STATIC_LEN = 70;
+
+// // Temperatures.
+constexpr uint16_t VP_T_E0_Is = 0x1036;  // 4 Byte Integer - HEAD_CURRENT_TEMP_VP
+constexpr uint16_t VP_T_E0_Set = 0x1034; // 2 Byte Integer - HEAD_SET_TEMP_VP
+
+constexpr uint16_t VP_T_Bed_Is = 0x103c;  // 4 Byte Integer - BED_SET_TEMP_VP
+constexpr uint16_t VP_T_Bed_Set = 0x103A; // 2 Byte Integer - BED_CURRENT_TEMP_VP
+
+constexpr uint16_t VP_Flowrate_E0 = 0x228A; // 2 Byte Integer
+
+constexpr uint16_t VP_Fan0_Percentage = 0x228F;  // 2 Byte Integer (0..100)
+
+constexpr uint16_t VP_Feedrate_Percentage = 0x1006; // 2 Byte Integer (0..100) - PRINT_SPEED_RATE_VP
+constexpr uint16_t VP_PrintProgress_Percentage = 0x1016; // 2 Byte Integer (0..100)
+
+constexpr uint16_t VP_PrintTimeProgressBar = 0x100E;
+
+constexpr uint16_t VP_PrintTime = 0x21a0;
+constexpr uint16_t VP_PrintTimeWithRemainingVisible = 0x2335;
+constexpr uint16_t VP_PrintTime_LEN = 19;
+
+constexpr uint16_t VP_PrintTimeRemaining = 0x231f;
+constexpr uint16_t VP_PrintTimeRemaining_LEN = 21;
+
+constexpr uint16_t VP_HideRemainingTime_Ico = 0x2380;
+constexpr uint16_t ICON_REMAINING_VISIBLE = 26;
+constexpr uint16_t ICON_REMAINING_HIDDEN = 27;
+
+constexpr uint16_t VP_Z_OFFSET = 0x1026;
+
+// // SDCard File Listing
+constexpr uint16_t VP_SD_ScrollEvent = 0x20D4; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
+constexpr uint16_t VP_SD_FileSelected = 0x2200; // Number of file field selected.
+constexpr uint16_t VP_SD_FileName_LEN = 21; // LEN is shared for all entries.
+constexpr uint16_t VP_SD_FileName_CNT = 5; // LEN is shared for all entries.
+constexpr uint16_t DGUS_SD_FILESPERSCREEN = VP_SD_FileName_CNT; // FIXME move that info to the display and read it from there.
+constexpr uint16_t VP_SD_FileName0 = 0x20D5;
+constexpr uint16_t VP_SD_FileName1 = VP_SD_FileName0 + VP_SD_FileName_LEN;
+constexpr uint16_t VP_SD_FileName2 = VP_SD_FileName1 + VP_SD_FileName_LEN;
+constexpr uint16_t VP_SD_FileName3 = VP_SD_FileName2 + VP_SD_FileName_LEN;
+constexpr uint16_t VP_SD_FileName4 = VP_SD_FileName3 + VP_SD_FileName_LEN;
+constexpr uint16_t VP_SD_FileName5 = VP_SD_FileName4 + VP_SD_FileName_LEN;
+
+constexpr uint16_t VP_SD_Print_ProbeOffsetZ = 0x32A0; //
+constexpr uint16_t VP_SD_Print_Filename = 0x2000; //
+
+constexpr uint16_t VP_ICON_OVERLAY_CLEAR = 10;
+constexpr uint16_t VP_ICON_OVERLAY_SELECTED = 6;
+
+// // Step per mm
+constexpr uint16_t VP_X_STEP_PER_MM = 0x3600;
+constexpr uint16_t VP_Y_STEP_PER_MM = 0x3604;
+constexpr uint16_t VP_Z_STEP_PER_MM = 0x3608;
+constexpr uint16_t VP_E0_STEP_PER_MM = 0x3610;
+// // PIDs
+constexpr uint16_t VP_E0_PID_P = 0x3700;
+constexpr uint16_t VP_E0_PID_I = 0x3702;
+constexpr uint16_t VP_E0_PID_D = 0x3704;
+constexpr uint16_t VP_BED_PID_P = 0x3710;
+constexpr uint16_t VP_BED_PID_I = 0x3712;
+constexpr uint16_t VP_BED_PID_D = 0x3714;
+
+// Power loss recovery
+constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x105F;
+
+// Buttons defined by Creality - Don't worry if you're confused by the naming, so am I
+constexpr uint16_t VP_BUTTON_MAINENTERKEY = 0x1002;
+constexpr uint16_t VP_BUTTON_ADJUSTENTERKEY = 0x1004;
+constexpr uint16_t VP_BUTTON_PAUSEPRINTKEY = 0x100A;
+constexpr uint16_t VP_BUTTON_TEMPCONTROL = 0x1030;
+constexpr uint16_t VP_BUTTON_COOLDOWN = 0x1032;
+constexpr uint16_t VP_BUTTON_PREPAREENTERKEY = 0x103E;
+
+constexpr uint16_t VP_BUTTON_SELECTFILEKEY = 0x20D3;
+constexpr uint16_t VP_BUTTON_STARTPRINTKEY = 0x20D2;
+constexpr uint16_t VP_BUTTON_STOPPRINTKEY = 0x1008;
+constexpr uint16_t VP_BUTTON_RESUMEPRINTKEY = 0x100C;
+constexpr uint16_t VP_BUTTON_BEDLEVELKEY = 0x1044;
+
+constexpr uint16_t VP_BUTTON_HEATLOADSTARTKEY = 0x1056;
+
+// Additional stuff defined by Creality
+constexpr uint16_t VP_FAN_TOGGLE = 0x101E;
+constexpr uint16_t VP_LED_TOGGLE = 0x101F;
+
+// Axis settings
+constexpr uint16_t VP_AXIS_SETTINGS_NAV_BUTTON = 0x22D9;
+constexpr uint16_t AXIS_SETTINGS_NAV_BUTTON_VAL_X = 1;
+constexpr uint16_t AXIS_SETTINGS_NAV_BUTTON_VAL_Y = 2;
+constexpr uint16_t AXIS_SETTINGS_NAV_BUTTON_VAL_Z = 3;
+constexpr uint16_t AXIS_SETTINGS_NAV_BUTTON_VAL_E = 4;
+
+constexpr uint16_t VP_AXIS_SETTINGS_TITLE_ICON = 0x22DB;
+constexpr uint16_t ICON_AXIS_SETTINGS_TITLE_X = 20;
+constexpr uint16_t ICON_AXIS_SETTINGS_TITLE_Y = 21;
+constexpr uint16_t ICON_AXIS_SETTINGS_TITLE_Z = 22;
+constexpr uint16_t ICON_AXIS_SETTINGS_TITLE_E = 23;
+
+constexpr uint16_t VP_AXIS_SETTINGS_NAV_BACKBUTTON = 0x22DD;
+
+constexpr uint16_t VP_AXIS_SETTINGS_AXIS_STEPSMM = 0x22DF; // 2-byte
+constexpr uint16_t VP_AXIS_SETTINGS_AXIS_MAX_ACCEL = 0x22E1; // 4-byte (!)
+constexpr uint16_t VP_AXIS_SETTINGS_AXIS_JERK = 0x22E5; // 2-byte
+constexpr uint16_t VP_AXIS_SETTINGS_AXIS_FEEDRATE = 0x22E7; // 2-byte
+
+constexpr uint16_t VP_AXIS_SETTINGS_AXIS_TMCCURRENT = 0x22E9; // 2-byte
+
+constexpr uint16_t VP_AXIS_SETTINGS_AXIS_TMCSTEALTHCHOP_BUTTON = 0x22EB; // 2-byte
+constexpr uint16_t VP_AXIS_SETTINGS_AXIS_TMCSTEALTHCHOP_ICON = 0x22ED; // 2-byte
+constexpr uint16_t VP_AXIS_SETTINGS_AXIS_TMCHYBRIDTHRESHOLD = 0x22EF; // 4-byte (!)
+
+constexpr uint16_t VP_AXIS_TUNING_NAV_BUTTON = 0x22F5;
+constexpr uint16_t VP_AXIS_TMC_NAV_BUTTON = 0x22F7;
+
+constexpr uint16_t VP_AXIS_TMC_NAV_ICON = 0x22F3; // 2-byte
+constexpr uint16_t AXIS_TMC_NAV_ICON_SHOWING = 10;
+constexpr uint16_t AXIS_TMC_NAV_ICON_HIDING = 11;
+
+// ... Advanced movement settings
+constexpr uint16_t VP_MOV_NAV_BUTTON = 0x2305;
+
+constexpr uint16_t VP_MOV_MINIMUM_SEGMENT_TIME = 0x22F9; // uint 2-byte
+constexpr uint16_t VP_MOV_MINIMUM_FEEDRATE = 0x22FB; // float 2-byte
+constexpr uint16_t VP_MOV_NORMAL_ACCELERATION = 0x22FD; // float 2-byte
+
+constexpr uint16_t VP_MOV_MINIMUM_TRAVEL_FEEDRATE = 0x2301; // float 2-byte
+constexpr uint16_t VP_MOV_MINIMUM_TRAVEL_ACCELERATION = 0x2303; // float 2-byte
+
+constexpr uint16_t VP_MOV_RETRACT_ACCELERATION = 0x2307; // float 4-byte
+
+// Misc settings
+constexpr uint16_t VP_MISCSETTINGS_NAV_BUTTON = 0x2311;
+
+constexpr uint16_t VP_FILAMENTRUNOUT_SENSOR_TOGGLE_BUTTON = 0x2309;
+constexpr uint16_t VP_FILAMENTRUNOUT_SENSOR_TOGGLE_ICON = 0x230b;
+
+constexpr uint16_t VP_PLR_TOGGLE_BUTTON = 0x230d;
+constexpr uint16_t VP_PLR_TOGGLE_ICON = 0x230F;
+
+// Mesh leveling
+constexpr uint16_t VP_LEVELING_NAV_BUTTON = 0x238a;
+constexpr uint16_t VP_LEVELING_EDIT_NAV_BUTTON = 0x23A8;
+
+constexpr uint16_t VP_MESH_SCREEN_MESSAGE_ICON = 0x22cb;
+constexpr uint16_t MESH_SCREEN_MESSAGE_ICON_LEVELING = 5;
+constexpr uint16_t MESH_SCREEN_MESSAGE_ICON_VIEWING = 6;
+
+constexpr uint16_t VP_MESH_LEVEL_TEMP = 0x108A;
+constexpr uint16_t VP_MESH_LEVEL_STATUS = 0x108D;
+
+constexpr uint8_t DGUS_GRID_VISUALIZATION_START_ID = GRID_MAX_POINTS > (4*4) ? 30 : 1;
+
+static_assert(
+  (GRID_MAX_POINTS == 16 && DGUS_GRID_VISUALIZATION_START_ID == 1)||  // CR-6 SE
+  (GRID_MAX_POINTS == 49 && DGUS_GRID_VISUALIZATION_START_ID == 30) || // CR-6 MAX
+  (GRID_MAX_POINTS != 16 && GRID_MAX_POINTS != 49),                    // Custom Leveling
+  "Incorrect offset selected for leveling config"
+);
+static_assert(GRID_MAX_POINTS_X == GRID_MAX_POINTS_Y, "Assuming bed leveling points is square");
+
+
+constexpr uint16_t VP_MESH_LEVEL_X0_Y0 = 0x1350;
+constexpr uint16_t SP_MESH_LEVEL_X0_Y0 = 0x5000;
+
+constexpr uint16_t MESH_LEVEL_EDGE_MAX_POINTS = 4;
+
+constexpr uint16_t MESH_LEVEL_VP_SIZE = 0x4; // 4-byte native float
+constexpr uint16_t MESH_LEVEL_SP_SIZE = 0x10; // 0x10 distance
+
+constexpr uint16_t MESH_LEVEL_VP_EDGE_SIZE = MESH_LEVEL_VP_SIZE * MESH_LEVEL_EDGE_MAX_POINTS;
+constexpr uint16_t MESH_LEVEL_SP_EDGE_SIZE = MESH_LEVEL_SP_SIZE * MESH_LEVEL_EDGE_MAX_POINTS;
+
+constexpr uint16_t MESH_LEVEL_MAX_POINTS = MESH_LEVEL_EDGE_MAX_POINTS * MESH_LEVEL_EDGE_MAX_POINTS;
+
+// Mesh inputs
+constexpr uint16_t VP_MESH_INPUT_X0_Y0 = 0x2360;
+
+#define MESH_INPUT_SUPPORTED_X_SIZE 4
+#define MESH_INPUT_SUPPORTED_Y_SIZE 4
+#define MESH_INPUT_SUPPORTED_SIZE 16
+#define MESH_INPUT_DATA_SIZE 2 // 2 byte integer
+
+// Color table: https://stackoverflow.com/q/13720937/646215
+// Color picker: https://ee-programming-notepad.blogspot.com/2016/10/16-bit-color-generator-picker.html
+// Colors below were picked on bed leveling visualizer defaults
+
+constexpr uint16_t MESH_COLOR_BELOW_ZERO = 0x899B;   // Blue
+constexpr uint16_t MESH_COLOR_NEAR_ZERO = 0x1C80;    // Green
+constexpr uint16_t MESH_COLOR_ABOVE_ZERO = 0xB800;    // Purple
+constexpr uint16_t MESH_COLOR_NOT_MEASURED = 0xFFFF; // White (becomes invisible on white background)
+
+constexpr float MESH_NEAR_ZERO = 0.020;
+constexpr float MESH_UNSET_EPSILON = 0.001;
+
+// Mesh validation pattern
+constexpr uint16_t VP_MESHPATTERN_NOZZLE_TEMP = 0x2313;
+constexpr uint16_t VP_MESHPATTERN_BED_TEMP = 0x2315;
+
+constexpr uint16_t VP_MESHPATTERN_START_BUTTON = 0x2317;
+constexpr uint16_t VP_MESHPATTERN_BUTTON_ICON = 0x2319;
+
+constexpr uint16_t VP_MESHPATTERN_NAV_BUTTON = 0x231B;
+
+constexpr uint16_t MESHPATTERN_BUTTON_START = 24; // This icon does not exist, and will therefore not show
+constexpr uint16_t MESHPATTERN_BUTTON_CANCEL = 25;
+
+
+// Movement screen
+constexpr uint16_t VP_X_POSITION = 0x1048;
+constexpr uint16_t SP_X_POSITION = 0x4000;
+constexpr uint16_t VP_Y_POSITION = 0x104A;
+constexpr uint16_t SP_Y_POSITION = 0x4030;
+constexpr uint16_t VP_Z_POSITION = 0x104C;
+constexpr uint16_t VP_Z_POSITION_PRECISION = 0x108F;
+constexpr uint16_t SP_Z_POSITION = 0x4060;
+constexpr uint16_t VP_BUTTON_MOVEKEY = 0x1046;
+
+// Buttons
+constexpr uint16_t VP_ESTEP_NAV_BUTTON = 0x2291;
+constexpr uint16_t VP_PIDTUNE_NAV_BUTTON = 0x2293;
+constexpr uint16_t VP_GENERIC_BACK_BUTTON = 0x2295; // Generic button for popping back to the old display
+
+constexpr uint16_t GENERIC_BACK_BUTTON_NEED_SAVE = 0x1;
+
+// PID tuning
+constexpr uint16_t VP_PIDTUNE_TARGET_TEMP = 0x2297;
+constexpr uint16_t VP_PIDTUNE_CYCLES = 0x2299;
+constexpr uint16_t VP_PIDTUNE_FAN_TOGGLE = 0x238C;
+constexpr uint16_t VP_PIDTUNE_FAN_TOGGLE_ICON = 0x238E;
+constexpr uint16_t VP_PIDTUNE_START_BUTTON = 0x229B;
+
+// FWRetract
+constexpr uint16_t VP_FWRETRACT_NAV_BUTTON = 0x22AD;
+
+constexpr uint16_t VP_FWRETRACT_RETRACT_LENGTH = 0x22B1;
+constexpr uint16_t VP_FWRETRACT_RETRACT_FEEDRATE = 0x22B3;
+constexpr uint16_t VP_FWRETRACT_RETRACT_ZHOP = 0x22B5;
+
+constexpr uint16_t VP_FWRETRACT_RESTART_LENGTH = 0x22B7;
+constexpr uint16_t VP_FWRETRACT_RESTART_FEEDRATE = 0x22B9;
+
+constexpr uint16_t VP_FWRETRACT_TOGGLE_BUTTON = 0x22BB;
+constexpr uint16_t VP_FWRETRACT_TOGGLE_BUTTON_ICON = 0x22BD;
+constexpr uint16_t VP_FWRETRACT_INDICATOR_ICON = 0x22BF;
+
+// Other tuning
+constexpr uint16_t VP_LINEAR_ADVANCE_FACTOR = 0x22AF;
+
+constexpr uint16_t VP_OTHER_TUNE_NAV_BUTTON = 0x2382;
+
+// Leveling settings
+constexpr uint16_t VP_TOGGLE_PROBING_HEATERS_OFF_ONOFF_BUTTON = 0x22C1;
+constexpr uint16_t VP_TOGGLE_PROBING_HEATERS_OFF_ONOFF_ICON = 0x22C3;
+
+constexpr uint16_t VP_TOGGLE_PROBE_PREHEAT_HOTEND_TEMP = 0x22C5;
+constexpr uint16_t VP_TOGGLE_PROBE_PREHEAT_BED_TEMP = 0x22C7;
+
+constexpr uint16_t VP_TOGGLE_PROBE_SETTINGS_NAV_BUTTON = 0x22C9;
+
+constexpr uint16_t VP_TOGGLE_POST_PROBING_TEMPERATURE_STABILIZATION_ICON = 0x22CD;
+constexpr uint16_t VP_TOGGLE_POST_PROBING_TEMPERATURE_STABILIZATION_BUTTON = 0x22CF;
+
+constexpr uint16_t VP_LEVELING_FADE_HEIGHT = 0x231D;
+
+// E-steps calibration
+constexpr uint16_t VP_ESTEPS_CURRENT = 0x229d;
+constexpr uint16_t VP_ESTEPS_CALIBRATION_TEMP = 0x229f;
+constexpr uint16_t VP_ESTEPS_CALIBRATION_LENGTH = 0x22a1;
+constexpr uint16_t VP_ESTEPS_CALIBRATION_MARK_LENGTH = 0x22ab;
+constexpr uint16_t VP_ESTEPS_CALIBRATION_LEFTOVER_LENGTH = 0x22a3;
+constexpr uint16_t VP_ESTEPS_CALCULATED_ESTEPS = 0x22a5;
+constexpr uint16_t VP_ESTEPS_CALIBRATESTART_BUTTON = 0x22a7;
+constexpr uint16_t VP_ESTEPS_APPLY_BUTTON = 0x22a9;
+constexpr uint16_t VP_ESTEPS_BACK_BUTTON = 0x22D7;
+
+// RGB
+constexpr uint16_t VP_RGB_NAV_BUTTON = 0x2390;
+
+constexpr uint16_t VP_RGB_CONTROL_R = 0x2392;
+constexpr uint16_t VP_RGB_CONTROL_G = 0x2394;
+constexpr uint16_t VP_RGB_CONTROL_B = 0x2396;
+constexpr uint16_t VP_RGB_CONTROL_W = 0x2398;
+constexpr uint16_t VP_RGB_CONTROL_I = 0x239A; // brightness
+
+constexpr uint16_t VP_RGB_NAV_BUTTON_ICON = 0x239E;
+constexpr uint16_t ICON_RGB_SETTINGS_AVAILABLE = 28;
+constexpr uint16_t ICON_RGB_SETTINGS_UNAVAILABLE = 29;
+
+// Filament load/unload
+constexpr uint16_t VP_FILCHANGE_NAV_BUTTON = 0x23a6;
+
+constexpr uint16_t VP_FILCHANGE_NOZZLE_TEMP = 0x23a0;
+constexpr uint16_t VP_FILCHANGE_LENGTH = 0x23a2;
+
+constexpr uint16_t VP_FILCHANGE_ACTION_BUTTON = 0x23a4;
+constexpr uint16_t FILCHANGE_ACTION_UNLOAD_BUTTON = 1;
+constexpr uint16_t FILCHANGE_ACTION_LOAD_BUTTON = 2;
+
+// Icons
+constexpr uint16_t ICON_TOGGLE_ON = 1;
+constexpr uint16_t ICON_TOGGLE_OFF = 2;
+
+constexpr uint16_t ICON_BACK_BUTTON_ENABLED = 7;
+constexpr uint16_t ICON_BACK_BUTTON_DISABLED = 8;
+
+constexpr uint16_t ICON_THROBBER_ANIM_OFF = 0;
+constexpr uint16_t ICON_THROBBER_ANIM_ON = 1;
+
+// Allow to visually disable/enable the back button
+constexpr uint16_t VP_BACK_BUTTON_STATE = 0x22D1;
+
+// Throbber animation
+constexpr uint16_t VP_BUSY_ANIM_STATE = 0x22D3;
+
+// Toggles
+constexpr uint16_t ICON_FAN_TOGGLE_ON = 1;
+constexpr uint16_t ICON_FAN_TOGGLE_OFF = 2;
+constexpr uint16_t ICON_LED_TOGGLE_ON = 3;
+constexpr uint16_t ICON_LED_TOGGLE_OFF = 4;
+constexpr uint16_t ICON_SOUND_TOGGLE_ON = 5;
+constexpr uint16_t ICON_SOUND_TOGGLE_OFF = 6;
+constexpr uint16_t ICON_FWRETRACT_AUTO_TOGGLE_ON = 9;
+constexpr uint16_t ICON_FWRETRACT_AUTO_TOGGLE_OFF = 10;
+constexpr uint16_t ICON_ACCURACY_TOGGLE_ON = 11;
+constexpr uint16_t ICON_ACCURACY_TOGGLE_OFF = 12;
+constexpr uint16_t ICON_POST_PROBE_TEMP_STABILIZATION_TOGGLE_ON = 13;
+constexpr uint16_t ICON_POST_PROBE_TEMP_STABILIZATION_TOGGLE_OFF = 14;
+
+constexpr uint16_t ICON_FWRETRACT_AUTO_DISENGAGED = 4; // This icon deliberately does not exist
+constexpr uint16_t ICON_FWRETRACT_AUTO_ENGAGED = 3;
+
+// Development helper
+constexpr uint16_t VP_DEVELOPMENT_HELPER_BUTTON = 0x22D5;
+constexpr uint16_t VP_DEVELOPMENT_HELPER_BUTTON_ACTION_FIRMWARE_UPDATE = 2;
+constexpr uint16_t VP_DEVELOPMENT_HELPER_BUTTON_ACTION_TO_MAIN_MENU = 4;
+constexpr uint16_t VP_DEVELOPMENT_HELPER_BUTTON_ACTION_RESET_DISPLAY = 8;
@@ -0,0 +1,188 @@
+
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+
+#include "../DGUSDisplayDef.h"
+#include "../DGUSDisplay.h"
+#include "../DGUSScreenHandler.h"
+
+#include "EstepsHandler.h"
+
+#include "../../ui_api.h"
+#include "../../../marlinui.h"
+
+#include "../../../../module/temperature.h"
+#include "../../../../module/settings.h"
+#include "../../../../module/planner.h"
+#include "../../../../gcode/gcode.h"
+
+// Storage init
+float EstepsHandler::set_esteps = 0;
+float EstepsHandler::calculated_esteps = 0;
+float EstepsHandler::remaining_filament = 0;
+float EstepsHandler::mark_filament_mm = 0;
+float EstepsHandler::filament_to_extrude = 0;
+celsius_t EstepsHandler::calibration_temperature = 0;
+
+void EstepsHandler::Init() {
+    // Use steps
+    set_esteps = ExtUI::getAxisSteps_per_mm(ExtUI::E0);
+    calculated_esteps = 0;
+
+    // Reset
+    filament_to_extrude = 100;
+    mark_filament_mm = 120;
+    remaining_filament = 0;
+
+    // Use configured PLA temps + 10 degrees
+    calibration_temperature = ui.material_preset[0].hotend_temp + 10;
+
+    // Welcome message
+    SetStatusMessage(PSTR("Ready"));
+}
+
+
+void EstepsHandler::HandleStartButton(DGUS_VP_Variable &var, void *val_ptr) {
+    //static_assert(ADVANCED_PAUSE_PURGE_LENGTH == 0, "Assuming PURGE_LENGTH is 0 so we can use M701");
+
+    // Validate
+    if (calibration_temperature < EXTRUDE_MINTEMP) {
+        SetStatusMessage(PSTR("Invalid temperature set"));
+        return;
+    }
+
+    if (filament_to_extrude < 10) {
+        SetStatusMessage(PSTR("Invalid extrusion length set"));
+        return;
+    }
+
+    if (mark_filament_mm < filament_to_extrude) {
+        SetStatusMessage(PSTR("Invalid mark length set"));
+        return;
+    }
+
+    // Synchronous operation - disable back button
+    DGUSSynchronousOperation syncOperation;
+    syncOperation.start();
+
+    // Prepare
+    bool zAxisWasRelative = GcodeSuite::axis_is_relative(Z_AXIS);
+    bool eAxisWasRelative = GcodeSuite::axis_is_relative(E_AXIS);
+    #if ENABLED(LIN_ADVANCE)
+      float kFactor = planner.extruder_advance_K[0];
+    #endif
+
+    GcodeSuite::set_e_relative();
+    GcodeSuite::set_relative_mode(true);
+    #if ENABLED(LIN_ADVANCE)
+      planner.extruder_advance_K[0] = 0;
+    #endif
+
+    ExtUI::injectCommands_P("G0 Z5 F150");
+    queue.advance();
+
+    // Heat up if necessary
+    if (abs(ExtUI::getActualTemp_celsius(ExtUI::E0) - calibration_temperature) > 2) {
+        thermalManager.setTargetHotend(calibration_temperature, ExtUI::H0);
+
+        SetStatusMessage(PSTR("Heating up..."));
+        thermalManager.wait_for_hotend(ExtUI::H0, false);
+    }
+
+    planner.synchronize();
+
+    // Set-up command
+    SetStatusMessage(PSTR("Extruding..."));
+
+    char cmd[64];
+    sprintf_P(cmd, PSTR("G1 E%f F50"), filament_to_extrude);
+
+    ExtUI::injectCommands(cmd);
+    queue.advance();
+    planner.synchronize();
+
+    // Restore position
+    ExtUI::injectCommands_P("G0 Z-5 F150");
+    queue.advance();
+    planner.synchronize();
+
+    // Restore defaults
+    if (!zAxisWasRelative) GcodeSuite::set_relative_mode(false);
+    if (!eAxisWasRelative) GcodeSuite::set_e_absolute();
+    #if ENABLED(LIN_ADVANCE)
+      planner.extruder_advance_K[0] = kFactor;
+    #endif
+
+    // Done
+    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_ESTEPS_CALIBRATION_RESULTS, false);
+    ScreenHandler.Buzzer(0, 250);
+    syncOperation.done();
+    SetStatusMessage(PSTR("Measure remaining filament"));
+}
+
+void EstepsHandler::HandleApplyButton(DGUS_VP_Variable &var, void *val_ptr) {
+    if (abs(calculated_esteps) < 1) {
+        // User intented to set e-steps directly
+        ExtUI::setAxisSteps_per_mm(set_esteps, ExtUI::E0);
+    } else {
+        ExtUI::setAxisSteps_per_mm(calculated_esteps, ExtUI::E0);
+    }
+
+    SaveSettingsAndReturn(true);
+}
+
+void EstepsHandler::HandleBackButton(DGUS_VP_Variable &var, void *val_ptr) {
+    // User intented to set e-steps directly
+    ExtUI::setAxisSteps_per_mm(set_esteps, ExtUI::E0);
+
+    SaveSettingsAndReturn(false);
+}
+
+void EstepsHandler::SaveSettingsAndReturn(bool fullConfirm) {
+    // Save & reset
+    settings.save();
+
+    if (fullConfirm) ScreenHandler.Buzzer(0, 250);
+
+    ScreenHandler.PopToOldScreen();
+    if (fullConfirm) ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN, false);
+
+    SetStatusMessage(PSTR("New e-steps value saved"));
+}
+
+void EstepsHandler::HandleRemainingFilament(DGUS_VP_Variable &var, void *val_ptr) {
+    ScreenHandler.DGUSLCD_SetFloatAsIntFromDisplay<1>(var, val_ptr);
+
+    // Calculate
+    constexpr float precision = 0.01;
+    float actualExtrusion = mark_filament_mm - remaining_filament;
+    if (actualExtrusion < (-precision)) {
+        SetStatusMessage(PSTR("Mark filament further"));
+        return;
+    }
+
+    if (actualExtrusion < precision) {
+        SetStatusMessage(PSTR("E-steps are correct"));
+        calculated_esteps = set_esteps;
+        return;
+    }
+
+    float current_steps = ExtUI::getAxisSteps_per_mm(ExtUI::E0);
+    SERIAL_ECHOLNPGM("Current steps: ", current_steps);
+    SERIAL_ECHOLNPGM("Actual extrusion: ", actualExtrusion);
+
+    float new_steps = (current_steps * filament_to_extrude) / actualExtrusion;
+    SERIAL_ECHOLNPGM("New steps: ", new_steps);
+
+    calculated_esteps = new_steps;
+
+    // Status update
+    SetStatusMessage(PSTR("Calculated new e-steps"));
+}
+
+void EstepsHandler::SetStatusMessage(PGM_P statusMessage) {
+    ScreenHandler.setstatusmessagePGM(statusMessage);
+}
+
+#endif
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <cstdint>
+
+class EstepsHandler {
+    public:
+        static void Init();
+
+        static void HandleStartButton(DGUS_VP_Variable &var, void *val_ptr);
+        static void HandleApplyButton(DGUS_VP_Variable &var, void *val_ptr);
+        static void HandleBackButton(DGUS_VP_Variable &var, void *val_ptr);
+
+        static void HandleRemainingFilament(DGUS_VP_Variable &var, void *val_ptr);
+
+    public:
+        static float set_esteps;
+        static float calculated_esteps;
+
+        static float mark_filament_mm;
+        static float remaining_filament;
+
+        static float filament_to_extrude;
+        static celsius_t calibration_temperature;
+
+    private:
+        static void SaveSettingsAndReturn(bool fullConfirm);
+        static void SetStatusMessage(PGM_P statusMessage);
+};
+
@@ -0,0 +1,106 @@
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+
+#include "../DGUSDisplayDef.h"
+#include "../DGUSDisplay.h"
+#include "../DGUSScreenHandler.h"
+
+#include "FilamentLoadUnloadHandler.h"
+
+#include "../../ui_api.h"
+#include "../../../marlinui.h"
+
+#include "../../../../module/temperature.h"
+#include "../../../../module/settings.h"
+#include "../../../../module/planner.h"
+#include "../../../../gcode/gcode.h"
+
+celsius_t FilamentLoadUnloadHandler::nozzle_temperature = 0;
+float FilamentLoadUnloadHandler::length = 0;
+
+void FilamentLoadUnloadHandler::Init() {
+    nozzle_temperature = ui.material_preset[0].hotend_temp;
+    length = 150;
+
+    if (ExtUI::isPrinting()) {
+        nozzle_temperature = ExtUI::getTargetTemp_celsius(ExtUI::extruder_t::E0);
+    }
+}
+
+void FilamentLoadUnloadHandler::HandleTemperature(DGUS_VP_Variable &var, void *val_ptr) {
+    ScreenHandler.DGUSLCD_SetValueDirectly<uint16_t>(var, val_ptr);
+
+    ValidateTemperatures();
+}
+
+void FilamentLoadUnloadHandler::HandleLoadUnloadButton(DGUS_VP_Variable &var, void *val_ptr) {
+    // Common for load/unload -> determine minimum temperature
+    if (length < 0.1) {
+        SetStatusMessage("Invalid feed length");
+        return;
+    }
+
+    if (ExtUI::isPrinting() && !ExtUI::isPrintingPaused()) {
+        SetStatusMessage(PSTR("Finish Printing First"));
+        return;
+    }
+
+    DGUSSynchronousOperation syncOperation;
+    uint16_t button_value = uInt16Value(val_ptr);
+    switch (button_value) {
+        case FILCHANGE_ACTION_LOAD_BUTTON:
+            syncOperation.start();
+
+            ChangeFilamentWithTemperature(PSTR("M701 L%f P0"));
+
+            syncOperation.done();
+        break;
+
+        case FILCHANGE_ACTION_UNLOAD_BUTTON:
+            syncOperation.start();
+
+            ChangeFilamentWithTemperature(PSTR("M702 U%f"));
+
+            syncOperation.done();
+        break;
+    }
+
+}
+
+void FilamentLoadUnloadHandler::ValidateTemperatures() {
+    LIMIT(nozzle_temperature, EXTRUDE_MINTEMP, HEATER_0_MAXTEMP - HOTEND_OVERSHOOT);
+}
+
+void FilamentLoadUnloadHandler::ChangeFilamentWithTemperature(PGM_P command) {
+    // Heat if necessary
+    if (ExtUI::getActualTemp_celsius(ExtUI::E0) < nozzle_temperature && abs(ExtUI::getActualTemp_celsius(ExtUI::E0) - nozzle_temperature) > THERMAL_PROTECTION_HYSTERESIS) {
+        SetStatusMessage(PSTR("Heating up..."));
+
+        uint16_t target_celsius = nozzle_temperature;
+        NOMORE(target_celsius, thermalManager.hotend_max_target(0));
+
+        thermalManager.setTargetHotend(target_celsius, ExtUI::H0);
+        thermalManager.wait_for_hotend(ExtUI::H0, false);
+    }
+
+    // Inject load filament command
+    SetStatusMessage(PSTR("Filament load/unload..."));
+
+    char cmd[64];
+    sprintf_P(cmd, command, length);
+
+    // Handle commands
+    SERIAL_ECHOPGM("Injecting command: ", cmd);
+    GcodeSuite::process_subcommands_now(cmd);
+    SERIAL_ECHOPGM_P("- done");
+
+    if (ScreenHandler.Settings.display_sound) ScreenHandler.Buzzer(500, 100);
+    SetStatusMessage(PSTR("Filament load/unload complete"));
+}
+
+void FilamentLoadUnloadHandler::SetStatusMessage(PGM_P statusMessage) {
+    ScreenHandler.setstatusmessagePGM(statusMessage);
+}
+
+#endif
@@ -0,0 +1,22 @@
+
+#pragma once
+
+#include <cstdint>
+
+class FilamentLoadUnloadHandler {
+    public:
+        static void Init();
+
+        static void HandleTemperature(DGUS_VP_Variable &var, void *val_ptr);
+        static void HandleLoadUnloadButton(DGUS_VP_Variable &var, void *val_ptr);
+
+    public:
+        static celsius_t nozzle_temperature;
+        static float length;
+        
+    private:
+        static void ValidateTemperatures();
+        static void ChangeFilamentWithTemperature(PGM_P command);
+        static void SetStatusMessage(PGM_P statusMessage);
+};
+
@@ -0,0 +1,150 @@
+
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) && HAS_MESH
+
+#include "../DGUSDisplayDef.h"
+#include "../DGUSDisplay.h"
+#include "../DGUSScreenHandler.h"
+
+#include "MeshValidationHandler.h"
+
+#include "../../ui_api.h"
+#include "../../../marlinui.h"
+
+#include "../../../../module/temperature.h"
+#include "../../../../module/settings.h"
+#include "../../../../module/planner.h"
+#include "../../../../gcode/gcode.h"
+
+celsius_t MeshValidationHandler::nozzle_temperature;
+celsius_t MeshValidationHandler::bed_temperature;
+bool MeshValidationHandler::is_running;
+bool MeshValidationHandler::started_from_screen;
+bool MeshValidationHandler::is_cancelling;
+feedRate_t MeshValidationHandler::prev_feedrate;
+
+void MeshValidationHandler::Init() {
+    // Set to PLA pre-heat temps by default
+    nozzle_temperature = ui.material_preset[0].hotend_temp;
+    bed_temperature = ui.material_preset[0].bed_temp;
+
+    ValidateTemperatures();
+}
+
+void MeshValidationHandler::HandleTemperature(DGUS_VP_Variable &var, void *val_ptr) {
+    ScreenHandler.DGUSLCD_SetValueDirectly<uint16_t>(var, val_ptr);
+
+    ValidateTemperatures();
+}
+
+void MeshValidationHandler::HandleStartOrCancelButton(DGUS_VP_Variable &var, void *val_ptr) {
+    if (!is_running) {
+        Start();
+    } else {
+        Cancel();
+    }
+}
+
+void MeshValidationHandler::Start() {
+    if (is_running) return;
+
+    // Validate
+    if (!ExtUI::getMeshValid()) {
+        SetStatusMessage("Please level bed first");
+        return;
+    }
+
+    // Block
+    ScreenHandler.SetSynchronousOperationStart();
+    is_running = true;
+    started_from_screen = true;
+
+    // Home if necessary - do this synchronously
+    if (!all_axes_trusted()) {
+        queue.inject_P("G28 U0");
+        queue.advance();
+    }
+
+    // Home X and Y so we droop at the side of the bed.
+    // G26 with temperature and set for full bed, full pattern, retract 4mm, prime 5mm
+    char gcodeBuffer[128] = {0};
+    sprintf_P(gcodeBuffer, PSTR("G90\nG0 X0\nG26 B%d H%d R Q4 P2 X0 Y0"), bed_temperature, nozzle_temperature);
+    queue.inject(gcodeBuffer);
+    queue.advance();
+
+    // Set feedrate
+    prev_feedrate = ExtUI::getFeedrate_mm_s();
+    ExtUI::setFeedrate_mm_s(MESH_VALIDATION_PATTERN_FEEDRATE);
+
+    SetStatusMessage("Starting...");
+}
+
+void MeshValidationHandler::Cancel() {
+    if (is_cancelling) return;
+
+    is_cancelling = true;
+    ExtUI::simulateUserClick();
+
+    SetStatusMessage("Cancelling...");
+}
+
+void MeshValidationHandler::OnMeshValidationStart() {
+    // Note: can also be called when manually invoking G26
+    if (ScreenHandler.getCurrentScreen() != DGUSLCD_SCREEN_MESH_VALIDATION) {
+        ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MESH_VALIDATION);
+    }
+
+    // Set state
+    ScreenHandler.SetSynchronousOperationStart();
+    is_running = true;
+}
+
+void MeshValidationHandler::OnMeshValidationFinish() {
+    // If invoked externally, pop back
+    if (!started_from_screen) {
+        ScreenHandler.PopToOldScreen();
+    }
+
+    if (started_from_screen) {
+        ExtUI::setFeedrate_mm_s(prev_feedrate);
+
+        char gcodeBuffer[128] = {0};
+        if (!is_cancelling) {
+            // Present
+            // - Set absolute mode
+            // - Present bed, high Z
+            // - Disable stepper
+            strcpy_P(gcodeBuffer, PSTR("M84"));
+
+            SetStatusMessage("Mesh validation pattern printed");
+        } else {
+            // Park and disable steppers
+            strcpy_P(gcodeBuffer, PSTR("G0 X5 F2000\nG27\nM84"));
+
+            SetStatusMessage("Canceled mesh validation pattern");
+        }
+
+        // Enqueue
+        gcode.process_subcommands_now(gcodeBuffer);
+    }
+
+    // Reset state
+    is_running = false;
+    started_from_screen = false;
+    is_cancelling = false;
+
+    ScreenHandler.SetSynchronousOperationFinish();
+    ExtUI::simulateUserClick();
+}
+
+void MeshValidationHandler::ValidateTemperatures() {
+    LIMIT(nozzle_temperature, EXTRUDE_MINTEMP, HEATER_0_MAXTEMP - HOTEND_OVERSHOOT);
+    LIMIT(bed_temperature, 40 /*Hardcoded minimum for G26, apparently*/, BED_MAXTEMP - BED_OVERSHOOT);
+}
+
+void MeshValidationHandler::SetStatusMessage(PGM_P statusMessage) {
+    ScreenHandler.setstatusmessagePGM(statusMessage);
+}
+
+#endif
@@ -0,0 +1,33 @@
+#include <cstdint>
+#if HAS_MESH
+class MeshValidationHandler {
+    public:
+        static void Init();
+
+        static void HandleTemperature(DGUS_VP_Variable &var, void *val_ptr);
+
+        static void HandleStartOrCancelButton(DGUS_VP_Variable &var, void *val_ptr);
+
+        static void OnMeshValidationStart();
+        static void OnMeshValidationFinish();
+
+    public:
+        static celsius_t nozzle_temperature;
+        static celsius_t bed_temperature;
+
+        static feedRate_t prev_feedrate;
+
+        static bool is_cancelling;
+        static bool is_running;
+        static bool started_from_screen;
+
+    private:
+        static void Start();
+        static void Cancel();
+
+        static void ValidateTemperatures();
+        static void SetStatusMessage(PGM_P statusMessage);
+};
+
+constexpr feedRate_t MESH_VALIDATION_PATTERN_FEEDRATE = G26_XY_FEEDRATE;
+#endif
@@ -0,0 +1,91 @@
+
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+
+#include "../DGUSDisplayDef.h"
+#include "../DGUSDisplay.h"
+#include "../DGUSScreenHandler.h"
+
+#include "PIDHandler.h"
+
+#include "../../ui_api.h"
+#include "../../../marlinui.h"
+
+#include "../../../../module/temperature.h"
+#include "../../../../module/settings.h"
+#include "../../../../module/planner.h"
+#include "../../../../gcode/gcode.h"
+
+// Storage init
+uint16_t PIDHandler::cycles = 0;
+celsius_t PIDHandler::calibration_temperature = 0;
+bool PIDHandler::fan_on = false;
+PGM_P PIDHandler::result_message = nullptr;
+
+void PIDHandler::Init() {
+    // Reset
+    cycles = 3;
+
+    fan_on = ExtUI::getTargetFan_percent(ExtUI::fan_t::FAN0) > 10;
+
+    // Use configured PLA temps + 10 degrees
+    calibration_temperature = ui.material_preset[0].hotend_temp + 15;
+
+    // Welcome message
+    SetStatusMessage(PSTR("Ready"));
+}
+
+
+void PIDHandler::HandleStartButton(DGUS_VP_Variable &var, void *val_ptr) {
+    //static_assert(ADVANCED_PAUSE_PURGE_LENGTH == 0, "Assuming PURGE_LENGTH is 0 so we can use M701");
+
+    // Validate
+    if (calibration_temperature < EXTRUDE_MINTEMP) {
+        SetStatusMessage(PSTR("Invalid temperature set"));
+        return;
+    }
+
+    if (calibration_temperature > HEATER_0_MAXTEMP) {
+        SetStatusMessage(PSTR("Invalid temperature set"));
+        return;
+    }
+
+    if (cycles < 1) {
+        SetStatusMessage(PSTR("Invalid number of cycles"));
+        return;
+    }
+
+    // Synchronous operation - disable back button
+    DGUSSynchronousOperation syncOperation;
+    syncOperation.start();
+
+    // Fan
+    const auto prev_fan_percentage = ExtUI::getActualFan_percent(ExtUI::fan_t::FAN0);
+    const uint8_t fan_speed = fan_on ? 255 : 0;
+
+    // Set-up command
+    SetStatusMessage(PSTR("PID tuning. Please wait..."));
+
+    char cmd[64]; // Add a G4 to allow the fan speed to take effect
+    sprintf_P(cmd, PSTR("M106 S%d\nG4 S2\nM303 S%d C%d U1"), fan_speed, calibration_temperature, cycles);
+    SERIAL_ECHOLNPGM("Executing: ", cmd);
+
+    ExtUI::injectCommands(cmd);
+    while (queue.has_commands_queued()) queue.advance();
+
+    // Done
+    ExtUI::setTargetFan_percent(prev_fan_percentage, ExtUI::fan_t::FAN0);
+
+    ScreenHandler.Buzzer(0, 250);
+    settings.save();
+    syncOperation.done();
+
+    SetStatusMessage(result_message);
+}
+
+void PIDHandler::SetStatusMessage(PGM_P statusMessage) {
+    ScreenHandler.setstatusmessagePGM(statusMessage);
+}
+
+#endif
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cstdint>
+
+class PIDHandler {
+    public:
+        static void Init();
+
+        static void HandleStartButton(DGUS_VP_Variable &var, void *val_ptr);
+
+    public:
+        static uint16_t cycles;
+        static celsius_t calibration_temperature;
+        static bool fan_on;
+        static PGM_P result_message;
+
+    private:
+
+        static void SetStatusMessage(PGM_P statusMessage);
+};
+
@@ -0,0 +1,470 @@
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+
+#include "../DGUSDisplayDef.h"
+#include "../DGUSDisplay.h"
+#include "../DGUSScreenHandler.h"
+
+#include "../../../../module/temperature.h"
+#include "../../../../module/motion.h"
+#include "../../../../module/planner.h"
+#include "../../../../feature/pause.h"
+#include "../../../../gcode/gcode.h"
+
+#if ENABLED(FILAMENT_RUNOUT_SENSOR)
+#include "../../../../feature/runout.h"
+#endif
+
+#include "../../../../module/settings.h"
+
+#include "../../ui_api.h"
+#include "../../../marlinui.h"
+
+#include "PageHandlers.h"
+
+
+// Definitions of page handlers
+
+void MainMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP) {
+        case VP_BUTTON_MAINENTERKEY:
+            switch (buttonValue) {
+                case 1:
+                    // Try to mount an unmounted card (BTT SKR board has especially some trouble sometimes)
+                    card.mount();
+                    ScreenHandler.SDCardInserted();
+                    break;
+
+                case 2:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PREPARE);
+                    break;
+
+                case 3:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_SETUP);
+                    break;
+
+                case 4:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_CALIBRATE);
+                    break;
+            }
+            break;
+    }
+}
+
+void SetupMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP) {
+        case VP_BUTTON_PREPAREENTERKEY:
+            switch(buttonValue) {
+                case 5: // About
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_INFO);
+                    break;
+
+                case 7: // Reset to factory settings
+                    settings.reset();
+                    settings.save();
+
+                    ExtUI::injectCommands_P(PSTR("M300"));
+
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN, false);
+                    ScreenHandler.setstatusmessagePGM(PSTR("Restored default settings. Please turn your printer off and then on to complete the reset"));
+                    break;
+            }
+            break;
+
+        case VP_BUTTON_TEMPCONTROL:
+            if (buttonValue == 2) ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TEMP);
+            break;
+
+        case VP_BUTTON_ADJUSTENTERKEY:
+            ScreenHandler.HandleLEDToggle();
+            break;
+    }
+}
+
+#if HAS_MESH
+  void LevelingModeHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+      switch (var.VP) {
+          case VP_BUTTON_BEDLEVELKEY:
+              switch (buttonValue) {
+                  case 1:
+                      queue.enqueue_one("G28 U0");
+                      queue.enqueue_one("G0 Z0");
+                  break;
+
+                  case 2:
+                      // Increase Z-offset
+                      ExtUI::smartAdjustAxis_steps(ExtUI::mmToWholeSteps(0.01, ExtUI::axis_t::Z), ExtUI::axis_t::Z, true);;
+                      ScreenHandler.ForceCompleteUpdate();
+                      ScreenHandler.RequestSaveSettings();
+                      break;
+
+                  case 3:
+                      // Decrease Z-offset
+                      ExtUI::smartAdjustAxis_steps(ExtUI::mmToWholeSteps(-0.01, ExtUI::axis_t::Z), ExtUI::axis_t::Z, true);;
+                      ScreenHandler.ForceCompleteUpdate();
+                      ScreenHandler.RequestSaveSettings();
+                      break;
+              }
+
+              break;
+
+          case VP_BUTTON_PREPAREENTERKEY:
+              if (buttonValue == 9) {
+                  #if DISABLED(HOTEND_IDLE_TIMEOUT)
+                      thermalManager.disable_all_heaters();
+                  #endif
+
+                  ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN, false);
+              }
+
+              if (buttonValue == 1) {
+                  // TODO: set state for "view leveling mesh"
+                  ScreenHandler.SetViewMeshLevelState();
+                  ScreenHandler.InitMeshValues();
+
+                  ScreenHandler.GotoScreen(DGUSLCD_SCREEN_LEVELING);
+              }
+              break;
+
+          case VP_BUTTON_MAINENTERKEY:
+              // Go to leveling screen
+              ExtUI::injectCommands_P("G28 U0\nG29 U0");
+
+              ScreenHandler.ResetMeshValues();
+
+              dgusdisplay.WriteVariable(VP_MESH_SCREEN_MESSAGE_ICON, static_cast<uint16_t>(MESH_SCREEN_MESSAGE_ICON_LEVELING));
+              ScreenHandler.GotoScreen(DGUSLCD_SCREEN_LEVELING);
+              break;
+      }
+  }
+
+  void LevelingHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+      switch (var.VP) {
+          case VP_BUTTON_BEDLEVELKEY:
+            const bool busy = TERN0(HOST_KEEPALIVE_FEATURE, ((ExtUI::getHostKeepaliveState() == GcodeSuite::MarlinBusyState::IN_PROCESS) || (ExtUI::getHostKeepaliveState() == GcodeSuite::MarlinBusyState::IN_HANDLER)));
+              if (!busy) {
+                  ScreenHandler.PopToOldScreen();
+              } else {
+                  ScreenHandler.setstatusmessagePGM("Wait for leveling completion...");
+              }
+              break;
+      }
+  }
+#endif
+
+void TempMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP) {
+        case VP_BUTTON_ADJUSTENTERKEY:
+            switch (buttonValue) {
+                case 3:
+                    ScreenHandler.HandleFanToggle();
+                break;
+            }
+
+            break;
+
+        case VP_BUTTON_TEMPCONTROL:
+            switch (buttonValue){
+                case 3:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TEMP_PLA);
+                    break;
+
+                case 4:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TEMP_ABS);
+                    break;
+            }
+            break;
+    }
+}
+
+void PrepareMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP) {
+        case VP_BUTTON_PREPAREENTERKEY:
+            switch (buttonValue){
+                case 3:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE10MM);
+                    break;
+
+                case 6:
+                    // Disable steppers
+                    ScreenHandler.HandleMotorLockUnlock(var, &buttonValue);
+                    break;
+            }
+        break;
+
+        case VP_BUTTON_HEATLOADSTARTKEY:
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_FEED);
+        break;
+
+        case VP_BUTTON_COOLDOWN:
+            ScreenHandler.HandleAllHeatersOff(var, &buttonValue);
+            break;
+
+        case VP_BUTTON_TEMPCONTROL:
+            switch (buttonValue) {
+                case 5:
+                    thermalManager.setTargetHotend(ui.material_preset[0].hotend_temp, 0);
+                    thermalManager.setTargetBed(ui.material_preset[0].bed_temp);
+
+                    break;
+
+                case 6:
+                    thermalManager.setTargetHotend(ui.material_preset[1].hotend_temp, 0);
+                    thermalManager.setTargetBed(ui.material_preset[1].bed_temp);
+                    break;
+            }
+            break;
+    }
+
+    ScreenHandler.ForceCompleteUpdate();
+}
+
+void TuneMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP) {
+        case VP_BUTTON_BEDLEVELKEY:
+            switch (buttonValue) {
+                case 2:
+                    // Increase Z-offset
+                    ExtUI::smartAdjustAxis_steps(ExtUI::mmToWholeSteps(0.01, ExtUI::axis_t::Z), ExtUI::axis_t::Z, true);;
+                    ScreenHandler.ForceCompleteUpdate();
+                    ScreenHandler.RequestSaveSettings();
+                    break;
+
+                case 3:
+                    // Decrease Z-offset
+                    ExtUI::smartAdjustAxis_steps(ExtUI::mmToWholeSteps(-0.01, ExtUI::axis_t::Z), ExtUI::axis_t::Z, true);;
+                    ScreenHandler.ForceCompleteUpdate();
+                    ScreenHandler.RequestSaveSettings();
+                    break;
+            }
+
+            break;
+
+        case VP_BUTTON_ADJUSTENTERKEY:
+            switch (buttonValue) {
+                case 2:
+                    ScreenHandler.GotoScreen(ExtUI::isPrintingPaused() ? DGUSLCD_SCREEN_PRINT_PAUSED : DGUSLCD_SCREEN_PRINT_RUNNING, false);
+                    break;
+
+                case 3:
+                    ScreenHandler.HandleFanToggle();
+                break;
+
+                case 4:
+                    ScreenHandler.HandleLEDToggle();
+                break;
+            }
+    }
+}
+
+void PrintRunningMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP) {
+        case VP_BUTTON_ADJUSTENTERKEY:
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TUNING);
+        break;
+
+        case VP_BUTTON_PAUSEPRINTKEY:
+          if (!ScreenHandler.HandlePendingUserConfirmation() && ExtUI::isPrintingPaused()) {
+            ExtUI::resumePrint();
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING);
+          } else
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_DIALOG_PAUSE);
+        break;
+
+        case VP_BUTTON_STOPPRINTKEY:
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_DIALOG_STOP);
+        break;
+    }
+}
+
+void PrintPausedMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP) {
+        case VP_BUTTON_RESUMEPRINTKEY:
+          #if ENABLED(FILAMENT_RUNOUT_SENSOR)
+            runout.reset();
+          #endif
+
+          if (!ScreenHandler.HandlePendingUserConfirmation()) {
+            ExtUI::resumePrint();
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING);
+          }
+        break;
+
+        case VP_BUTTON_ADJUSTENTERKEY:
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_TUNING);
+        break;
+
+        case VP_BUTTON_STOPPRINTKEY:
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_DIALOG_STOP);
+        break;
+    }
+}
+
+void PrintPauseDialogHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP){
+        case VP_BUTTON_PAUSEPRINTKEY:
+            switch (buttonValue) {
+                case 2:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING);
+                    ScreenHandler.setstatusmessagePGM(PSTR("Pausing print - please wait..."));
+                    ExtUI::pausePrint();
+                    break;
+
+                case 3:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING);
+                    break;
+            }
+            break;
+    }
+}
+
+void PrintFinishMenuHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP){
+        case VP_BUTTON_MAINENTERKEY:
+            switch (buttonValue) {
+                case 5:
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN);
+                    break;
+            }
+            break;
+    }
+}
+
+void FilamentRunoutHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP){
+        case VP_BUTTON_RESUMEPRINTKEY:
+            ExtUI::resumePrint();
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING);
+        break;
+
+        case VP_BUTTON_STOPPRINTKEY:
+            ExtUI::stopPrint();
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN);
+        break;
+    }
+}
+
+void StopConfirmScreenHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP){
+        case VP_BUTTON_STOPPRINTKEY:
+            switch (buttonValue) {
+                case 2:
+                    ExtUI::stopPrint();
+                    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MAIN);
+                break;
+
+                case 3:
+                    ScreenHandler.GotoScreen(ExtUI::isPrintingPaused() ? DGUSLCD_SCREEN_PRINT_PAUSED : DGUSLCD_SCREEN_PRINT_RUNNING);
+                break;
+            }
+        break;
+    }
+}
+
+void PreheatSettingsScreenHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    switch (var.VP){
+        case VP_BUTTON_PREPAREENTERKEY:
+            // Save button, save settings and go back
+            ScreenHandler.RequestSaveSettings();
+            ScreenHandler.PopToOldScreen();
+        break;
+
+        case VP_BUTTON_COOLDOWN: // You can't make this up
+            // Back button, discard settings
+            settings.load();
+            ScreenHandler.PopToOldScreen();
+            break;
+    }
+}
+
+void MoveHandler(DGUS_VP_Variable &var, unsigned short buttonValue) {
+    if (var.VP == VP_BUTTON_MOVEKEY) {
+        switch (buttonValue) {
+        case 1:
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE10MM, false);
+            break;
+        case 2:
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE1MM, false);
+            break;
+        case 3:
+            ScreenHandler.GotoScreen(DGUSLCD_SCREEN_MOVE01MM, false);
+            break;
+        case 4:
+            // Temporary copy probe settings so we home without preheating, then restore setings afterward
+            //This machine should never home Z cold...
+            //auto prev_probe_settings = probe.settings;
+
+            //probe.settings.preheat_bed_temp = 0;
+            //probe.settings.preheat_hotend_temp = 0;
+            //probe.settings.stabilize_temperatures_after_probing = false;
+
+            ExtUI::injectCommands_P("G28");
+            while (queue.has_commands_queued()) queue.advance();
+
+            // ... Restore settings
+            //probe.settings = prev_probe_settings;
+            break;
+        }
+    }
+}
+
+// Register the page handlers
+#define PAGE_HANDLER(SCRID, HDLRPTR) { .ScreenID=SCRID, .Handler=HDLRPTR },
+const struct PageHandler PageHandlers[] PROGMEM = {
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_MAIN, MainMenuHandler)
+
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_SETUP, SetupMenuHandler)
+
+    #if HAS_MESH
+      PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_ZOFFSET_LEVEL, LevelingModeHandler)
+      PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_LEVELING, LevelingHandler)
+    #endif
+
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_TEMP, TempMenuHandler)
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_TEMP_PLA, PreheatSettingsScreenHandler)
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_TEMP_ABS, PreheatSettingsScreenHandler)
+
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_TUNING, TuneMenuHandler)
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_MOVE01MM, MoveHandler)
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_MOVE1MM, MoveHandler)
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_MOVE10MM, MoveHandler)
+
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_FILAMENTRUNOUT1, FilamentRunoutHandler)
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_FILAMENTRUNOUT2, FilamentRunoutHandler)
+
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_DIALOG_STOP, StopConfirmScreenHandler)
+
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_PRINT_RUNNING, PrintRunningMenuHandler)
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_PRINT_PAUSED, PrintPausedMenuHandler)
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_PRINT_FINISH, PrintFinishMenuHandler)
+
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_DIALOG_PAUSE, PrintPauseDialogHandler)
+
+    PAGE_HANDLER(DGUSLCD_Screens::DGUSLCD_SCREEN_PREPARE, PrepareMenuHandler)
+
+    // Terminating
+    PAGE_HANDLER(static_cast<DGUSLCD_Screens>(0) ,0)
+};
+
+void DGUSCrealityDisplay_HandleReturnKeyEvent(DGUS_VP_Variable &var, void *val_ptr) {
+  const struct PageHandler *map = PageHandlers;
+  const uint16_t *ret;
+  const DGUSLCD_Screens current_screen = DGUSScreenHandler::getCurrentScreen();
+
+  while ((ret = (uint16_t*) pgm_read_ptr(&(map->Handler)))) {
+    if ((map->ScreenID) == current_screen) {
+        uint16_t button_value = uInt16Value(val_ptr);
+
+        SERIAL_ECHOLNPGM("Invoking handler for screen ", current_screen);
+        SERIAL_ECHOLNPGM("with VP=", var.VP, " value=", button_value);
+
+        map->Handler(var, button_value);
+        return;
+    }
+
+    map++;
+  }
+}
+
+#endif
@@ -0,0 +1,11 @@
+#pragma once
+
+// Mapping of handlers per page. This construction is necessary because the CR-6 touch screen re-uses the same button IDs all over the place.
+typedef void (*DGUS_CREALITY_SCREEN_BUTTON_HANDLER)(DGUS_VP_Variable &var, unsigned short buttonValue);
+
+struct PageHandler {
+  DGUSLCD_Screens ScreenID;
+  DGUS_CREALITY_SCREEN_BUTTON_HANDLER Handler;
+};
+
+void DGUSCrealityDisplay_HandleReturnKeyEvent(DGUS_VP_Variable &var, void *val_ptr);
@@ -0,0 +1,272 @@
+/**
+ * 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/>.
+ *
+ */
+
+/**
+ * dgus_creality_lcd.cpp
+ *
+ * DGUS implementation written by coldtobi in 2019 for Marlin
+ */
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+
+#include "ui_api.h"
+#include "../marlinui.h"
+#include "./dgus_creality/DGUSDisplay.h"
+#include "./dgus_creality/DGUSDisplayDef.h"
+#include "./dgus_creality/DGUSScreenHandler.h"
+#include "./dgus_creality/creality_touch/PIDHandler.h"
+#include "./dgus_creality/creality_touch/MeshValidationHandler.h"
+
+#if ENABLED(POWER_LOSS_RECOVERY)
+  #include "../../feature/powerloss.h"
+#endif
+
+extern const char NUL_STR[];
+
+namespace ExtUI {
+
+  void onStartup() {
+    ScreenHandler.Init();
+    ScreenHandler.UpdateScreenVPData();
+  }
+
+  void onIdle() { ScreenHandler.loop(); }
+
+  void onPrinterKilled(FSTR_P const error, FSTR_P const component) {
+    ScreenHandler.sendinfoscreen(GET_TEXT_F(MSG_HALTED), error, GET_TEXT_F(MSG_PLEASE_RESET), GET_TEXT_F(MSG_PLEASE_RESET), true, true, true, true);
+
+    if (error == GET_TEXT_F(MSG_ERR_MAXTEMP) || error == GET_TEXT_F(MSG_THERMAL_RUNAWAY))     {
+      ScreenHandler.GotoScreen(DGUSLCD_SCREEN_THERMAL_RUNAWAY);
+    } else if ( error == GET_TEXT_F(MSG_HEATING_FAILED_LCD)) {
+      ScreenHandler.GotoScreen(DGUSLCD_SCREEN_HEATING_FAILED);
+    }else if (error == GET_TEXT_F(MSG_ERR_MINTEMP)) {
+      ScreenHandler.GotoScreen(DGUSLCD_SCREEN_THERMISTOR_ERROR);
+    } else {
+      ScreenHandler.GotoScreen(DGUSLCD_SCREEN_KILL);
+    }
+
+    ScreenHandler.KillScreenCalled();
+    while (!ScreenHandler.loop());  // Wait while anything is left to be sent
+}
+
+  void onMediaInserted() { TERN_(SDSUPPORT, ScreenHandler.SDCardInserted()); }
+  void onMediaError()    { TERN_(SDSUPPORT, ScreenHandler.SDCardError()); }
+  void onMediaRemoved()  { TERN_(SDSUPPORT, ScreenHandler.SDCardRemoved()); }
+
+  void onPlayTone(const uint16_t frequency, const uint16_t duration) {
+    if (ScreenHandler.getCurrentScreen() == DGUSLCD_SCREEN_FEED) {
+        // We're in the feed (load filament) workflow - no beep - there is no confirmation
+        return;
+    }
+
+    ScreenHandler.Buzzer(frequency, duration);
+  }
+
+bool hasPrintTimer = false;
+
+  void onPrintTimerStarted() {
+    hasPrintTimer = true;
+
+    if (!IS_SD_FILE_OPEN() && !(PrintJobRecovery::valid() && PrintJobRecovery::exists())) {
+      ScreenHandler.SetPrintingFromHost();
+    }
+
+#if ENABLED(LCD_SET_PROGRESS_MANUALLY)
+    ui.progress_reset();
+#endif
+
+    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_RUNNING);
+  }
+
+  void onPrintTimerPaused() {
+    // Handle M28 Pause SD print - But only if we're not waiting on a user
+    if (ExtUI::isPrintingFromMediaPaused() && ScreenHandler.getCurrentScreen() == DGUSLCD_SCREEN_PRINT_RUNNING && !ExtUI::awaitingUserConfirm()) {
+      ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_PAUSED);
+    }
+  }
+
+  void onPrintTimerStopped() {
+    hasPrintTimer = false;
+
+    ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_FINISH);
+  }
+
+  void onFilamentRunout(const extruder_t extruder) {
+    // Only navigate to filament runout screen when we don't use M600 for changing the filament - otherwise it gets confusing for the user
+    #ifndef FILAMENT_RUNOUT_SCRIPT
+      #define FILAMENT_RUNOUT_SCRIPT "M25"
+    #endif
+    if (strcmp_P(FILAMENT_RUNOUT_SCRIPT, PSTR("M600")) != 0) {
+      ScreenHandler.FilamentRunout();
+    }
+  }
+
+  void onUserConfirmed() {
+    SERIAL_ECHOLN("User confirmation invoked");
+    setPauseMenuResponse(PAUSE_RESPONSE_RESUME_PRINT);
+    ExtUI::setUserConfirmed();
+  }
+
+  void onUserConfirmRequired(const char * const msg) {
+    //if (msg) {
+      SERIAL_ECHOLNPGM("User confirmation requested: ", msg);
+
+      if (ScreenHandler.getCurrentScreen() == DGUSLCD_SCREEN_FEED) {
+        // We're in the feed (load filament) workflow - immediately assume confirmed
+        onUserConfirmed();
+        return;
+      }
+
+      ScreenHandler.setstatusmessagePGM(msg);
+      ScreenHandler.sendinfoscreen("Confirmation required", msg, NUL_STR, "Ok", true, true, false, true);
+
+      if (ExtUI::isPrinting()) {
+        ScreenHandler.GotoScreen(DGUSLCD_SCREEN_PRINT_PAUSED);
+      } else {
+        ScreenHandler.GotoScreen(DGUSLCD_SCREEN_POPUP);
+      }
+    //}
+    //else if (ScreenHandler.getCurrentScreen() == DGUSLCD_SCREEN_POPUP) {
+    //  DEBUG_ECHOLNPAIR("User confirmation canceled");
+
+    //  ScreenHandler.setstatusmessagePGM(nullptr);
+    //  ScreenHandler.PopToOldScreen();
+    //}
+  }
+
+  void onStatusChanged(const char * const msg) { ScreenHandler.setstatusmessage(msg); }
+
+  void onFactoryReset() {
+    ScreenHandler.OnFactoryReset();
+  }
+
+   void onHomingStart() {
+    ScreenHandler.OnHomingStart();
+  }
+
+  void onHomingDone() {
+    ScreenHandler.OnHomingComplete();
+  }
+
+  void onPrintDone() {
+    ScreenHandler.OnPrintFinished();
+  }
+
+  void onStoreSettings(char *buff) {
+    ScreenHandler.StoreSettings(buff);
+  }
+
+  void onLoadSettings(const char *buff) {
+    ScreenHandler.LoadSettings(buff);
+  }
+
+  void onPostprocessSettings() {
+    // Called after loading or resetting stored settings
+  }
+
+  void onSettingsStored(bool success) {
+    // Called after the entire EEPROM has been written,
+    // whether successful or not.
+  }
+
+  void onSettingsLoaded(bool success) {
+    // Called after the entire EEPROM has been read,
+    // whether successful or not.
+  }
+
+  #if HAS_MESH
+    void onLevelingStart() {
+      #if HAS_BED_PROBE
+        ScreenHandler.OnMeshLevelingStart();
+      #endif
+    }
+
+    void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {
+      #if HAS_BED_PROBE
+        ScreenHandler.OnMeshLevelingUpdate(xpos, ypos, zval);
+      #endif
+    }
+
+    void onMeshUpdate(const int8_t xpos, const int8_t ypos, const ExtUI::probe_state_t state) {
+      #if HAS_BED_PROBE
+        ScreenHandler.OnMeshLevelingUpdate(xpos, ypos, 0);
+      #endif
+    }
+    void onLevelingDone() {
+
+    }
+
+  #endif
+
+  #if ENABLED(POWER_LOSS_RECOVERY)
+    void onPowerLossResume() {
+      // Called on resume from power-loss
+      ScreenHandler.OnPowerlossResume();
+    }
+  #endif
+
+
+  #if HAS_PID_HEATING
+    void onPidTuning(const result_t rst) {
+      // Called for temperature PID tuning result
+      switch (rst) {
+        case PID_BAD_HEATER_ID:
+          PIDHandler::result_message = GET_TEXT(MSG_PID_BAD_HEATER_ID);
+          ScreenHandler.setstatusmessagePGM(PIDHandler::result_message);
+          break;
+        case PID_TEMP_TOO_HIGH:
+          PIDHandler::result_message = GET_TEXT(MSG_PID_TEMP_TOO_HIGH);
+          ScreenHandler.setstatusmessagePGM(PIDHandler::result_message);
+          break;
+        case PID_TUNING_TIMEOUT:
+          PIDHandler::result_message = GET_TEXT(MSG_PID_TIMEOUT);
+          ScreenHandler.setstatusmessagePGM(PIDHandler::result_message);
+          break;
+        case PID_DONE:
+          PIDHandler::result_message = GET_TEXT(MSG_PID_AUTOTUNE_DONE);
+          ScreenHandler.setstatusmessagePGM(PIDHandler::result_message);
+          break;
+		default:
+		  break;
+      }
+    }
+  #endif
+
+  void onSteppersDisabled() {
+  }
+
+  void onSteppersEnabled() {
+  }
+
+  #if HAS_MESH
+    void onMeshValidationStarting() {
+      MeshValidationHandler::OnMeshValidationStart();
+    }
+
+    void onMeshValidationFinished() {
+      MeshValidationHandler::OnMeshValidationFinish();
+    }
+  #endif
+}
+#endif // HAS_DGUS_LCD
@@ -395,7 +395,12 @@ void DGUSReturnKeyCodeHandler::Command_SettingsMenu(DGUS_VP &vp, void *data) {
 }

 static void _gotoTrammingPoint(unsigned char point) {
-  constexpr float lfrb[4] = BED_TRAMMING_INSET_LFRB;
+  #if ENABLED(BED_TRAMMING_USE_PROBE)
+      float lfrb[4] = {X_MIN_BED + probe.min_x(), Y_MIN_BED + probe.min_y(),
+             X_MAX_BED - probe.max_x(), Y_MAX_BED - probe.max_y() };
+  #else
+    constexpr float lfrb[4] = BED_TRAMMING_INSET_LFRB;
+  #endif
  float x, y;

  switch (point) {
@@ -38,6 +38,9 @@
 #if ENABLED(ADVANCED_PAUSE_FEATURE)
  #include "../../../feature/pause.h"
 #endif
+#if ENABLED(BED_TRAMMING_USE_PROBE)
+  #include "../../../module/probe.h"
+#endif
 #if ENABLED(POWER_LOSS_RECOVERY)
  #include "../../../feature/powerloss.h"
 #endif
@@ -464,7 +467,14 @@ void DGUSRxHandler::moveToPoint(DGUS_VP &vp, void *data_ptr) {
  }

  const uint8_t point = ((uint8_t*)data_ptr)[1];
-  constexpr float lfrb[4] = BED_TRAMMING_INSET_LFRB;
+
+  #if ENABLED(BED_TRAMMING_USE_PROBE)
+      float lfrb[4] = {X_MIN_BED + probe.min_x(), Y_MIN_BED + probe.min_y(),
+             X_MAX_BED - probe.max_x(), Y_MAX_BED - probe.max_y() };
+  #else
+    constexpr float lfrb[4] = BED_TRAMMING_INSET_LFRB;
+  #endif
+
  float x, y;

  switch (point) {
@@ -34,14 +34,13 @@ void FilamentRunoutScreen::onRedraw(draw_mode_t what) {
  w.heading(   GET_TEXT_F(MSG_FILAMENT));
  w.toggle( 2, GET_TEXT_F(MSG_RUNOUT_SENSOR), getFilamentRunoutEnabled());

-  #if HAS_FILAMENT_RUNOUT_DISTANCE
-    w.heading(GET_TEXT_F(MSG_RUNOUT_DISTANCE_MM));
-    w.units(GET_TEXT_F(MSG_UNITS_MM));
-    w.precision(0);
-    w.color(e_axis);
-    w.adjuster( 10, FPSTR(NUL_STR), getFilamentRunoutDistance_mm(), getFilamentRunoutEnabled());
-    w.increments();
-  #endif
+  w.heading(GET_TEXT_F(MSG_RUNOUT_DISTANCE_MM));
+  w.units(GET_TEXT_F(MSG_UNITS_MM));
+  w.precision(0);
+  w.color(e_axis);
+  w.adjuster( 10, FPSTR(NUL_STR), getFilamentRunoutDistance_mm(), getFilamentRunoutEnabled());
+  w.increments();
+
 }

 bool FilamentRunoutScreen::onTouchHeld(uint8_t tag) {
@@ -49,10 +48,8 @@ bool FilamentRunoutScreen::onTouchHeld(uint8_t tag) {
  const float increment = getIncrement();
  switch (tag) {
    case 2: setFilamentRunoutEnabled(!getFilamentRunoutEnabled()); break;
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      case  10: UI_DECREMENT(FilamentRunoutDistance_mm); break;
-      case  11: UI_INCREMENT(FilamentRunoutDistance_mm); break;
-    #endif
+    case  10: UI_DECREMENT(FilamentRunoutDistance_mm); break;
+    case  11: UI_INCREMENT(FilamentRunoutDistance_mm); break;
    default:
      return false;
  }
@@ -0,0 +1,303 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+/* ****************************************
+ * lcd/extui/lib/Creality/Creality_DWIN.h
+ * ****************************************
+ * Extensible_UI implementation for Creality DWIN
+ * 10SPro, Max, CRX, and others
+ * Based original Creality release, ported to ExtUI for Marlin 2.0
+ * Written by Insanity Automation, sponsored by Tiny Machines 3D
+ *
+ * ***************************************/
+
+#pragma once
+
+#include "string.h"
+#include <Arduino.h>
+#include "../ui_api.h"
+#if ENABLED(EXTENSIBLE_UI)
+namespace ExtUI {
+/*********************************/
+#define FHONE   (0x5A)
+#define FHTWO   (0xA5)
+#define FHLENG  (0x06)
+
+#define TEXTBYTELEN		18
+#define MaxFileNumber	20// 16
+
+#define	CEIconGrap	12
+#define	FileNum	MaxFileNumber
+#define	FileNameLen	TEXTBYTELEN
+
+#define SizeofDatabuf		46
+
+/*************Register and Variable addr*****************/
+#define	RegAddr_W	0x80
+#define	RegAddr_R	0x81
+#define	VarAddr_W	0x82
+#define	VarAddr_R	0x83
+#define	ExchangePageBase	(unsigned long)0x5A010000	//the first page ID. other page = first page ID + relevant num;
+#define	StartSoundSet	((unsigned long)0x060480A0)		// 06,start-music; 04, 4 musics; 80, the volume value; 04, return value about music number.
+#define	FONT_EEPROM	90
+#define	AutoLeve_EEPROM	100
+#define	FanOn	255
+#define FanOff	0
+
+/*variable addr*/
+#define	ExchangepageAddr	0x0084
+#define	SoundAddr			0x00A0
+#define	StartIcon			0x1000
+#define	FeedrateDisplay		0x1006 // Speed
+#define	Stopprint			0x1008
+#define	Pauseprint			0x100A
+#define	Resumeprint			0x100C
+#define	PrintscheduleIcon		0x100E
+#define	Timehour			0x1010
+#define	Timemin				0x1012
+#define	Percentage			0x1016
+#define	FanKeyIcon			0x101E
+#define Flowrate        0x1300
+
+#define RunoutToggle    0x1018
+#define PowerLossToggle 0x101A
+#define LedToggle       0x101C
+
+#define StepMM_X      0x1242
+#define StepMM_Y      0x1246
+#define StepMM_Z      0x124A
+#define StepMM_E      0x124E
+
+#define ProbeOffset_X  0x1236
+#define ProbeOffset_Y  0x123A
+#define ProbeOffset_Z  0x1026
+
+#define T2Offset_X    0x1090
+#define T2Offset_Y    0x1094
+#define T2Offset_Z    0x1098
+#define T2StepMM_E    0x109C
+
+#define ActiveToolVP  0x1014
+
+#define HotendPID_AutoTmp 0x1252
+#define BedPID_AutoTmp    0x1254
+
+#define HotendPID_P 0x1256
+#define HotendPID_I 0x125A
+#define HotendPID_D 0x125E
+
+#define BedPID_P 0x1262
+#define BedPID_I 0x1266
+#define BedPID_D 0x126A
+
+#define Jerk_X 0x1270
+#define Jerk_Y 0x1272
+#define Jerk_Z 0x1274
+#define Jerk_E 0x1276
+
+#define Feed_X 0x1278
+#define Feed_Y 0x127A
+#define Feed_Z 0x127C
+#define Feed_E 0x127E
+
+#define Accel_X 0x1280
+#define Accel_Y 0x1282
+#define Accel_Z 0x1284
+#define Accel_E 0x1286
+
+#define ShapingZetaX 0x10A0
+#define ShapingZetaY 0x10A2
+#define ShapingFreqX 0x10A4
+#define ShapingFreqY 0x10A8
+
+#define LinAdvKFactor 0x10AA
+
+#define RunoutMode 0x10AC
+
+#define BabystepIncrement 0x10AE
+
+#define	HeatPercentIcon		0x1024
+
+#define	NzBdSet				0x1032 // cooldown Hotend and Bed
+#define	NozzlePreheat		0x1034 // setpoint
+#define	NozzleTemp			0x1036 // Actual
+#define	BedPreheat			0x103A // Setpoint
+#define	Bedtemp				0x103C // Actual
+
+#define e2Temp      0x1050
+#define e2Preheat   0x104E
+
+#define	AutoZeroIcon		0x1042
+#define	AutoLevelIcon		0x1045
+#define	AutoZero			0x1046
+#define	DisplayXaxis			0x1048
+#define	DisplayYaxis			0x104A
+#define	DisplayZaxis			0x104C
+
+#define	FilementUnit1		0x1054
+#define	Exchfilement			0x1056
+#define	FilementUnit2		0x1058
+
+#define	MacVersion			0x1060
+#define	SoftVersion			0x106A
+#define	PrinterSize			0x1074
+#define	CorpWebsite			0x107E
+#define	VolumeIcon			0x108A
+#define	SoundIcon			0x108C
+#define	AutolevelIcon		0x108D
+#define	ExchFlmntIcon		0x108E
+#define	AutolevelVal			0x1100
+
+#define	FilenameIcon			0x1200
+#define	FilenameIcon1		0x1220
+#define	Printfilename			0x2000
+#define	FilesCurentPage		0x1310
+#define	FilesMaxPage		0x1312
+#define	SDFILE_ADDR		0x200A
+#define	FilenamePlay			0x20D2
+#define	FilenameChs			0x20D3
+#define	Choosefilename		0x20D4
+#define	FilenameCount		0x20DE
+#define	FilenameNature		0x6003
+
+#define VolumeDisplay 0x1140
+#define DisplayBrightness 0x1142
+#define DisplayStandbyBrightness 0x1144
+#define DisplayStandbyEnableIndicator 0x1146
+#define DisplayStandbySeconds 0x1148
+
+#define StatusMessageString 0x2064
+
+#if defined(TARGET_STM32F4)
+  #define DWIN_SERIAL Serial1
+#else
+  #define DWIN_SERIAL LCD_SERIAL
+#endif
+
+/************struct**************/
+
+typedef enum : uint8_t {
+  DGUS_IDLE,           //< waiting for DGUS_HEADER1.
+  DGUS_HEADER1_SEEN,   //< DGUS_HEADER1 received
+  DGUS_HEADER2_SEEN,   //< DGUS_HEADER2 received
+  DGUS_WAIT_TELEGRAM,  //< LEN received, Waiting for to receive all bytes.
+} rx_datagram_state_t;
+
+
+typedef struct DataBuf
+{
+    unsigned char len;
+    unsigned char head[2];
+    unsigned char command;
+    unsigned long addr;
+    unsigned long bytelen;
+    unsigned short data[32];
+    unsigned char reserv[4];
+} DB;
+
+struct creality_dwin_settings_t {
+  size_t settings_size;
+  uint8_t settings_version;
+
+  bool display_standby;
+  bool display_sound;
+  int8_t screen_rotation;
+  int16_t display_volume;
+  uint8_t standby_screen_brightness;
+  uint8_t screen_brightness;
+  int16_t standby_time_seconds;
+
+};
+
+
+
+void SetTouchScreenConfiguration();
+
+class RTSSHOW {
+  public:
+    RTSSHOW();
+    int RTS_RecData();
+    void RTS_SDCardInit(void);
+    void RTS_SDCardUpate(bool, bool);
+    int RTS_CheckFilement(int);
+    void RTS_SndData(void);
+    void RTS_SndData(const String &, unsigned long, unsigned char = VarAddr_W);
+    void RTS_SndData(const char[], unsigned long, unsigned char = VarAddr_W);
+    void RTS_SndData(char, unsigned long, unsigned char = VarAddr_W);
+    void RTS_SndData(unsigned char*, unsigned long, unsigned char = VarAddr_W);
+    void RTS_SndData(int, unsigned long, unsigned char = VarAddr_W);
+    void RTS_SndData(float, unsigned long, unsigned char = VarAddr_W);
+    void RTS_SndData(unsigned int,unsigned long, unsigned char = VarAddr_W);
+    void RTS_SndData(long,unsigned long, unsigned char = VarAddr_W);
+    void RTS_SndData(unsigned long,unsigned long, unsigned char = VarAddr_W);
+    void WriteVariable(uint16_t adr, const void* values, uint8_t valueslen, bool isstr=false, char fillChar = ' ');
+    void WriteVariable(uint16_t adr, long);
+    void RTS_SDcard_Stop();
+    void RTS_HandleData();
+    void RTS_Init();
+
+    DB recdat;
+    DB snddat;
+    unsigned char databuf[SizeofDatabuf];
+
+  static rx_datagram_state_t rx_datagram_state;
+  static uint8_t rx_datagram_len;
+  static bool Initialized;
+  };
+
+static RTSSHOW rtscheck;
+
+  #define	Addvalue	3
+  #define	PrintChoice_Value	(0+Addvalue)
+  #define	Zoffset_Value		(3+Addvalue)
+  #define	Setting_Value		(8+Addvalue)
+  #define	XYZEaxis_Value		(12+Addvalue)
+  #define	Filement_Value		(15+Addvalue)
+  #define	Language_Value		(18+Addvalue)
+  #define	Filename_Value		(22+Addvalue)
+  #define	Idex_Settings_Value		(26+Addvalue)
+
+  enum PROC_COM {Printfile=0,Ajust,Feedrate,PrintChoice=PrintChoice_Value,Zoffset=Zoffset_Value,TempControl,ManualSetTemp,Setting=Setting_Value,
+  ReturnBack,Bedlevel,Autohome,XYZEaxis=XYZEaxis_Value,Filement=Filement_Value,LanguageChoice=Language_Value,No_Filement,PwrOffNoF,Volume,Filename=Filename_Value,Idex_Settings=Idex_Settings_Value};
+
+  const unsigned long Addrbuf[] = {0x1002, 0x1004, 0x1006, 0x1008, 0x100A, 0x100C,  0x1026, 0x1030, 0x1032, 0x1034, 0x103A,
+                0x103E, 0x1040, 0x1044, 0x1046, 0x1048, 0x104A, 0x104C, 0x1054, 0x1056, 0x1058,
+                0x105C, 0x105E, 0x105F, 0x1088, 0};
+
+void RTSUpdate();
+void RTSInit();
+
+}
+#ifndef MAIN_MENU_ITEM_1_GCODE
+  #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
+    #define MEASURING_GCODE "M190S55\nG28O\nG34\nG29\nM400\nM104S215\nG28\nM109S215\nM420S1\nG1X100Y100F5000\nG1Z0\nM500\nM117 Set Z Offset"
+  #elif ENABLED(AUTO_BED_LEVELING_UBL)
+    #define MEASURING_GCODE "M190S55\nG28O\nG34\nG29P1\nG29P3\nG29S1\nG29S0\nG29F0.0\nG29A\nM104S215\nG28\nM109S215\nG1X150Y150F5000\nG1Z0\nM500\nM400\nM117 Set Z Offset"
+  #else
+    #define MEASURING_GCODE "G28"
+  #endif
+#else
+  #define MEASURING_GCODE MAIN_MENU_ITEM_1_GCODE
+#endif
+
+
+#endif
@@ -0,0 +1,189 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+/* ****************************************
+ * lcd/extui/lib/Creality/FileNavigator.cpp
+ * ****************************************
+ * Extensible_UI implementation for Creality DWIN
+ * 10SPro, Max, CR10V2
+ * Based on implementations for Anycubic Chiron and Nextion by Nick Wells and Skorpi08
+ * Written by Insanity Automation
+ * ***************************************/
+
+#include "../../../inc/MarlinConfigPre.h"
+#if ENABLED(EXTENSIBLE_UI)
+
+
+#include "FileNavigator.h"
+
+using namespace ExtUI;
+
+#define DEBUG_OUT NEXDEBUGLEVEL
+#include "../../../core/debug_out.h"
+
+FileList  FileNavigator::filelist;                          // Instance of the Marlin file API
+char      FileNavigator::currentfoldername[MAX_PATH_LEN];   // Current folder path
+uint16_t  FileNavigator::lastindex;
+uint8_t   FileNavigator::folderdepth;
+uint16_t  FileNavigator::currentindex;                      // override the panel request
+
+FileNavigator filenavigator;
+
+FileNavigator::FileNavigator() { reset(); }
+
+void FileNavigator::reset() {
+  currentfoldername[0] = '\0';
+  folderdepth  = 0;
+  currentindex = 0;
+  lastindex    = 0;
+  // Start at root folder
+  while (!filelist.isAtRootDir()) filelist.upDir();
+  refresh();
+}
+
+void FileNavigator::refresh() { filelist.refresh(); }
+
+
+bool FileNavigator::getIndexisDir(uint16_t index){
+  filelist.seek(index);
+  return filelist.isDir();
+}
+
+const char *FileNavigator::getIndexName(uint16_t index){
+  filelist.seek(index);
+  return filelist.shortFilename();
+}
+
+uint16_t FileNavigator::maxFiles() {
+  return filelist.count();
+}
+
+void FileNavigator::getFiles(uint16_t index) {
+  uint16_t files = DISPLAY_FILES, fcnt  = 0;
+  if (index == 0)
+    currentindex = 0;
+  else {
+    // Each time we change folder we reset the file index to 0 and keep track
+    // of the current position as the TFT panel isn't aware of folder trees.
+    --currentindex; // go back a file to take account of the .. added to the root.
+    if (index > lastindex)
+      currentindex += files + 1;
+    else if (currentindex >= files)
+      currentindex -= files - 1;
+    else
+      currentindex = 0;
+  }
+  lastindex = index;
+
+
+  // Clear currently drawn screen
+  for (int i = 0; i < DISPLAY_FILES; i++)
+  {
+    for (int j = 0; j < 20; j++)
+      rtscheck.RTS_SndData(0, SDFILE_ADDR + (i * 20) + j);
+  }
+
+  for (int j = 0; j < 10; j++)
+  {
+    rtscheck.RTS_SndData(0, Printfilename + j);  //clean screen.
+    rtscheck.RTS_SndData(0, Choosefilename + j); //clean filename
+  }
+  for (int j = 0; j < 8; j++)
+    rtscheck.RTS_SndData(0, FilenameCount + j);
+  for (int j = 1; j <= DISPLAY_FILES; j++)
+  {
+    rtscheck.RTS_SndData(10, FilenameIcon + j);
+    rtscheck.RTS_SndData(10, FilenameIcon1 + j);
+  }
+
+  DEBUG_ECHOLNPGM("index=", index, " currentindex=", currentindex, "folderdepth=", folderdepth);
+
+  if (currentindex == 0 && folderdepth > 0) { // Add a link to go up a folder
+    files--;
+    rtscheck.RTS_SndData("Up Directory", SDFILE_ADDR);
+    fcnt++;
+  }
+  else if(currentindex == DISPLAY_FILES && folderdepth > 0)
+    currentindex--;
+
+  for (uint16_t seek = currentindex; seek < currentindex + files; seek++) {
+    if (filelist.seek(seek)) {
+      const int filelen = strlen(filelist.filename());
+      if(filelen > 20)
+      {
+        char *buf = (char *)filelist.filename();
+        //char buf[filelen];
+        //strcpy(&buf[filelen], filelist.filename());
+        buf[18] = '\0'; // cutoff at screen edge
+        rtscheck.RTS_SndData(buf, (SDFILE_ADDR + (fcnt * 20)));
+      }
+      else
+        rtscheck.RTS_SndData(filelist.filename(), (SDFILE_ADDR + (fcnt * 20)));
+
+      if (filelist.isDir())
+      {
+        rtscheck.RTS_SndData((uint8_t)4, FilenameIcon + (fcnt+1));
+        rtscheck.RTS_SndData((unsigned long)0x041F, (FilenameNature + ((1+fcnt) * 16))); // Change BG of selected line to Blue
+      }
+      else
+      {
+        rtscheck.RTS_SndData((uint8_t)0, FilenameIcon + (fcnt+1));
+        rtscheck.RTS_SndData((unsigned long)0xFFFF, (FilenameNature + ((1+fcnt) * 16))); // white
+      }
+      SERIAL_ECHOLNPGM("-", seek, " '", filelist.filename(), "' '", currentfoldername, "", filelist.shortFilename(), "'\n");
+      fcnt++;
+    }
+  }
+}
+
+void FileNavigator::changeDIR(char *folder) {
+  DEBUG_ECHOLNPGM("currentfolder: ", currentfoldername, "  New: ", folder);
+  if (folderdepth >= MAX_FOLDER_DEPTH) return; // limit the folder depth
+  strcat(currentfoldername, folder);
+  strcat(currentfoldername, "/");
+  filelist.changeDir(folder);
+  refresh();
+  folderdepth++;
+  currentindex = 0;
+}
+
+void FileNavigator::upDIR() {
+  filelist.upDir();
+  refresh();
+  folderdepth--;
+  currentindex = 0;
+  // Remove the last child folder from the stored path
+  if (folderdepth == 0) {
+    currentfoldername[0] = '\0';
+    reset();
+  }
+  else {
+    char *pos = nullptr;
+    for (uint8_t f = 0; f < folderdepth; f++)
+      pos = strchr(currentfoldername, '/');
+    pos[1] = '\0';
+  }
+  DEBUG_ECHOLNPGM("depth: ", folderdepth, " currentfoldername: ", currentfoldername);
+}
+
+char* FileNavigator::getCurrentFolderName() { return currentfoldername; }
+#endif
@@ -0,0 +1,63 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+/* ****************************************
+ * lcd/extui/lib/Creality/FileNavigator.h
+ * ****************************************
+ * Extensible_UI implementation for Creality DWIN
+ * 10SPro, Max, CRX and others
+ * Based on implementations for Anycubic Chiron and Nextion by Nick Wells and Skorpi08
+ * Written by Insanity Automation
+ * ***************************************/
+
+#include "../ui_api.h"
+#include "Creality_DWIN.h"
+
+#define MAX_FOLDER_DEPTH                4    // Limit folder depth TFT has a limit for the file path
+#define MAX_CMND_LEN                   16 * MAX_FOLDER_DEPTH // Maximum Length for a Panel command
+#define MAX_PATH_LEN                   16 * MAX_FOLDER_DEPTH // Maximum number of characters in a SD file path
+#define DISPLAY_FILES                   4
+
+using namespace ExtUI;
+
+class FileNavigator {
+  public:
+    FileNavigator();
+    static void  reset();
+    static void  getFiles(uint16_t);
+    static void  upDIR();
+    static void  changeDIR(char *);
+    static void  refresh();
+    static char* getCurrentFolderName();
+    static uint8_t  folderdepth;
+    static uint16_t currentindex;
+    static bool getIndexisDir(uint16_t);
+    const char *getIndexName(uint16_t);
+    static uint16_t maxFiles();
+  private:
+    static FileList filelist;
+    static char     currentfoldername[MAX_PATH_LEN];
+    static uint16_t lastindex;
+};
+
+extern FileNavigator filenavigator;
@@ -683,15 +683,23 @@ namespace ExtUI {
  }

  #if HAS_FILAMENT_SENSOR
-    bool getFilamentRunoutEnabled()                 { return runout.enabled; }
-    void setFilamentRunoutEnabled(const bool value) { runout.enabled = value; }
+    bool getFilamentRunoutEnabled(const extruder_t extruder/*=E0*/)                 { return (runout.enabled[extruder] && (runout.mode[extruder]!=0)); }
+    void setFilamentRunoutEnabled(const bool value, const extruder_t extruder/*=E0*/) { runout.enabled[extruder] = value; }
    bool getFilamentRunoutState()                   { return runout.filament_ran_out; }
    void setFilamentRunoutState(const bool value)   { runout.filament_ran_out = value; }
+    float getFilamentRunoutDistance_mm()                 { return runout.runout_distance(); }
+    void setFilamentRunoutDistance_mm(const_float_t value) { runout.set_runout_distance(constrain(value, 0, 999)); }
+    int getRunoutMode(const extruder_t extruder/*=E0*/){
+      return (int)runout.mode[extruder];
+    }
+    void setRunoutMode(const int mode, const extruder_t extruder/*=E0*/){
+      if((mode >= 0 && mode <=2) || mode==7) {
+        runout.mode[extruder] = (RunoutMode)mode;
+        runout.setup();
+      }
+    }
+

-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      float getFilamentRunoutDistance_mm()                 { return runout.runout_distance(); }
-      void setFilamentRunoutDistance_mm(const_float_t value) { runout.set_runout_distance(constrain(value, 0, 999)); }
-    #endif
  #endif

  #if ENABLED(CASE_LIGHT_ENABLE)
@@ -726,6 +734,26 @@ namespace ExtUI {
    }
  #endif

+  #if HAS_SHAPING
+    float getShapingZeta(const axis_t axis) {
+      return stepper.get_shaping_damping_ratio(AxisEnum(axis));
+    }
+    void setShapingZeta(const float zeta, const axis_t axis) {
+      if (WITHIN(zeta, 0, 1)) {
+        stepper.set_shaping_damping_ratio(AxisEnum(axis), zeta);
+      }
+    }
+    float getShapingFrequency(const axis_t axis) {
+      return stepper.get_shaping_frequency(AxisEnum(axis));
+    }
+    void setShapingFrequency(const float freq, const axis_t axis) {
+      constexpr float min_freq = float(uint32_t(STEPPER_TIMER_RATE) / 2) / shaping_time_t(-2);
+      if (freq == 0.0f || freq > min_freq) {
+        stepper.set_shaping_frequency(AxisEnum(axis), freq);
+      }
+    }
+  #endif
+
  #if HAS_JUNCTION_DEVIATION

    float getJunctionDeviation_mm() { return planner.junction_deviation_mm; }
@@ -894,6 +922,7 @@ namespace ExtUI {
  #if HAS_BED_PROBE
    float getProbeOffset_mm(const axis_t axis) { return probe.offset.pos[axis]; }
    void setProbeOffset_mm(const_float_t val, const axis_t axis) { probe.offset.pos[axis] = val; }
+    probe_limits getBedProbeLimits() {return (probe_limits){probe.min_x(), probe.min_y(), probe.max_x(), probe.max_y()};}
  #endif

  #if ENABLED(BACKLASH_GCODE)
@@ -1101,7 +1130,7 @@ namespace ExtUI {
    return isPrinting() && (isPrintingFromMediaPaused() || print_job_timer.isPaused());
  }

-  bool isMediaInserted() { return TERN0(HAS_MEDIA, IS_SD_INSERTED()); }
+  bool isMediaInserted() { return TERN0(HAS_MEDIA, IS_SD_INSERTED() || card.isMounted()); }

  void pausePrint()  { ui.pause_print(); }
  void resumePrint() { ui.resume_print(); }
@@ -58,11 +58,12 @@ namespace ExtUI {

  static constexpr size_t eeprom_data_size = 48;

-  enum axis_t     : uint8_t { X, Y, Z, I, J, K, U, V, W, X2, Y2, Z2, Z3, Z4 };
-  enum extruder_t : uint8_t { E0, E1, E2, E3, E4, E5, E6, E7 };
-  enum heater_t   : uint8_t { H0, H1, H2, H3, H4, H5, BED, CHAMBER, COOLER };
-  enum fan_t      : uint8_t { FAN0, FAN1, FAN2, FAN3, FAN4, FAN5, FAN6, FAN7 };
-  enum result_t   : uint8_t { PID_STARTED, PID_BAD_HEATER_ID, PID_TEMP_TOO_HIGH, PID_TUNING_TIMEOUT, PID_DONE };
+  enum axis_t       : uint8_t { X, Y, Z, I, J, K, U, V, W, X2, Y2, Z2, Z3, Z4 };
+  enum extruder_t   : uint8_t { E0, E1, E2, E3, E4, E5, E6, E7 };
+  enum heater_t     : uint8_t { H0, H1, H2, H3, H4, H5, BED, CHAMBER, COOLER };
+  enum fan_t        : uint8_t { FAN0, FAN1, FAN2, FAN3, FAN4, FAN5, FAN6, FAN7 };
+  enum result_t     : uint8_t { PID_STARTED, PID_BAD_HEATER_ID, PID_TEMP_TOO_HIGH, PID_TUNING_TIMEOUT, PID_DONE };
+  struct probe_limits { float pos[4];};

  constexpr uint8_t extruderCount = EXTRUDERS;
  constexpr uint8_t hotendCount   = HOTENDS;
@@ -251,6 +252,13 @@ namespace ExtUI {
    void setLinearAdvance_mm_mm_s(const_float_t, const extruder_t);
  #endif

+  #if HAS_SHAPING
+    float getShapingZeta(const axis_t);
+    void setShapingZeta(const float, const axis_t);
+    float getShapingFrequency(const axis_t);
+    void setShapingFrequency(const float, const axis_t);
+  #endif
+
  #if HAS_JUNCTION_DEVIATION
    float getJunctionDeviation_mm();
    void setJunctionDeviation_mm(const_float_t);
@@ -285,6 +293,7 @@ namespace ExtUI {
  #if HAS_BED_PROBE
    float getProbeOffset_mm(const axis_t);
    void setProbeOffset_mm(const_float_t, const axis_t);
+    probe_limits getBedProbeLimits();
  #endif

  #if ENABLED(BACKLASH_GCODE)
@@ -301,15 +310,14 @@ namespace ExtUI {
  #endif

  #if HAS_FILAMENT_SENSOR
-    bool getFilamentRunoutEnabled();
-    void setFilamentRunoutEnabled(const bool);
+    bool getFilamentRunoutEnabled(const extruder_t extruder=E0);
+    void setFilamentRunoutEnabled(const bool, const extruder_t extruder=E0);
    bool getFilamentRunoutState();
    void setFilamentRunoutState(const bool);
-
-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      float getFilamentRunoutDistance_mm();
-      void setFilamentRunoutDistance_mm(const_float_t);
-    #endif
+    float getFilamentRunoutDistance_mm();
+    void setFilamentRunoutDistance_mm(const_float_t);
+    int getRunoutMode(const extruder_t extruder=E0);
+    void setRunoutMode(const int, const extruder_t extruder=E0);
  #endif

  #if ENABLED(CASE_LIGHT_ENABLE)
@@ -712,6 +712,11 @@ namespace LanguageNarrow_en {
  LSTR MSG_FILAMENT_CHANGE_NOZZLE         = _UxGT("  Nozzle: ");
  LSTR MSG_RUNOUT_SENSOR                  = _UxGT("Runout Sensor");
  LSTR MSG_RUNOUT_DISTANCE_MM             = _UxGT("Runout Dist mm");
+  LSTR MSG_RUNOUT_MODE                    = _UxGT("Runout Mode");
+  LSTR MSG_RUNOUT_MODE_HIGH               = _UxGT("Sensor High");
+  LSTR MSG_RUNOUT_MODE_LOW                = _UxGT("Sensor Low");
+  LSTR MSG_RUNOUT_MODE_MOTION             = _UxGT("Motion Encoder");
+  LSTR MSG_RUNOUT_MODE_NONE               = _UxGT("No Sensor");
  LSTR MSG_RUNOUT_ENABLE                  = _UxGT("Enable Runout");
  LSTR MSG_RUNOUT_ACTIVE                  = _UxGT("Runout Active");
  LSTR MSG_INVERT_EXTRUDER                = _UxGT("Invert Extruder");
@@ -1050,8 +1050,10 @@ void MarlinUI::init() {
                  // loop and that the abs of the encoderDiff value is tracked.
                  const float encoderStepRate = encoderMovementSteps / float(ms - lastEncoderMovementMillis) * 1000;

-                  if (encoderStepRate >= ENCODER_100X_STEPS_PER_SEC)     encoderMultiplier = 100;
-                  else if (encoderStepRate >= ENCODER_10X_STEPS_PER_SEC) encoderMultiplier = 10;
+                  #if defined(ENCODER_100X_STEPS_PER_SEC)
+                    if (encoderStepRate >= ENCODER_100X_STEPS_PER_SEC)     encoderMultiplier = 100;
+                  #endif
+                  if (encoderStepRate >= ENCODER_10X_STEPS_PER_SEC) encoderMultiplier = 10;

                  // Enable to output the encoder steps per second value
                  //#define ENCODER_RATE_MULTIPLIER_DEBUG
@@ -1869,6 +1871,7 @@ void MarlinUI::host_notify(const char * const cstr) {
    const PauseMode mode/*=PAUSE_MODE_SAME*/,
    const uint8_t extruder/*=active_extruder*/
  ) {
+    SERIAL_ECHOLNPGM("PauseMsg=", message);
    pause_mode = mode;
    ExtUI::pauseModeStatus = message;
    switch (message) {
@@ -45,7 +45,7 @@
  #include "../../module/temperature.h"
 #endif

-#if HAS_FILAMENT_RUNOUT_DISTANCE
+#if HAS_FILAMENT_SENSOR
  #include "../../feature/runout.h"
 #endif

@@ -99,6 +99,54 @@ void menu_backlash();

 #endif

+#if HAS_FILAMENT_SENSOR
+
+  void set_runout_mode_none(const uint8_t e)   { runout.mode[e] = RM_NONE; runout.setup(); }
+  void set_runout_mode_high(const uint8_t e)   { runout.mode[e] = RM_OUT_ON_HIGH; runout.setup(); }
+  void set_runout_mode_low(const uint8_t e)    { runout.mode[e] = RM_OUT_ON_LOW; runout.setup(); }
+  void set_runout_mode_motion(const uint8_t e) { runout.mode[e] = RM_MOTION_SENSOR; runout.setup(); }
+
+  #define RUNOUT_EDIT_ITEMS(F) do{ \
+    EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled[F]); \
+    ACTION_ITEM(MSG_RUNOUT_MODE_NONE,   []{ set_runout_mode_none(F);   }); \
+    ACTION_ITEM(MSG_RUNOUT_MODE_HIGH,   []{ set_runout_mode_high(F);   }); \
+    ACTION_ITEM(MSG_RUNOUT_MODE_LOW,    []{ set_runout_mode_low(F);    }); \
+    ACTION_ITEM(MSG_RUNOUT_MODE_MOTION, []{ set_runout_mode_motion(F); }); \
+    editable.decimal = runout.runout_distance(F); \
+    EDIT_ITEM_FAST(float3, MSG_RUNOUT_DISTANCE_MM, &editable.decimal, 1, 999, \
+      []{ runout.set_runout_distance(editable.decimal, F); }, true \
+    ); \
+  }while(0)
+
+  void menu_runout_config() {
+    START_MENU();
+    BACK_ITEM(MSG_CONFIGURATION);
+    RUNOUT_EDIT_ITEMS(0);
+    #if NUM_RUNOUT_SENSORS > 1
+      RUNOUT_EDIT_ITEMS(1);
+    #endif
+    #if NUM_RUNOUT_SENSORS > 2
+      RUNOUT_EDIT_ITEMS(2);
+    #endif
+    #if NUM_RUNOUT_SENSORS > 3
+      RUNOUT_EDIT_ITEMS(3);
+    #endif
+    #if NUM_RUNOUT_SENSORS > 4
+      RUNOUT_EDIT_ITEMS(4);
+    #endif
+    #if NUM_RUNOUT_SENSORS > 5
+      RUNOUT_EDIT_ITEMS(5);
+    #endif
+    #if NUM_RUNOUT_SENSORS > 6
+      RUNOUT_EDIT_ITEMS(6);
+    #endif
+    #if NUM_RUNOUT_SENSORS > 7
+      RUNOUT_EDIT_ITEMS(7);
+    #endif
+    END_MENU();
+  }
+#endif
+
 #if DISABLED(NO_VOLUMETRICS) || ENABLED(ADVANCED_PAUSE_FEATURE)
  //
  // Advanced Settings > Filament
@@ -152,11 +200,8 @@ void menu_backlash();
      #endif
    #endif

-    #if HAS_FILAMENT_RUNOUT_DISTANCE
-      editable.decimal = runout.runout_distance();
-      EDIT_ITEM_FAST(float3, MSG_RUNOUT_DISTANCE_MM, &editable.decimal, 1, 999,
-        []{ runout.set_runout_distance(editable.decimal); }, true
-      );
+    #if HAS_FILAMENT_SENSOR
+      SUBMENU(MSG_RUNOUT_MODE, menu_runout_config);
    #endif

    END_MENU();
@@ -94,16 +94,22 @@ static_assert(COUNT(lco) == 4 || lcodiff == 1 || lcodiff == 3, "The first two BE
 constexpr int nr_edge_points = tramming_3_points ? 3 : 4;
 constexpr int available_points = nr_edge_points + ENABLED(BED_TRAMMING_INCLUDE_CENTER);
 constexpr int center_index = TERN(BED_TRAMMING_INCLUDE_CENTER, available_points - 1, -1);
-constexpr float inset_lfrb[4] = BED_TRAMMING_INSET_LFRB;
-constexpr xy_pos_t lf { (X_MIN_BED) + inset_lfrb[0], (Y_MIN_BED) + inset_lfrb[1] },
+#if DISABLED(BED_TRAMMING_USE_PROBE)
+  constexpr float inset_lfrb[4] = BED_TRAMMING_INSET_LFRB;
+  constexpr xy_pos_t lf { (X_MIN_BED) + inset_lfrb[0], (Y_MIN_BED) + inset_lfrb[1] },
                   rb { (X_MAX_BED) - inset_lfrb[2], (Y_MAX_BED) - inset_lfrb[3] };
-
+#endif
 static int8_t bed_corner;

 /**
 * Move to the next corner coordinates
 */
 static void _lcd_goto_next_corner() {
+  #if ENABLED(BED_TRAMMING_USE_PROBE)
+    xy_pos_t lf = {X_MIN_BED + probe.min_x() + 0.01f, Y_MIN_BED + probe.min_y() + 0.01f },
+             rb = {X_MAX_BED - probe.max_x() - 0.01f, Y_MAX_BED - probe.max_y() - 0.01f };
+  #endif
+
  xy_pos_t corner_point = lf;                     // Left front

  if (tramming_3_points) {
@@ -165,11 +171,6 @@ static void _lcd_goto_next_corner() {

 #if ENABLED(BED_TRAMMING_USE_PROBE)

-  #define VALIDATE_POINT(X, Y, STR) static_assert(Probe::build_time::can_reach((X), (Y)), \
-    "BED_TRAMMING_INSET_LFRB " STR " inset is not reachable with the default NOZZLE_TO_PROBE offset and PROBING_MARGIN.")
-  VALIDATE_POINT(lf.x, Y_CENTER, "left"); VALIDATE_POINT(X_CENTER, lf.y, "front");
-  VALIDATE_POINT(rb.x, Y_CENTER, "right"); VALIDATE_POINT(X_CENTER, rb.y, "back");
-
  #ifndef PAGE_CONTAINS
    #define PAGE_CONTAINS(...) true
  #endif
@@ -629,7 +629,7 @@ void menu_configuration() {
  #endif

  #if HAS_FILAMENT_SENSOR
-    EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
+    EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled[active_extruder], runout.reset);
  #endif

  #if HAS_FANCHECK
@@ -259,7 +259,7 @@ void menu_pause_option() {
  #if HAS_FILAMENT_SENSOR
    const bool still_out = runout.filament_ran_out;
    if (still_out)
-      EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled, runout.reset);
+      EDIT_ITEM(bool, MSG_RUNOUT_SENSOR, &runout.enabled[active_extruder], runout.reset);
  #else
    constexpr bool still_out = false;
  #endif
@@ -50,6 +50,10 @@
  #include "../feature/joystick.h"
 #endif

+#if HAS_FILAMENT_SENSOR
+  #include "../feature/runout.h"
+#endif
+
 #if HAS_BED_PROBE
  #include "probe.h"
 #endif
@@ -481,22 +485,35 @@ void __O2 Endstops::report_states() {
  #if USE_Z_MIN_PROBE
    print_es_state(PROBE_TRIGGERED(), F(STR_Z_PROBE));
  #endif
-  #if MULTI_FILAMENT_SENSOR
-    #define _CASE_RUNOUT(N) case N: pin = FIL_RUNOUT##N##_PIN; state = FIL_RUNOUT##N##_STATE; break;
+  #if HAS_FILAMENT_SENSOR
    for (uint8_t i = 1; i <= NUM_RUNOUT_SENSORS; ++i) {
      pin_t pin;
-      uint8_t state;
      switch (i) {
        default: continue;
+        #define _CASE_RUNOUT(N) case N: pin = FIL_RUNOUT##N##_PIN; break;
        REPEAT_1(NUM_RUNOUT_SENSORS, _CASE_RUNOUT)
+        #undef _CASE_RUNOUT
      }
-      SERIAL_ECHOPGM(STR_FILAMENT);
-      if (i > 1) SERIAL_CHAR(' ', '0' + i);
-      print_es_state(extDigitalRead(pin) != state);
+      const RunoutMode rm = runout.mode[i - 1];
+      const uint8_t outval = runout.out_state(i - 1);
+
+      #if DISABLED(SLIM_LCD_MENUS)
+        SERIAL_ECHOPGM(STR_FILAMENT);
+        if (i > 1) SERIAL_CHAR(' ', '0' + i);
+        SERIAL_ECHOPGM(": ");
+        if (rm == RM_NONE)
+          SERIAL_ECHOLNPGM(STR_OFF);
+        else if (rm == RM_MOTION_SENSOR) {
+          SERIAL_ECHOPGM("MOTION : ");
+          print_es_state(extDigitalRead(pin) == outval);
+        }
+        else
+          SERIAL_ECHOLNPGM_P(extDigitalRead(pin) == outval ? PSTR("OUT") : PSTR("PRESENT"));
+      #else
+        print_es_state(extDigitalRead(pin) == outval, F(STR_FILAMENT));
+      #endif
    }
-    #undef _CASE_RUNOUT
-  #elif HAS_FILAMENT_SENSOR
-    print_es_state(READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE, F(STR_FILAMENT));
+
  #endif

  TERN_(BLTOUCH, bltouch._reset_SW_mode());
@@ -41,8 +41,8 @@

 // Check the integrity of data offsets.
 // Can be disabled for production build.
-//#define DEBUG_EEPROM_READWRITE
-//#define DEBUG_EEPROM_OBSERVE
+#define DEBUG_EEPROM_READWRITE
+#define DEBUG_EEPROM_OBSERVE

 #include "settings.h"

@@ -120,9 +120,6 @@

 #if HAS_FILAMENT_SENSOR
  #include "../feature/runout.h"
-  #ifndef FIL_RUNOUT_ENABLED_DEFAULT
-    #define FIL_RUNOUT_ENABLED_DEFAULT true
-  #endif
 #endif

 #if ENABLED(ADVANCE_K_EXTRA)
@@ -251,8 +248,11 @@ typedef struct SettingsDataStruct {
  //
  // FILAMENT_RUNOUT_SENSOR
  //
-  bool runout_sensor_enabled;                           // M412 S
-  float runout_distance_mm;                             // M412 D
+  #if HAS_FILAMENT_SENSOR
+    bool runout_enabled[NUM_RUNOUT_SENSORS];            // M591 S
+    float runout_distance_mm[NUM_RUNOUT_SENSORS];       // M591 D
+    uint8_t runout_mode[NUM_RUNOUT_SENSORS];            // M591 P
+  #endif

  //
  // ENABLE_LEVELING_FADE_HEIGHT
@@ -892,22 +892,14 @@ void MarlinSettings::postprocess() {
    //
    // Filament Runout Sensor
    //
+    #if HAS_FILAMENT_SENSOR
    {
-      #if HAS_FILAMENT_SENSOR
-        const bool &runout_sensor_enabled = runout.enabled;
-      #else
-        constexpr int8_t runout_sensor_enabled = -1;
-      #endif
-      _FIELD_TEST(runout_sensor_enabled);
-      EEPROM_WRITE(runout_sensor_enabled);
-
-      #if HAS_FILAMENT_RUNOUT_DISTANCE
-        const float &runout_distance_mm = runout.runout_distance();
-      #else
-        constexpr float runout_distance_mm = 0;
-      #endif
-      EEPROM_WRITE(runout_distance_mm);
+      _FIELD_TEST(runout_enabled);
+      for(uint8_t e=0; e<NUM_RUNOUT_SENSORS; ++e) EEPROM_WRITE(runout.enabled[e]);
+      for(uint8_t e=0; e<NUM_RUNOUT_SENSORS; ++e) EEPROM_WRITE(runout.runout_distance(e));
+      for(uint8_t e=0; e<NUM_RUNOUT_SENSORS; ++e) EEPROM_WRITE(runout.mode[e]);
    }
+    #endif

    //
    // Global Leveling
@@ -1910,22 +1902,28 @@ void MarlinSettings::postprocess() {
      //
      // Filament Runout Sensor
      //
+      #if HAS_FILAMENT_SENSOR
      {
-        int8_t runout_sensor_enabled;
-        _FIELD_TEST(runout_sensor_enabled);
-        EEPROM_READ(runout_sensor_enabled);
-        #if HAS_FILAMENT_SENSOR
-          runout.enabled = runout_sensor_enabled < 0 ? FIL_RUNOUT_ENABLED_DEFAULT : runout_sensor_enabled;
-        #endif
+        _FIELD_TEST(runout_enabled);

-        TERN_(HAS_FILAMENT_SENSOR, if (runout.enabled) runout.reset());
+        bool runout_enabled[NUM_RUNOUT_SENSORS];
+        float runout_distance_mm[NUM_RUNOUT_SENSORS];
+        RunoutMode runout_mode[NUM_RUNOUT_SENSORS];

-        float runout_distance_mm;
+        EEPROM_READ(runout_enabled);
        EEPROM_READ(runout_distance_mm);
-        #if HAS_FILAMENT_RUNOUT_DISTANCE
-          if (!validating) runout.set_runout_distance(runout_distance_mm);
-        #endif
+        EEPROM_READ(runout_mode);
+
+        if (!validating) {
+          for(uint8_t e=0; e < NUM_RUNOUT_SENSORS; ++e) {
+            runout.enabled[e] = runout_enabled[e];
+            runout.set_runout_distance(runout_distance_mm[e], e);
+            runout.mode[e] = runout_mode[e];
+          }
+          runout.reset();
+        }
      }
+      #endif

      //
      // Global Leveling
@@ -3120,9 +3118,16 @@ void MarlinSettings::reset() {
  //

  #if HAS_FILAMENT_SENSOR
-    runout.enabled = FIL_RUNOUT_ENABLED_DEFAULT;
+    constexpr bool fred[] = FIL_RUNOUT_ENABLED;
+    constexpr uint8_t frm[] = FIL_RUNOUT_MODE;
+    constexpr float frd[] = FIL_RUNOUT_DISTANCE_MM;
+    static_assert(COUNT(fred) == NUM_RUNOUT_SENSORS, "FIL_RUNOUT_ENABLED must have NUM_RUNOUT_SENSORS values.");
+    static_assert(COUNT(frm) == NUM_RUNOUT_SENSORS, "FIL_RUNOUT_MODE must have NUM_RUNOUT_SENSORS values.");
+    static_assert(COUNT(frd) == NUM_RUNOUT_SENSORS, "FIL_RUNOUT_DISTANCE_MM must have NUM_RUNOUT_SENSORS values.");
+    COPY(runout.enabled, fred);
+    COPY(runout.mode, frm);
+    for(uint8_t e = 0; e < NUM_RUNOUT_SENSORS; ++e) runout.set_runout_distance(frd[e], e);
    runout.reset();
-    TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, runout.set_runout_distance(FILAMENT_RUNOUT_DISTANCE_MM));
  #endif

  //
@@ -3907,7 +3912,7 @@ void MarlinSettings::reset() {
    //
    // Filament Runout Sensor
    //
-    TERN_(HAS_FILAMENT_SENSOR, gcode.M412_report(forReplay));
+    TERN_(HAS_FILAMENT_SENSOR, gcode.M591_report(forReplay));

    #if HAS_ETHERNET
      CONFIG_ECHO_HEADING("Ethernet");
@@ -122,7 +122,7 @@ Stepper stepper; // Singleton
  #include "../feature/mixing.h"
 #endif

-#if HAS_FILAMENT_RUNOUT_DISTANCE
+#if HAS_FILAMENT_SENSOR
  #include "../feature/runout.h"
 #endif

@@ -2293,7 +2293,7 @@ hal_timer_t Stepper::block_phase_isr() {
          PAGE_SEGMENT_UPDATE_POS(E);
        }
      #endif
-      TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, runout.block_completed(current_block));
+      TERN_(HAS_FILAMENT_SENSOR, runout.block_completed(current_block));
      discard_current_block();
    }
    else {
@@ -36,14 +36,6 @@
 #define BOARD_INFO_NAME      "Tenlog D3 Hero"
 #define DEFAULT_MACHINE_NAME BOARD_INFO_NAME

-//
-// Servos
-//
-#define SERVO0_PIN                            11
-#define SERVO1_PIN                             6
-#define SERVO2_PIN                            -1  // Original pin 5 used for hotend fans
-#define SERVO3_PIN                             4
-
 //
 // Limit Switches
 //
@@ -52,15 +44,13 @@
 #define Y_MIN_PIN                             14
 //#define Y_MAX_PIN                           15  // Connected to "DJ" plug on extruder heads
 #define Z_MIN_PIN                             18
-#define Z_MAX_PIN                             19
-
-//
-// Z Probe (when not Z_MIN_PIN)
-//
-#ifndef Z_MIN_PROBE_PIN
-  #define Z_MIN_PROBE_PIN                     15  // Ramps is normally 32
+#if ENABLED(BLTOUCH)
+  #define SERVO0_PIN                          19
+#else
+  #define Z_MAX_PIN                           19
 #endif

+
 //
 // Steppers
 //
@@ -99,16 +89,17 @@
 //#define Z2_CS_PIN                          40
 //#endif

-#define E0_STEP_PIN                           26
-#define E0_DIR_PIN                            28
-#define E0_ENABLE_PIN                         24
+
+#define E0_STEP_PIN                           57
+#define E0_DIR_PIN                            58
+#define E0_ENABLE_PIN                         59
 //#ifndef E0_CS_PIN
  //define E0_CS_PIN                          42
 //#endif

-#define E1_STEP_PIN                           57
-#define E1_DIR_PIN                            58
-#define E1_ENABLE_PIN                         59
+#define E1_STEP_PIN                           26
+#define E1_DIR_PIN                            28
+#define E1_ENABLE_PIN                         24
 //#ifndef E1_CS_PIN
  //define E1_CS_PIN                          44
 //#endif
@@ -120,8 +111,8 @@
 //
 // Temperature Sensors
 //
-#define TEMP_0_PIN                            13  // Analog Input
-#define TEMP_1_PIN                            15  // Analog Input
+#define TEMP_0_PIN                            15  // Analog Input
+#define TEMP_1_PIN                            13  // Analog Input
 #define TEMP_BED_PIN                          14  // Analog Input

 // SPI for MAX Thermocouple
@@ -134,8 +125,8 @@
 //
 // Heaters / Fans
 //
-#define HEATER_0_PIN                          10
-#define HEATER_1_PIN                          11
+#define HEATER_0_PIN                          11
+#define HEATER_1_PIN                          10
 #define HEATER_BED_PIN                         8

 #define FAN0_PIN                               9
@@ -143,9 +134,16 @@

 // XXX Runout support unknown?
 //#define NUM_RUNOUT_SENSORS                   0
-//#define FIL_RUNOUT_PIN                      22
+#define FIL_RUNOUT_PIN                        15
 //#define FIL_RUNOUT2_PIN                     21

+//
+// PSU and Powerloss Recovery
+//
+#ifdef PSU_CONTROL
+   #define PS_ON_PIN               40
+#endif
+
 //
 // Misc. Functions
 //
@@ -111,6 +111,11 @@
  #endif
 #endif

+#if ENABLED(MINIPANEL)
+  #undef DOGLCD_CS
+  #define DOGLCD_CS                  28
+#endif
+
 /**
  PIN:   0   Port: B0        E0_DIR_PIN                  protected
  PIN:   1   Port: B1        E0_STEP_PIN                 protected
@@ -177,7 +177,15 @@
 #define CASE_LIGHT_PIN                      PA13

 #ifndef NEOPIXEL_PIN
-  #define NEOPIXEL_PIN                      PA8
+#define NEOPIXEL_PIN                        PA8
+#endif
+
+#define CASE_LIGHT_PIN                      LED_CONTROL_PIN
+
+#define SUICIDE_PIN                         PC13
+
+#ifndef SUICIDE_PIN_INVERTING
+  #define SUICIDE_PIN_INVERTING               false
 #endif

 #define SUICIDE_PIN                         PC13
@@ -64,8 +64,14 @@
 //
 // Probe
 //
-#ifndef PROBE_TARE_PIN
-  #define PROBE_TARE_PIN                    PA5
+#if ENABLED(NOZZLE_AS_PROBE)
+  #ifndef PROBE_TARE_PIN
+    #define PROBE_TARE_PIN                  PA5
+  #endif
+#else
+  #ifndef SERVO0_PIN
+    #define SERVO0_PIN                      PA5
+  #endif
 #endif

 //
@@ -112,3 +118,5 @@
 // Misc. Functions
 //
 #define CASE_LIGHT_PIN                      PA6
+
+#define LED_PIN                             PA6
@@ -38,6 +38,10 @@
  #include "../lcd/e3v2/proui/dwin.h"
 #endif

+#if ENABLED(EXTENSIBLE_UI)
+  #include "../lcd/extui/ui_api.h"
+#endif
+
 #include "../module/planner.h"        // for synchronize
 #include "../module/printcounter.h"
 #include "../gcode/queue.h"
@@ -494,6 +498,7 @@ void CardReader::mount() {
  else {
    flag.mounted = true;
    SERIAL_ECHO_MSG(STR_SD_CARD_OK);
+    TERN_(EXTENSIBLE_UI, ExtUI::onMediaInserted()); // ExtUI response
  }

  if (flag.mounted)
@@ -1,154 +1,209 @@
+## Creality 427 Board TFT and Touchscreen Firmware For F1rst Layer Kits
+
+This branch is specifically intended to support the kits sold by F1rst Layer including Creality 427 boards, touchscreens, and other upgrades.
+
+
+- [Dual Gear Extruders](https://amzn.to/3lZfg08)
+- [Creality 427 Board with Runout Sensor](https://amzn.to/2Y1jrke)
+- [Creality 427 Board and BLTouch](https://amzn.to/3CT57Jk)
+- [E3V2 Upgrade Kit (Screen, 427 board, bltouch, runout)](https://amzn.to/3EZnhec)
+- [Ender 3 100mm Z Extension Kit](https://amzn.to/2XWH78F)
+
+- [CR10S Pro / V2](https://www.tinymachines3d.com/products/cr-10s-pro-v2-3d-printer?rfsn=3419592.cc302fe)
+- [CR10 Max](https://www.tinymachines3d.com/products/creality-cr-10-max-3d-printer?rfsn=3419592.cc302fe)
+- [Ender 5 Plus](https://www.tinymachines3d.com/products/ender-5-plus-silent-board-custom-dual-z-3d-printer?rfsn=3419592.cc302fe)
+- [Ender 6](https://amzn.to/3JRyOhi)
+- [CR-X / Pro](https://www.tinymachines3d.com/products/creality-cr-x-pro-3d-printer-with-dual-extruder-and-bl-touch?rfsn=3419592.cc302fe)
+- [CR10 V2 ](https://www.tinymachines3d.com/products/creality-cr-10-v2-3d-printer?rfsn=3419592.cc302fe)
+- [CR10 V3 ](https://www.tinymachines3d.com/products/creality-cr-10-v3-plus-3d-printer-with-genuine-e3d-direct-drive-extruder-and-bl-touch?rfsn=3419592.cc302fe)
+- [Ender 3 / Pro 4.2.2 and 4.2.7](https://amzn.to/3BRHlxY)
+- [Ender 3 V2](https://www.tinymachines3d.com/products/ender-3-v2?rfsn=3419592.cc302fe)
+- [Ender 3 Max](https://www.tinymachines3d.com/products/ender-3-max-3d-printer?rfsn=3419592.cc302fe)
+- [Ender 5 / Pro 4.2.2 and 4.2.7](https://amzn.to/3gMb2Yu)
+- [CR10S5 500mm](https://www.tinymachines3d.com/products/creality-cr-10-s5-3d-printer?rfsn=3419592.cc302fe)
+- [CR6 SE](https://www.tinymachines3d.com/products/creality-cr-6-se-3d-printer?rfsn=3419592.cc302fe)
+- [CR6 Max](https://www.tinymachines3d.com/products/creality-cr-6-max-3d-printer?rfsn=3419592.cc302fe)
+- [CR10 Smart](https://www.tinymachines3d.com/products/creality-cr-10-smart-3d-printer?rfsn=3419592.cc302fe)
+- [Ender 7](https://www.tinymachines3d.com/products/ender-7-3d-printer?rfsn=3419592.cc302fe)
+- [CR30](https://www.tinymachines3d.com/products/cr-30-infinite-z-belt-3d-printer?rfsn=3419592.cc302fe)
+- [Sermoon D1](https://amzn.to/3LXfZeD)
+- [CR5 / Pro HT](https://amzn.to/3gWvpBt)
+- [Ender 3 S1](https://www.tinymachines3d.com/products/ender-3-s1-3d-printer?rfsn=3419592.cc302fe)
+- [Ender 2 Pro](https://www.tinymachines3d.com/products/ender-2-pro-3d-printer?rfsn=3419592.cc302fe)
+
+- CR10S, CR10S4, CR20 and Pro, CR10, CR10Mini, CR2020, Ender 4, Ender 2 - Legacy support
+- These configurations exist however due to age and product availability are no longer actively tested
+
+## Coming Soon
+- [CR10 Smart Pro](https://www.tinymachines3d.com/products/cr-10-smart-pro-3d-printer?rfsn=3419592.cc302fe)
+- [CR200B]()
+
+## Resin machines below from Tiny Machines are listed simply as an additional way to help support the project. If youre considering buying one, please do so through the following links :
+ - [Halot One CL-60](https://www.tinymachines3d.com/products/halot-one-cl-60-resin-3d-printer?rfsn=3419592.cc302fe)
+ - [LD-002R](https://www.tinymachines3d.com/products/ld-002r-resin-printer?rfsn=3419592.cc302fe)
+ - [LD-002H](https://www.tinymachines3d.com/products/ld-002h-resin-3d-printer?rfsn=3419592.cc302fe)
+ - [LD-006](https://www.tinymachines3d.com/products/ld-006-resin-3d-printer?rfsn=3419592.cc302fe)
+ - [UW-02 Washer](https://www.tinymachines3d.com/products/uw-02-washing-curing-machine?rfsn=3419592.cc302fe)
+
+
+Ender 3V2 has a dedicated file set. CR10 Smart has a dedicated high resolution screen set. Portrait displays use the CR6/E3 Touch variant and landscape use the combined set.
+
+Screen files are archived with [7-Zip](https://www.7-zip.org/) simply because it came out 1/5 the file size of a zip file. That added up fast!
+
+There is a limitation with Windows systems and path depth so the file names need to be shorter than we would prefer. If you get an error compiling due to the path limit, move the folder to the root of your hard drive. Here is a legend to help decode the files:
+
+- BLT = BLTouch
+- BIL = Bilinear Leveling
+- UBL - Unified Bed Leveling
+- DZ = Dual Z Steppers
+- Fil = FilamentRunout
+- Slnt = Creality Silent Board
+- H = E3D Hemera Extruder
+- MC = Mosquito Creality mount
+- ME = Mosquito E3D mount
+- Melzi Host option disables local SD card to allow more features and buffer for Octoprint control
+- NF = Noise filtering for machines with cable extensions - reduces homing accuracy!
+- LR = Stock runout replaced with Lerdge
+- ZM = BLTouch connected to ZMin port instead of Probe pin 5 connector harness
+
+## Support
+
+This firmware is provided to the public as-is with no warranty or guarantee. It's based on a large open source project and there is no entitlement to support. If you are a F1rst Layer customer, you can contact them for support. I will provide support to Patreons as I am able. If you require more immediate support and are not a Tiny Machines 3D or F1rst Layer customer, you may contact Tiny Machines at support@tinymachines3d.com about purchasing support hours. Aside from this, we are active on many Facebook groups as well as several discord channels and typically help anyone we can when we come across them.
+
+We have now created a dedicated Discord server to handle support and archive relevant guides and instructions. Patreon supporters will get priority assistance.
+
+## We will NOT handle any support requests for any built compiled from upstream code. The display library from here was taken and submitted upstream without consultation or properly tagging authorship of changes. It was kept off the upstream repo as it was explicitly designed as a drop in library before the Extensible UI API methodology was butchered by hybrid applications with direct includes being repeatedly duplicated. We will not now or ever spend the time to chase bugs caused by changes to the API data types made without concern for backwards compatability.
+
+Extensible UI was designed to allow UI code to live standalone long term. If the API was managed and either versioned or functions overloaded, not changed, UI's no longer being actively maintained would not require maintenance by the Marlin team. The intention was any UI set would drop into the Lib folder and just work. This UI has been maintained under that mindset despite the upstream implementations being full of macros requiring direct pointer access to processed variables, making them fundamentally incompatible with the API, however still relying on its event trigger mechanism.
+
+As another reason this was not placed upstream was to eliminate the nead to develop around merge conflicts following previous code theft issues which have cuased most development to now proceed in the dark, the merge upstream was caught by exactly that, merge issues while adding IDEX functionality.
+
+Due to the blatent disregard to intentions and correct attribution, all support Marlin links have been removed from this repo and open PRs closed, and as long as the situation remains, no further work will be submitted upstream.
+
+Shout out to Tom Brazier, as nearly all notable improvements to the Marlin core code since the last release have come from him.
+
+Insanity Automation Discord - https://discord.gg/TKmJ85PyG4
+
+## Primary Notes for DW7.4.8
+   - Added Linear Adv and Input Shaping Screens
+   - Signifigant improvement in response times following changes to new generation machines
+   -- The DWIN OS 3.5 had an option to enable NOACK with an addon bin file. 4.0 has a specific throttled response OS revision. 4.5 needed a totally different UI image flashed. No way it could all live together without completely confusing users so we set about figuring out how to keep universal support and found a balance in data send cycles that the 2560 buffers could still handle the replies without overunning.
+   - Added support for changing runout sensor type on the LCD
+   - Added toggle to change babystepping increment on the LCD
+   - Thanks to EvilGremlin for some of the icon and display graphics work
+
+## Primary Notes for DW7.4.7
+   - Added IDEX screens
+   - Fan adjustment now numeric instead of simple on/off
+   - Tap Z offset on adjustment screen to type numeric value
+   - Sync to 2.1.2 with LA now on for all builds, Silent specific builds eliminated
+   - TODO note prior to building release batches - Primary outstanding bug is upstream issue causing M600 to fail to resume, verified on both DWIN and Standard full graphics displays.
+
+## Primary Notes for DW7.4.6
+  - Added Support for the Ender 2 Pro
+  - Added support for the Ender 3 S1 thanks to F1rst Layer providing a machine!
+  - Added support for the new DACAI screens being used on current production E3V2 and S1 machines
+  - Added support for runtime configurable runout sensors matching RRF M591 including type and polarity
+  - Moved E3V2/S1 machines to Marlin Display
+  - - Due to the ongoing fued between developers and GPL violations involved with both the Pro/Enahnced UI and the Jyers UI, we have decided to support neither and stay away from the conflict as much as possible. The Marlin UI has more configuration functionality and the menus are more adaptive to the configuration of the machine. This is based off of the default Marlin menu system and will be the most stable long term going forward as well. The cosmetics and graphical icons may not be as nice as with the other UI's however we belive the added functionality more than makes up for it.
+  - Removed non-touchscreen 8 bit UBL builds due to RAM constraints
+  - Removed Pre-Built Melzi / Sanguino files. These are legacy and no longer actively supported. Its recommended to purchase replacement 32bit motherboards for any machine still using it from https://amzn.to/3KdqyI8
+
+## Primary Notes for DW7.4.5
+  - Added support for CR10 Smart - Thanks to Tinymachines for providing the machine
+  - Revised file size issues causing corrupted screens on DWINOS3/4 displays (Sermoon, E6/7 etc)
+  - Added support for enabling / disabling filament runout and power loss recovery on the touchscreen
+  - Added LED control for equiped machines
+  - Resolved issue redirecting some users to chinese language displays instead of manual move screens
+  - Update to upstream current as of 2022-02-04
+  - CR6 / E3 Portrait Touchscreen files have an added NextGen dwin set. This supports the new DWIN OS 4 screens that began shipping in december. There are a few cosmetic issues left to resolve, but we decided to add them now anyway so that users who haver that hardware and will require it are not stuck.
+
+## Primary Notes for DW7.4.4
+  - Added Feedrate / Accel / Jerk Screens
+  - Touchscreen DGUS tools bumped to 8.2
+  - - All Portrait displays operate with the same build
+  - - Older screens (10S Pro) audio file selection is a bit off, havnt found a way to properly enforce wav file used yet
+  - Ender 7 support
+  - Sermoon D1 Support
+  - - Some users have reported Z clicking that the scripts run in the Leveling screen resolves, so if you hear clicking from the Z stepper when printing, run measuring from the leveling screen after powerup before printing.
+  - E3V2 Screens Icon issue fixed thanks to note from Jyers on icon file size limit
+
+## Primary Notes for DW7.4.3
+
+ - PID Messaging Fixed
+ - M600 / Advanced pause messaging improved
+ - Volume / Brightness numeric entry fixed
+ - Bump base to 2.0.9.2
+ -- Includes improved UI for the E3V2 with expanded menus submitted by Jyers
+ - Add Gcode configuration to disable BLTouch High Speed Mode to allow runtime config to support CRTouch
+ -- This one is pending upstream https://github.com/MarlinFirmware/Marlin/pull/22916
+ - Untested preliminary support for the Sermoon D1
+ -- Preliminary reports say it works aside from the LCD
+ -- I do not own one of these, however a local community member has offered to bring his down when im done with the Ender 7
+ - CR30 Support Added
+
+## Primary Notes for DW7.4
+- Touch screen primarily based on the fork by the [CR6 Community](https://github.com/CR6Community)
+- E3V2 is currently using the modified Jyers UI as merged into Marlin upstream
+
+## About Our Branches
+
+The firmware branches maintained here are made possible by the support of [F1rst Layer](https://amzn.to/2XWHVdH) and [Tiny Machines 3D](https://www.tinymachines3d.com/?rfsn=3419592.cc302fe) as well as our customer base through our 3D printing Services.
+Maintaining and developing these branches takes a significant investment, made up of time and machines. To support continued development, please consider your next 3D Printer purchases from Tiny Machines 3D, F1rst Layer, Bondtech, or Slice Engineering and thank them for supporting open source!
+and thank them for supporting open source development. Or, consider us for printing services outside of your machine’s capabilities. Print service requests can be sent to d.menzel@insanityautomation.com and we will
+respond typically within 1 working day. If you do not need anything printed or a 3D Printer but still want to contribute, you can support us through [Patreon](https://www.patreon.com/InsanityAutomation).
+
+## Setup
+
+All configuration options intended to be adjusted by end users have been placed in the top section of Configuration.h and have been documented there. There is typically a break line to segregate the standard
+configuration below. Anything aside from the upper options is intended for advanced users only.
+Please keep in mind when flashing the Creality 32 bit boards with the binary files (.bin) that occasionally they will not accept particular filenames. This is most common with reflashing after an aborted flash. The machine stores the filename it was last flashed with, so renaming the file to something such as firmware.bin or firmware1.bin (anything different than what it is now) will typically resolve any issue with file names.
+
+## Known Issues
+ - While auto leveling (measuring) is in progress pressing other buttons on the screen can abort portions of the script depending where it is
+ - - The process includes heating the bed before probing, probing then heating the nozzle before moving to Z0.
+  - Thanks to Jarrett Wendt for finding that if you are experiencing distorted sounds, and use a Mac, the default Archive Utility on MacOS has been found to be corrupting the files. If you're on a Mac, try unzipping with The Unarchiver or Keka instead.
+
+## Future Goals
+
+For this branch, we still have some active goals open that we plan to continue working on provided there is continued interest in the project.
+- CR10 Smart Power controls and network reset pin output to web interface device
+- Screens for IS and LA adjustment
+
+
+
+## Creality Firmware Branches
+  - Most Creality machines [CrealityDwin_2.0](https://github.com/InsanityAutomation/Marlin/tree/CrealityDwin_2.0)
+  - CR6 modified from [CR-6 Community](https://github.com/CR6Community) - [Creality CR6](https://github.com/InsanityAutomation/Marlin/tree/CR-6Devel)
+## Formbot / Vivedino Firmware Branches
+  - Raptor 1/2 Firmware [Raptor_2.0.X](https://github.com/InsanityAutomation/Marlin/tree/Raptor_2.0.X)
+  - Trex 2+/3 Firmware [TM_Trex2+_2.0.x](https://github.com/InsanityAutomation/Marlin/tree/TM_Trex2+_2.0.x)
+## Mamorubot / HieHa Firmware Branches
+  - SX4/SX2 Firmware [TM_SX4_2.0](https://github.com/InsanityAutomation/Marlin/tree/TM_SX4_2.0)
+## Other Firmware
+  - Raise 3D N2+ (Dual) 2.0 [Raise3D-N2+-Dual](https://github.com/InsanityAutomation/Marlin/tree/Raise3D-N2+-Dual)
+  - Evnovo Artillery Sidewinder X1 2.0 [Evnovo X1](https://github.com/InsanityAutomation/Marlin/tree/ArtilleryX1_2.0_Devel)
+  - [Anet E16](https://github.com/InsanityAutomation/Marlin/tree/AnetE16V2.0.5.2)
+  - Lulzbot with Universal Tools options [Lulzbot](https://github.com/InsanityAutomation/Marlin/tree/LulzbotTestBase)
+  - Funmat HT with Graphical Display [Funmat HT](https://github.com/InsanityAutomation/Marlin/tree/FunmatHT)
+  - [Modix Big60](https://github.com/InsanityAutomation/Marlin/tree/ModixBig60)
+  - Tronxy Chithu Machines [Tronxy](https://github.com/InsanityAutomation/Marlin/tree/TronxyX5SA)
+
+
+
+[Marlin Commit History](https://github.com/MarlinFirmware/Marlin/pulls?q=is%3Apr+is%3Aclosed+author%3AInsanityAutomation)
+
+## Marlin
+This is just one of many forks of Marlin. We don't try to bury that behind fancy marketting or anything else.
+
 <p align="center"><img src="buildroot/share/pixmaps/logo/marlin-outrun-nf-500.png" height="250" alt="MarlinFirmware's logo" /></p>

 <h1 align="center">Marlin 3D Printer Firmware</h1>

 <p align="center">
    <a href="/LICENSE"><img alt="GPL-V3.0 License" src="https://img.shields.io/github/license/marlinfirmware/marlin.svg"></a>
-    <a href="https://github.com/MarlinFirmware/Marlin/graphs/contributors"><img alt="Contributors" src="https://img.shields.io/github/contributors/marlinfirmware/marlin.svg"></a>
-    <a href="https://github.com/MarlinFirmware/Marlin/releases"><img alt="Last Release Date" src="https://img.shields.io/github/release-date/MarlinFirmware/Marlin"></a>
-    <a href="https://github.com/MarlinFirmware/Marlin/actions"><img alt="CI Status" src="https://github.com/MarlinFirmware/Marlin/actions/workflows/test-builds.yml/badge.svg"></a>
-    <a href="https://github.com/sponsors/thinkyhead"><img alt="GitHub Sponsors" src="https://img.shields.io/github/sponsors/thinkyhead?color=db61a2"></a>
-    <br />
-    <a href="https://fosstodon.org/@marlinfirmware"><img alt="Follow MarlinFirmware on Mastodon" src="https://img.shields.io/mastodon/follow/109450200866020466?domain=https%3A%2F%2Ffosstodon.org&logoColor=%2300B&style=social"></a>
 </p>

-Additional documentation can be found at the [Marlin Home Page](https://marlinfw.org/).
-Please test this firmware and let us know if it misbehaves in any way. Volunteers are standing by!
-
-## Marlin 2.1 Bugfix Branch
-
-__Not for production use. Use with caution!__
-
-Marlin 2.1 takes this popular RepRap firmware to the next level by adding support for much faster 32-bit and ARM-based boards while improving support for 8-bit AVR boards. Read about Marlin's decision to use a "Hardware Abstraction Layer" below.
-
-This branch is for patches to the latest 2.1.x release version. Periodically this branch will form the basis for the next minor 2.1.x release.
-
-Download earlier versions of Marlin on the [Releases page](https://github.com/MarlinFirmware/Marlin/releases).
-
-## Example Configurations
-
-Before you can build Marlin for your machine you'll need a configuration for your specific hardware. Upon request, your vendor will be happy to provide you with the complete source code and configurations for your machine, but you'll need to get updated configuration files if you want to install a newer version of Marlin. Fortunately, Marlin users have contributed dozens of tested configurations to get you started. Visit the [MarlinFirmware/Configurations](https://github.com/MarlinFirmware/Configurations) repository to find the right configuration for your hardware.
-
-## Building Marlin 2.1
-
-To build and upload Marlin you will use one of these tools:
-
- The free [Visual Studio Code](https://code.visualstudio.com/download) using the [Auto Build Marlin](https://marlinfw.org/docs/basics/auto_build_marlin.html) extension.
- The free [Arduino IDE](https://www.arduino.cc/en/main/software) : See [Building Marlin with Arduino](https://marlinfw.org/docs/basics/install_arduino.html)
- You can also use VSCode with devcontainer : See [Installing Marlin (VSCode devcontainer)](http://marlinfw.org/docs/basics/install_devcontainer_vscode.html).
-
-Marlin is optimized to build with the **PlatformIO IDE** extension for **Visual Studio Code**. You can still build Marlin with **Arduino IDE**, and we hope to improve the Arduino build experience, but at this time PlatformIO is the better choice.
-
-## Hardware Abstraction Layer (HAL)
-
-Marlin includes an abstraction layer to provide a common API for all the platforms it targets. This allows Marlin code to address the details of motion and user interface tasks at the lowest and highest levels with no system overhead, tying all events directly to the hardware clock.
-
-Every new HAL opens up a world of hardware. At this time we need HALs for RP2040 and the Duet3D family of boards. A HAL that wraps an RTOS is an interesting concept that could be explored. Did you know that Marlin includes a Simulator that can run on Windows, macOS, and Linux? Join the Discord to help move these sub-projects forward!
-
-## 8-Bit AVR Boards
-
-A core tenet of this project is to keep supporting 8-bit AVR boards while also maintaining a single codebase that applies equally to all machines. We want casual hobbyists to benefit from the community's innovations as much as possible just as much as those with fancier machines. Plus, those old AVR-based machines are often the best for your testing and feedback!
-
-### Supported Platforms
-
-  Platform|MCU|Example Boards
-  --------|---|-------
-  [Arduino AVR](https://www.arduino.cc/)|ATmega|RAMPS, Melzi, RAMBo
-  [Teensy++ 2.0](https://www.microchip.com/en-us/product/AT90USB1286)|AT90USB1286|Printrboard
-  [Arduino Due](https://www.arduino.cc/en/Guide/ArduinoDue)|SAM3X8E|RAMPS-FD, RADDS, RAMPS4DUE
-  [ESP32](https://github.com/espressif/arduino-esp32)|ESP32|FYSETC E4, E4d@BOX, MRR
-  [LPC1768](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/lpc1700-cortex-m3/512-kb-flash-64-kb-sram-ethernet-usb-lqfp100-package:LPC1768FBD100)|ARM® Cortex-M3|MKS SBASE, Re-ARM, Selena Compact
-  [LPC1769](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/lpc1700-cortex-m3/512-kb-flash-64-kb-sram-ethernet-usb-lqfp100-package:LPC1769FBD100)|ARM® Cortex-M3|Smoothieboard, Azteeg X5 mini, TH3D EZBoard
-  [STM32F103](https://www.st.com/en/microcontrollers-microprocessors/stm32f103.html)|ARM® Cortex-M3|Malyan M200, GTM32 Pro, MKS Robin, BTT SKR Mini
-  [STM32F401](https://www.st.com/en/microcontrollers-microprocessors/stm32f401.html)|ARM® Cortex-M4|ARMED, Rumba32, SKR Pro, Lerdge, FYSETC S6, Artillery Ruby
-  [STM32F7x6](https://www.st.com/en/microcontrollers-microprocessors/stm32f7x6.html)|ARM® Cortex-M7|The Borg, RemRam V1
-  [STM32G0B1RET6](https://www.st.com/en/microcontrollers-microprocessors/stm32g0x1.html)|ARM® Cortex-M0+|BigTreeTech SKR mini E3 V3.0
-  [STM32H743xIT6](https://www.st.com/en/microcontrollers-microprocessors/stm32h743-753.html)|ARM® Cortex-M7|BigTreeTech SKR V3.0, SKR EZ V3.0, SKR SE BX V2.0/V3.0
-  [SAMD51P20A](https://www.adafruit.com/product/4064)|ARM® Cortex-M4|Adafruit Grand Central M4
-  [Teensy 3.5](https://www.pjrc.com/store/teensy35.html)|ARM® Cortex-M4|
-  [Teensy 3.6](https://www.pjrc.com/store/teensy36.html)|ARM® Cortex-M4|
-  [Teensy 4.0](https://www.pjrc.com/store/teensy40.html)|ARM® Cortex-M7|
-  [Teensy 4.1](https://www.pjrc.com/store/teensy41.html)|ARM® Cortex-M7|
-  Linux Native|x86/ARM/etc.|Raspberry Pi
-
-## Submitting Patches
-
-Proposed patches should be submitted as a Pull Request against the ([bugfix-2.1.x](https://github.com/MarlinFirmware/Marlin/tree/bugfix-2.1.x)) branch.
-
- This branch is for fixing bugs and integrating any new features for the duration of the Marlin 2.1.x life-cycle.
- Follow the [Coding Standards](https://marlinfw.org/docs/development/coding_standards.html) to gain points with the maintainers.
- Please submit Feature Requests and Bug Reports to the [Issue Queue](https://github.com/MarlinFirmware/Marlin/issues/new/choose). Support resources are also listed there.
- Whenever you add new features, be sure to add tests to `buildroot/tests` and then run your tests locally, if possible.
-  - It's optional: Running all the tests on Windows might take a long time, and they will run anyway on GitHub.
-  - If you're running the tests on Linux (or on WSL with the code on a Linux volume) the speed is much faster.
-  - You can use `make tests-all-local` or `make tests-single-local TEST_TARGET=...`.
-  - If you prefer Docker you can use `make tests-all-local-docker` or `make tests-all-local-docker TEST_TARGET=...`.
-
-## Marlin Support
-
-The Issue Queue is reserved for Bug Reports and Feature Requests. To get help with configuration and troubleshooting, please use the following resources:
-
- [Marlin Documentation](https://marlinfw.org) - Official Marlin documentation
- [Marlin Discord](https://discord.gg/n5NJ59y) - Discuss issues with Marlin users and developers
- Facebook Group ["Marlin Firmware"](https://www.facebook.com/groups/1049718498464482/)
- RepRap.org [Marlin Forum](https://forums.reprap.org/list.php?415)
- Facebook Group ["Marlin Firmware for 3D Printers"](https://www.facebook.com/groups/3Dtechtalk/)
- [Marlin Configuration](https://www.youtube.com/results?search_query=marlin+configuration) on YouTube
-
-## Contributors
-
-Marlin is constantly improving thanks to a huge number of contributors from all over the world bringing their specialties and talents. Huge thanks are due to [all the contributors](https://github.com/MarlinFirmware/Marlin/graphs/contributors) who regularly patch up bugs, help direct traffic, and basically keep Marlin from falling apart. Marlin's continued existence would not be possible without them.
-
-## Administration
-
-Regular users can open and close their own issues, but only the administrators can do project-related things like add labels, merge changes, set milestones, and kick trolls. The current Marlin admin team consists of:
-
-<table align="center">
-<tr><td>Project Maintainer</td></tr>
-<tr><td>
-
- 🇺🇸  **Scott Lahteine**
-       [@thinkyhead](https://github.com/thinkyhead)
-       [<kbd>  Donate 💸  </kbd>](https://www.thinkyhead.com/donate-to-marlin)
-
-</td><td>
-
- 🇺🇸  **Roxanne Neufeld**
-       [@Roxy-3D](https://github.com/Roxy-3D)
-
- 🇺🇸  **Keith Bennett**
-       [@thisiskeithb](https://github.com/thisiskeithb)
-       [<kbd>  Donate 💸  </kbd>](https://github.com/sponsors/thisiskeithb)
-
- 🇺🇸  **Jason Smith**
-       [@sjasonsmith](https://github.com/sjasonsmith)
-
-</td><td>
-
- 🇧🇷  **Victor Oliveira**
-       [@rhapsodyv](https://github.com/rhapsodyv)
-
- 🇬🇧  **Chris Pepper**
-       [@p3p](https://github.com/p3p)
-
-🇳🇿  **Peter Ellens**
-       [@ellensp](https://github.com/ellensp)
-       [<kbd>  Donate 💸  </kbd>](https://ko-fi.com/ellensp)
-
-</td><td>
-
- 🇺🇸  **Bob Kuhn**
-       [@Bob-the-Kuhn](https://github.com/Bob-the-Kuhn)
-
- 🇳🇱  **Erik van der Zalm**
-       [@ErikZalm](https://github.com/ErikZalm)
-       [<kbd>  Donate 💸  </kbd>](https://flattr.com/submit/auto?user_id=ErikZalm&url=https://github.com/MarlinFirmware/Marlin&title=Marlin&language=&tags=github&category=software)
-
-</td></tr>
-</table>
-
-## License
-
 Marlin is published under the [GPL license](/LICENSE) because we believe in open development. The GPL comes with both rights and obligations. Whether you use Marlin firmware as the driver for your open or closed-source product, you must keep Marlin open, and you must provide your compatible Marlin source code to end users upon request. The most straightforward way to comply with the Marlin license is to make a fork of Marlin on Github, perform your modifications, and direct users to your modified fork.

 While we can't prevent the use of this code in products (3D printers, CNC, etc.) that are closed source or crippled by a patent, we would prefer that you choose another firmware or, better yet, make your own.
@@ -0,0 +1,7 @@
+#!/bin/bash
+for file in *; do
+	if [ "$file" != "*" ] ; then
+		zip $file.zip $file
+	fi
+done
+
--- a/Show More
+++ b/Show More