btt stm32 CR6 Fixes

* Add Dagoma D6 board as used in their DiscoUltimate v2 TMC.

Taken from the Dagoma fork of Marlin DU_MC branch where it is called FYSETC_DAGOMA_F5 and explicitly confirmed by Dagoma as being the D6:

"the BOARD_FYSETC_DAGOMA_F5 is effectively the definition for the D6"

---------

Co-authored-by: thisiskeithb <13375512+thisiskeithb@users.noreply.github.com>
Co-authored-by: Orel <37673727+0r31@users.noreply.github.com>

.github/workflows/ci-build-tests.yml

@@ -1,9 +1,9 @@
 #
-# test-builds.yml
+# ci-build-tests.yml
 # Do test builds to catch compile errors
 #
 
-name: CI
+name: CI - Build Tests
 
 on:
   pull_request:
@@ -27,7 +27,7 @@ on:
 
 jobs:
   test_builds:
-    name: Run All Tests
+    name: Build Test
     if: github.repository == 'MarlinFirmware/Marlin'
 
     runs-on: ubuntu-latest

.github/workflows/ci-unit-tests.yml

@@ -0,0 +1,73 @@
+#
+# ci-unit-tests.yml
+# Build and execute unit tests to catch functional issues in code
+#
+
+name: CI - Unit Tests
+
+on:
+  pull_request:
+    branches:
+    - bugfix-2.1.x
+    # Cannot be enabled on 2.1.x until it contains the unit test framework
+    #- 2.1.x
+    paths-ignore:
+    - config/**
+    - data/**
+    - docs/**
+    - '**/*.md'
+  push:
+    branches:
+    - bugfix-2.1.x
+    # Cannot be enabled on 2.1.x until it contains the unit test framework
+    #- 2.1.x
+    paths-ignore:
+    - config/**
+    - data/**
+    - docs/**
+    - '**/*.md'
+
+jobs:
+  # This runs all unit tests as a single job. While it should be possible to break this up into
+  # multiple jobs, they currently run quickly and finish long before the compilation tests.
+  run_unit_tests:
+    name: Unit Test
+    # These tests will only be able to run on the bugfix-2.1.x branch, until the next release
+    # pulls them into additional branches.
+    if: github.repository == 'MarlinFirmware/Marlin'
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out the PR
+      uses: actions/checkout@v4
+
+    - name: Cache pip
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+
+    - name: Cache PlatformIO
+      uses: actions/cache@v4
+      with:
+        path: ~/.platformio
+        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+
+    - name: Select Python 3.9
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.9'
+        architecture: 'x64'
+
+    - name: Install PlatformIO
+      run: |
+        pip install -U platformio
+        pio upgrade --dev
+        pio pkg update --global
+
+    - name: Run All Unit Tests
+      run: |
+        make unit-test-all-local

Makefile

@@ -12,7 +12,12 @@ help:
 	@echo "make tests-single-local-docker : Run a single test locally, using docker"
 	@echo "make tests-all-local           : Run all tests locally"
 	@echo "make tests-all-local-docker    : Run all tests locally, using docker"
-	@echo "make setup-local-docker        : Build the local docker image"
+#	@echo "make unit-test-single-ci      : Run a single code test from inside the CI"
+#	@echo "make unit-test-single-local   : Run a single code test locally"
+#	@echo "make unit-test-single-local-docker : Run a single code test locally, using docker-compose"
+	@echo "make unit-test-all-local      : Run all code tests locally"
+	@echo "make unit-test-all-local-docker : Run all code tests locally, using docker-compose"
+	@echo "make setup-local-docker        : Setup local docker-compose"
 	@echo ""
 	@echo "Options for testing:"
 	@echo "  TEST_TARGET          Set when running tests-single-*, to select the"
@@ -43,7 +48,7 @@ tests-single-local:
 tests-single-local-docker:
 	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local-docker" ; return 1; fi
 	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
-	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
+	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) make tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
 
 tests-all-local:
 	export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
@@ -52,10 +57,31 @@ tests-all-local:
 
 tests-all-local-docker:
 	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
-	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
+	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) make tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
+
+#unit-test-single-ci:
+#	export GIT_RESET_HARD=true
+#	$(MAKE) unit-test-single-local TEST_TARGET=$(TEST_TARGET)
+
+# TODO: How can we limit tests with ONLY_TEST with platformio?
+#unit-test-single-local:
+#	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make unit-test-all-local" ; return 1; fi
+#	platformio run -t marlin_$(TEST_TARGET)
+
+#unit-test-single-local-docker:
+#	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make unit-test-all-local-docker" ; return 1; fi
+#	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
+#	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS)  $(CONTAINER_IMAGE) make unit-test-single-local TEST_TARGET=$(TEST_TARGET) ONLY_TEST="$(ONLY_TEST)"
+
+unit-test-all-local:
+	platformio run -t test-marlin -e linux_native_test
+
+unit-test-all-local-docker:
+	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
+	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS)  $(CONTAINER_IMAGE) make unit-test-all-local
 
 setup-local-docker:
-	$(CONTAINER_RT_BIN) build -t $(CONTAINER_IMAGE) -f docker/Dockerfile .
+	$(CONTAINER_RT_BIN) buildx build -t $(CONTAINER_IMAGE) -f docker/Dockerfile .
 
 PINS := $(shell find Marlin/src/pins -mindepth 2 -name '*.h')
 

Marlin/Version.h

@@ -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,177 @@
 /**
  * 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 " TM3D " 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 "2024-04-11"
+#define STRING_DISTRIBUTION_DATE "2024-04-08"
 
 /**
  * Defines a generic printer name to be output to the LCD after booting Marlin.
  */
-//#define MACHINE_NAME "3D Printer"
+#if(ENABLED(MachineMini))
+  #define CUSTOM_MACHINE_NAME "Mini SuPeR"
+#elif(ENABLED(MachineCR10Smart))
+  #define CUSTOM_MACHINE_NAME "TM3D CR10Smart"
+#elif(ENABLED(MachineCR10SmartPro))
+  #define CUSTOM_MACHINE_NAME "TM3D CR10SmartPro"
+#elif(ENABLED(MachineEnder2))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender2"
+#elif(ENABLED(MachineEnder2Pro))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender2 Pro"
+#elif(ENABLED(MachineEnder3))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender3"
+#elif(ENABLED(MachineEnder3Max))
+  #define CUSTOM_MACHINE_NAME "TM3D E3Max"
+#elif(ENABLED(MachineEnder6))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender6"
+#elif(ENABLED(MachineEnder7))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender7"
+#elif(ENABLED(MachineEnder3V2))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender3V2"
+#elif(ENABLED(MachineEnder3S1))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender3S1"
+#elif(ENABLED(MachineEnder4))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender4"
+#elif(ENABLED(MachineEnder5))
+  #define CUSTOM_MACHINE_NAME "TM3D Ender5"
+#elif(ENABLED(MachineEnder5Plus))
+  #define CUSTOM_MACHINE_NAME "TM3D E5 Plus"
+#elif(ENABLED(MachineCR20))
+  #define CUSTOM_MACHINE_NAME "SuPeR CR-20"
+#elif(ENABLED(MachineCR10Orig))
+  #define CUSTOM_MACHINE_NAME "SuPeR CR-10"
+#elif(ENABLED(MachineCRX))
+  #define CUSTOM_MACHINE_NAME "TM3D CR-X"
+#elif ENABLED(MachineCR10SProV2)
+  #define CUSTOM_MACHINE_NAME "TM3D 10SProV2"
+#elif(ENABLED(MachineCR10SPro))
+  #define CUSTOM_MACHINE_NAME "TM3D 10S Pro"
+#elif(ENABLED(MachineCR10Max))
+  #define CUSTOM_MACHINE_NAME "TM3D Max"
+#elif(ENABLED(MachineCR10SV3))
+  #define CUSTOM_MACHINE_NAME "TM3D CR10V3"
+#elif(ENABLED(MachineCR10SV2))
+  #define CUSTOM_MACHINE_NAME "TM3D CR10V2"
+#elif(ENABLED(MachineCR10Std))
+  #define CUSTOM_MACHINE_NAME "300 SuPeR"
+#elif(ENABLED(MachineS4))
+  #define CUSTOM_MACHINE_NAME "400 SuPeR"
+#elif(ENABLED(MachineS5))
+  #define CUSTOM_MACHINE_NAME "500 SuPeR"
+#elif ENABLED(MachineCR2020)
+  #define CUSTOM_MACHINE_NAME "TM3D 2020"
+#elif ENABLED(MachineSermoonD1)
+  #define CUSTOM_MACHINE_NAME "SermoonD1"
+#elif ENABLED(MachineCR5)
+  #define CUSTOM_MACHINE_NAME "CR5 Pro"
+#elif ENABLED(MachineCR6)
+  #define CUSTOM_MACHINE_NAME "CR6"
+#elif ENABLED(MachineCR6Max)
+  #define CUSTOM_MACHINE_NAME "CR6 Max"
+#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 +206,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 +217,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 "tinymachines3d.com"
 
 /**
  * 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

Marlin/_Bootscreen.h

@@ -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
+};

Marlin/_Statusscreen.h

@@ -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

Marlin/src/HAL/AVR/HAL.h

@@ -141,8 +141,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
 

Marlin/src/HAL/AVR/MarlinSerial.cpp

@@ -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.

Marlin/src/HAL/AVR/MarlinSerial.h

@@ -205,7 +205,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
 
@@ -276,7 +276,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;

Marlin/src/HAL/HC32/MarlinHAL.cpp

@@ -123,6 +123,11 @@ void MarlinHAL::init() {
 
   // Register min serial
   TERN_(POSTMORTEM_DEBUGGING, install_min_serial());
+
+  // warn if low memory after init
+  if (freeMemory() < 1024) {
+    SERIAL_WARN_MSG("HAL: low memory after init!\n");
+  }
 }
 
 void MarlinHAL::init_board() {}
@@ -147,7 +152,31 @@ void MarlinHAL::delay_ms(const int ms) {
   delay(ms);
 }
 
-void MarlinHAL::idletask() {}
+void MarlinHAL::idletask() {
+  #if ENABLED(MARLIN_DEV_MODE)
+    // check & print serial RX errors
+    MSerialT *serials[] = { &MSerial1, &MSerial2 };
+    for (int serial = 0; serial < 2; serial++) {
+      usart_receive_error_t err = serials[serial]->getReceiveError();
+      if (err != usart_receive_error_t::None) {
+        // "Warning: MSerial[n] RX [Framing|Parity|Overrun] Error"
+        SERIAL_WARN_START();
+        SERIAL_ECHOPGM(" MSerial");
+        SERIAL_ECHO(serial + 1);
+        SERIAL_ECHOPGM(" RX ");
+        switch(err) {
+          case usart_receive_error_t::FramingError: SERIAL_ECHOPGM("Framing"); break;
+          case usart_receive_error_t::ParityError:  SERIAL_ECHOPGM("Parity");  break;
+          case usart_receive_error_t::OverrunError: SERIAL_ECHOPGM("Overrun"); break;
+          case usart_receive_error_t::RxDataDropped: SERIAL_ECHOPGM("DataDropped"); break;
+          default: break;
+        }
+        SERIAL_ECHOPGM(" Error");
+        SERIAL_EOL();
+      }
+    }
+  #endif
+}
 
 uint8_t MarlinHAL::get_reset_source() {
   // Query reset cause from RMU

Marlin/src/HAL/HC32/MarlinSerial.cpp

@@ -46,14 +46,34 @@ constexpr bool serial_handles_emergency(int port) {
 //
 // Define serial ports
 //
-#define DEFINE_HWSERIAL_MARLIN(name, n)      \
+
+// serial port where RX and TX use IRQs
+#define DEFINE_IRQ_SERIAL_MARLIN(name, n)      \
   MSerialT name(serial_handles_emergency(n), \
                 &USART##n##_config,          \
                 BOARD_USART##n##_TX_PIN,     \
                 BOARD_USART##n##_RX_PIN);
 
-DEFINE_HWSERIAL_MARLIN(MSerial1, 1);
-DEFINE_HWSERIAL_MARLIN(MSerial2, 2);
+// serial port where RX uses DMA and TX uses IRQs
+// all serial ports use DMA1
+// since there are 4 USARTs and 4 DMA channels, we can use the USART number as the DMA channel
+#define DEFINE_DMA_SERIAL_MARLIN(name, n)      \
+  MSerialT name(serial_handles_emergency(n), \
+                &USART##n##_config,          \
+                BOARD_USART##n##_TX_PIN,     \
+                BOARD_USART##n##_RX_PIN,     \
+                M4_DMA1,                     \
+                ((en_dma_channel_t)(n - 1))); // map USART1 to DMA channel 0, USART2 to DMA channel 1, etc.
+
+#define DEFINE_SERIAL_MARLIN(name, n) TERN(SERIAL_DMA, DEFINE_DMA_SERIAL_MARLIN(name, n), DEFINE_IRQ_SERIAL_MARLIN(name, n))
+
+DEFINE_SERIAL_MARLIN(MSerial1, 1);
+DEFINE_SERIAL_MARLIN(MSerial2, 2);
+
+// TODO: remove this warning when SERIAL_DMA has been tested some more
+#if ENABLED(SERIAL_DMA)
+  #warning "SERIAL_DMA may be unstable on HC32F460."
+#endif
 
 //
 // Serial port assertions

Marlin/src/HAL/HC32/MarlinSerial.h

@@ -25,17 +25,42 @@
 #include <drivers/usart/Usart.h>
 
 // Optionally set uart IRQ priority to reduce overflow errors
-// #define UART_IRQ_PRIO 1
+//#define UART_RX_IRQ_PRIO 1
+//#define UART_TX_IRQ_PRIO 1
+//#define UART_RX_DMA_IRQ_PRIO 1
 
 struct MarlinSerial : public Usart {
-  MarlinSerial(struct usart_config_t *usart_device, gpio_pin_t tx_pin, gpio_pin_t rx_pin) : Usart(usart_device, tx_pin, rx_pin) {}
+  MarlinSerial(
+    struct usart_config_t *usart_device, 
+    gpio_pin_t tx_pin, 
+    gpio_pin_t rx_pin
+    #if ENABLED(SERIAL_DMA)
+    , M4_DMA_TypeDef *dma_unit = nullptr,
+    en_dma_channel_t rx_dma_channel = DmaCh0
+    #endif
+  ) : Usart(usart_device, tx_pin, rx_pin) {
+    #if ENABLED(SERIAL_DMA)
+      if (dma_unit != nullptr) {
+        enableRxDma(dma_unit, rx_dma_channel);
+      }
+    #endif
+  }
 
-  #ifdef UART_IRQ_PRIO
+  #if defined(UART_RX_IRQ_PRIO) || defined(UART_TX_IRQ_PRIO) || defined(UART_RX_DMA_IRQ_PRIO)
     void setPriority() {
-      NVIC_SetPriority(c_dev()->interrupts.rx_data_available.interrupt_number, UART_IRQ_PRIO);
-      NVIC_SetPriority(c_dev()->interrupts.rx_error.interrupt_number, UART_IRQ_PRIO);
-      NVIC_SetPriority(c_dev()->interrupts.tx_buffer_empty.interrupt_number, UART_IRQ_PRIO);
-      NVIC_SetPriority(c_dev()->interrupts.tx_complete.interrupt_number, UART_IRQ_PRIO);
+      #if defined(UART_RX_IRQ_PRIO)
+        NVIC_SetPriority(c_dev()->interrupts.rx_data_available.interrupt_number, UART_RX_IRQ_PRIO);
+        NVIC_SetPriority(c_dev()->interrupts.rx_error.interrupt_number, UART_RX_IRQ_PRIO);
+      #endif
+
+      #if defined(UART_TX_IRQ_PRIO)
+        NVIC_SetPriority(c_dev()->interrupts.tx_buffer_empty.interrupt_number, UART_TX_IRQ_PRIO);
+        NVIC_SetPriority(c_dev()->interrupts.tx_complete.interrupt_number, UART_TX_IRQ_PRIO);
+      #endif
+
+      #if defined(UART_RX_DMA_IRQ_PRIO) && ENABLED(SERIAL_DMA)
+        NVIC_SetPriority(c_dev()->dma.rx.rx_data_available_dma_btc.interrupt_number, UART_RX_DMA_IRQ_PRIO);
+      #endif
     }
 
     void begin(uint32_t baud) {
@@ -47,7 +72,12 @@ struct MarlinSerial : public Usart {
       Usart::begin(baud, config);
       setPriority();
     }
-  #endif
+
+    void begin(uint32_t baud, const stc_usart_uart_init_t *config, const bool rxNoiseFilter = true) {
+      Usart::begin(baud, config, rxNoiseFilter);
+      setPriority();
+    }
+  #endif // UART_RX_IRQ_PRIO || UART_TX_IRQ_PRIO || UART_RX_DMA_IRQ_PRIO
 };
 
 typedef Serial1Class<MarlinSerial> MSerialT;

Marlin/src/HAL/HC32/app_config.h

@@ -0,0 +1,70 @@
+/**
+ * app_config.h is included by the hc32f460 arduino build script for every source file.
+ * it is used to configure the arduino core (and ddl) automatically according 
+ * to the settings in Configuration.h and Configuration_adv.h.
+ */
+#pragma once
+#ifndef _HC32_APP_CONFIG_H_
+#define _HC32_APP_CONFIG_H_
+
+#include "../../inc/MarlinConfigPre.h"
+
+//
+// dev mode
+//
+#if ENABLED(MARLIN_DEV_MODE)
+  #define __DEBUG 1
+  #define __CORE_DEBUG 1
+#endif
+
+//
+// Fault Handlers and Panic
+//
+
+#if ENABLED(POSTMORTEM_DEBUGGING)
+  // disable arduino core fault handler, as we define our own
+  #define CORE_DISABLE_FAULT_HANDLER 1
+#endif
+
+// force-enable panic handler so that we can use our custom one (in MinSerial)
+#define PANIC_ENABLE 1
+
+// use short filenames in ddl debug and core panic output
+#define __DEBUG_SHORT_FILENAMES 1
+#define __PANIC_SHORT_FILENAMES 1
+
+// omit panic messages in core panic output
+#define __OMIT_PANIC_MESSAGE 1
+
+//
+// Usart
+//
+
+// disable serial globals (Serial1, Serial2, ...), as we define our own
+#define DISABLE_SERIAL_GLOBALS 1
+
+// increase the size of the Usart buffers (both RX and TX)
+// NOTE: 
+// the heap usage will increase by (SERIAL_BUFFER_SIZE - 64) * "number of serial ports used"
+// if running out of heap, the system may become unstable
+//#define SERIAL_BUFFER_SIZE 256
+
+// enable support for Usart Clock Divider / Oversampling auto config
+#define USART_AUTO_CLKDIV_OS_CONFIG 1
+
+// enable USART_RX_DMA_SUPPORT core option when SERIAL_DMA is enabled
+#if ENABLED(SERIAL_DMA)
+  #define USART_RX_DMA_SUPPORT 1
+#endif
+
+//
+// Misc.
+//
+
+// redirect printf to host serial
+#define REDIRECT_PRINTF_TO_SERIAL 1
+
+// FIXME override F_CPU to PCLK1, as marlin freaks out otherwise
+#define F_CPU (SYSTEM_CLOCK_FREQUENCIES.pclk1)
+
+#endif // _HC32_APP_CONFIG_H_

Marlin/src/HAL/HC32/inc/SanityCheck.h

@@ -20,6 +20,20 @@
  *
  */
 #pragma once
+#include <core_util.h>
+
+#if !defined(ARDUINO_CORE_VERSION_INT) || !defined(GET_VERSION_INT)
+  // version macros were introduced in arduino core version 1.1.0
+  // below that version, we polyfill them
+  #define GET_VERSION_INT(major, minor, patch) ((major * 100000) + (minor * 1000) + patch)
+  #define ARDUINO_CORE_VERSION_INT GET_VERSION_INT(1, 0, 0)
+#endif
+
+#if ARDUINO_CORE_VERSION_INT < GET_VERSION_INT(1, 1, 0)
+  // because we use app_config.h introduced in arduino core version 1.1.0, the 
+  // HAL is not compatible with older versions
+  #error "The HC32 HAL is not compatible with Arduino Core versions < 1.1.0. Consider updating the Arduino Core."
+#endif
 
 #ifndef BOARD_XTAL_FREQUENCY
   #error "BOARD_XTAL_FREQUENCY is required for HC32F460."
@@ -74,3 +88,18 @@
     #error "HC32 HAL uses a custom panic handler. Do not define PANIC_USARTx_TX_PIN."
   #endif
 #endif
+
+#if ENABLED(SERIAL_DMA)
+  #if !defined(USART_RX_DMA_SUPPORT)
+    #error "SERIAL_DMA requires USART_RX_DMA_SUPPORT to be enabled in the arduino core."
+  #endif
+
+  // USART_RX_DMA_SUPPORT does not implement core_hook_usart_rx_irq, which is required for the emergency parser
+  #if ENABLED(EMERGENCY_PARSER)
+    #error "EMERGENCY_PARSER is not supported with SERIAL_DMA. Please disable either SERIAL_DMA or EMERGENCY_PARSER."
+  #endif
+
+  #if ARDUINO_CORE_VERSION_INT < GET_VERSION_INT(1, 1, 0)
+    #error "SERIAL_DMA is not supported with arduino core version < 1.1.0."
+  #endif
+#endif

Marlin/src/HAL/HC32/sdio.cpp

@@ -54,7 +54,7 @@
     fn                                              \
   }
 
-stc_sd_handle_t *handle;
+stc_sd_handle_t *handle = nullptr;
 
 bool SDIO_Init() {
   // Configure SDIO pins
@@ -66,36 +66,45 @@ bool SDIO_Init() {
   GPIO_SetFunc(BOARD_SDIO_CMD, Func_Sdio);
   GPIO_SetFunc(BOARD_SDIO_DET, Func_Sdio);
 
+  // If a handle is already initialized, free it before creating a new one
+  // otherwise, we will leak memory, which will eventually crash the system
+  if (handle != nullptr) {
+    delete handle->pstcDmaInitCfg;
+    delete handle->pstcCardInitCfg;
+    delete handle;
+    handle = nullptr;
+  }
+
   // Create DMA configuration
   stc_sdcard_dma_init_t *dmaConf = new stc_sdcard_dma_init_t;
   dmaConf->DMAx = SDIO_DMA_PERIPHERAL;
   dmaConf->enDmaCh = SDIO_DMA_CHANNEL;
 
+  // Create card configuration
+  // This should be a fairly safe configuration for most cards
+  stc_sdcard_init_t *cardConf = new stc_sdcard_init_t;
+  cardConf->enBusWidth = SdiocBusWidth4Bit;
+  cardConf->enClkFreq = SdiocClk400K;
+  cardConf->enSpeedMode = SdiocNormalSpeedMode;
+  cardConf->pstcInitCfg = nullptr;
+
   // Create handle in DMA mode
   handle = new stc_sd_handle_t;
   handle->SDIOCx = SDIO_PERIPHERAL;
   handle->enDevMode = SdCardDmaMode;
   handle->pstcDmaInitCfg = dmaConf;
-
-  // Create card configuration
-  // This should be a fairly safe configuration for most cards
-  stc_sdcard_init_t cardConf = {
-    .enBusWidth = SdiocBusWidth4Bit,
-    .enClkFreq = SdiocClk400K,
-    .enSpeedMode = SdiocNormalSpeedMode,
-    //.pstcInitCfg = NULL,
-  };
+  //handle->pstcCardInitCfg = cardConf; // assigned in SDCARD_Init
 
   // Initialize sd card
-  en_result_t rc = SDCARD_Init(handle, &cardConf);
+  en_result_t rc = SDCARD_Init(handle, cardConf);
   if (rc != Ok) printf("SDIO_Init() error (rc=%u)\n", rc);
 
   return rc == Ok;
 }
 
 bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
-  CORE_ASSERT(handle != NULL, "SDIO not initialized");
-  CORE_ASSERT(dst != NULL, "SDIO_ReadBlock dst is NULL");
+  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
+  CORE_ASSERT(dst != nullptr, "SDIO_ReadBlock dst is NULL", return false);
 
   WITH_RETRY(SDIO_READ_RETRIES, {
     en_result_t rc = SDCARD_ReadBlocks(handle, block, 1, dst, SDIO_READ_TIMEOUT);
@@ -107,8 +116,8 @@ bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
 }
 
 bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
-  CORE_ASSERT(handle != NULL, "SDIO not initialized");
-  CORE_ASSERT(src != NULL, "SDIO_WriteBlock src is NULL");
+  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
+  CORE_ASSERT(src != nullptr, "SDIO_WriteBlock src is NULL", return false);
 
   WITH_RETRY(SDIO_WRITE_RETRIES, {
     en_result_t rc = SDCARD_WriteBlocks(handle, block, 1, (uint8_t *)src, SDIO_WRITE_TIMEOUT);
@@ -120,12 +129,12 @@ bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
 }
 
 bool SDIO_IsReady() {
-  CORE_ASSERT(handle != NULL, "SDIO not initialized");
+  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
   return bool(handle->stcCardStatus.READY_FOR_DATA);
 }
 
 uint32_t SDIO_GetCardSize() {
-  CORE_ASSERT(handle != NULL, "SDIO not initialized");
+  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return 0);
 
   // Multiply number of blocks with block size to get size in bytes
   const uint64_t cardSizeBytes = uint64_t(handle->stcSdCardInfo.u32LogBlockNbr) * uint64_t(handle->stcSdCardInfo.u32LogBlockSize);

Marlin/src/HAL/LINUX/hardware/Timer.cpp

@@ -37,7 +37,10 @@ Timer::Timer() {
 }
 
 Timer::~Timer() {
-  timer_delete(timerid);
+  if (timerid != 0) {
+    timer_delete(timerid);
+    timerid = 0;
+  }
 }
 
 void Timer::init(uint32_t sig_id, uint32_t sim_freq, callback_fn* fn) {

Marlin/src/HAL/LINUX/main.cpp

@@ -21,6 +21,7 @@
  */
 
 #ifdef __PLAT_LINUX__
+#ifndef UNIT_TEST
 
 //#define GPIO_LOGGING // Full GPIO and Positional Logging
 
@@ -135,4 +136,5 @@ int main() {
   read_serial.join();
 }
 
+#endif // UNIT_TEST
 #endif // __PLAT_LINUX__

Marlin/src/HAL/LPC1768/HAL.h

@@ -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

Marlin/src/HAL/STM32/HAL.h

@@ -112,7 +112,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(EXTENSIBLE_UI)
     #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
   #endif
 #endif

Marlin/src/HAL/STM32/MarlinSerial.h

@@ -43,6 +43,7 @@
 
 #else // Arduino non-DMA
 
+  FORCE_INLINE static uint8_t buffer_overruns() { return 0; }
   typedef void (*usart_rx_callback_t)(serial_t * obj);
 
   struct MarlinSerial : public HardwareSerial {
@@ -53,6 +54,8 @@
     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; } // Not implemented. Void to avoid platform-dependent code.
+    FORCE_INLINE uint32_t dropped() { return 0; }
 
     protected:
       usart_rx_callback_t _rx_callback;

Marlin/src/HAL/STM32F1/HAL.h

@@ -138,7 +138,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

Marlin/src/MarlinCore.cpp

@@ -474,11 +474,16 @@ inline void manage_inactivity(const bool no_stepper_sleep=false) {
 
   #if HAS_KILL
 
-    // Check if the kill button was pressed and wait just in case it was an accidental
-    // key kill key press
+    // Check if the kill button was pressed and wait to ensure the signal is not noise
+    // typically caused by poor insulation and grounding on LCD cables.
+    // Lower numbers here will increase response time and therefore safety rating.
+    // It is recommended to set this as low as possibe without false triggers.
     // -------------------------------------------------------------------------------
+    #ifndef KILL_DELAY
+      #define KILL_DELAY 250
+    #endif
+
     static int killCount = 0;   // make the inactivity button a bit less responsive
-    const int KILL_DELAY = 750;
     if (kill_state())
       killCount++;
     else if (killCount > 0)

Marlin/src/core/boards.h

@@ -131,6 +131,7 @@
 #define BOARD_PXMALION_CORE_I3        1164  // Pxmalion Core I3
 #define BOARD_PANOWIN_CUTLASS         1165  // Panowin Cutlass (as found in the Panowin F1)
 #define BOARD_KODAMA_BARDO            1166  // Kodama Bardo V1.x (as found in the Kodama Trinus)
+#define BOARD_DAGOMA_D6               1167  // Dagoma D6 (as found in the Dagoma DiscoUltimate V2 TMC)
 
 //
 // RAMBo and derivatives

Marlin/src/feature/host_actions.cpp

@@ -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

Marlin/src/feature/mmu/mmu2.cpp

@@ -135,7 +135,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

Marlin/src/feature/pause.cpp

@@ -214,12 +214,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();
@@ -680,7 +689,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));
@@ -689,7 +698,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

Marlin/src/feature/power.cpp

@@ -122,6 +122,7 @@ void Power::power_off() {
   TERN_(HAS_SUICIDE, suicide());
 
   if (!psu_on) return;
+  SERIAL_ECHOLNPGM(STR_POWEROFF);
 
   SERIAL_ECHOLNPGM(STR_POWEROFF);
 

Marlin/src/feature/runout.cpp

@@ -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

Marlin/src/feature/runout.h

@@ -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,36 +306,12 @@ 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)
@@ -354,15 +320,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);
@@ -371,116 +338,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

Marlin/src/gcode/bedlevel/abl/G29.cpp

@@ -985,6 +985,9 @@ G29_TYPE GcodeSuite::G29() {
     process_subcommands_now(F(EVENT_GCODE_AFTER_G29));
   #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();

Marlin/src/gcode/control/M111.cpp

@@ -66,7 +66,7 @@ void GcodeSuite::M111() {
     SERIAL_ECHOPGM(STR_DEBUG_OFF);
     #if !(defined(__AVR__) && defined(USBCON))
       #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
-        SERIAL_ECHOPGM("\nBuffer Overruns: ", MYSERIAL1.buffer_overruns());
+        //SERIAL_ECHOPGM("\nBuffer Overruns: ", MYSERIAL1.buffer_overruns());
       #endif
       #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
         SERIAL_ECHOPGM("\nFraming Errors: ", MYSERIAL1.framing_errors());

Marlin/src/gcode/feature/pause/M600.cpp

@@ -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

Marlin/src/gcode/feature/powerloss/M413.cpp

@@ -72,6 +72,7 @@ void GcodeSuite::M413_report(const bool forReplay/*=true*/) {
       , " B", recovery.bed_temp_threshold
     #endif
   );
+  SERIAL_ECHO(" ; ");
   serialprintln_onoff(recovery.enabled);
 }
 

Marlin/src/gcode/feature/runout/M591.cpp

@@ -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,18 +76,19 @@ void GcodeSuite::M412() {
   }
 }
 
-void GcodeSuite::M412_report(const bool forReplay/*=true*/) {
+void GcodeSuite::M591_report(const bool forReplay/*=true*/) {
   TERN_(MARLIN_SMALL_BUILD, return);
-
   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

Marlin/src/gcode/gcode.cpp

@@ -865,10 +865,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
@@ -943,6 +939,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 ENABLED(NONLINEAR_EXTRUSION)
         case 592: M592(); break;                                  // M592: Nonlinear Extrusion control
       #endif

Marlin/src/gcode/gcode.h

@@ -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)
  * M592 - Get or set nonlinear extrusion parameters. (Requires NONLINEAR_EXTRUSION)
  * 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)
@@ -1035,8 +1035,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

Marlin/src/gcode/host/M115.cpp

@@ -154,7 +154,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)

Marlin/src/gcode/motion/G2_G3.cpp

@@ -373,6 +373,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
       const float arc_mm_remaining = flat_mm - segment_mm * i;
       hints.safe_exit_speed_sqr = _MIN(limiting_speed_sqr, 2 * limiting_accel * arc_mm_remaining);

Marlin/src/inc/Conditionals_LCD.h

@@ -1191,10 +1191,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
@@ -1203,9 +1207,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
@@ -1214,9 +1216,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
@@ -1225,9 +1224,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
@@ -1236,9 +1232,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
@@ -1247,9 +1240,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
@@ -1258,9 +1248,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
@@ -1269,9 +1256,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
@@ -1881,6 +1865,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

Marlin/src/inc/Conditionals_adv.h

@@ -954,6 +954,12 @@
   #define HAS_MOTOR_CURRENT_I2C 1
 #endif
 
+#if ENABLED(DUAL_X_CARRIAGE)
+  #ifndef INVERT_X2_DIR
+    #define INVERT_X2_DIR INVERT_X_DIR
+  #endif
+#endif
+
 // X2 but not IDEX => Dual Synchronized X Steppers
 #if defined(X2_DRIVER_TYPE) && DISABLED(DUAL_X_CARRIAGE)
   #define HAS_SYNCED_X_STEPPERS 1

Marlin/src/inc/Conditionals_post.h

@@ -2902,7 +2902,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)

Marlin/src/inc/SanityCheck.h

@@ -235,9 +235,11 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
   #error "SERIAL_XON_XOFF and SERIAL_STATS_* features not supported on USB-native AVR devices."
 #endif
 
-// Serial DMA is only available for some STM32 MCUs
+// Serial DMA is only available for some STM32 MCUs and HC32
 #if ENABLED(SERIAL_DMA)
-  #if !HAL_STM32 || NONE(STM32F0xx, STM32F1xx, STM32F2xx, STM32F4xx, STM32F7xx)
+  #if defined(ARDUINO_ARCH_HC32)
+    // checks for HC32 are located in HAL/HC32/inc/SanityCheck.h
+  #elif !HAL_STM32 || NONE(STM32F0xx, STM32F1xx, STM32F2xx, STM32F4xx, STM32F7xx)
     #error "SERIAL_DMA is only available for some STM32 MCUs and requires HAL/STM32."
   #elif !defined(HAL_UART_MODULE_ENABLED) || defined(HAL_UART_MODULE_ONLY)
     #error "SERIAL_DMA requires STM32 platform HAL UART (without HAL_UART_MODULE_ONLY)."
@@ -539,10 +541,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)
-    static_assert(nullptr == strstr(FILAMENT_RUNOUT_SCRIPT, "M600"), "FILAMENT_RUNOUT_SCRIPT cannot make use of M600 unless ADVANCED_PAUSE_FEATURE is enabled");
+  #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
 
@@ -1534,14 +1597,16 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
 #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
 
@@ -1837,6 +1902,8 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
     #error "DUAL_X_CARRIAGE requires X2_HOME_POS, X2_MIN_POS, and X2_MAX_POS."
   #elif X_HOME_TO_MAX
     #error "DUAL_X_CARRIAGE requires X_HOME_DIR -1."
+  #elif (X2_HOME_POS <= X1_MAX_POS) || (X2_MAX_POS < X1_MAX_POS)
+    #error "DUAL_X_CARRIAGE will crash if X1 can meet or exceed X2 travel."
   #endif
 #endif
 
@@ -2640,7 +2707,7 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
   + 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) \
@@ -3568,9 +3635,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."

Marlin/src/inc/Version.h

@@ -42,7 +42,7 @@
  * version was tagged.
  */
 #ifndef STRING_DISTRIBUTION_DATE
-  #define STRING_DISTRIBUTION_DATE "2024-04-11"
+  #define STRING_DISTRIBUTION_DATE "2024-04-15"
 #endif
 
 /**

Marlin/src/inc/Warnings.cpp

@@ -99,7 +99,7 @@
   #warning "Warning! Don't use dummy thermistors (998/999) for final build!"
 #endif
 
-#if NONE(HAS_RESUME_CONTINUE, HOST_PROMPT_SUPPORT)
+#if NONE(HAS_RESUME_CONTINUE, HOST_PROMPT_SUPPORT, UNIT_TEST)
   #warning "Your Configuration provides no method to acquire user feedback!"
 #endif
 

Marlin/src/lcd/dogm/marlinui_DOGM.cpp

@@ -377,7 +377,13 @@ void MarlinUI::draw_kill_screen() {
 void MarlinUI::clear_lcd() { } // Automatically cleared by Picture Loop
 
 #if HAS_DISPLAY_SLEEP
-  void MarlinUI::sleep_display(const bool sleep/*=true*/) { sleep ? u8g.sleepOn() : u8g.sleepOff(); }
+  void MarlinUI::sleep_display(const bool sleep/*=true*/) { 
+    static bool asleep = false;
+    if (asleep != sleep){
+      sleep ? u8g.sleepOn() : u8g.sleepOff(); 
+      asleep = sleep;
+    }
+  }
 #endif
 
 #if HAS_LCD_BRIGHTNESS

Marlin/src/lcd/e3v2/creality/dwin.cpp

@@ -2950,7 +2950,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
 
@@ -4068,8 +4072,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);
   }

Marlin/src/lcd/e3v2/marlinui/dwin_lcd.cpp

@@ -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 ----------------------------------------*/

Marlin/src/lcd/e3v2/marlinui/ui_common.cpp

@@ -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();
 

Marlin/src/lcd/e3v2/proui/dwin.cpp

@@ -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
 
@@ -2318,12 +2318,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(CONFIGURE_FILAMENT_CHANGE)
@@ -2388,6 +2388,11 @@ void setFlow() { setPIntOnClick(FLOW_EDIT_MIN, FLOW_EDIT_MAX, []{ planner.refres
 #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);

Marlin/src/lcd/e3v2/proui/endstop_diag.cpp

@@ -85,7 +85,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();
 }
 

Marlin/src/lcd/extui/dgus_creality/DGUSDisplay.cpp

@@ -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

Marlin/src/lcd/extui/dgus_creality/DGUSDisplay.h

@@ -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);

Marlin/src/lcd/extui/dgus_creality/DGUSDisplayDef.h

@@ -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

Marlin/src/lcd/extui/dgus_creality/DGUSScreenHandler.h

@@ -0,0 +1,469 @@
+/**
+ * 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"
+
+#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();
+      }
+    }
+};

Marlin/src/lcd/extui/dgus_creality/DGUSVPVariable.h

@@ -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)); }

Marlin/src/lcd/extui/dgus_creality/creality_touch/AxisSettingsHandler.cpp

@@ -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

Marlin/src/lcd/extui/dgus_creality/creality_touch/AxisSettingsHandler.h

@@ -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);
+};
+

Marlin/src/lcd/extui/dgus_creality/creality_touch/DGUSDisplayDef.cpp

@@ -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

Marlin/src/lcd/extui/dgus_creality/creality_touch/DGUSDisplayDef.h

@@ -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;

Marlin/src/lcd/extui/dgus_creality/creality_touch/EstepsHandler.cpp

@@ -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

Marlin/src/lcd/extui/dgus_creality/creality_touch/EstepsHandler.h

@@ -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);
+};
+

Marlin/src/lcd/extui/dgus_creality/creality_touch/FilamentLoadUnloadHandler.cpp

@@ -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

Marlin/src/lcd/extui/dgus_creality/creality_touch/FilamentLoadUnloadHandler.h

@@ -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);
+};
+

Marlin/src/lcd/extui/dgus_creality/creality_touch/MeshValidationHandler.cpp

@@ -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

Marlin/src/lcd/extui/dgus_creality/creality_touch/MeshValidationHandler.h

@@ -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

Marlin/src/lcd/extui/dgus_creality/creality_touch/PIDHandler.cpp

@@ -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

Marlin/src/lcd/extui/dgus_creality/creality_touch/PIDHandler.h

@@ -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);
+};
+

Marlin/src/lcd/extui/dgus_creality/creality_touch/PageHandlers.cpp

@@ -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

Marlin/src/lcd/extui/dgus_creality/creality_touch/PageHandlers.h

@@ -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);

Marlin/src/lcd/extui/dgus_creality_lcd.cpp

@@ -0,0 +1,267 @@
+/**
+ * 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) {
+      ScreenHandler.OnMeshLevelingUpdate(xpos, ypos, zval);
+    }
+
+    void onMeshUpdate(const int8_t xpos, const int8_t ypos, const ExtUI::probe_state_t state) {
+      ScreenHandler.OnMeshLevelingUpdate(xpos, ypos, 0);
+    }
+    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

Marlin/src/lcd/extui/dgus_e3s1pro/DGUSReturnKeyCodeHandler.cpp

@@ -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) {

Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.cpp

@@ -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) {

Marlin/src/lcd/extui/ftdi_eve_touch_ui/generic/filament_runout_screen.cpp

@@ -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) {
@@ -51,10 +50,8 @@ bool FilamentRunoutScreen::onTouchHeld(uint8_t tag) {
   #endif
   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;
   }

Marlin/src/lcd/extui/ia_dwin/Creality_DWIN.h

@@ -0,0 +1,304 @@
+/**
+ * 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	IconPrintstatus		0x1014
+#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

Marlin/src/lcd/extui/ia_dwin/FileNavigator.cpp

@@ -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

Marlin/src/lcd/extui/ia_dwin/FileNavigator.h

@@ -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;

Marlin/src/lcd/extui/ui_api.cpp

@@ -722,15 +722,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)
@@ -765,6 +773,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; }
@@ -933,6 +961,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)
@@ -1169,7 +1198,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()); }
 
   // Pause/Resume/Stop are implemented in MarlinUI
   void pausePrint()  { ui.pause_print(); }

Marlin/src/lcd/extui/ui_api.h

@@ -68,6 +68,7 @@ namespace ExtUI {
   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 };
+  struct probe_limits { float pos[4];};
   #if HAS_PID_HEATING
     enum pidresult_t : uint8_t { PID_STARTED, PID_BED_STARTED, PID_CHAMBER_STARTED, PID_BAD_HEATER_ID, PID_TEMP_TOO_HIGH, PID_TUNING_TIMEOUT, PID_DONE };
   #endif
@@ -327,6 +328,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
+
   // JD or Jerk Control
   #if HAS_JUNCTION_DEVIATION
     float getJunctionDeviation_mm();
@@ -367,6 +375,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
 
   // Backlash Control
@@ -385,15 +394,14 @@ namespace ExtUI {
 
   // Filament Runout Sensor
   #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
 
   // Case Light Control

Marlin/src/lcd/language/language_en.h

@@ -719,6 +719,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");

Marlin/src/lcd/menu/menu_advanced.cpp

@@ -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();

Marlin/src/lcd/menu/menu_bed_tramming.cpp

@@ -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

Marlin/src/lcd/menu/menu_configuration.cpp

@@ -634,7 +634,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

Marlin/src/lcd/menu/menu_filament.cpp

@@ -264,7 +264,7 @@ void menu_pause_option() {
 
   #if HAS_FILAMENT_SENSOR
     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);
   #endif
 
   if (!still_out)

Marlin/src/module/endstops.cpp

@@ -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());

Marlin/src/module/settings.cpp

@@ -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"
 
@@ -116,9 +116,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)
@@ -249,8 +246,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
@@ -904,22 +904,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
@@ -1935,22 +1927,26 @@ 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
-        if (!validating) runout.enabled = runout_sensor_enabled < 0 ? FIL_RUNOUT_ENABLED_DEFAULT : runout_sensor_enabled;
-        #endif
+        bool runout_enabled[NUM_RUNOUT_SENSORS];
+        float runout_distance_mm[NUM_RUNOUT_SENSORS];
+        RunoutMode runout_mode[NUM_RUNOUT_SENSORS];
 
-        TERN_(HAS_FILAMENT_SENSOR, if (runout.enabled) runout.reset());
-
-        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
@@ -3166,9 +3162,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
 
   //
@@ -3969,7 +3972,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");

Marlin/src/module/stepper.cpp

@@ -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
 
@@ -2292,7 +2292,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 {

Marlin/src/pins/pins.h

@@ -224,6 +224,8 @@
   #include "ramps/pins_RAMPS_CREALITY.h"            // ATmega2560                           env:mega2560
 #elif MB(DAGOMA_F5)
   #include "ramps/pins_DAGOMA_F5.h"                 // ATmega2560                           env:mega2560
+#elif MB(DAGOMA_D6)
+  #include "ramps/pins_DAGOMA_D6.h"                 // ATmega2560                           env:mega2560ext
 #elif MB(FYSETC_F6_13)
   #include "ramps/pins_FYSETC_F6_13.h"              // ATmega2560                           env:FYSETC_F6
 #elif MB(FYSETC_F6_14)

Marlin/src/pins/ramps/pins_DAGOMA_D6.h

@@ -0,0 +1,119 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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
+
+#if HOTENDS > 2 || E_STEPPERS > 2
+  #error "Dagoma3D D6 supports up to 2 hotends / E-steppers."
+#endif
+
+#define BOARD_INFO_NAME "Dagoma3D D6"
+
+//
+// Trinamic Stallguard pins
+//
+#define X_DIAG_PIN                            43
+#define Y_DIAG_PIN                            41
+#define Z_DIAG_PIN                            47
+#define E0_DIAG_PIN                           21
+#define E1_DIAG_PIN                           20
+
+//
+// Endstops
+//
+#define X_STOP_PIN                             2
+#define Y_STOP_PIN                             3
+#define Z_STOP_PIN                            15
+
+//
+// Filament Runout Sensor
+//
+#ifndef FIL_RUNOUT_PIN
+  #define FIL_RUNOUT_PIN                      39
+#endif
+#if EXTRUDERS > 1 && !defined(FIL_RUNOUT2_PIN)
+  #define FIL_RUNOUT2_PIN                     14
+#endif
+
+// Alter timing for graphical display
+#if IS_U8GLIB_ST7920
+  #ifndef BOARD_ST7920_DELAY_1
+    #define BOARD_ST7920_DELAY_1               0
+  #endif
+  #ifndef BOARD_ST7920_DELAY_2
+    #define BOARD_ST7920_DELAY_2             250
+  #endif
+  #ifndef BOARD_ST7920_DELAY_3
+    #define BOARD_ST7920_DELAY_3             250
+  #endif
+#endif
+
+#define KILL_PIN                              -1  // NC
+
+#define LCD_CONTRAST_DEFAULT                 255
+
+//
+// Sensorless homing DIAG pin is not directly connected to the MCU. Close
+// the jumper next to the limit switch socket when using sensorless homing.
+//
+#if HAS_TMC_UART
+  /**
+   * TMC2208/TMC2209 stepper drivers
+   */
+  #define X_SERIAL_RX_PIN                     73
+  #define X_SERIAL_TX_PIN                     73
+  #define Y_SERIAL_RX_PIN                     73
+  #define Y_SERIAL_TX_PIN                     73
+  #define Z_SERIAL_RX_PIN                     73
+  #define Z_SERIAL_TX_PIN                     73
+  #define E0_SERIAL_RX_PIN                    73
+  #define E0_SERIAL_TX_PIN                    73
+  #define E1_SERIAL_RX_PIN                    12
+  #define E1_SERIAL_TX_PIN                    12
+
+  // Default TMC slave addresses
+  #ifndef X_SLAVE_ADDRESS
+    #define X_SLAVE_ADDRESS                    0
+  #endif
+  #ifndef Y_SLAVE_ADDRESS
+    #define Y_SLAVE_ADDRESS                    1
+  #endif
+  #ifndef Z_SLAVE_ADDRESS
+    #define Z_SLAVE_ADDRESS                    2
+  #endif
+  #ifndef E0_SLAVE_ADDRESS
+    #define E0_SLAVE_ADDRESS                   3
+  #endif
+  #ifndef E1_SLAVE_ADDRESS
+    #define E1_SLAVE_ADDRESS                   3
+  #endif
+  static_assert(X_SLAVE_ADDRESS == 0, "X_SLAVE_ADDRESS must be 0 for BOARD_DAGOMA_D6.");
+  static_assert(Y_SLAVE_ADDRESS == 1, "Y_SLAVE_ADDRESS must be 1 for BOARD_DAGOMA_D6.");
+  static_assert(Z_SLAVE_ADDRESS == 2, "Z_SLAVE_ADDRESS must be 2 for BOARD_DAGOMA_D6.");
+  static_assert(E0_SLAVE_ADDRESS == 3, "E0_SLAVE_ADDRESS must be 3 for BOARD_DAGOMA_D6.");
+  static_assert(E1_SLAVE_ADDRESS == 3, "E1_SLAVE_ADDRESS must be 3 for BOARD_DAGOMA_D6.");
+
+#endif
+
+//
+// Import default RAMPS 1.4 pins
+//
+#include "pins_RAMPS.h"

Marlin/src/pins/ramps/pins_TENLOG_D3_HERO.h

@@ -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
 //

Marlin/src/pins/sanguino/pins_MELZI_CREALITY.h

@@ -105,6 +105,11 @@
   #define BEEPER_PIN -1
 #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

Marlin/src/pins/stm32f1/pins_CREALITY_V45x.h

@@ -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

Marlin/src/sd/cardreader.cpp

@@ -36,6 +36,10 @@
   #include "../lcd/e3v2/creality/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"
@@ -491,6 +495,7 @@ void CardReader::mount() {
   else {
     flag.mounted = true;
     SERIAL_ECHO_MSG(STR_SD_CARD_OK);
+    TERN_(EXTENSIBLE_UI, ExtUI::isMediaInserted()); // ExtUI response
   }
 
   if (flag.mounted)

Marlin/src/tests/marlin_tests.cpp

@@ -37,41 +37,6 @@
 // Startup tests are run at the end of setup()
 void runStartupTests() {
   // Call post-setup tests here to validate behaviors.
-
-  // String with cutoff at 20 chars:
-  // "F-string, 1234.50, 2"
-  SString<20> str20;
-  str20 = F("F-string, ");
-  str20.append(1234.5f).append(',').append(' ')
-       .append(2345.67).append(',').append(' ')
-       .echoln();
-
-  // Truncate to "F-string"
-  str20.trunc(8).echoln();
-
-  // 100 dashes, but chopped down to DEFAULT_MSTRING_SIZE (20)
-  TSS(repchr_t('-', 100)).echoln();
-
-  // Hello World!-123456------   <spaces!33
-  // ^ eol! ... 1234.50*2345.602 = 2895645.67
-  SString<100> str(F("Hello"));
-  str.append(F(" World!"));
-  str += '-';
-  str += uint8_t(123);
-  str += F("456");
-  str += repchr_t('-', 6);
-  str += Spaces(3);
-  str += "< spaces!";
-  str += int8_t(33);
-  str.eol();
-  str += "^ eol!";
-
-  str.append("...", 1234.5f, '*', p_float_t(2345.602, 3), F(" = "), 1234.5 * 2345.602).echoln();
-
-  // Print it again with SERIAL_ECHOLN
-  auto print_char_ptr = [](char * const str) { SERIAL_ECHOLN(str); };
-  print_char_ptr(str);
-
 }
 
 // Periodic tests are run from within loop()

Marlin/tests/README.md

@@ -0,0 +1,5 @@
+These test files are executed by the unit-tests built from the `<root>/test` folder.
+
+These are placed outside of the main PlatformIO test folder so we can collect all test files and compile them into multiple PlatformIO test binaries. This enables tests to be executed against a variety of Marlin configurations.
+
+To execute these tests, refer to the top-level Makefile.

Marlin/tests/gcode/test_gcode.cpp

@@ -0,0 +1,58 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../test/unit_tests.h"
+#include <src/gcode/gcode.h>
+#include <src/gcode/parser.h>
+
+MARLIN_TEST(gcode, process_parsed_command) {
+  GcodeSuite suite;
+  parser.command_letter = 'G';
+  parser.codenum = 0;
+  suite.process_parsed_command(false);
+}
+
+MARLIN_TEST(gcode, parse_g1_xz) {
+  char current_command[] = "G0 X10 Z30";
+  parser.command_letter = -128;
+  parser.codenum = -1;
+  parser.parse(current_command);
+  TEST_ASSERT_EQUAL('G', parser.command_letter);
+  TEST_ASSERT_EQUAL(0, parser.codenum);
+  TEST_ASSERT_TRUE(parser.seen('X'));
+  TEST_ASSERT_FALSE(parser.seen('Y'));
+  TEST_ASSERT_TRUE(parser.seen('Z'));
+  TEST_ASSERT_FALSE(parser.seen('E'));
+}
+
+MARLIN_TEST(gcode, parse_g1_nxz) {
+  char current_command[] = "N123 G0 X10 Z30";
+  parser.command_letter = -128;
+  parser.codenum = -1;
+  parser.parse(current_command);
+  TEST_ASSERT_EQUAL('G', parser.command_letter);
+  TEST_ASSERT_EQUAL(0, parser.codenum);
+  TEST_ASSERT_TRUE(parser.seen('X'));
+  TEST_ASSERT_FALSE(parser.seen('Y'));
+  TEST_ASSERT_TRUE(parser.seen('Z'));
+  TEST_ASSERT_FALSE(parser.seen('E'));
+}