move G29 stuff to #27146

Merge branch 'bugfix-2.1.x' into pr/26754
[cron] Bump distribution date (2024-05-29)
2024-06-02 14:43:22 -05:00 · 2024-06-02 14:26:36 -05:00 · 2024-05-29 00:26:13 +00:00 · 2024-05-28 19:05:03 -05:00 · 2024-05-28 18:49:39 -05:00 · 2024-05-28 18:22:39 -05:00
501 changed files with 4741 additions and 20119 deletions
@@ -14,6 +14,8 @@ on:
    - config/**
    - data/**
    - docs/**
+    - test/**
+    - Marlin/tests/**
    - '**/*.md'
  push:
    branches:
@@ -23,6 +25,8 @@ on:
    - config/**
    - data/**
    - docs/**
+    - test/**
+    - Marlin/tests/**
    - '**/*.md'

 jobs:
@@ -0,0 +1,51 @@
+#
+# ci-validate-pins.yml
+# Validate that all of the pins files are unchanged by pinsformat.py
+#
+
+name: CI - Validate Pins Files
+
+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:
+    - 'Marlin/src/pins/*/**'
+  push:
+    branches:
+    - bugfix-2.1.x
+    # Cannot be enabled on 2.1.x until it contains the unit test framework
+    #- 2.1.x
+    paths:
+    - 'Marlin/src/pins/*/**'
+
+jobs:
+  validate_pins_files:
+    name: Validate Pins Files
+    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: Select Python 3.9
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.9'
+        architecture: 'x64'
+
+    - name: Validate all pins files
+      run: |
+        make validate-pins -j
@@ -2,22 +2,23 @@ SCRIPTS_DIR := buildroot/share/scripts
 CONTAINER_RT_BIN := docker
 CONTAINER_RT_OPTS := --rm -v $(PWD):/code -v platformio-cache:/root/.platformio
 CONTAINER_IMAGE := marlin-dev
+UNIT_TEST_CONFIG ?= default

 help:
 	@echo "Tasks for local development:"
 	@echo "make marlin                    : Build marlin for the configured board"
-	@echo "make format-pins               : Reformat all pins files"
+	@echo "make format-pins -j            : Reformat all pins files (-j for parallel execution)"
+	@echo "make validate-pins -j          : Validate all pins files, fails if any require reformatting"
 	@echo "make tests-single-ci           : Run a single test from inside the CI"
 	@echo "make tests-single-local        : Run a single test locally"
 	@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 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-single-local    : Run unit tests for a single config locally"
+	@echo "make unit-test-single-local-docker : Run unit tests for a single config locally, using docker"
 	@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 "make unit-test-all-local-docker : Run all code tests locally, using docker"
+	@echo "make setup-local-docker        : Setup local docker using buildx"
 	@echo ""
 	@echo "Options for testing:"
 	@echo "  TEST_TARGET          Set when running tests-single-*, to select the"
@@ -27,6 +28,9 @@ help:
 	@echo "                       run on GitHub CI"
 	@echo "  ONLY_TEST            Limit tests to only those that contain this, or"
 	@echo "                       the index of the test (1-based)"
+	@echo "  UNIT_TEST_CONFIG     Set the name of the config from the test folder, without"
+	@echo "                       the leading number. Default is 'default'". Used with the
+	@echo "                       unit-test-single-* tasks"
 	@echo "  VERBOSE_PLATFORMIO   If you want the full PIO output, set any value"
 	@echo "  GIT_RESET_HARD       Used by CI: reset all local changes. WARNING:"
 	@echo "                       THIS WILL UNDO ANY CHANGES YOU'VE MADE!"
@@ -51,27 +55,29 @@ tests-single-local-docker:
 	$(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:
+	@python -c "import yaml" 2>/dev/null || (echo 'pyyaml module is not installed. Install it with "python -m pip install pyyaml"' && exit 1)
 	export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
 	  && export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
-	  && for TEST_TARGET in $$($(SCRIPTS_DIR)/get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; done
+	  && for TEST_TARGET in $$(python $(SCRIPTS_DIR)/get_test_targets.py) ; do \
+	    if [ "$$TEST_TARGET" = "linux_native" ] && [ "$$(uname)" = "Darwin" ]; then \
+	      echo "Skipping tests for $$TEST_TARGET on macOS" ; \
+	      continue ; \
+	    fi ; \
+	    echo "Running tests for $$TEST_TARGET" ; \
+	    run_tests . $$TEST_TARGET || exit 1 ; \
+	    sleep 5; \
+	  done

 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)

-#unit-test-single-ci:
-#	export GIT_RESET_HARD=true
-#	$(MAKE) unit-test-single-local TEST_TARGET=$(TEST_TARGET)
+unit-test-single-local:
+	platformio run -t marlin_$(UNIT_TEST_CONFIG) -e linux_native_test

-# 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-single-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-single-local UNIT_TEST_CONFIG=$(UNIT_TEST_CONFIG)

 unit-test-all-local:
 	platformio run -t test-marlin -e linux_native_test
@@ -85,7 +91,14 @@ setup-local-docker:

 PINS := $(shell find Marlin/src/pins -mindepth 2 -name '*.h')

+.PHONY: $(PINS) format-pins validate-pins
+
 $(PINS): %:
-	@echo "Formatting $@" && node $(SCRIPTS_DIR)/pinsformat.js $@
+	@echo "Formatting $@"
+	@python $(SCRIPTS_DIR)/pinsformat.py $< $@

 format-pins: $(PINS)
+
+validate-pins: format-pins
+	@echo "Validating pins files"
+	@git diff --exit-code || (git status && echo "\nError: Pins files are not formatted correctly. Run \"make format-pins\" to fix.\n" && exit 1)
@@ -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 <http://www.gnu.org/licenses/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
 #pragma once
@@ -28,177 +28,25 @@
 /**
 * Marlin release version identifier
 */
-#define SHORT_BUILD_VERSION "DW7.4.9"
+//#define SHORT_BUILD_VERSION "bugfix-2.1.x"

 /**
 * Verbose version identifier which should contain a reference to the location
 * from where the binary was downloaded or the source code was compiled.
 */
-
-#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
+//#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION

 /**
 * 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-08"
+//#define STRING_DISTRIBUTION_DATE "2024-05-29"

 /**
 * Defines a generic printer name to be output to the LCD after booting Marlin.
 */
-#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
+//#define MACHINE_NAME "3D Printer"

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

 /**
 * Default generic printer UUID.
@@ -217,12 +65,12 @@
 * The WEBSITE_URL is the location where users can get more information such as
 * documentation about a specific Marlin release.
 */
-#define WEBSITE_URL "tinymachines3d.com"
+//#define WEBSITE_URL "marlinfw.org"

 /**
 * 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
@@ -1,93 +0,0 @@
-/**
- * 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
-};
@@ -1,74 +0,0 @@
-/**
- * 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
@@ -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 || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
-    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
+  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
  #endif
 #endif

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

-  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
+  #if ANY(HAS_DGUS_LCD, 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.
@@ -205,7 +205,7 @@
    static ring_buffer_pos_t available();
    static void write(const uint8_t c);
    static void flushTX();
-    #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
+    #if ANY(HAS_DGUS_LCD, 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       = (ANY(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS) || ENABLED(DWINOS_4));
+    static constexpr bool RX_OVERRUNS       = ALL(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
  };

  typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialLCD;
@@ -61,7 +61,7 @@
 #else
  #define G2_PWM_Z 0
 #endif
-#if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
+#if HAS_MOTOR_CURRENT_PWM_E
  #define G2_PWM_E 1
 #else
  #define G2_PWM_E 0
@@ -18,30 +18,30 @@ extern "C" {
 void sd_mmc_spi_mem_init() {
 }

-Ctrl_status sd_mmc_spi_test_unit_ready() {
-  #ifdef DISABLE_DUE_SD_MMC
-    return CTRL_NO_PRESENT;
-  #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return CTRL_NO_PRESENT;
-  return CTRL_GOOD;
-}
-
-// NOTE: This function is defined as returning the address of the last block
-// in the card, which is cardSize() - 1
-Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return CTRL_NO_PRESENT;
-  *nb_sector = card.diskIODriver()->cardSize() - 1;
-  return CTRL_GOOD;
+inline bool media_ready() {
+  return IS_SD_INSERTED() && !IS_SD_PRINTING() && !IS_SD_FILE_OPEN() && card.isMounted();
 }

 bool sd_mmc_spi_unload(bool) { return true; }

 bool sd_mmc_spi_wr_protect() { return false; }

-bool sd_mmc_spi_removal() {
-  return (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted());
+bool sd_mmc_spi_removal() { return !media_ready(); }
+
+Ctrl_status sd_mmc_spi_test_unit_ready() {
+  #ifdef DISABLE_DUE_SD_MMC
+    return CTRL_NO_PRESENT;
+  #endif
+  if (!media_ready()) return CTRL_NO_PRESENT;
+  return CTRL_GOOD;
+}
+
+// NOTE: This function is defined as returning the address of the last block
+// in the card, which is cardSize() - 1
+Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
+  if (!media_ready()) return CTRL_NO_PRESENT;
+  *nb_sector = card.diskIODriver()->cardSize() - 1;
+  return CTRL_GOOD;
 }

 #if ACCESS_USB == true
@@ -61,8 +61,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
  #ifdef DISABLE_DUE_SD_MMC
    return CTRL_NO_PRESENT;
  #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return CTRL_NO_PRESENT;
+  if (!media_ready()) return CTRL_NO_PRESENT;

  #ifdef DEBUG_MMC
  {
@@ -101,8 +100,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
  #ifdef DISABLE_DUE_SD_MMC
    return CTRL_NO_PRESENT;
  #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return CTRL_NO_PRESENT;
+  if (!media_ready()) return CTRL_NO_PRESENT;

  #ifdef DEBUG_MMC
  {
@@ -74,7 +74,7 @@
 //!
 //! @brief This function initializes the hw/sw resources required to drive the SD_MMC_SPI.
 //!/
-extern void           sd_mmc_spi_mem_init(void);
+void sd_mmc_spi_mem_init();

 //!
 //! @brief This function tests the state of the SD_MMC memory and sends it to the Host.
@@ -87,7 +87,7 @@ extern void           sd_mmc_spi_mem_init(void);
 //!   Media not present    ->    CTRL_NO_PRESENT
 //!   Media has changed    ->    CTRL_BUSY
 //!/
-extern Ctrl_status    sd_mmc_spi_test_unit_ready(void);
+Ctrl_status sd_mmc_spi_test_unit_ready();

 //!
 //! @brief This function gives the address of the last valid sector.
@@ -98,7 +98,7 @@ extern Ctrl_status    sd_mmc_spi_test_unit_ready(void);
 //!   Media ready          ->  CTRL_GOOD
 //!   Media not present    ->  CTRL_NO_PRESENT
 //!/
-extern Ctrl_status    sd_mmc_spi_read_capacity(uint32_t *nb_sector);
+Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector);

 /*! \brief Unload/Load the SD/MMC card selected
 *
@@ -109,7 +109,7 @@ extern Ctrl_status    sd_mmc_spi_read_capacity(uint32_t *nb_sector);
 *
 * \return \c true if unload/load done success.
 */
-extern bool sd_mmc_spi_unload(bool unload);
+bool sd_mmc_spi_unload(bool unload);

 //!
 //! @brief This function returns the write protected status of the memory.
@@ -120,14 +120,14 @@ extern bool sd_mmc_spi_unload(bool unload);
 //!
 //! @return false  -> the memory is not write-protected (always)
 //!/
-extern bool           sd_mmc_spi_wr_protect(void);
+bool sd_mmc_spi_wr_protect();

 //!
 //! @brief This function tells if the memory has been removed or not.
 //!
 //! @return false  -> The memory isn't removed
 //!
-extern bool           sd_mmc_spi_removal(void);
+bool sd_mmc_spi_removal();

 //---- ACCESS DATA FUNCTIONS ----

@@ -147,7 +147,7 @@ extern bool           sd_mmc_spi_removal(void);
 //!   It is ready    ->    CTRL_GOOD
 //!   A error occur  ->    CTRL_FAIL
 //!
-extern Ctrl_status    sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector);
+Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector);

 //! This function initializes the SD/MMC memory for a write operation
 //!
@@ -161,7 +161,7 @@ extern Ctrl_status    sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector);
 //!   It is ready    ->    CTRL_GOOD
 //!   An error occurs  ->    CTRL_FAIL
 //!
-extern Ctrl_status    sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector);
+Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector);

 #endif // #if ACCESS_USB == true

@@ -142,12 +142,31 @@
 // ADC
 //
 #define HAL_ADC_VREF_MV 3300
-#define HAL_ADC_RESOLUTION 10
+#define HAL_ADC_RESOLUTION 12

 #define GET_PIN_MAP_PIN(index) index
 #define GET_PIN_MAP_INDEX(pin) pin
 #define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)

+//
+// Debug port disable
+// JTMS / SWDIO = PA13
+// JTCK / SWCLK = PA14
+// JTDI         = PA15
+// JTDO         = PB3
+// NJTRST       = PB4
+//
+#define DBG_SWCLK _BV(0)
+#define DBG_SWDIO _BV(1)
+#define DBG_TDO   _BV(2)
+#define DBG_TDI   _BV(3)
+#define DBG_TRST  _BV(4)
+#define DBG_ALL (DBG_SWCLK | DBG_SWDIO | DBG_TDO | DBG_TDI | DBG_TRST)
+
+#define JTAGSWD_RESET() PORT_DebugPortSetting(DBG_ALL, Enable);
+#define JTAG_DISABLE() PORT_DebugPortSetting(DBG_TDO | DBG_TDI | DBG_TRST, Disable);
+#define JTAGSWD_DISABLE() PORT_DebugPortSetting(DBG_ALL, Disable);
+
 //
 // MarlinHAL implementation
 //
@@ -232,7 +232,9 @@ int MarlinHAL::freeMemory() {
  return &top - _sbrk(0);
 }

-void MarlinHAL::adc_init() {}
+void MarlinHAL::adc_init() {
+  analogReadResolution(HAL_ADC_RESOLUTION);
+}

 void MarlinHAL::adc_enable(const pin_t pin) {
  #if TEMP_SENSOR_SOC
@@ -31,8 +31,8 @@

 struct MarlinSerial : public Usart {
  MarlinSerial(
-    struct usart_config_t *usart_device, 
-    gpio_pin_t tx_pin, 
+    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,
@@ -1,6 +1,6 @@
 /**
 * 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 
+ * it is used to configure the arduino core (and ddl) automatically according
 * to the settings in Configuration.h and Configuration_adv.h.
 */
 #pragma once
@@ -44,7 +44,7 @@
 #define DISABLE_SERIAL_GLOBALS 1

 // increase the size of the Usart buffers (both RX and TX)
-// NOTE: 
+// 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
@@ -64,7 +64,12 @@
 // 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)
+// F_CPU must be known at compile time, but on HC32F460 it's not.
+// Thus we assume HCLK to be 200MHz, as that's what is configured in
+// 'core_hook_sysclock_init' in 'sysclock.cpp'.
+// If you face issues with this assumption, please double-check with the values
+// printed by 'MarlinHAL::HAL_clock_frequencies_dump'.
+// see also: HAL_TIMER_RATE in timers.h
+#define F_CPU 200000000 // 200MHz HCLK

 #endif // _HC32_APP_CONFIG_H_
@@ -30,7 +30,7 @@
 #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 
+  // 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
@@ -96,29 +96,44 @@ void core_hook_sysclock_init() {
    #endif
  #endif

-  // Setup clock divisors for sysclk = 200 MHz:
+  // sysclk is now configured according to F_CPU (i.e., 200MHz PLL output)
+  constexpr uint32_t sysclock = F_CPU;
+
+  // Setup clock divisors for sysclk = 200 MHz
  // Note: PCLK1 is used for step+temp timers, and need to be kept at 50 MHz (until there is a better solution)
-  stc_clk_sysclk_cfg_t sysClkConf = {
+  constexpr stc_clk_sysclk_cfg_t sysClkConf = {
      .enHclkDiv = ClkSysclkDiv1,  // HCLK  = 200 MHz (CPU)
      .enExclkDiv = ClkSysclkDiv2, // EXCLK = 100 MHz (SDIO)
-      .enPclk0Div = ClkSysclkDiv1, // PCLK0 = 200 MHz (Timer6 (not used))
+      .enPclk0Div = ClkSysclkDiv2, // PCLK0 = 100 MHz (Timer6 (not used))
      .enPclk1Div = ClkSysclkDiv4, // PCLK1 = 50 MHz (USART, SPI, I2S, Timer0 (step+temp), TimerA (Servo))
-      .enPclk2Div = ClkSysclkDiv4, // PCLK2 = 50 MHz (ADC)
-      .enPclk3Div = ClkSysclkDiv4, // PCLK3 = 50 MHz (I2C, WDT)
+      .enPclk2Div = ClkSysclkDiv8, // PCLK2 = 25 MHz (ADC)
+      .enPclk3Div = ClkSysclkDiv8, // PCLK3 = 25 MHz (I2C, WDT)
      .enPclk4Div = ClkSysclkDiv2, // PCLK4 = 100 MHz (ADC ctl)
  };
+
+  #if ARDUINO_CORE_VERSION_INT >= GET_VERSION_INT(1, 2, 0)
+    assert_system_clocks_valid<
+      sysclock,
+      sysClkConf.enHclkDiv,
+      sysClkConf.enPclk0Div,
+      sysClkConf.enPclk1Div,
+      sysClkConf.enPclk2Div,
+      sysClkConf.enPclk3Div,
+      sysClkConf.enPclk4Div,
+      sysClkConf.enExclkDiv
+    >();
+  #endif
+
  sysclock_set_clock_dividers(&sysClkConf);

  // Set power mode
-  #define POWER_MODE_SYSTEM_CLOCK 200000000 // 200 MHz
-  power_mode_update_pre(POWER_MODE_SYSTEM_CLOCK);
+  power_mode_update_pre(sysclock);

  // Switch to MPLL as sysclk source
  CLK_SetSysClkSource(CLKSysSrcMPLL);

  // Set power mode
-  power_mode_update_post(POWER_MODE_SYSTEM_CLOCK);
-  #undef POWER_MODE_SYSTEM_CLOCK
+  power_mode_update_post(sysclock);
 }

 #endif // ARDUINO_ARCH_HC32
@@ -38,44 +38,48 @@ extern Timer0 step_timer;
 // Timer Configurations
 //

-// TODO: some calculations (step irq min_step_rate) require the timer rate to be known at compile time
-//       this is not possible with the HC32F460, as the timer rate depends on PCLK1
-//       as a workaround, PCLK1 = 50MHz is assumed (check with clock dump in MarlinHAL::init())
-#define HAL_TIMER_RATE 50000000 // 50MHz
-// #define HAL_TIMER_RATE TIMER0_BASE_FREQUENCY
-
-// TODO: CYCLES_PER_MICROSECOND seems to be used by Marlin to calculate the number of cycles per microsecond in the timer ISRs
-//       by default, it uses F_CPU, but since that is not known at compile time for HC32, we overwrite it here
-#undef CYCLES_PER_MICROSECOND
-#define CYCLES_PER_MICROSECOND (HAL_TIMER_RATE / 1000000UL)
+/**
+ * HAL_TIMER_RATE must be known at compile time since it's used to calculate
+ * STEPPER_TIMER_RATE, which is used in 'constexpr' calculations.
+ * On the HC32F460 the timer rate depends on PCLK1, which is derived from the
+ * system clock configured at runtime. As a workaround, we use the existing
+ * assumption of a 200MHz clock, defining F_CPU as 200000000, then configure PCLK1
+ * as F_CPU with a divider of 4 in 'sysclock.cpp::core_hook_sysclock_init'.
+ *
+ * If you face issues with this assumption, please double-check with the values
+ * printed by 'MarlinHAL::HAL_clock_frequencies_dump'.
+ *
+ * TODO: If the 'constexpr' requirement is ever lifted, use TIMER0_BASE_FREQUENCY instead
+ */
+#define HAL_TIMER_RATE (F_CPU / 4) // i.e., 50MHz
+//#define HAL_TIMER_RATE TIMER0_BASE_FREQUENCY

 // Temperature timer
-#define TEMP_TIMER_NUM (&temp_timer)
-#define TEMP_TIMER_PRIORITY DDL_IRQ_PRIORITY_02
-#define TEMP_TIMER_PRESCALE 16ul
-#define TEMP_TIMER_RATE 1000                 // 1kHz
-#define TEMP_TIMER_FREQUENCY TEMP_TIMER_RATE // Alias for Marlin
+#define TEMP_TIMER_NUM        (&temp_timer)
+#define TEMP_TIMER_PRIORITY   DDL_IRQ_PRIORITY_02
+#define TEMP_TIMER_PRESCALE     16UL          // 12.5MHz
+#define TEMP_TIMER_RATE       1000            // 1kHz
+#define TEMP_TIMER_FREQUENCY  TEMP_TIMER_RATE // 1kHz also

 // Stepper timer
-#define STEP_TIMER_NUM (&step_timer)
-#define STEP_TIMER_PRIORITY DDL_IRQ_PRIORITY_01
-#define STEPPER_TIMER_PRESCALE 16ul
+#define STEP_TIMER_NUM         (&step_timer)
+#define STEP_TIMER_PRIORITY    DDL_IRQ_PRIORITY_00  // Top priority, nothing else uses it
+#define STEPPER_TIMER_PRESCALE  16UL                // 12.5MHz

-// TODO: STEPPER_TIMER_RATE seems to work fine like this, but requires further testing...
-#define STEPPER_TIMER_RATE (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE) // 50MHz / 16 = 3.125MHz
-#define STEPPER_TIMER_TICKS_PER_US (STEPPER_TIMER_RATE / 1000000)
+#define STEPPER_TIMER_RATE (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)  // 50MHz / 16 = 3.125MHz
+#define STEPPER_TIMER_TICKS_PER_US (STEPPER_TIMER_RATE / 1000000UL)   // Integer 3

 // Pulse timer (== stepper timer)
-#define PULSE_TIMER_NUM STEP_TIMER_NUM
-#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
-#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
+#define PULSE_TIMER_NUM           STEP_TIMER_NUM
+#define PULSE_TIMER_PRESCALE      STEPPER_TIMER_PRESCALE
+#define PULSE_TIMER_TICKS_PER_US  STEPPER_TIMER_TICKS_PER_US

 //
 // Channel aliases
 //
-#define MF_TIMER_TEMP TEMP_TIMER_NUM
-#define MF_TIMER_STEP STEP_TIMER_NUM
-#define MF_TIMER_PULSE PULSE_TIMER_NUM
+#define MF_TIMER_TEMP   TEMP_TIMER_NUM
+#define MF_TIMER_STEP   STEP_TIMER_NUM
+#define MF_TIMER_PULSE  PULSE_TIMER_NUM

 //
 // HAL functions
@@ -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 || ENABLED(DWINOS_4)
+  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.available()
  #endif
 #endif
@@ -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 || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)  || ENABLED(EXTENSIBLE_UI)
+  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif
@@ -43,7 +43,6 @@

 #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 {
@@ -55,7 +54,6 @@

    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;
@@ -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 || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(DWINOS_4)
+  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif
@@ -266,7 +266,7 @@ PGMSTR(M112_KILL_STR, "M112 Shutdown");
 MarlinState marlin_state = MF_INITIALIZING;

 // For M109 and M190, this flag may be cleared (by M108) to exit the wait loop
-bool wait_for_heatup = true;
+bool wait_for_heatup = false;

 // For M0/M1, this flag may be cleared (by M108) to exit the wait-for-user loop
 #if HAS_RESUME_CONTINUE
@@ -383,9 +383,9 @@
 #define BOARD_CREALITY_V452           5050  // Creality v4.5.2 (STM32F103RC / STM32F103RE)
 #define BOARD_CREALITY_V453           5051  // Creality v4.5.3 (STM32F103RC / STM32F103RE)
 #define BOARD_CREALITY_V521           5052  // Creality v5.2.1 (STM32F103VE) as found in the SV04
-#define BOARD_CREALITY_V24S1          5053  // Creality v2.4.S1 (STM32F103RC / STM32F103RE) v101 as found in the Ender-7
-#define BOARD_CREALITY_V24S1_301      5054  // Creality v2.4.S1_301 (STM32F103RC / STM32F103RE) v301 as found in the Ender-3 S1
-#define BOARD_CREALITY_V25S1          5055  // Creality v2.5.S1 (STM32F103RE) as found in the CR-10 Smart Pro
+#define BOARD_CREALITY_V24S1          5053  // Creality v2.4.S1 (STM32F103RC / STM32F103RE) CR-FDM-v2.4.S1_v101 as found in the Ender-7
+#define BOARD_CREALITY_V24S1_301      5054  // Creality v2.4.S1_301 (STM32F103RC / STM32F103RE) CR-FDM-v24S1_301 as found in the Ender-3 S1
+#define BOARD_CREALITY_V25S1          5055  // Creality v2.5.S1 (STM32F103RE) CR-FDM-v2.5.S1_100 as found in the CR-10 Smart Pro
 #define BOARD_TRIGORILLA_PRO          5056  // Trigorilla Pro (STM32F103ZE)
 #define BOARD_FLY_MINI                5057  // FLYmaker FLY MINI (STM32F103RC)
 #define BOARD_FLSUN_HISPEED           5058  // FLSUN HiSpeedV1 (STM32F103VE)
@@ -468,6 +468,11 @@
 #define BOARD_FYSETC_CHEETAH_V30      5250  // FYSETC Cheetah V3.0 (STM32F446RC)
 #define BOARD_BLACKBEEZMINI_V1        5251  // BlackBeezMini V1 (STM32F401CCU6)

+//
+// Other ARM Cortex-M4
+//
+#define BOARD_CREALITY_CR4NS          5300  // Creality CR4NS200320C13 (GD32F303RET6) as found in the Ender-3 V3 SE
+
 //
 // ARM Cortex-M7
 //
@@ -135,6 +135,7 @@
 #define STR_BUSY_PAUSED_FOR_USER            "busy: paused for user"
 #define STR_BUSY_PAUSED_FOR_INPUT           "busy: paused for input"
 #define STR_Z_MOVE_COMP                     "Z_move_comp"
+#define STR_LINE_NO                         "Line: "
 #define STR_RESEND                          "Resend: "
 #define STR_UNKNOWN_COMMAND                 "Unknown command: \""
 #define STR_ACTIVE_EXTRUDER                 "Active Extruder: "
@@ -89,7 +89,8 @@
 #define HYPOT2(x,y) (sq(x)+sq(y))
 #define NORMSQ(x,y,z) (sq(x)+sq(y)+sq(z))

-#define CIRCLE_AREA(R) (float(M_PI) * sq(float(R)))
+#define FLOAT_SQ(I) sq(float(I))
+#define CIRCLE_AREA(R) (float(M_PI) * FLOAT_SQ(R))
 #define CIRCLE_CIRC(R) (2 * float(M_PI) * float(R))

 #define SIGN(a) ({__typeof__(a) _a = (a); (_a>0)-(_a<0);})
@@ -196,8 +197,8 @@
 #define ENABLED(V...)       DO(ENA,&&,V)
 #define DISABLED(V...)      DO(DIS,&&,V)
 #define ANY(V...)          !DISABLED(V)
-#define ALL                 ENABLED
-#define NONE                DISABLED
+#define ALL(V...)           ENABLED(V)
+#define NONE(V...)          DISABLED(V)
 #define COUNT_ENABLED(V...) DO(ENA,+,V)
 #define MANY(V...)          (COUNT_ENABLED(V) > 1)

@@ -629,7 +630,7 @@
 #define DEFER4(M) M EMPTY EMPTY EMPTY EMPTY()()()()

 // Force define expansion
-#define EVAL           EVAL16
+#define EVAL(V...)     EVAL16(V)
 #define EVAL4096(V...) EVAL2048(EVAL2048(V))
 #define EVAL2048(V...) EVAL1024(EVAL1024(V))
 #define EVAL1024(V...) EVAL512(EVAL512(V))
@@ -143,13 +143,13 @@ public:

  // Set with format string and arguments, like printf
  template<typename... Args>
-  MString& setf_P(PGM_P const fmt, Args... more) { SNPRINTF_P(str, SIZE, fmt, more...); debug(F("setf_P")); return *this; }
+  MString& setf_P(PGM_P const pfmt, Args... more) { SNPRINTF_P(str, SIZE, pfmt, more...); debug(F("setf_P")); return *this; }

  template<typename... Args>
-  MString& setf(const char *fmt, Args... more)   { SNPRINTF(str, SIZE, fmt, more...);   debug(F("setf"));   return *this; }
+  MString& setf(const char *fmt, Args... more) { SNPRINTF(str, SIZE, fmt, more...); debug(F("setf")); return *this; }

  template<typename... Args>
-  MString& setf(FSTR_P const fmt, Args... more)  { return setf_P(FTOP(fmt), more...); }
+  MString& setf(FSTR_P const ffmt, Args... more) { return setf_P(FTOP(ffmt), more...); }

  // Chainable String appenders
  MString& append()                           { debug(F("nil")); return *this; } // for macros that might emit no output
@@ -206,9 +206,9 @@ public:
  MString& append(const spaces_t &s) { return append(repchr_t(' ', s.count)); }

  template<typename... Args>
-  MString& appendf_P(PGM_P const fmt, Args... more) {
+  MString& appendf_P(PGM_P const pfmt, Args... more) {
    int sz = length();
-    if (sz < SIZE) SNPRINTF_P(str + sz, SIZE - sz, fmt, more...);
+    if (sz < SIZE) SNPRINTF_P(str + sz, SIZE - sz, pfmt, more...);
    debug(F("appendf_P"));
    return *this;
  }
@@ -271,13 +271,13 @@ public:
  SString& set() { super::set(); return *this; }

  template<typename... Args>
-  SString& setf_P(PGM_P const fmt, Args... more) { super::setf_P(fmt, more...); return *this; }
+  SString& setf_P(PGM_P const pfmt, Args... more) { super::setf_P(pfmt, more...); return *this; }

  template<typename... Args>
-  SString& setf(const char *fmt, Args... more)   { super::setf(fmt, more...); return *this; }
+  SString& setf(const char *fmt, Args... more)    { super::setf(fmt, more...); return *this; }

  template<typename... Args>
-  SString& setf(FSTR_P const fmt, Args... more)  { super::setf(fmt, more...); return *this; }
+  SString& setf(FSTR_P const ffmt, Args... more)  { super::setf(ffmt, more...); return *this; }

  template <typename T>
  SString& set(const T &v) { super::set(v); return *this; }
@@ -46,6 +46,7 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
 #define NUM_AXIS_ELEM(O)      NUM_AXIS_LIST(O.x, O.y, O.z, O.i, O.j, O.k, O.u, O.v, O.w)
 #define NUM_AXIS_DECL(T,V)    NUM_AXIS_LIST(T x=V, T y=V, T z=V, T i=V, T j=V, T k=V, T u=V, T v=V, T w=V)
 #define MAIN_AXIS_NAMES       NUM_AXIS_LIST(X, Y, Z, I, J, K, U, V, W)
+#define MAIN_AXIS_NAMES_LC    NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)
 #define STR_AXES_MAIN         NUM_AXIS_GANG("X", "Y", "Z", STR_I, STR_J, STR_K, STR_U, STR_V, STR_W)

 #define LOGICAL_AXIS_GANG(E,V...)  NUM_AXIS_GANG(V) GANG_ITEM_E(E)
@@ -58,17 +59,21 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
 #define LOGICAL_AXIS_ELEM(O)       LOGICAL_AXIS_LIST(O.e, O.x, O.y, O.z, O.i, O.j, O.k, O.u, O.v, O.w)
 #define LOGICAL_AXIS_DECL(T,V)     LOGICAL_AXIS_LIST(T e=V, T x=V, T y=V, T z=V, T i=V, T j=V, T k=V, T u=V, T v=V, T w=V)
 #define LOGICAL_AXIS_NAMES         LOGICAL_AXIS_LIST(E, X, Y, Z, I, J, K, U, V, W)
+#define LOGICAL_AXIS_NAMES_LC      LOGICAL_AXIS_LIST(e, x, y, z, i, j, k, u, v, w)
 #define LOGICAL_AXIS_MAP(F)        MAP(F, LOGICAL_AXIS_NAMES)
+#define LOGICAL_AXIS_MAP_LC(F)     MAP(F, LOGICAL_AXIS_NAMES_LC)
 #define STR_AXES_LOGICAL           LOGICAL_AXIS_GANG("E", "X", "Y", "Z", STR_I, STR_J, STR_K, STR_U, STR_V, STR_W)

 #if NUM_AXES
  #define NUM_AXES_SEP ,
  #define MAIN_AXIS_MAP(F)    MAP(F, MAIN_AXIS_NAMES)
+  #define MAIN_AXIS_MAP_LC(F) MAP(F, MAIN_AXIS_NAMES_LC)
  #define OPTARGS_NUM(T)      , NUM_AXIS_ARGS(T)
  #define OPTARGS_LOGICAL(T)  , LOGICAL_AXIS_ARGS(T)
 #else
  #define NUM_AXES_SEP
  #define MAIN_AXIS_MAP(F)
+  #define MAIN_AXIS_MAP_LC(F)
  #define OPTARGS_NUM(T)
  #define OPTARGS_LOGICAL(T)
 #endif
@@ -79,6 +84,7 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
 #define NUM_AXIS_ARGS_(T)       NUM_AXIS_ARGS(T) NUM_AXES_SEP
 #define NUM_AXIS_ELEM_(T)       NUM_AXIS_ELEM(T) NUM_AXES_SEP
 #define MAIN_AXIS_NAMES_        MAIN_AXIS_NAMES NUM_AXES_SEP
+#define MAIN_AXIS_NAMES_LC_     MAIN_AXIS_NAMES_LC NUM_AXES_SEP

 #if LOGICAL_AXES
  #define LOGICAL_AXES_SEP ,
@@ -92,6 +98,7 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
 #define LOGICAL_AXIS_ARGS_(T)       LOGICAL_AXIS_ARGS(T) LOGICAL_AXES_SEP
 #define LOGICAL_AXIS_ELEM_(T)       LOGICAL_AXIS_ELEM(T) LOGICAL_AXES_SEP
 #define LOGICAL_AXIS_NAMES_         LOGICAL_AXIS_NAMES LOGICAL_AXES_SEP
+#define LOGICAL_AXIS_NAMES_LC_      LOGICAL_AXIS_NAMES_LC LOGICAL_AXES_SEP

 #define SECONDARY_AXIS_GANG(V...) GANG_N(SECONDARY_AXES, V)
 #define SECONDARY_AXIS_CODE(V...) CODE_N(SECONDARY_AXES, V)
@@ -159,7 +166,7 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
 // General Flags for some number of states
 template<size_t N>
 struct Flags {
-  typedef uvalue_t(N) flagbits_t;
+  typedef bits_t(N) flagbits_t;
  typedef struct { bool b0:1, b1:1, b2:1, b3:1, b4:1, b5:1, b6:1, b7:1; } N8;
  typedef struct { bool b0:1, b1:1, b2:1, b3:1, b4:1, b5:1, b6:1, b7:1, b8:1, b9:1, b10:1, b11:1, b12:1, b13:1, b14:1, b15:1; } N16;
  typedef struct { bool b0:1,  b1:1,  b2:1,  b3:1,  b4:1,  b5:1,  b6:1,  b7:1,  b8:1,  b9:1, b10:1, b11:1, b12:1, b13:1, b14:1, b15:1,
@@ -219,7 +226,7 @@ typedef struct {
 //
 //  - X_AXIS, Y_AXIS, and Z_AXIS should be used for axes in Cartesian space
 //  - A_AXIS, B_AXIS, and C_AXIS should be used for Steppers, corresponding to XYZ on Cartesians
-//  - X_HEAD, Y_HEAD, and Z_HEAD should be used for Steppers on Core kinematics
+//  - X_HEAD, Y_HEAD, and Z_HEAD should be used for axes on Core kinematics
 //
 enum AxisEnum : uint8_t {

@@ -603,9 +610,9 @@ struct XYZval {
  // If any element is true then it's true
  FI constexpr operator bool()  const { return 0 NUM_AXIS_GANG(|| x, || y, || z, || i, || j, || k, || u, || v, || w); }
  // Smallest element
-  FI constexpr T small()        const { return TERN(HAS_X_AXIS, _MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)), 0); }
+  FI constexpr T small()        const { return TERN0(HAS_X_AXIS, _MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w))); }
  // Largest element
-  FI constexpr T large()        const { return TERN(HAS_X_AXIS, _MAX(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)), 0); }
+  FI constexpr T large()        const { return TERN0(HAS_X_AXIS, _MAX(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w))); }

  // Explicit copy and copies with conversion
  FI constexpr XYZval<T>           copy() const { XYZval<T> o = *this; return o; }
@@ -1084,6 +1091,7 @@ public:
  FI bool toggle(const AxisEnum n) { TBI(bits, n); return TEST(bits, n); }
  FI void bset(const AxisEnum n) { SBI(bits, n); }
  FI void bclr(const AxisEnum n) { CBI(bits, n); }
+  FI void bset(const AxisEnum n, const bool b) { if (b) bset(n); else bclr(n); }

  // Accessor via an AxisEnum (or any integer) [index]
  FI bool operator[](const int n) const { return TEST(bits, n); }
@@ -46,10 +46,16 @@ BDS_Leveling bdl;
 #define DEBUG_OUT ENABLED(DEBUG_OUT_BD)
 #include "../../../core/debug_out.h"

-// M102 S-5   Read raw Calibrate data
-// M102 S-6   Start Calibrate
-// M102 S4    Set the adjustable Z height value (e.g., 'M102 S4' means it will do adjusting while the Z height <= 0.4mm , disable with 'M102 S0'.)
-// M102 S-1   Read sensor information
+/**
+ * M102 S<#> : Set adjustable Z height in 0.1mm units (10ths of a mm)
+ *             (e.g., 'M102 S4' enables adjusting for Z <= 0.4mm)
+ * M102 S0   : Disable adjustable Z height
+ *
+ * M102 S-1  : Read BDsensor version
+ * M102 S-2  : Read BDsensor distance value
+ * M102 S-5  : Read raw Calibration data
+ * M102 S-6  : Start Calibration
+ */

 #define MAX_BD_HEIGHT                 4.0f
 #define CMD_READ_VERSION              1016
@@ -765,7 +765,7 @@ void unified_bed_leveling::shift_mesh_height() {

      const grid_count_t point_num = (GRID_MAX_POINTS - count) + 1;
      SERIAL_ECHOLNPGM("Probing mesh point ", point_num, "/", GRID_MAX_POINTS, ".");
-      TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), point_num, int(GRID_MAX_POINTS)));
+      TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT_F(MSG_PROBING_POINT), point_num, int(GRID_MAX_POINTS)));
      TERN_(HAS_BACKLIGHT_TIMEOUT, ui.refresh_backlight_timeout());

      #if HAS_MARLINUI_MENU
@@ -1494,7 +1494,7 @@ void unified_bed_leveling::smart_fill_mesh() {

      for (uint8_t i = 0; i < 3; ++i) {
        SERIAL_ECHOLNPGM("Tilting mesh (", i + 1, "/3)");
-        TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/3"), GET_TEXT(MSG_LCD_TILTING_MESH), i + 1));
+        TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/3"), GET_TEXT_F(MSG_LCD_TILTING_MESH), i + 1));

        measured_z = probe.probe_at_point(points[i], i < 2 ? PROBE_PT_RAISE : PROBE_PT_LAST_STOW, param.V_verbosity);
        if ((abort_flag = isnan(measured_z))) break;
@@ -1550,7 +1550,7 @@ void unified_bed_leveling::smart_fill_mesh() {
          #endif

          SERIAL_ECHOLNPGM("Tilting mesh point ", point_num, "/", total_points, "\n");
-          TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_LCD_TILTING_MESH), point_num, total_points));
+          TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT_F(MSG_LCD_TILTING_MESH), point_num, total_points));

          measured_z = probe.probe_at_point(rpos, parser.seen_test('E') ? PROBE_PT_STOW : PROBE_PT_RAISE, param.V_verbosity); // TODO: Needs error handling

@@ -137,7 +137,7 @@ void FWRetract::retract(const bool retracting E_OPTARG(bool swapping/*=false*/))
    // Retract by moving from a faux E position back to the current E position
    current_retract[active_extruder] = base_retract;
    prepare_internal_move_to_destination(                 // set current from destination
-      settings.retract_feedrate_mm_s * TERN1(RETRACT_SYNC_MIXING, (MIXING_STEPPERS))
+      MUL_TERN(RETRACT_SYNC_MIXING, settings.retract_feedrate_mm_s, MIXING_STEPPERS)
    );

    // Is a Z hop set, and has the hop not yet been done?
@@ -165,8 +165,7 @@ void FWRetract::retract(const bool retracting E_OPTARG(bool swapping/*=false*/))

    // Recover E, set_current_to_destination
    prepare_internal_move_to_destination(
-      (swapping ? settings.swap_retract_recover_feedrate_mm_s : settings.retract_recover_feedrate_mm_s)
-      * TERN1(RETRACT_SYNC_MIXING, (MIXING_STEPPERS))
+      MUL_TERN(RETRACT_SYNC_MIXING, swapping ? settings.swap_retract_recover_feedrate_mm_s : settings.retract_recover_feedrate_mm_s, MIXING_STEPPERS)
    );
  }

@@ -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[active_extruder] = false;
+                runout.enabled = false;
                runout.reset();
              }
            #endif
@@ -130,7 +130,7 @@ public:
  }

  // Accessors
-  static uint16_t pixels() { return adaneo1.numPixels() * TERN1(NEOPIXEL2_INSERIES, 2); }
+  static uint16_t pixels() { return MUL_TERN(NEOPIXEL2_INSERIES, adaneo1.numPixels(), 2); }

  static uint32_t pixel_color(const uint16_t n) {
    #if ENABLED(NEOPIXEL2_INSERIES)
@@ -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) != runout.out_state())
+  #define FILAMENT_PRESENT() (READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE)
 #else
  #define FILAMENT_PRESENT() true
 #endif
@@ -214,21 +214,12 @@ 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
-          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;
+          #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)
          }
        #else
-          if (READ(FIL_RUNOUT_PIN) != runout.out_state(active_extruder))
-            wait_for_user = false;
+          if (READ(FIL_RUNOUT_PIN) != FIL_RUNOUT_STATE) wait_for_user = false;
        #endif
      #endif
      idle_no_sleep();
@@ -689,7 +680,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));
@@ -698,7 +689,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
@@ -122,7 +122,6 @@ void Power::power_off() {
  TERN_(HAS_SUICIDE, suicide());

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

  SERIAL_ECHOLNPGM(STR_POWEROFF);

@@ -32,9 +32,9 @@

 FilamentMonitor runout;

-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
+bool FilamentMonitorBase::enabled = true,
+     FilamentMonitorBase::filament_ran_out;  // = false
+
 #if ENABLED(HOST_ACTION_COMMANDS)
  bool FilamentMonitorBase::host_handling; // = false
 #endif
@@ -45,10 +45,15 @@ RunoutMode FilamentMonitorBase::mode[NUM_RUNOUT_SENSORS]; // Initialized by sett
  #include "../core/debug_out.h"
 #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
+#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

 //
 // Filament Runout event handler
@@ -44,6 +44,12 @@
  #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
@@ -58,37 +64,24 @@ inline bool should_monitor_runout() { return did_pause_print || printingIsActive

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

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

 typedef TFilamentMonitor<
-          RunoutResponseDelayed,
-          FilamentSensorCore
+          TERN(HAS_FILAMENT_RUNOUT_DISTANCE, RunoutResponseDelayed, RunoutResponseDebounced),
+          FilamentSensor
        > 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[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; }
+    static bool enabled, filament_ran_out;

    #if ENABLED(HOST_ACTION_COMMANDS)
      static bool host_handling;
@@ -118,14 +111,24 @@ 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 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; }
+    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

    // 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[active_extruder]) {
+      if (enabled) {
        response.block_completed(b);
        sensor.block_completed(b);
      }
@@ -134,11 +137,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()) {
-        cli(); // Prevent RunoutResponseDelayed::block_completed from accumulating here
+        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, cli()); // Prevent RunoutResponseDelayed::block_completed from accumulating here
        response.run();
        sensor.run();
        const runout_flags_t runout_flags = response.has_run_out();
-        sei();
+        TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, sei());
        #if MULTI_FILAMENT_SENSOR
          #if ENABLED(WATCH_ALL_RUNOUT_SENSORS)
            const bool ran_out = bool(runout_flags);  // any sensor triggers
@@ -179,40 +182,27 @@ 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)
-      #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);
+      #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
      #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)
@@ -222,7 +212,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) | (runout.out_state(N-1) ? 0 : _BV(N-1))
+      #define _INVERT_BIT(N) | (FIL_RUNOUT##N##_STATE ? 0 : _BV(N - 1))
      return poll_runout_pins() ^ uint8_t(0 REPEAT_1(NUM_RUNOUT_SENSORS, _INVERT_BIT));
      #undef _INVERT_BIT
    }
@@ -244,21 +234,17 @@ class FilamentSensorBase {
    #endif
 };

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

-    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
-      }
+  /**
+   * 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 void poll_motion_sensor() {
        static uint8_t old_state;
@@ -266,17 +252,17 @@ class FilamentSensorCore : public 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 < 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 < TERN(FILAMENT_SWITCH_AND_MOTION, NUM_MOTION_SENSORS, 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) {
@@ -289,12 +275,36 @@ class FilamentSensorCore : public FilamentSensorBase {
        motion_detected = 0;
      }

-    static void run() {
-      if (runout.mode[active_extruder] == RM_MOTION_SENSOR) {
-        poll_motion_sensor();
+      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
      }
-      else if (runout.mode[active_extruder] != RM_NONE) {
-        for(uint8_t s = 0; s < NUM_RUNOUT_SENSORS; ++s) {
+
+    public:
+      static void block_completed(const block_t * const) {}
+
+      static void run() {
+        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)
@@ -306,12 +316,36 @@ class FilamentSensorCore : public 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 *********************************/

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

-// 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;
+  // 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;

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

      static void reset() {
        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) filament_present(i);
@@ -338,33 +371,116 @@ class RunoutResponseDelayed {
        #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; i < NUM_RUNOUT_SENSORS; ++i)
-            SERIAL_ECHO(i ? F(", ") : F("Remaining mm: "), mm_countdown[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 = 0; i < NUM_RUNOUT_SENSORS; ++i)
+              SERIAL_ECHO(i ? F(", ") : F("Runout remaining mm: "), mm_countdown.runout[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();
+            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);
        }
      #endif
-    }

-    static runout_flags_t has_run_out() {
-      runout_flags_t runout_flags{0};
+      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};
        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_distance_mm[extruder];
+        runout_count[extruder] = runout_threshold;
      }
  };

+#endif // !HAS_FILAMENT_RUNOUT_DISTANCE
@@ -31,7 +31,7 @@ static uint32_t axis_plug_backward = 0;
 void stepper_driver_backward_error(FSTR_P const fstr) {
  SERIAL_ERROR_START();
  SERIAL_ECHOLN(fstr, F(" driver is backward!"));
-  ui.status_printf(2, F(S_FMT S_FMT), FTOP(fstr), GET_TEXT(MSG_DRIVER_BACKWARD));
+  ui.status_printf(2, F(S_FMT S_FMT), FTOP(fstr), GET_TEXT_F(MSG_DRIVER_BACKWARD));
 }

 void stepper_driver_backward_check() {
@@ -32,6 +32,12 @@

 /**
 * G42: Move X & Y axes to mesh coordinates (I & J)
+ *
+ * Parameters:
+ *   F<feedrate> : Feedrate in mm/min
+ *   I<index>    : X axis point index
+ *   J<index>    : Y axis point index
+ *   P<bool>     : Flag to put the prove at the given point
 */
 void GcodeSuite::G42() {
  if (MOTION_CONDITIONS) {
@@ -683,7 +683,7 @@ G29_TYPE GcodeSuite::G29() {
          if (TERN0(IS_KINEMATIC, !probe.can_reach(abl.probePos))) continue;

          if (abl.verbose_level) SERIAL_ECHOLNPGM("Probing mesh point ", pt_index, "/", abl.abl_points, ".");
-          TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), int(pt_index), int(abl.abl_points)));
+          TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT_F(MSG_PROBING_POINT), int(pt_index), int(abl.abl_points)));

          #if ENABLED(BD_SENSOR_PROBE_NO_STOP)
            if (PR_INNER_VAR == inStart) {
@@ -782,7 +782,7 @@ G29_TYPE GcodeSuite::G29() {

      for (uint8_t i = 0; i < 3; ++i) {
        if (abl.verbose_level) SERIAL_ECHOLNPGM("Probing point ", i + 1, "/3.");
-        TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/3"), GET_TEXT(MSG_PROBING_POINT), int(i + 1)));
+        TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/3"), GET_TEXT_F(MSG_PROBING_POINT), int(i + 1)));

        // Retain the last probe position
        abl.probePos = xy_pos_t(points[i]);
@@ -985,9 +985,6 @@ 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();
@@ -253,7 +253,7 @@ void GcodeSuite::G29() {

  if (state == MeshNext) {
    SERIAL_ECHOLNPGM("MBL G29 point ", _MIN(mbl_probe_index, GRID_MAX_POINTS), " of ", GRID_MAX_POINTS);
-    if (mbl_probe_index > 0) TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), _MIN(mbl_probe_index, GRID_MAX_POINTS), int(GRID_MAX_POINTS)));
+    if (mbl_probe_index > 0) TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT_F(MSG_PROBING_POINT), _MIN(mbl_probe_index, GRID_MAX_POINTS), int(GRID_MAX_POINTS)));
  }

  report_current_position();
@@ -149,7 +149,7 @@ void GcodeSuite::M48() {
    for (uint8_t n = 0; n < n_samples; ++n) {
      #if HAS_STATUS_MESSAGE
        // Display M48 progress in the status bar
-        ui.status_printf(0, F(S_FMT ": %d/%d"), GET_TEXT(MSG_M48_POINT), int(n + 1), int(n_samples));
+        ui.status_printf(0, F(S_FMT ": %d/%d"), GET_TEXT_F(MSG_M48_POINT), int(n + 1), int(n_samples));
      #endif

      // When there are "legs" of movement move around the point before probing
@@ -20,6 +20,11 @@
 *
 */

+/**
+ * gcode/control/M10_M11.cpp
+ * Air Evacuation
+ */
+
 #include "../../inc/MarlinConfig.h"

 #if ENABLED(AIR_EVACUATION)
@@ -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());
@@ -68,7 +68,7 @@ void GcodeSuite::M907() {
      #define HAS_X_Y_XY_I_J_K_U_V_W 1
    #endif

-    #if HAS_X_Y_XY_I_J_K_U_V_W || ANY_PIN(MOTOR_CURRENT_PWM_E, MOTOR_CURRENT_PWM_Z)
+    #if HAS_X_Y_XY_I_J_K_U_V_W || HAS_MOTOR_CURRENT_PWM_E || PIN_EXISTS(MOTOR_CURRENT_PWM_Z)

      if (!parser.seen("S"
        #if HAS_X_Y_XY_I_J_K_U_V_W
@@ -77,7 +77,7 @@ void GcodeSuite::M907() {
        #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
          "Z"
        #endif
-        #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
+        #if HAS_MOTOR_CURRENT_PWM_E
          "E"
        #endif
      )) return M907_report();
@@ -94,7 +94,7 @@ void GcodeSuite::M907() {
      #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
        if (parser.seenval('Z')) stepper.set_digipot_current(1, parser.value_int());
      #endif
-      #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
+      #if HAS_MOTOR_CURRENT_PWM_E
        if (parser.seenval('E')) stepper.set_digipot_current(2, parser.value_int());
      #endif

@@ -133,7 +133,7 @@ void GcodeSuite::M907() {
      SERIAL_ECHOLNPGM_P(                                     // PWM-based has 3 values:
          PSTR("  M907 X"), stepper.motor_current_setting[0]  // X, Y, (I, J, K, U, V, W)
        , SP_Z_STR,         stepper.motor_current_setting[1]  // Z
-        #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
+        #if HAS_MOTOR_CURRENT_PWM_E
          , SP_E_STR,       stepper.motor_current_setting[2]  // E
        #endif
      );
@@ -44,6 +44,15 @@ void GcodeSuite::M593_report(const bool forReplay/*=true*/) {
      " D", stepper.get_shaping_damping_ratio(Y_AXIS)
    );
  #endif
+  #if ENABLED(INPUT_SHAPING_Z)
+    #if ANY(INPUT_SHAPING_X, INPUT_SHAPING_Y)
+      report_echo_start(forReplay);
+    #endif
+    SERIAL_ECHOLNPGM("  M593 Z"
+      " F", stepper.get_shaping_frequency(Z_AXIS),
+      " D", stepper.get_shaping_damping_ratio(Z_AXIS)
+    );
+  #endif
 }

 /**
@@ -59,14 +68,17 @@ void GcodeSuite::M593() {

  const bool seen_X = TERN0(INPUT_SHAPING_X, parser.seen_test('X')),
             seen_Y = TERN0(INPUT_SHAPING_Y, parser.seen_test('Y')),
-             for_X = seen_X || TERN0(INPUT_SHAPING_X, (!seen_X && !seen_Y)),
-             for_Y = seen_Y || TERN0(INPUT_SHAPING_Y, (!seen_X && !seen_Y));
+             seen_Z = TERN0(INPUT_SHAPING_Z, parser.seen_test('Z')),
+             for_X = seen_X || TERN0(INPUT_SHAPING_X, (!seen_X && !seen_Y && !seen_Z)),
+             for_Y = seen_Y || TERN0(INPUT_SHAPING_Y, (!seen_X && !seen_Y && !seen_Z)),
+             for_Z = seen_Z || TERN0(INPUT_SHAPING_Z, (!seen_X && !seen_Y && !seen_Z));

  if (parser.seen('D')) {
    const float zeta = parser.value_float();
    if (WITHIN(zeta, 0, 1)) {
      if (for_X) stepper.set_shaping_damping_ratio(X_AXIS, zeta);
      if (for_Y) stepper.set_shaping_damping_ratio(Y_AXIS, zeta);
+      if (for_Z) stepper.set_shaping_damping_ratio(Z_AXIS, zeta);
    }
    else
      SERIAL_ECHO_MSG("?Zeta (D) value out of range (0-1)");
@@ -78,6 +90,7 @@ void GcodeSuite::M593() {
    if (freq == 0.0f || freq > min_freq) {
      if (for_X) stepper.set_shaping_frequency(X_AXIS, freq);
      if (for_Y) stepper.set_shaping_frequency(Y_AXIS, freq);
+      if (for_Z) stepper.set_shaping_frequency(Z_AXIS, freq);
    }
    else
      SERIAL_ECHOLNPGM(GCODE_ERR_MSG("Frequency (F) must be greater than ", min_freq, " or 0 to disable"));
@@ -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) == runout.out_state(1)) ? 1 : 0;
+          DXC_ext = (READ(FIL_RUNOUT2_PIN) == FIL_RUNOUT2_STATE) ? 1 : 0;
      #else
        DXC_ext = active_extruder;
      #endif
@@ -28,46 +28,36 @@
 #include "../../../feature/runout.h"

 /**
- * M591: Configure filament runout detection
+ * M412: Enable / Disable 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
- *  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
+ *  D<linear> : Extra distance to continue after runout is triggered
 */
-void GcodeSuite::M591() {
-  if (parser.seen("RSDP" TERN_(HOST_ACTION_COMMANDS, "H"))) {
+void GcodeSuite::M412() {
+  if (parser.seen("RS"
+    TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, "D")
+    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();
-    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;
-      }
-    }
+    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
  }
  else {
    SERIAL_ECHO_START();
    SERIAL_ECHOPGM("Filament runout ");
-    serialprint_onoff(runout.enabled[active_extruder]);
-    SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(active_extruder), "mm");
-    SERIAL_ECHOPGM(" ; Mode ", runout.mode[active_extruder]);
+    serialprint_onoff(runout.enabled);
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
+      SERIAL_ECHOPGM(" ; Distance ", runout.runout_distance(), "mm");
+    #endif
    #if ENABLED(HOST_ACTION_COMMANDS)
      SERIAL_ECHOPGM(" ; Host handling ");
      serialprint_onoff(runout.host_handling);
@@ -76,19 +66,18 @@ void GcodeSuite::M591() {
  }
 }

-void GcodeSuite::M591_report(const bool forReplay/*=true*/) {
+void GcodeSuite::M412_report(const bool forReplay/*=true*/) {
  TERN_(MARLIN_SMALL_BUILD, return);
+
  report_heading_etc(forReplay, F(STR_FILAMENT_RUNOUT_SENSOR));
-  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]
-    );
+  SERIAL_ECHOPGM(
+    "  M412 S", runout.enabled
+    #if HAS_FILAMENT_RUNOUT_DISTANCE
+      , " D", LINEAR_UNIT(runout.runout_distance())
+    #endif
+    , " ; Sensor "
+  );
+  serialprintln_onoff(runout.enabled);
 }

 #endif // HAS_FILAMENT_SENSOR
@@ -865,6 +865,10 @@ 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
@@ -939,11 +943,6 @@ 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
@@ -1106,6 +1105,10 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
        case 1002: M1002(); break;                                // M1002: [INTERNAL] Tool-change and Relative E Move
      #endif

+      #if ENABLED(ONE_CLICK_PRINT)
+        case 1003: M1003(); break;                                // M1003: [INTERNAL] Set the current dir to /
+      #endif
+
      #if ENABLED(UBL_MESH_WIZARD)
        case 1004: M1004(); break;                                // M1004: UBL Mesh Wizard
      #endif
@@ -143,7 +143,7 @@
 *        R<temp> Wait for extruder current temp to reach target temp. ** Wait for heating or cooling. **
 *        If AUTOTEMP is enabled, S<mintemp> B<maxtemp> F<factor>. Exit autotemp by any M109 without F
 *
- * M110 - Set the current line number. (Used by host printing)
+ * M110 - Get or set the current line number. (Used by host printing)
 * M111 - Set debug flags: "M111 S<flagbits>". See flag bits defined in enum.h.
 * M112 - Full Shutdown.
 *
@@ -234,6 +234,7 @@
 * 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)
@@ -258,7 +259,6 @@
 * 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,9 +1035,8 @@ private:
  #endif

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

  #if HAS_MULTI_LANGUAGE
@@ -1277,6 +1276,10 @@ private:
    static void M1002();
  #endif

+  #if ENABLED(ONE_CLICK_PRINT)
+    static void M1003();
+  #endif
+
  #if ENABLED(UBL_MESH_WIZARD)
    static void M1004();
  #endif
@@ -24,11 +24,19 @@
 #include "../queue.h" // for last_N

 /**
- * M110: Set Current Line Number
+ * M110: Get or set Current Line Number
+ *
+ * Parameters:
+ *   N<int>  Number to set as last-processed command
+ *
+ * Without parameters:
+ *   Report the last-processed (not last-received or last-enqueued) command
+ *   (To purge the queue and resume from this line, the host should use 'M999' instead.)
 */
 void GcodeSuite::M110() {

  if (parser.seenval('N'))
    queue.set_current_line_number(parser.value_long());
-
+  else
+    SERIAL_ECHOLNPGM(STR_LINE_NO, queue.get_current_line_number());
 }
@@ -154,7 +154,7 @@ void GcodeSuite::M115() {
    // AUTOLEVEL (G29)
    cap_line(F("AUTOLEVEL"), ENABLED(HAS_AUTOLEVEL));

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

    // Z_PROBE (G30)
@@ -373,8 +373,6 @@ 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);
@@ -34,7 +34,7 @@
  #include "../../feature/probe_temp_comp.h"
 #endif

-#if ANY(DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI)
+#if ANY(DWIN_CREALITY_LCD_JYERSUI, EXTENSIBLE_UI)
  #define VERBOSE_SINGLE_PROBE
 #endif

@@ -55,7 +55,7 @@ inline bool G38_run_probe() {
    }
  #endif

-  planner.synchronize();  // wait until the machine is idle
+  planner.synchronize(); // Wait until the machine is idle

  // Move flag value
  #if ENABLED(G38_PROBE_AWAY)
@@ -54,6 +54,21 @@ void mpe_settings_init() {
  mpe_settings_report();
 }

+/**
+ * M951: Magnetic Parking Extruder
+ *
+ * Parameters:
+ *   L<linear>    : Set X[0] position
+ *   R<linear>    : Set X[1] position
+ *   I<linear>    : Set grab distance
+ *   J<feedrate>  : Set slow feedrate
+ *   H<feedrate>  : Set fast feedrate
+ *   D<feedrate>  : Set travel feedrate
+ *   C<factor>    : Set compensation factor
+ *
+ * With no parameters report the current settings.
+ *
+ */
 void GcodeSuite::M951() {
  if (parser.seenval('L')) mpe_settings.parking_xpos[0] = parser.value_linear_units();
  if (parser.seenval('R')) mpe_settings.parking_xpos[1] = parser.value_linear_units();
@@ -212,6 +212,11 @@ public:
   */
  static void set_current_line_number(long n) { serial_state[ring_buffer.command_port().index].last_N = n; }

+  /**
+   * Get the current line number for the last received command
+   */
+  static long get_current_line_number() { return serial_state[ring_buffer.command_port().index].last_N; }
+
  #if ENABLED(BUFFER_MONITORING)

    private:
@@ -0,0 +1,36 @@
+/**
+ * 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 "../../inc/MarlinConfig.h"
+
+#if ENABLED(ONE_CLICK_PRINT)
+
+#include "../gcode.h"
+#include "../../sd/cardreader.h"
+
+/**
+ * M1003: Set the current dir to /. Should come after 'M24'.
+ *        Prevents the SD menu getting stuck in the newest file's workDir.
+ */
+void GcodeSuite::M1003() { card.cdroot(); }
+
+#endif // ONE_CLICK_PRINT
@@ -49,7 +49,7 @@
 */

 void GcodeSuite::M306() {
-  const uint8_t e = TERN(HAS_MULTI_EXTRUDER, parser.intval('E', active_extruder), 0);
+  const uint8_t e = TERN0(HAS_MULTI_EXTRUDER, parser.intval('E', active_extruder));
  if (e >= (EXTRUDERS)) {
    SERIAL_ECHOLNPGM("?(E)xtruder index out of range (0-", (EXTRUDERS) - 1, ").");
    return;
@@ -21,7 +21,7 @@
 */

 /**
- * gcode/temp/M86-M87.cpp
+ * gcode/temp/M86_M87.cpp
 *
 * Hotend Idle Timeout
 */
@@ -893,10 +893,11 @@
  #endif
 #endif

-// FSMC/SPI TFT Panels (LVGL)
+// FSMC/SPI TFT Panels (LVGL) with encoder click wheel
 #if ENABLED(TFT_LVGL_UI)
  #define HAS_TFT_LVGL_UI 1
  #define SERIAL_RUNTIME_HOOK 1
+  #define STD_ENCODER_PULSES_PER_STEP 4
 #endif

 // FSMC/SPI TFT Panels
@@ -976,6 +977,17 @@
  #define DETECT_I2C_LCD_DEVICE 1
 #endif

+/**
+ * Ender-3 V2 DWIN with Encoder
+ */
+#if ANY(DWIN_CREALITY_LCD, DWIN_LCD_PROUI)
+  #define HAS_DWIN_E3V2_BASIC 1
+#endif
+#if ANY(HAS_DWIN_E3V2_BASIC, DWIN_CREALITY_LCD_JYERSUI)
+  #define HAS_DWIN_E3V2 1
+  #define STD_ENCODER_PULSES_PER_STEP 4
+#endif
+
 // Encoder behavior
 #ifndef STD_ENCODER_PULSES_PER_STEP
  #if ENABLED(TOUCH_SCREEN)
@@ -997,10 +1009,12 @@
  #define ENCODER_FEEDRATE_DEADZONE 6
 #endif

-// Shift register panels
-// ---------------------
-// 2 wire Non-latching LCD SR from:
-// https://github.com/fmalpartida/New-LiquidCrystal/wiki/schematics#user-content-ShiftRegister_connection
+/**
+ * Shift register panels
+ * ---------------------
+ * 2 wire Non-latching LCD SR from:
+ * https://github.com/fmalpartida/New-LiquidCrystal/wiki/schematics#user-content-ShiftRegister_connection
+ */
 #if ENABLED(FF_INTERFACEBOARD)
  #define SR_LCD_3W_NL    // Non latching 3 wire shift register
  #define IS_ULTIPANEL 1
@@ -1040,11 +1054,6 @@
  #define EXTENSIBLE_UI
 #endif

-// Aliases for LCD features
-#if ANY(DWIN_CREALITY_LCD, DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI)
-  #define HAS_DWIN_E3V2 1
-#endif
-
 // E3V2 extras
 #if HAS_DWIN_E3V2 || IS_DWIN_MARLINUI
  #define SERIAL_CATCHALL 0
@@ -1191,14 +1200,10 @@
 * 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
@@ -1207,7 +1212,9 @@
    #endif
  #endif
  #if NUM_RUNOUT_SENSORS >= 2
-    #define MULTI_FILAMENT_SENSOR 1
+    #ifndef FIL_RUNOUT2_STATE
+      #define FIL_RUNOUT2_STATE FIL_RUNOUT_STATE
+    #endif
    #ifndef FIL_RUNOUT2_PULLUP
      #define FIL_RUNOUT2_PULLUP FIL_RUNOUT_PULLUP
    #endif
@@ -1216,6 +1223,9 @@
    #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
@@ -1224,6 +1234,9 @@
    #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
@@ -1232,6 +1245,9 @@
    #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
@@ -1240,6 +1256,9 @@
    #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
@@ -1248,6 +1267,9 @@
    #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
@@ -1256,6 +1278,9 @@
    #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
@@ -1578,8 +1603,6 @@
 #endif
 #if CORE_IS_XY || CORE_IS_XZ || CORE_IS_YZ
  #define IS_CORE 1
-#endif
-#if IS_CORE
  #if CORE_IS_XY
    #define CORE_AXIS_1 A_AXIS
    #define CORE_AXIS_2 B_AXIS
@@ -1865,30 +1888,6 @@
  #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
@@ -112,8 +112,8 @@
  #undef DISABLE_IDLE_X
  #undef INPUT_SHAPING_X
  #undef SAFE_BED_LEVELING_START_X
-  #undef SHAPING_BUFFER_X
  #undef SHAPING_FREQ_X
+  #undef SHAPING_ZETA_X
  #undef STEALTHCHOP_X
 #endif

@@ -128,8 +128,8 @@
  #undef INPUT_SHAPING_Y
  #undef QUICK_HOME
  #undef SAFE_BED_LEVELING_START_Y
-  #undef SHAPING_BUFFER_Y
  #undef SHAPING_FREQ_Y
+  #undef SHAPING_ZETA_Y
  #undef STEALTHCHOP_Y
  #undef STEP_STATE_Y
 #endif
@@ -142,8 +142,11 @@
  #undef ENABLE_LEVELING_FADE_HEIGHT
  #undef HOME_Z_FIRST
  #undef HOMING_Z_WITH_PROBE
+  #undef INPUT_SHAPING_Z
  #undef NUM_Z_STEPPERS
  #undef SAFE_BED_LEVELING_START_Z
+  #undef SHAPING_FREQ_Z
+  #undef SHAPING_ZETA_Z
  #undef STEALTHCHOP_Z
  #undef STEP_STATE_Z
  #undef Z_IDLE_HEIGHT
@@ -1185,7 +1188,7 @@
  #elif HAS_DRIVER(A4988)
    #define MINIMUM_STEPPER_POST_DIR_DELAY 200
  #elif HAS_TRINAMIC_CONFIG || HAS_TRINAMIC_STANDALONE
-    #define MINIMUM_STEPPER_POST_DIR_DELAY 70
+    #define MINIMUM_STEPPER_POST_DIR_DELAY 100
  #else
    #define MINIMUM_STEPPER_POST_DIR_DELAY 0   // Expect at least 10µS since one Stepper ISR must transpire
  #endif
@@ -1311,7 +1314,8 @@
 * currently HAL.h must be included ahead of pins.h.
 */
 #if LCD_IS_SERIAL_HOST && !defined(LCD_SERIAL_PORT)
-  #if MB(MKS_MONSTER8_V1, BTT_SKR_MINI_E3_V1_0, BTT_SKR_MINI_E3_V1_2, BTT_SKR_MINI_E3_V2_0, BTT_SKR_MINI_E3_V3_0, BTT_SKR_MINI_E3_V3_0_1, BTT_SKR_E3_TURBO, BTT_OCTOPUS_V1_1, AQUILA_V101)
+  #if MB(MKS_MONSTER8_V1, BTT_SKR_MINI_E3_V1_0, BTT_SKR_MINI_E3_V1_2, BTT_SKR_MINI_E3_V2_0, BTT_SKR_MINI_E3_V3_0, BTT_SKR_MINI_E3_V3_0_1, BTT_SKR_E3_TURBO, BTT_OCTOPUS_V1_1, BTT_SKR_V3_0, BTT_SKR_V3_0_EZ, AQUILA_V101)
+
    #define LCD_SERIAL_PORT 1
  #elif MB(CREALITY_V24S1_301, CREALITY_V24S1_301F4, CREALITY_F401RE, CREALITY_V423, CREALITY_CR4NTXXC10, MKS_ROBIN, PANOWIN_CUTLASS, KODAMA_BARDO)
    #define LCD_SERIAL_PORT 2
@@ -1337,7 +1341,7 @@
 #endif

 // Input shaping
-#if ANY(INPUT_SHAPING_X, INPUT_SHAPING_Y)
+#if ANY(INPUT_SHAPING_X, INPUT_SHAPING_Y, INPUT_SHAPING_Z)
  #define HAS_ZV_SHAPING 1
 #endif

@@ -2814,7 +2814,7 @@
 #if PIN_EXISTS(DIGIPOTSS)
  #define HAS_MOTOR_CURRENT_SPI 1
 #endif
-#if HAS_EXTRUDERS && PIN_EXISTS(MOTOR_CURRENT_PWM_E)
+#if ANY_PIN(MOTOR_CURRENT_PWM_E, MOTOR_CURRENT_PWM_E0, MOTOR_CURRENT_PWM_E1)
  #define HAS_MOTOR_CURRENT_PWM_E 1
 #endif
 #if HAS_MOTOR_CURRENT_PWM_E || ANY_PIN(MOTOR_CURRENT_PWM_X, MOTOR_CURRENT_PWM_Y, MOTOR_CURRENT_PWM_XY, MOTOR_CURRENT_PWM_Z, MOTOR_CURRENT_PWM_I, MOTOR_CURRENT_PWM_J, MOTOR_CURRENT_PWM_K, MOTOR_CURRENT_PWM_U, MOTOR_CURRENT_PWM_V, MOTOR_CURRENT_PWM_W)
@@ -2902,7 +2902,7 @@
  #define HAS_TEMPERATURE 1
 #endif

-#if HAS_TEMPERATURE && ANY(HAS_MARLINUI_MENU, HAS_DWIN_E3V2, HAS_DGUS_LCD_CLASSIC, DGUS_LCD_UI_CREALITY_TOUCH)
+#if HAS_TEMPERATURE && ANY(HAS_MARLINUI_MENU, HAS_DWIN_E3V2, HAS_DGUS_LCD_CLASSIC)
  #ifdef PREHEAT_10_LABEL
    #define PREHEAT_COUNT 10
  #elif defined(PREHEAT_9_LABEL)
@@ -52,8 +52,6 @@
  #include HAL_PATH(.., inc/Conditionals_type.h)

  #include "Changes.h"
-  #include "SanityCheck.h"
-  #include HAL_PATH(.., inc/SanityCheck.h)

  // Include all core headers
  #include "../core/language.h"
@@ -65,3 +63,8 @@
 #endif

 #include "../core/multi_language.h"
+
+#ifndef __MARLIN_DEPS__
+  #include "SanityCheck.h"
+  #include HAL_PATH(.., inc/SanityCheck.h)
+#endif
@@ -388,8 +388,8 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
 /**
 * Custom Boot and Status screens
 */
-#if ENABLED(SHOW_CUSTOM_BOOTSCREEN) && NONE(HAS_MARLINUI_U8GLIB, TOUCH_UI_FTDI_EVE, IS_DWIN_MARLINUI)
-  #error "SHOW_CUSTOM_BOOTSCREEN requires Graphical LCD or TOUCH_UI_FTDI_EVE."
+#if ENABLED(SHOW_CUSTOM_BOOTSCREEN) && NONE(HAS_MARLINUI_HD44780, HAS_MARLINUI_U8GLIB, TOUCH_UI_FTDI_EVE, IS_DWIN_MARLINUI)
+  #error "SHOW_CUSTOM_BOOTSCREEN requires Character LCD, Graphical LCD, or TOUCH_UI_FTDI_EVE."
 #elif ENABLED(SHOW_CUSTOM_BOOTSCREEN) && DISABLED(SHOW_BOOTSCREEN)
  #error "SHOW_CUSTOM_BOOTSCREEN requires SHOW_BOOTSCREEN."
 #elif ENABLED(CUSTOM_STATUS_SCREEN_IMAGE) && !HAS_MARLINUI_U8GLIB
@@ -541,71 +541,10 @@ 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 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 ... }."
+  #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");
  #endif
 #endif

@@ -1597,17 +1536,18 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
 #endif

 #if ENABLED(LCD_BED_TRAMMING)
-  #if ENABLED(BED_TRAMMING_USE_PROBE)
+  #ifndef BED_TRAMMING_INSET_LFRB
+    #error "LCD_BED_TRAMMING requires BED_TRAMMING_INSET_LFRB values."
+  #elif 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
+  static_assert(BED_TRAMMING_Z_HOP >= 0, "BED_TRAMMING_Z_HOP must be >= 0.");
+#elif ANY(DGUS_LCD_UI_RELOADED, DGUS_LCD_UI_E3S1PRO)
+  #error "LCD_BED_TRAMMING is required for the selected display."
 #endif

 /**
@@ -2707,7 +2647,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, DGUS_LCD_UI_CREALITY_TOUCH) \
+  + COUNT_ENABLED(DWIN_CREALITY_LCD, DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI, DWIN_MARLINUI_PORTRAIT, DWIN_MARLINUI_LANDSCAPE) \
  + 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) \
@@ -2763,6 +2703,28 @@ static_assert(NUM_SERVOS <= NUM_SERVO_PLUGS, "NUM_SERVOS (or some servo index) i
 #undef IS_U8GLIB_SSD1306
 #undef IS_EXTUI

+/**
+ * Make sure LCD language settings are distinct
+ */
+#if NUM_LANGUAGES > 1
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_2), STRINGIFY(LCD_LANGUAGE)), "Error: LCD_LANGUAGE_2 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE.");
+#endif
+#if NUM_LANGUAGES > 2
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_3), STRINGIFY(LCD_LANGUAGE)), "Error: LCD_LANGUAGE_3 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE.");
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_3), STRINGIFY(LCD_LANGUAGE_2)), "Error: LCD_LANGUAGE_3 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE_2.");
+#endif
+#if NUM_LANGUAGES > 3
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_4), STRINGIFY(LCD_LANGUAGE)), "Error: LCD_LANGUAGE_4 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE.");
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_4), STRINGIFY(LCD_LANGUAGE_2)), "Error: LCD_LANGUAGE_4 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE_2.");
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_4), STRINGIFY(LCD_LANGUAGE_3)), "Error: LCD_LANGUAGE_4 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE_3.");
+#endif
+#if NUM_LANGUAGES > 4
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_5), STRINGIFY(LCD_LANGUAGE)), "Error: LCD_LANGUAGE_5 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE.");
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_5), STRINGIFY(LCD_LANGUAGE_2)), "Error: LCD_LANGUAGE_5 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE_2.");
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_5), STRINGIFY(LCD_LANGUAGE_3)), "Error: LCD_LANGUAGE_5 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE_3.");
+  static_assert(strcmp(STRINGIFY(LCD_LANGUAGE_5), STRINGIFY(LCD_LANGUAGE_4)), "Error: LCD_LANGUAGE_5 (" STRINGIFY(LCD_LANGUAGE) ") cannot be the same as LCD_LANGUAGE_4.");
+#endif
+
 #if ANY(TFT_GENERIC, MKS_TS35_V2_0, MKS_ROBIN_TFT24, MKS_ROBIN_TFT28, MKS_ROBIN_TFT32, MKS_ROBIN_TFT35, MKS_ROBIN_TFT43, MKS_ROBIN_TFT_V1_1R, \
        TFT_TRONXY_X5SA, ANYCUBIC_TFT35, ANYCUBIC_TFT35, LONGER_LK_TFT28, ANET_ET4_TFT28, ANET_ET5_TFT35, BIQU_BX_TFT70, BTT_TFT35_SPI_V1_0)
  #if NONE(TFT_COLOR_UI, TFT_CLASSIC_UI, TFT_LVGL_UI)
@@ -3635,9 +3597,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."
@@ -4246,7 +4208,12 @@ static_assert(_PLUS_TEST(3), "DEFAULT_MAX_ACCELERATION values must be positive."
 */
 #if HAS_ZV_SHAPING
  #if ENABLED(DELTA)
-    #error "Input Shaping is not compatible with DELTA kinematics."
+    #if !ALL(INPUT_SHAPING_X, INPUT_SHAPING_Y, INPUT_SHAPING_Z)
+      #error "INPUT_SHAPING_X, INPUT_SHAPING_Y and INPUT_SHAPING_Z must all be enabled for DELTA."
+    #else
+      static_assert(SHAPING_FREQ_X == SHAPING_FREQ_Y && SHAPING_FREQ_Y == SHAPING_FREQ_Z, "SHAPING_FREQ_X, SHAPING_FREQ_Y and SHAPING_FREQ_Z must be the same for DELTA.");
+      static_assert(SHAPING_ZETA_X == SHAPING_ZETA_Y && SHAPING_ZETA_Y == SHAPING_ZETA_Z, "SHAPING_ZETA_X, SHAPING_ZETA_Y and SHAPING_ZETA_Z must be the same for DELTA.");
+    #endif
  #elif ENABLED(SCARA)
    #error "Input Shaping is not compatible with SCARA kinematics."
  #elif ENABLED(TPARA)
@@ -4258,9 +4225,19 @@ static_assert(_PLUS_TEST(3), "DEFAULT_MAX_ACCELERATION values must be positive."
  #elif ENABLED(DIRECT_STEPPING)
    #error "Input Shaping is not compatible with DIRECT_STEPPING."
  #elif ALL(INPUT_SHAPING_X, CORE_IS_XZ)
-    #error "INPUT_SHAPING_X is not supported with COREXZ."
+    #if !ALL(INPUT_SHAPING_X, INPUT_SHAPING_Z)
+      #error "INPUT_SHAPING_X and INPUT_SHAPING_Z must both be enabled for COREXZ."
+    #else
+      static_assert(SHAPING_FREQ_X == SHAPING_FREQ_Z, "SHAPING_FREQ_X and SHAPING_FREQ_Z must be the same for COREXZ.");
+      static_assert(SHAPING_ZETA_X == SHAPING_ZETA_Z, "SHAPING_ZETA_X and SHAPING_ZETA_Z must be the same for COREXZ.");
+    #endif
  #elif ALL(INPUT_SHAPING_Y, CORE_IS_YZ)
-    #error "INPUT_SHAPING_Y is not supported with COREYZ."
+    #if !ALL(INPUT_SHAPING_Y, INPUT_SHAPING_Z)
+      #error "INPUT_SHAPING_Y and INPUT_SHAPING_Z must both be enabled for COREYZ."
+    #else
+      static_assert(SHAPING_FREQ_Y == SHAPING_FREQ_Z, "SHAPING_FREQ_Y and SHAPING_FREQ_Z must be the same for COREYZ.");
+      static_assert(SHAPING_ZETA_Y == SHAPING_ZETA_Z, "SHAPING_ZETA_Y and SHAPING_ZETA_Z must be the same for COREYZ.");
+    #endif
  #elif ANY(CORE_IS_XY, MARKFORGED_XY, MARKFORGED_YX)
    #if !ALL(INPUT_SHAPING_X, INPUT_SHAPING_Y)
      #error "INPUT_SHAPING_X and INPUT_SHAPING_Y must both be enabled for COREXY, COREYX, or MARKFORGED_*."
@@ -4275,6 +4252,7 @@ static_assert(_PLUS_TEST(3), "DEFAULT_MAX_ACCELERATION values must be positive."
  #else
    TERN_(INPUT_SHAPING_X, static_assert((SHAPING_FREQ_X) > 0, "SHAPING_FREQ_X must be > 0 or SHAPING_MIN_FREQ must be set."));
    TERN_(INPUT_SHAPING_Y, static_assert((SHAPING_FREQ_Y) > 0, "SHAPING_FREQ_Y must be > 0 or SHAPING_MIN_FREQ must be set."));
+    TERN_(INPUT_SHAPING_Z, static_assert((SHAPING_FREQ_Z) > 0, "SHAPING_FREQ_Z must be > 0 or SHAPING_MIN_FREQ must be set."));
  #endif
  #ifdef __AVR__
    #if ENABLED(INPUT_SHAPING_X)
@@ -4291,6 +4269,13 @@ static_assert(_PLUS_TEST(3), "DEFAULT_MAX_ACCELERATION values must be positive."
        static_assert((SHAPING_FREQ_Y) == 0 || (SHAPING_FREQ_Y) * 2 * 0x10000 >= (STEPPER_TIMER_RATE), "SHAPING_FREQ_Y is below the minimum (16) for AVR 16MHz.");
      #endif
    #endif
+    #if ENABLED(INPUT_SHAPING_Z)
+      #if F_CPU > 16000000
+        static_assert((SHAPING_FREQ_Z) == 0 || (SHAPING_FREQ_Z) * 2 * 0x10000 >= (STEPPER_TIMER_RATE), "SHAPING_FREQ_Z is below the minimum (20) for AVR 20MHz.");
+      #else
+        static_assert((SHAPING_FREQ_Z) == 0 || (SHAPING_FREQ_Z) * 2 * 0x10000 >= (STEPPER_TIMER_RATE), "SHAPING_FREQ_Z is below the minimum (16) for AVR 16MHz.");
+      #endif
+    #endif
  #endif
 #endif

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

 /**
@@ -99,8 +99,8 @@
  #warning "Warning! Don't use dummy thermistors (998/999) for final build!"
 #endif

-#if NONE(HAS_RESUME_CONTINUE, HOST_PROMPT_SUPPORT, UNIT_TEST)
-  #warning "Your Configuration provides no method to acquire user feedback!"
+#if NONE(HAS_RESUME_CONTINUE, HOST_PROMPT_SUPPORT, UNIT_TEST, NO_USER_FEEDBACK_WARNING)
+  #warning "Your Configuration provides no method to acquire user feedback! (Define NO_USER_FEEDBACK_WARNING to suppress this warning.)"
 #endif

 #if MB(DUE3DOM_MINI) && PIN_EXISTS(TEMP_2) && !TEMP_SENSOR_BOARD
@@ -690,8 +690,12 @@
  #warning "To prevent step loss, motion will pause for PRINTCOUNTER auto-save."
 #endif

-#if HOMING_Z_WITH_PROBE && IS_CARTESIAN && DISABLED(Z_SAFE_HOMING)
-  #error "Z_SAFE_HOMING is recommended when homing with a probe. Enable Z_SAFE_HOMING or comment out this line to continue."
+#if HOMING_Z_WITH_PROBE && IS_CARTESIAN && NONE(Z_SAFE_HOMING, NO_Z_SAFE_HOMING_WARNING)
+  #error "Z_SAFE_HOMING is recommended when homing with a probe. (Enable Z_SAFE_HOMING or define NO_Z_SAFE_HOMING_WARNING to suppress this warning.)"
+#endif
+
+#if ENABLED(BIQU_MICROPROBE_V2) && NONE(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN, NO_MICROPROBE_WARNING)
+  #warning "BIQU MicroProbe V2 detect signal requires a strong pull-up. Some processors have weak internal pull-up capabilities, so we recommended connecting MicroProbe SIGNAL / GND to Z-MIN / Z-STOP instead of the dedicated PROBE port. (Define NO_MICROPROBE_WARNING to suppress this warning.)"
 #endif

 //
@@ -714,8 +718,8 @@
  #warning "Disabled CONFIGURATION_EMBEDDING because the target usually has less flash storage. Define FORCE_CONFIG_EMBED to override."
 #endif

-#if HAS_LCD_CONTRAST && LCD_CONTRAST_MIN >= LCD_CONTRAST_MAX
-  #warning "Contrast cannot be changed when LCD_CONTRAST_MIN >= LCD_CONTRAST_MAX."
+#if HAS_LCD_CONTRAST && LCD_CONTRAST_MIN >= LCD_CONTRAST_MAX && DISABLED(NO_LCD_CONTRAST_WARNING)
+  #warning "Contrast cannot be changed when LCD_CONTRAST_MIN >= LCD_CONTRAST_MAX. (Define NO_LCD_CONTRAST_WARNING to suppress this warning.)"
 #endif

 #if PROGRESS_MSG_EXPIRE > 0 && HAS_STATUS_MESSAGE_TIMEOUT
@@ -784,8 +788,13 @@
 /**
 * Input Shaping
 */
-#if HAS_ZV_SHAPING && ANY(CORE_IS_XY, MARKFORGED_XY, MARKFORGED_YX)
-  #warning "Input Shaping for CORE / MARKFORGED kinematic axes is still experimental."
+#if HAS_ZV_SHAPING
+  #if ANY(CORE_IS_XY, MARKFORGED_XY, MARKFORGED_YX)
+    #warning "Input Shaping for CORE / MARKFORGED kinematic axes is still experimental."
+  #endif
+  #if ENABLED(I2S_STEPPER_STREAM)
+    #warning "Input Shaping has not been tested with I2S_STEPPER_STREAM."
+  #endif
 #endif

 /**
@@ -860,3 +869,10 @@
 #if DISABLED(EDITABLE_STEPS_PER_UNIT)
  #warning "EDITABLE_STEPS_PER_UNIT is required to enable G92 runtime configuration of steps-per-unit."
 #endif
+
+/**
+ * HC32 clock speed is hard-coded in Marlin
+ */
+#if defined(ARDUINO_ARCH_HC32) && F_CPU == 200000000
+  #warning "HC32 clock is assumed to be 200MHz. If this isn't the case for your board please submit a report so we can add support."
+#endif
@@ -331,15 +331,24 @@ void MarlinUI::set_custom_characters(const HD44780CharSet screen_charset/*=CHARS

  #endif // HAS_MEDIA

-  #if ENABLED(SHOW_BOOTSCREEN)
-    // Set boot screen corner characters
-    if (screen_charset == CHARSET_BOOT) {
-      for (uint8_t i = 4; i--;)
-        createChar_P(i, corner[i]);
-    }
-    else
-  #endif
-    { // Info Screen uses 5 special characters
+  switch (screen_charset) {
+
+    #if ENABLED(SHOW_BOOTSCREEN)
+      case CHARSET_BOOT: {
+        // Set boot screen corner characters
+        for (uint8_t i = 4; i--;) createChar_P(i, corner[i]);
+      } break;
+    #endif
+
+    #if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
+      case CHARSET_BOOT_CUSTOM: {
+        for (uint8_t i = COUNT(customBootChars); i--;)
+          createChar_P(i, customBootChars[i]);
+      } break;
+    #endif
+
+    default: {
+      // Info Screen uses 5 special characters
      createChar_P(LCD_STR_BEDTEMP[0], bedTemp);
      createChar_P(LCD_STR_DEGREE[0], degree);
      createChar_P(LCD_STR_THERMOMETER[0], thermometer);
@@ -361,7 +370,9 @@ void MarlinUI::set_custom_characters(const HD44780CharSet screen_charset/*=CHARS
            createChar_P(LCD_STR_FOLDER[0], folder);
          #endif
        }
-    }
+    } break;
+
+  }

 }

@@ -400,6 +411,42 @@ bool MarlinUI::detected() {
  return TERN1(DETECT_I2C_LCD_DEVICE, lcd.LcdDetected() == 1);
 }

+#if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
+
+  #ifndef CUSTOM_BOOTSCREEN_X
+    #define CUSTOM_BOOTSCREEN_X -1
+  #endif
+  #ifndef CUSTOM_BOOTSCREEN_Y
+    #define CUSTOM_BOOTSCREEN_Y ((LCD_HEIGHT - COUNT(custom_boot_lines)) / 2)
+  #endif
+  #ifndef CUSTOM_BOOTSCREEN_TIMEOUT
+    #define CUSTOM_BOOTSCREEN_TIMEOUT 2500
+  #endif
+
+  void MarlinUI::draw_custom_bootscreen(const uint8_t/*=0*/) {
+    set_custom_characters(CHARSET_BOOT_CUSTOM);
+    lcd.clear();
+    const int8_t sx = CUSTOM_BOOTSCREEN_X;
+    const uint8_t sy = CUSTOM_BOOTSCREEN_Y;
+    for (lcd_uint_t i = 0; i < COUNT(custom_boot_lines); ++i) {
+      PGM_P const pstr = (PGM_P)pgm_read_ptr(&custom_boot_lines[i]);
+      const uint8_t clen = utf8_strlen_P(pstr);
+      const lcd_uint_t x = sx >= 0 ? sx : (LCD_WIDTH - clen) / 2;
+      for (lcd_uint_t j = 0; j < clen; ++j) {
+        const lchar_t c = pgm_read_byte(&pstr[j]);
+        lcd_put_lchar(x + j, sy + i, c == '\x08' ? '\x00' : c);
+      }
+    }
+  }
+
+  // Shows the custom bootscreen and delays
+  void MarlinUI::show_custom_bootscreen() {
+    draw_custom_bootscreen();
+    safe_delay(CUSTOM_BOOTSCREEN_TIMEOUT);
+  }
+
+#endif // SHOW_CUSTOM_BOOTSCREEN
+
 #if HAS_SLOW_BUTTONS
  uint8_t MarlinUI::read_slow_buttons() {
    #if ENABLED(LCD_I2C_TYPE_MCP23017)
@@ -466,6 +513,8 @@ void MarlinUI::clear_lcd() { lcd.clear(); }
  }

  void MarlinUI::show_bootscreen() {
+    TERN_(SHOW_CUSTOM_BOOTSCREEN, show_custom_bootscreen());
+
    set_custom_characters(CHARSET_BOOT);
    lcd.clear();

@@ -660,9 +709,6 @@ FORCE_INLINE void _draw_bed_status(const bool blink) {
      lcd_put_u8str(F("K"));
    #else
      lcd_put_u8str(cutter_power2str(cutter.unitPower));
-      #if CUTTER_UNIT_IS(PERCENT)
-        lcd_put_u8str(F("%"));
-      #endif
    #endif

    lcd_put_u8str(F(" "));
@@ -27,6 +27,20 @@

 #include "../../inc/MarlinConfig.h"

+#if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
+
+  #include "../../../_Bootscreen.h"
+
+  #ifdef CUSTOM_BOOTSCREEN_Y
+    #define CUSTOM_BOOT_LAST COUNT(custom_boot_lines) + CUSTOM_BOOTSCREEN_Y
+  #else
+    #define CUSTOM_BOOT_LAST COUNT(custom_boot_lines)
+  #endif
+
+  static_assert(CUSTOM_BOOT_LAST <= LCD_HEIGHT, "custom_boot_lines (plus CUSTOM_BOOTSCREEN_Y) doesn't fit on the selected LCD.");
+
+#endif
+
 #if ENABLED(LCD_I2C_TYPE_PCF8575)

  // NOTE: These are register-mapped pins on the PCF8575 controller, not Arduino pins.
@@ -24,9 +24,9 @@
 #include "../inc/MarlinConfig.h"

 #if ((!HAS_ADC_BUTTONS && IS_NEWPANEL) || BUTTONS_EXIST(EN1, EN2)) && !IS_TFTGLCD_PANEL
-  #define HAS_ENCODER_WHEEL 1
+  #define HAS_MARLINUI_ENCODER 1
 #endif
-#if (HAS_ENCODER_WHEEL || ANY_BUTTON(ENC, BACK, UP, DOWN, LEFT, RIGHT)) && DISABLED(TOUCH_UI_FTDI_EVE)
+#if (HAS_MARLINUI_ENCODER || ANY_BUTTON(ENC, BACK, UP, DOWN, LEFT, RIGHT)) && DISABLED(TOUCH_UI_FTDI_EVE)
  #define HAS_DIGITAL_BUTTONS 1
 #endif
 #if !HAS_ADC_BUTTONS && (IS_RRW_KEYPAD || (HAS_WIRED_LCD && !IS_NEWPANEL))
@@ -377,10 +377,10 @@ 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*/) { 
+  void MarlinUI::sleep_display(const bool sleep/*=true*/) {
    static bool asleep = false;
    if (asleep != sleep){
-      sleep ? u8g.sleepOn() : u8g.sleepOff(); 
+      sleep ? u8g.sleepOn() : u8g.sleepOff();
      asleep = sleep;
    }
  }
@@ -42,10 +42,6 @@

 #include <stdlib.h>

-#ifndef ENCODER_PULSES_PER_STEP
-  #define ENCODER_PULSES_PER_STEP 4
-#endif
-
 EncoderRate encoderRate;

 // TODO: Replace with ui.quick_feedback
@@ -53,32 +49,12 @@ void Encoder_tick() {
  TERN_(HAS_BEEPER, if (ui.sound_on) buzzer.click(10));
 }

-// Encoder initialization
-void encoderConfiguration() {
-  #if BUTTON_EXISTS(EN1)
-    SET_INPUT_PULLUP(BTN_EN1);
-  #endif
-  #if BUTTON_EXISTS(EN2)
-    SET_INPUT_PULLUP(BTN_EN2);
-  #endif
-  #if BUTTON_EXISTS(ENC)
-    SET_INPUT_PULLUP(BTN_ENC);
-  #endif
-  #if HAS_BEEPER
-    SET_OUTPUT(BEEPER_PIN);     // TODO: Use buzzer.h which already inits this
-  #endif
-}
-
 // Analyze encoder value and return state
 EncoderState encoderReceiveAnalyze() {
  const millis_t now = millis();
-  static uint8_t lastEncoderBits;
-  uint8_t newbutton = 0;
-  static signed char temp_diff = 0;
+  static int8_t temp_diff = 0; // Cleared on each full step, as configured

  EncoderState temp_diffState = ENCODER_DIFF_NO;
-  if (BUTTON_PRESSED(EN1)) newbutton |= EN_A;
-  if (BUTTON_PRESSED(EN2)) newbutton |= EN_B;
  if (BUTTON_PRESSED(ENC)) {
    static millis_t next_click_update_ms;
    if (ELAPSED(now, next_click_update_ms)) {
@@ -98,71 +74,47 @@ EncoderState encoderReceiveAnalyze() {
    }
    else return ENCODER_DIFF_NO;
  }
-  if (newbutton != lastEncoderBits) {
-    switch (newbutton) {
-      case 0:
-             if (lastEncoderBits == 1) temp_diff++;
-        else if (lastEncoderBits == 2) temp_diff--;
-        break;
-      case 2:
-             if (lastEncoderBits == 0) temp_diff++;
-        else if (lastEncoderBits == 3) temp_diff--;
-        break;
-      case 3:
-             if (lastEncoderBits == 2) temp_diff++;
-        else if (lastEncoderBits == 1) temp_diff--;
-        break;
-      case 1:
-             if (lastEncoderBits == 3) temp_diff++;
-        else if (lastEncoderBits == 0) temp_diff--;
-        break;
-    }
-    lastEncoderBits = newbutton;
-  }

-  if (ABS(temp_diff) >= ENCODER_PULSES_PER_STEP) {
-    if (temp_diff > 0) temp_diffState = TERN(REVERSE_ENCODER_DIRECTION, ENCODER_DIFF_CCW, ENCODER_DIFF_CW);
-    else temp_diffState = TERN(REVERSE_ENCODER_DIRECTION, ENCODER_DIFF_CW, ENCODER_DIFF_CCW);
+  temp_diff += ui.get_encoder_delta();
+
+  const int8_t abs_diff = ABS(temp_diff);
+  if (abs_diff >= ENCODER_PULSES_PER_STEP) {
+    temp_diffState = temp_diff > 0
+      ? TERN(REVERSE_ENCODER_DIRECTION, ENCODER_DIFF_CCW, ENCODER_DIFF_CW)
+      : TERN(REVERSE_ENCODER_DIRECTION, ENCODER_DIFF_CW,  ENCODER_DIFF_CCW);
+
+    int32_t encoder_multiplier = 1;

    #if ENABLED(ENCODER_RATE_MULTIPLIER)

-      millis_t ms = millis();
-      int32_t encoder_multiplier = 1;
+      const millis_t ms = millis();

-      // if must encoder rati multiplier
+      // Encoder rate multiplier
      if (encoderRate.enabled) {
-        const float abs_diff = ABS(temp_diff),
-                    encoderMovementSteps = abs_diff / (ENCODER_PULSES_PER_STEP);
-        if (encoderRate.lastEncoderTime) {
-          // Note that the rate is always calculated between two passes through the
-          // loop and that the abs of the temp_diff value is tracked.
-          const float encoderStepRate = encoderMovementSteps / float(ms - encoderRate.lastEncoderTime) * 1000;
-          if (ENCODER_100X_STEPS_PER_SEC > 0 && encoderStepRate >= ENCODER_100X_STEPS_PER_SEC)
-            encoder_multiplier = 100;
-          else if (ENCODER_10X_STEPS_PER_SEC > 0 && encoderStepRate >= ENCODER_10X_STEPS_PER_SEC)
-            encoder_multiplier = 10;
-          else if (ENCODER_5X_STEPS_PER_SEC > 0 && encoderStepRate >= ENCODER_5X_STEPS_PER_SEC)
-            encoder_multiplier = 5;
-        }
+        // Note that the rate is always calculated between two passes through the
+        // loop and that the abs of the temp_diff value is tracked.
+        const float encoderStepRate = ((float(abs_diff) / float(ENCODER_PULSES_PER_STEP)) * 1000.0f) / float(ms - encoderRate.lastEncoderTime);
        encoderRate.lastEncoderTime = ms;
+        if (ENCODER_100X_STEPS_PER_SEC > 0 && encoderStepRate >= ENCODER_100X_STEPS_PER_SEC)
+          encoder_multiplier = 100;
+        else if (ENCODER_10X_STEPS_PER_SEC > 0 && encoderStepRate >= ENCODER_10X_STEPS_PER_SEC)
+          encoder_multiplier = 10;
+        else if (ENCODER_5X_STEPS_PER_SEC > 0 && encoderStepRate >= ENCODER_5X_STEPS_PER_SEC)
+          encoder_multiplier = 5;
      }

-    #else
-
-      constexpr int32_t encoder_multiplier = 1;
-
    #endif

-    // encoderRate.encoderMoveValue += (temp_diff * encoder_multiplier) / (ENCODER_PULSES_PER_STEP);
-    encoderRate.encoderMoveValue = (temp_diff * encoder_multiplier) / (ENCODER_PULSES_PER_STEP);
-    if (encoderRate.encoderMoveValue < 0) encoderRate.encoderMoveValue = -encoderRate.encoderMoveValue;
+    encoderRate.encoderMoveValue = abs_diff * encoder_multiplier / (ENCODER_PULSES_PER_STEP);

    temp_diff = 0;
  }
+
  if (temp_diffState != ENCODER_DIFF_NO) {
    TERN_(HAS_BACKLIGHT_TIMEOUT, ui.refresh_backlight_timeout());
    if (!ui.backlight) ui.refresh_brightness();
  }
+
  return temp_diffState;
 }

@@ -47,9 +47,6 @@ typedef enum {

 #define ENCODER_WAIT_MS TERN(DWIN_LCD_PROUI, 10, 20)

-// Encoder initialization
-void encoderConfiguration();
-
 // Analyze encoder value and return state
 EncoderState encoderReceiveAnalyze();

@@ -2950,11 +2950,7 @@ void hmiControl() {
  void hmiLeveling() {
    popupWindowLeveling();
    dwinUpdateLCD();
-    #if defined(MAIN_MENU_ITEM_1_GCODE)
-      queue.inject(F(MAIN_MENU_ITEM_1_GCODE));
-    #else
-      queue.inject(F("G28O\nG29\nG28\nG1Z0"));
-    #endif
+    queue.inject(F("G28O\nG29"));
  }
 #endif

@@ -4072,8 +4068,8 @@ void hmiInit() {
  hmiSDCardInit();

  for (uint16_t t = 0; t <= 100; t += 2) {
-    dwinIconShow(ICON, ICON_Bar, 15, 450);
-    dwinDrawRectangle(1, COLOR_BG_BLACK, 15 + t * 242 / 100, 450, 257, 470);
+    dwinIconShow(ICON, ICON_Bar, 15, 260);
+    dwinDrawRectangle(1, COLOR_BG_BLACK, 15 + t * 242 / 100, 260, 257, 280);
    dwinUpdateLCD();
    delay(20);
  }
@@ -4082,7 +4078,6 @@ void hmiInit() {
 }

 void dwinInitScreen() {
-  encoderConfiguration();
  hmiInit();
  hmiSetLanguageCache();
  hmiStartFrame(true);
@@ -5143,7 +5143,6 @@ void MarlinUI::init_lcd() {
  if (dwinHandshake()) SERIAL_ECHOLNPGM("ok."); else SERIAL_ECHOLNPGM("error.");
  dwinFrameSetDir(1); // Orientation 90°
  dwinUpdateLCD();     // Show bootscreen (first image)
-  encoderConfiguration();
  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);
@@ -48,7 +48,6 @@ void dwinStartup() {
  dwinFrameClear(COLOR_BG_BLACK); // MarlinUI handles the bootscreen so just clear here
  dwinJPGShowAndCache(3);
  dwinUpdateLCD();
-  dwinJPGShowAndCache(3);
 }

 /*---------------------------------------- Picture related functions ----------------------------------------*/
@@ -108,8 +108,8 @@ void MarlinUI::clear_lcd() {
      #define INFO_CENTER ((LCD_PIXEL_WIDTH) - 200 / 2)
      #define VERSION_Y   84
    #endif
-    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()));
+
+    dwinDrawString(false, font10x20, COLOR_YELLOW, COLOR_BG_BLACK, INFO_CENTER - (dwin_string.length * 10) / 2, VERSION_Y, S(dwin_string.string()));
    TERN_(SHOW_CUSTOM_BOOTSCREEN, safe_delay(CUSTOM_BOOTSCREEN_TIMEOUT));
    clear_lcd();

@@ -22,9 +22,6 @@

 /**
 * Bed Level Tools for Pro UI
- * Extended by: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.2.0
- * Date: 2023/05/03
 *
 * Based on the original work of: Henri-J-Norden
 * https://github.com/Jyers/Marlin/pull/126
@@ -22,9 +22,6 @@

 /**
 * Bed Level Tools for Pro UI
- * Extended by: Miguel A. Risco-Castillo (MRISCOC)
- * Version: 3.2.0
- * Date: 2023/05/03
 *
 * Based on the original work of: Henri-J-Norden
 * https://github.com/Jyers/Marlin/pull/126
@@ -22,7 +22,8 @@

 /**
 * DWIN Enhanced implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.25.3
 * Date: 2023/05/18
 */
@@ -37,6 +38,7 @@

 #include "../../utf8.h"
 #include "../../marlinui.h"
+#include "../../extui/ui_api.h"
 #include "../../../MarlinCore.h"
 #include "../../../core/serial.h"
 #include "../../../core/macros.h"
@@ -199,7 +201,7 @@ typedef struct {
 } select_t;
 select_t select_page{0}, select_print{0};

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

@@ -1311,7 +1313,7 @@ void eachMomentUpdate() {
          TERN_(PIDTEMP, if (hmiValue.tempControl == PIDTEMP_START) { plot.update(thermalManager.wholeDegHotend(0)); })
          TERN_(PIDTEMPBED, if (hmiValue.tempControl == PIDTEMPBED_START) { plot.update(thermalManager.wholeDegBed()); })
          TERN_(PIDTEMPCHAMBER, if (hmiValue.tempControl == PIDTEMPCHAMBER_START) { plot.update(thermalManager.wholeDegChamber()); })
-          TERN_(MPCTEMP, if (hmiValue.tempControl == MPCTEMP_START) { plot.update(thermalManager.wholeDegHotend(0)); })
+          TERN_(MPCTEMP, if (hmiValue.tempControl == MPC_STARTED) { plot.update(thermalManager.wholeDegHotend(0)); })
          if (hmiFlag.abort_flag || hmiFlag.pause_flag || print_job_timer.isPaused()) {
            hmiReturnScreen();
          }
@@ -1566,7 +1568,7 @@ void dwinLevelingDone() {
    switch (hmiValue.tempControl) {
      default: return;
      #if ENABLED(MPC_AUTOTUNE)
-        case MPCTEMP_START:
+        case MPC_STARTED:
          DWINUI::drawCenteredString(hmiData.colorPopupTxt, 70, GET_TEXT_F(MSG_MPC_AUTOTUNE));
          DWINUI::drawString(hmiData.colorPopupTxt, gfrm.x, gfrm.y - DWINUI::fontHeight() - 4, F("MPC target:     Celsius"));
          DWINUI::drawCenteredString(hmiData.colorPopupTxt, 92, GET_TEXT_F(MSG_PID_FOR_NOZZLE));
@@ -1619,7 +1621,7 @@ void dwinLevelingDone() {

      switch (result) {
        #if ENABLED(MPCTEMP)
-          case MPCTEMP_START:
+          case MPC_STARTED:
        #elif ENABLED(PIDTEMP)
          case PIDTEMP_START:
        #endif
@@ -1655,7 +1657,7 @@ void dwinLevelingDone() {

    void drawHPlot() {
      TERN_(PIDTEMP, dwinDrawPlot(PIDTEMP_START));
-      TERN_(MPCTEMP, dwinDrawPlot(MPCTEMP_START));
+      TERN_(MPCTEMP, dwinDrawPlot(MPC_STARTED));
    }
    void drawBPlot() {
      TERN_(PIDTEMPBED, dwinDrawPlot(PIDTEMPBED_START));
@@ -1741,7 +1743,7 @@ void dwinLevelingDone() {
  void dwinMPCTuning(tempcontrol_t result) {
    hmiValue.tempControl = result;
    switch (result) {
-      case MPCTEMP_START:
+      case MPC_STARTED:
        hmiSaveProcessID(ID_MPCProcess);
        #if PROUI_TUNING_GRAPH
          dwinDrawPIDMPCPopup();
@@ -1909,7 +1911,6 @@ void MarlinUI::init_lcd() {
  const bool hs = dwinHandshake(); UNUSED(hs);
  dwinFrameSetDir(1);
  dwinJPGCacheTo1(Language_English);
-  encoderConfiguration();
 }

 void dwinInitScreen() {
@@ -2318,12 +2319,12 @@ void setMoveZ() { hmiValue.axis = Z_AXIS; setPFloatOnClick(Z_MIN_POS, Z_MAX_POS,
 #if HAS_FILAMENT_SENSOR
  void setRunoutEnable() {
    runout.reset();
-    runout.enabled[0] = !runout.enabled[0];
-    Draw_Chkb_Line(CurrentMenu->line(), runout.enabled[0]);
-    DWIN_UpdateLCD();
+    toggleCheckboxLine(runout.enabled);
  }
-  void ApplyRunoutDistance() { runout.set_runout_distance(MenuData.Value / MINUNITMULT); }
-  void SetRunoutDistance() { SetFloatOnClick(0, 999, UNITFDIGITS, runout.runout_distance(), ApplyRunoutDistance); }
+  #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
 #endif

 #if ENABLED(CONFIGURE_FILAMENT_CHANGE)
@@ -2388,11 +2389,6 @@ 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);
@@ -3150,7 +3146,7 @@ void drawControlMenu() {
        enableLiveCaseLightBrightness = true;  // Allow live update of brightness in control menu
        MENU_ITEM(ICON_CaseLight, MSG_CASE_LIGHT, onDrawSubMenu, drawCaseLightMenu);
      #else
-        MENU_ITEM(ICON_CaseLight, MSG_CASE_LIGHT, onDrawChkbMenu, setCaseLight, &caselight.on);
+        EDIT_ITEM(ICON_CaseLight, MSG_CASE_LIGHT, onDrawChkbMenu, setCaseLight, &caselight.on);
      #endif
    #endif
    #if ENABLED(LED_CONTROL_MENU)
@@ -3320,7 +3316,7 @@ void drawFilSetMenu() {
  if (SET_MENU(filSetMenu, MSG_FILAMENT_SET, 9)) {
    BACK_ITEM(drawAdvancedSettingsMenu);
    #if HAS_FILAMENT_SENSOR
-      EDIT_ITEM(ICON_Runout, MSG_RUNOUT_ENABLE, onDrawChkbMenu, setRunoutEnable, &runout.enabled);
+      EDIT_ITEM(ICON_Runout, MSG_RUNOUT_SENSOR, onDrawChkbMenu, setRunoutEnable, &runout.enabled);
    #endif
    #if HAS_FILAMENT_RUNOUT_DISTANCE
      EDIT_ITEM(ICON_Runout, MSG_RUNOUT_DISTANCE_MM, onDrawPFloatMenu, setRunoutDistance, &runout.runout_distance());
@@ -3411,7 +3407,7 @@ void drawTuneMenu() {
      MENU_ITEM(ICON_FilMan, MSG_FILAMENTCHANGE, onDrawMenuItem, changeFilament);
    #endif
    #if HAS_FILAMENT_SENSOR
-      EDIT_ITEM(ICON_Runout, MSG_RUNOUT_ENABLE, onDrawChkbMenu, setRunoutEnable, &runout.enabled);
+      EDIT_ITEM(ICON_Runout, MSG_RUNOUT_SENSOR, onDrawChkbMenu, setRunoutEnable, &runout.enabled);
    #endif
    #if ENABLED(PROUI_ITEM_PLR)
      EDIT_ITEM(ICON_Pwrlossr, MSG_OUTAGE_RECOVERY, onDrawChkbMenu, setPwrLossr, &recovery.enabled);
@@ -3482,9 +3478,16 @@ void drawTuneMenu() {
    void setShapingYZeta() { hmiValue.axis = Y_AXIS; setFloatOnClick(0, 1, 2, stepper.get_shaping_damping_ratio(Y_AXIS), applyShapingZeta); }
  #endif

+  #if ENABLED(INPUT_SHAPING_Z)
+    void onDrawShapingZFreq(MenuItem* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, 2, stepper.get_shaping_frequency(Z_AXIS)); }
+    void onDrawShapingZZeta(MenuItem* menuitem, int8_t line) { onDrawFloatMenu(menuitem, line, 2, stepper.get_shaping_damping_ratio(Z_AXIS)); }
+    void setShapingZFreq() { hmiValue.axis = Z_AXIS; setFloatOnClick(0, 200, 2, stepper.get_shaping_frequency(Z_AXIS), applyShapingFreq); }
+    void setShapingZZeta() { hmiValue.axis = Z_AXIS; setFloatOnClick(0, 1, 2, stepper.get_shaping_damping_ratio(Z_AXIS), applyShapingZeta); }
+  #endif
+
  void drawInputShaping_menu() {
    checkkey = ID_Menu;
-    if (SET_MENU(inputShapingMenu, MSG_INPUT_SHAPING, 5)) {
+    if (SET_MENU(inputShapingMenu, MSG_INPUT_SHAPING, 1 PLUS_TERN0(INPUT_SHAPING_X, 2) PLUS_TERN0(INPUT_SHAPING_Y, 2) PLUS_TERN0(INPUT_SHAPING_Z, 2))) {
      BACK_ITEM(drawMotionMenu);
      #if ENABLED(INPUT_SHAPING_X)
        MENU_ITEM(ICON_ShapingX, MSG_SHAPING_A_FREQ, onDrawShapingXFreq, setShapingXFreq);
@@ -3494,6 +3497,10 @@ void drawTuneMenu() {
        MENU_ITEM(ICON_ShapingY, MSG_SHAPING_B_FREQ, onDrawShapingYFreq, setShapingYFreq);
        MENU_ITEM(ICON_ShapingY, MSG_SHAPING_B_ZETA, onDrawShapingYZeta, setShapingYZeta);
      #endif
+      #if ENABLED(INPUT_SHAPING_Z)
+        MENU_ITEM(ICON_ShapingZ, MSG_SHAPING_C_FREQ, onDrawShapingZFreq, setShapingZFreq);
+        MENU_ITEM(ICON_ShapingZ, MSG_SHAPING_C_ZETA, onDrawShapingZZeta, setShapingZZeta);
+      #endif
    }
    updateMenu(inputShapingMenu);
  }
@@ -23,7 +23,8 @@

 /**
 * DWIN Enhanced implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.25.3
 * Date: 2023/05/18
 */
@@ -90,7 +91,7 @@ enum processID : uint8_t {
      PID_TUNING_TIMEOUT,
    #endif
    #if ENABLED(MPC_AUTOTUNE)
-      MPCTEMP_START,
+      MPC_STARTED,
      MPC_TEMP_ERROR,
      MPC_INTERRUPTED,
    #endif
@@ -23,7 +23,8 @@

 /**
 * DWIN general defines and data structs for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.12.2
 * Date: 2022/08/08
 */
@@ -22,7 +22,8 @@

 /**
 * DWIN Enhanced implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.12.1
 * Date: 2023/01/22
 */
@@ -23,7 +23,8 @@

 /**
 * DWIN Enhanced implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.12.1
 * Date: 2023/01/22
 */
@@ -22,7 +22,8 @@

 /**
 * DWIN Enhanced implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.11.1
 * Date: 2022/02/28
 */
@@ -23,7 +23,8 @@

 /**
 * DWIN Enhanced implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.11.1
 * Date: 2022/02/28
 */
@@ -22,7 +22,8 @@

 /**
 * DWIN Enhanced implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.21.1
 * Date: 2023/03/21
 */
@@ -23,7 +23,8 @@

 /**
 * DWIN Enhanced implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 3.21.1
 * Date: 2023/03/21
 */
@@ -22,7 +22,8 @@

 /**
 * DWIN Endstops diagnostic page for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 1.4.3
 * Date: 2023/05/10
 */
@@ -85,7 +86,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) != runout.out_state());
+  TERN_(HAS_FILAMENT_SENSOR, draw_es_state(READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE));
  dwinUpdateLCD();
 }

@@ -23,7 +23,8 @@

 /**
 * DWIN End Stops diagnostic page for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 1.4.3
 * Date: 2023/05/10
 */
@@ -22,7 +22,8 @@

 /**
 * Lock screen implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 2.3.2
 * Date: 2022/11/20
 */
@@ -23,7 +23,8 @@

 /**
 * Lock screen implementation for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 2.3.2
 * Date: 2022/11/20
 */
@@ -22,7 +22,8 @@

 /**
 * Mesh Viewer for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * version: 4.2.1
 * Date: 2023/05/05
 */
@@ -23,7 +23,8 @@

 /**
 * Mesh Viewer for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * version: 4.2.1
 * Date: 2023/05/05
 */
@@ -22,7 +22,8 @@

 /**
 * Print Stats page for PRO UI
- * Author: Miguel A. Risco-Castillo (MRISCOC)
+ * Based on the original work of: Miguel Risco-Castillo (MRISCOC)
+ * https://github.com/mriscoc/Ender3V2S1
 * Version: 1.4.0
 * Date: 2022/12/03
 */
@@ -55,9 +56,9 @@ void PrintStats::draw() {
  DWINUI::drawString(MRG,  80, TS(GET_TEXT_F(MSG_INFO_PRINT_COUNT), F(": "), ps.totalPrints));
  DWINUI::drawString(MRG, 100, TS(GET_TEXT_F(MSG_INFO_COMPLETED_PRINTS), F(": "), ps.finishedPrints));
  duration_t(print_job_timer.getStats().printTime).toDigital(str, true);
-  DWINUI::drawString(MRG, 120, MString<50>(GET_TEXT_F(MSG_INFO_PRINT_TIME), F(": "), str));
+  DWINUI::drawString(MRG, 120, TS(GET_TEXT_F(MSG_INFO_PRINT_TIME), F(": "), str));
  duration_t(print_job_timer.getStats().longestPrint).toDigital(str, true);
-  DWINUI::drawString(MRG, 140, MString<50>(GET_TEXT(MSG_INFO_PRINT_LONGEST), F(": "), str));
+  DWINUI::drawString(MRG, 140, TS(GET_TEXT_F(MSG_INFO_PRINT_LONGEST), F(": "), str));
  DWINUI::drawString(MRG, 160, TS(GET_TEXT_F(MSG_INFO_PRINT_FILAMENT), F(": "), p_float_t(ps.filamentUsed / 1000, 2), F(" m")));
 }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Scott Lahteine	4d4fb0cf39	move G29 stuff to #27146	2024-06-02 14:43:22 -05:00
Scott Lahteine	81e4698097	Merge branch 'bugfix-2.1.x' into pr/26754	2024-06-02 14:26:36 -05:00
thinkyhead	95f81d2565	[cron] Bump distribution date (2024-05-29)	2024-05-29 00:26:13 +00:00
Scott Lahteine	9c922f0eab	🧑‍💻 Fix test STM32F103RC_btt_USB	2024-05-28 19:05:03 -05:00
Scott Lahteine	35a03d66e5	🔨 Update SAMD51 build deps	2024-05-28 18:49:39 -05:00
Mihai	a4a0887fa7	🐛 Fix NONE, ALL, EVAL macro collision (#27132 )	2024-05-28 18:22:39 -05:00
thinkyhead	e7c9cf3e1d	[cron] Bump distribution date (2024-05-27)	2024-05-27 00:22:53 +00:00
ellensp	6710616a09	🩹 Longer3D LK has ONBOARD_SDIO (#27129 )	2024-05-26 12:09:18 -05:00
Scott Lahteine	2064c83c66	🚸 Fix SD nav after "one click print" (2)	2024-05-26 12:04:14 -05:00
thinkyhead	2e97ad1f4b	[cron] Bump distribution date (2024-05-26)	2024-05-26 12:07:31 +00:00
Scott Lahteine	4f85f88ae3	🚸 Fix SD nav after "one click print"	2024-05-26 02:18:37 -05:00
thinkyhead	181a57ae9b	[cron] Bump distribution date (2024-05-24)	2024-05-24 00:22:18 +00:00
Keith Bennett	3ee1248cf2	🩹 Even more Z input shaper followup (#27119 ) Followup to #27118	2024-05-23 14:58:22 +12:00
thinkyhead	68c3916d46	[cron] Bump distribution date (2024-05-23)	2024-05-23 00:21:53 +00:00
Keith Bennett	e3bbacd8b9	📝 Update Input Shaping comments (#27116 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>	2024-05-22 18:30:44 -05:00
Scott Lahteine	f915371248	🧑‍💻 More language cleanup	2024-05-22 17:37:13 -05:00
Scott Lahteine	dbf0f5faec	we don't have this yet	2024-05-22 14:08:54 -05:00
Andrew	ea848aa891	🩹 Z input shaper followup (#27118 ) Followup to #27073	2024-05-22 14:07:04 -05:00
Scott Lahteine	5157849c60	🧑‍💻 Remove unused strings, label some	2024-05-22 13:07:33 -05:00
Scott Lahteine	ca31f9789e	🩹 Fix LCD getFreeTxBuffer typo	2024-05-21 19:26:18 -05:00
Scott Lahteine	78d3cf1de1	🎨 PGM => _P rename	2024-05-21 19:26:18 -05:00
Scott Lahteine	521e7eafce	🧑‍💻 Clarify media "mounted"	2024-05-21 19:26:18 -05:00
thinkyhead	2d78a80cf6	[cron] Bump distribution date (2024-05-22)	2024-05-22 00:21:43 +00:00
Scott Lahteine	cb963669db	Merge branch 'bugfix-2.1.x' into pr/26754	2024-05-21 15:28:09 -05:00
Miguel Risco-Castillo	5f32698da5	✨ Ender-3 V3 board CR4NS200320C13 (#27003 )	2024-05-21 15:20:12 -05:00
thinkyhead	1845056014	[cron] Bump distribution date (2024-05-21)	2024-05-21 00:22:16 +00:00
Jason Smith	0b8ec2aa74	🎨 Decimal TMC address (#27028 )	2024-05-20 17:16:49 -05:00
ellensp	578bdd4b20	🧑‍💻 Address trailing spaces (#27108 )	2024-05-20 00:04:51 -05:00
Jonathan Brazier	6b6865d068	✨ INPUT_SHAPING_Z (#27073 )	2024-05-20 00:03:03 -05:00
Andrew	6c018eb770	📝 Update some G-code and other comments (#27034 )	2024-05-20 00:01:05 -05:00
ellensp	5561bafbe6	✨ M110 Get Command Line Number (#27090 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>	2024-05-19 23:11:30 -05:00
ellensp	75eee04972	🩹 Return 0 for bad index in Temperature::getHeaterPower (#27037 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>	2024-05-19 23:10:15 -05:00
ellensp	ee1d1faa52	🔨 Sim pins / INI cleanup	2024-05-19 23:07:24 -05:00
Chris	dbd3e10959	🩹 Solid background for DWIN_MARLINUI text (#27029 )	2024-05-19 22:53:45 -05:00
Andrew	fde330af5a	🎨 Fix MarlinUI "untyped" string args (#27046 )	2024-05-19 21:50:24 -05:00
Keith Bennett	e8d953257e	🔨 Warn about Input Shaping + I2S_STEPPER_STREAM (#27051 )	2024-05-19 21:45:57 -05:00
Keith Bennett	cc86e9ecce	✅ Fix CI badge (#27060 )	2024-05-19 21:44:22 -05:00
vrooze	5a6db519d6	✨ Ender-3 V2 LCD with SKR 3[EZ] (#27061 )	2024-05-19 20:31:53 -05:00
thinkyhead	98d09e5304	[cron] Bump distribution date (2024-05-20)	2024-05-20 00:35:32 +00:00
Vovodroid	d87a0ea7f7	🚸 Quickly apply touch screen fan/laser edit (#27064 )	2024-05-19 19:32:43 -05:00
Dave Gateman	0e2bd069d4	🩹 Fix cutter power extra '%' (#27105 )	2024-05-19 18:53:38 -05:00
ellensp	feca9a33d5	✨ SHOW_CUSTOM_BOOTSCREEN for HD44780 (#26793 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>	2024-05-19 18:51:52 -05:00
Scott Lahteine	eec1aec071	🐛 Fix multi-byte menu string buffer overrun (#27100 )	2024-05-19 18:43:04 -05:00
Scott Lahteine	a97d1088f0	🔧 Ensure distinct languages (#27107 )	2024-05-19 18:42:07 -05:00
Scott Lahteine	a7317de3b4	🔨 Sim needs GLM_ENABLE_EXPERIMENTAL	2024-05-19 14:12:17 -05:00
thinkyhead	06762db050	[cron] Bump distribution date (2024-05-18)	2024-05-18 00:22:00 +00:00
Vovodroid	4f3ebea3a6	🐛 Fix FT_MOTION block reference (#27063 )	2024-05-17 16:47:44 -05:00
ellensp	fa88e0f054	🔨 Windows Simulator needs -DGLM_ENABLE_EXPERIMENTAL (#27092 )	2024-05-17 16:04:36 -05:00
Mihai	2fd7c2b865	⚡️ Fix motion smoothness (#27013 )	2024-05-16 20:48:21 -05:00
jam-berg	ef0bd975cf	🩹 Fix Ender 2 Pro EXP1-7 pin (PB15 / LCD_RS) (#27074 )	2024-05-16 20:23:17 -05:00
Keith Bennett	bdc14ddbd7	⏪️ Revert DELTA Z endstop homing patch (#27088 ) Reverts #26297 `f7a3172c20`	2024-05-16 20:18:41 -05:00
Mihai	383e6f4646	🐛 Move LASER_POWER_TRAP cruise to cruise block (#27031 )	2024-05-16 20:05:27 -05:00
thinkyhead	e37415c95b	[cron] Bump distribution date (2024-05-17)	2024-05-17 00:22:14 +00:00
Scott Lahteine	a33112a4c0	🐛 Reorder `FLOAT_SQ` Followup to `5f96dffb`	2024-05-15 20:30:14 -05:00
thinkyhead	7e8007f024	[cron] Bump distribution date (2024-05-16)	2024-05-16 00:21:28 +00:00
Chris	f320c2a455	🧑‍💻 Define, apply F_CPU on HC32 (#27086 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>	2024-05-15 18:10:04 -05:00
Chris	6eedeaedaf	🐛 Fix HC32 temperature ADC (#27085 )	2024-05-15 15:49:40 -05:00
Chris	6b5e19cfc4	🐛 Fix HC32 watchdog timeout (#27084 ) by reducing PCLK3 clock	2024-05-15 15:45:52 -05:00
ellensp	3dc437add4	🎨 Apply TERN0/1 for some contexts (#27036 )	2024-05-15 15:42:19 -05:00
Scott Lahteine	5f96dffb9b	🧑‍💻 FLOAT_SQ macro	2024-05-15 15:21:39 -05:00
Mihai	6423b8031d	⚡️ Add / enforce min_entry_speed_sqr (#27089 )	2024-05-15 15:01:56 -05:00
thinkyhead	bbdad79ce5	[cron] Bump distribution date (2024-05-13)	2024-05-13 00:22:55 +00:00
Keith Bennett	a2daee8f7a	📝 MPCTEMP is tested (#27075 )	2024-05-12 17:39:58 -05:00
ellensp	909e3ad116	🩹 Motor PWM followup (#27087 ) Followup to `08fe8a3076`	2024-05-12 17:31:02 -05:00
Scott Lahteine	556616c4f0	🧑‍💻 Controller warning as macro	2024-05-12 14:37:27 -05:00
Miguel Risco-Castillo	46e426ce96	📝 Use "based on" for partial ProUI (#26998 )	2024-05-12 13:28:38 -05:00
Alexander Thomas Julian	f5f6c37c17	🐛 LCD Bed Tramming fixes (#26962 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>	2024-05-12 13:25:14 -05:00
Scott Lahteine	08fe8a3076	🔧 Undef motor current PWM for unused axes	2024-05-12 13:21:32 -05:00
thinkyhead	dabcea991f	[cron] Bump distribution date (2024-05-12)	2024-05-12 00:24:03 +00:00
Scott Lahteine	4a5bd47b6a	🎨 Apply MUL_TERN	2024-05-11 13:41:15 -05:00
thinkyhead	e5742a98df	[cron] Bump distribution date (2024-05-11)	2024-05-11 18:06:35 +00:00
Keith Bennett	774cecc3b4	🩹 Fix AT90USB1286 PIO upload (#27070 )	2024-05-11 12:03:04 -05:00
Keith Bennett	83b7e32ec4	🩹 Fix Nextion cstr/fstr typo (#27071 )	2024-05-11 12:02:17 -05:00
thinkyhead	a22155bd96	[cron] Bump distribution date (2024-05-10)	2024-05-10 00:21:41 +00:00
narno2202	1da947f548	⚡️ FT_MOTION : Core and other refinements (#26720 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com> Co-authored-by: Ulendo Alex <alex@ulendo.io>	2024-05-09 16:57:23 -05:00
Scott Lahteine	70332b271b	🎨 DGUS PGM => _P	2024-05-09 16:23:03 -05:00
David Buezas	a3960dfa53	🚸 New encoder logic & debounce (#26723 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>	2024-05-09 16:20:57 -05:00
Scott Lahteine	4296ddb92c	also…	2024-05-08 18:37:16 -05:00
Scott Lahteine	6be8ed2956	Merge branch 'bugfix-2.1.x' into pr/26754	2024-05-08 18:23:29 -05:00
Scott Lahteine	1f0c4d809a	name change	2024-05-08 18:09:25 -05:00
thinkyhead	bab1917311	[cron] Bump distribution date (2024-05-07)	2024-05-07 01:00:35 +00:00
Andrew	49348716f5	🩹 Fix printf et.al. expecting F-strings (#27032 )	2024-05-06 18:58:00 -05:00
thinkyhead	eb781afe7b	[cron] Bump distribution date (2024-05-03)	2024-05-03 00:21:23 +00:00
Jason Smith	39f53c3f8c	🧑‍💻Improve make tests-all-local (#27040 ) * Sleep 5 seconds between platforms * Inform users if they need to install pyyaml * Fix old workflow name * Skip linux_native on Darwin	2024-05-02 06:36:24 -07:00
thinkyhead	b5307aaaad	[cron] Bump distribution date (2024-05-02)	2024-05-02 00:21:16 +00:00
Andrew	f5cf667c95	🎨 Clarify some string parameters (#26949 ) Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>	2024-05-01 15:08:15 -05:00
thinkyhead	737095f852	[cron] Bump distribution date (2024-04-30)	2024-04-30 00:20:48 +00:00
Keith Bennett	f56952c9e6	🔧 Assert TMC slave addresses, minor pins cleanup (#26842 )	2024-04-28 22:17:02 -07:00
Keith Bennett	ca5a7be5e8	🔧 More suppressible warnings (#27009 ) * 🔧 Suppressible LCD contrast warning * 🔧 Suppressible Z_SAFE_HOMING warning * 🔧 Suppressible user feedback warning	2024-04-28 18:15:07 -07:00
thinkyhead	582c5a36d7	[cron] Bump distribution date (2024-04-29)	2024-04-29 00:21:47 +00:00
Chris	a8058729cc	🩹Free debug pins in HC32 HAL (#26985 ) implements DISABLE_DEBUG and DISABLE_JTAG in HAL	2024-04-28 15:59:28 -07:00
Keith Bennett	a2f024ffe3	🔧 Rework MKS Monster8 pins (#26988 )	2024-04-28 15:53:48 -07:00
thinkyhead	e1d65cc5e0	[cron] Bump distribution date (2024-04-28)	2024-04-28 00:23:55 +00:00
ellensp	75cda8d191	📝Update comments to match board labeling (#27016 )	2024-04-27 13:13:00 -07:00
thinkyhead	af8dcc6ee8	[cron] Bump distribution date (2024-04-25)	2024-04-25 00:29:51 +00:00
Scott Lahteine	2270bf41d7	🩹 IA-Creality minor cleanup	2024-04-24 18:09:32 -05:00
Scott Lahteine	489ef6e5e1	🩹 Simple IA-Creality babystep patch See https://github.com/MarlinFirmware/Marlin/issues/26896#issuecomment-2015630458 Co-Authored-By: ellensp <530024+ellensp@users.noreply.github.com>	2024-04-24 17:58:51 -05:00
InsanityAutomation	cecc745844	🚸 Fix duplicate temperature report (#26952 )	2024-04-24 17:51:08 -05:00
thinkyhead	5366362e47	[cron] Bump distribution date (2024-04-24)	2024-04-24 00:46:36 +00:00
ellensp	a1ecea60fd	✏️ MPCTEMP_START => MPC_STARTED (#27002 )	2024-04-23 19:35:11 -05:00
Keith Bennett	882421a03e	🔧 BIQU MicroProbe V2 pull-up warning (#27008 )	2024-04-23 19:19:02 -05:00
Jason Smith	a36f72e886	🎨 Format pins which fail validation (#27007 )	2024-04-23 14:19:14 -07:00
Jason Smith	247e989377	✅ CI - Validate Pins Formatting (#26996 )	2024-04-22 21:10:35 -05:00
thinkyhead	91ae676b9b	[cron] Bump distribution date (2024-04-23)	2024-04-23 00:21:36 +00:00
Scott Lahteine	a955e06259	🎨 Clean up after recent PRs	2024-04-22 18:59:18 -05:00
thinkyhead	31683ce35b	[cron] Bump distribution date (2024-04-22)	2024-04-22 00:22:27 +00:00
Jason Smith	d773570cd6	🐛 Fix Flags<N> data storage width (#26995 ) * Fix Flags and associated unit tests	2024-04-21 00:24:57 -07:00
Jason Smith	556da2b3fc	✅ Add additional unit tests for types.h (#26994 ) * Add more XYval (and similar) unit tests * Add Flags tests, with multiple BUGs identified	2024-04-20 23:59:43 -07:00
Jason Smith	9e19a6efe1	✅ Unit test improvements (#26993 ) - Reset config.ini in restore_configs - Allow running a single configuration of unit tests locally	2024-04-20 23:40:26 -07:00
InsanityAutomation	f433b2c433	🔧 Add RAMPS TMC SPI pins when !TMC_USE_SW_SPI (#26960 ) * Allows RAMPS to auto assign HW SPI Pins for TMC	2024-04-20 18:27:56 -07:00
Aron List	bc0d7d7140	🐛 Fix PID upon entering PID_FUNCTIONAL_RANGE (#26926 ) The PID algorithm did not cache the last seen temperature until it entered the PID_FUNCTIONAL_RANGE. This caused an incorrect output power to be calculated temporarily while the algorithm caught up. This has likely always been a problem for bed and chamber PID. For the hotend this error was introduced in refactoring in commit `54e7b933cd`.	2024-04-20 18:18:49 -07:00
thinkyhead	24f8831021	[cron] Bump distribution date (2024-04-21)	2024-04-21 00:23:15 +00:00
Jason Smith	9a8fb80eed	🎨Match unit test folder structure to code (#26990 )	2024-04-20 17:00:07 -07:00
Jason Smith	ca12459b9c	✅ Skip compile tests when editing unit tests (#26991 )	2024-04-20 15:55:30 -07:00
InsanityAutomation	e1ab911c35	📝Improve Freeze Feature comment (#26959 ) * Fix and Improve Freeze Feature comment	2024-04-20 14:58:13 -07:00
ellensp	58d4494365	add ui_api.h include (#26977 )	2024-04-20 14:48:31 -07:00
ellensp	d502e5beaa	🐛 Fix auto-assignment errors for J and U axis (#26979 )	2024-04-20 14:46:48 -07:00
Chris	b4a95db7da	🚨Fix buffer overrun warning in UBL (#26984 ) to account for null terminator	2024-04-20 14:43:31 -07:00
thinkyhead	02ba6f9f3a	[cron] Bump distribution date (2024-04-19)	2024-04-19 00:21:25 +00:00
Andrew	dba0010607	🎨 Rename some G-code files (#26981 )	2024-04-18 18:04:03 -05:00
I3DBeeTech	90667f6114	🐛 Fix BLACKBEEZMINI fan, info (#26983 )	2024-04-18 15:54:17 -05:00
thinkyhead	d6961b2626	[cron] Bump distribution date (2024-04-17)	2024-04-17 06:06:51 +00:00
Javlon Sodikov	07ebb8171f	🩹Fix ProUI error when !CASELIGHT_USES_BRIGHTNESS (#26976 ) * Fix the compile error with the case light menu Fix the compile error with the case light menu * Add failing test --------- Co-authored-by: Jason Smith <jason.inet@gmail.com>	2024-04-16 22:25:22 -07:00
thinkyhead	245db73929	[cron] Bump distribution date (2024-04-16)	2024-04-16 18:06:16 +00:00
Scott Lahteine	9342dae8f0	📝 Remove dead PDF links	2024-04-16 12:18:26 -05:00
Scott Lahteine	1eff7796d5	add _t	2024-03-09 21:24:08 -06:00
Scott Lahteine	5c77117e4b	refine	2024-01-31 18:05:57 -06:00
Scott Lahteine	4504446e2e	onLevelingDone for G29_RETRY_AND_RECOVER	2024-01-31 17:57:21 -06:00
Scott Lahteine	8f8e1323da	mmc fix	2024-01-31 17:33:47 -06:00
Scott Lahteine	e882457e42	redundant ExtUI::onLevelingDone	2024-01-31 17:28:36 -06:00
Scott Lahteine	1696a06950	tweaks	2024-01-31 17:27:10 -06:00
InsanityAutomation	85f60cc71a	Baseline ExtUI Additions	2024-01-31 08:42:39 -05:00