btt stm32 CR6 Fixes

Upstream fixes
SKR2/3
2024-06-26 10:26:47 -04:00 · 2024-06-18 15:46:57 -04:00 · 2024-06-03 14:40:38 -04:00 · 2024-04-16 10:05:38 -04:00 · 2024-04-16 10:05:17 -04:00 · 2024-04-10 16:24:02 -04:00
630 changed files with 22567 additions and 7177 deletions
@@ -14,8 +14,6 @@ on:
    - config/**
    - data/**
    - docs/**
-    - test/**
-    - Marlin/tests/**
    - '**/*.md'
  push:
    branches:
@@ -25,8 +23,6 @@ on:
    - config/**
    - data/**
    - docs/**
-    - test/**
-    - Marlin/tests/**
    - '**/*.md'

 jobs:
@@ -37,7 +33,6 @@ jobs:
    runs-on: ubuntu-latest

    strategy:
-      fail-fast: true
      matrix:
        test-platform:

@@ -1,51 +0,0 @@
-#
-# 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,23 +2,22 @@ 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 -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 format-pins               : Reformat all pins files"
 	@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-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-single-ci      : Run a single code test from inside the CI"
+#	@echo "make unit-test-single-local   : Run a single code test locally"
+#	@echo "make unit-test-single-local-docker : Run a single code test locally, using docker-compose"
 	@echo "make unit-test-all-local      : Run all code tests locally"
-	@echo "make unit-test-all-local-docker : Run all code tests locally, using docker"
-	@echo "make setup-local-docker        : Setup local docker using buildx"
+	@echo "make unit-test-all-local-docker : Run all code tests locally, using docker-compose"
+	@echo "make setup-local-docker        : Setup local docker-compose"
 	@echo ""
 	@echo "Options for testing:"
 	@echo "  TEST_TARGET          Set when running tests-single-*, to select the"
@@ -28,9 +27,6 @@ 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!"
@@ -55,29 +51,27 @@ 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 $$(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
+	  && for TEST_TARGET in $$($(SCRIPTS_DIR)/get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; 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-local:
-	platformio run -t marlin_$(UNIT_TEST_CONFIG) -e linux_native_test
+#unit-test-single-ci:
+#	export GIT_RESET_HARD=true
+#	$(MAKE) unit-test-single-local TEST_TARGET=$(TEST_TARGET)

-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)
+# TODO: How can we limit tests with ONLY_TEST with platformio?
+#unit-test-single-local:
+#	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make unit-test-all-local" ; return 1; fi
+#	platformio run -t marlin_$(TEST_TARGET)
+
+#unit-test-single-local-docker:
+#	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make unit-test-all-local-docker" ; return 1; fi
+#	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
+#	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS)  $(CONTAINER_IMAGE) make unit-test-single-local TEST_TARGET=$(TEST_TARGET) ONLY_TEST="$(ONLY_TEST)"

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

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

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

 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 <https://www.gnu.org/licenses/>.
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 #pragma once
@@ -28,25 +28,177 @@
 /**
 * Marlin release version identifier
 */
-//#define SHORT_BUILD_VERSION "bugfix-2.1.x"
+#define SHORT_BUILD_VERSION "DW7.4.9"

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

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

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

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

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

 /**
 * Set the vendor info the serial USB interface, if changable
 * Currently only supported by DUE platform
 */
-//#define USB_DEVICE_VENDOR_ID           0x0000
-//#define USB_DEVICE_PRODUCT_ID          0x0000
-//#define USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
+//#define  USB_DEVICE_VENDOR_ID           0x0000
+//#define  USB_DEVICE_PRODUCT_ID          0x0000
+//#define  USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
@@ -0,0 +1,93 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Custom Bitmap for splashscreen
+ *
+ * You may use one of the following tools to generate the C++ bitmap array from
+ * a black and white image:
+ *
+ *  - http://www.marlinfw.org/tools/u8glib/converter.html
+ *  - http://www.digole.com/tools/PicturetoC_Hex_converter.php
+ */
+
+#define CUSTOM_BOOTSCREEN_TIMEOUT   2500
+#define CUSTOM_BOOTSCREEN_BMPWIDTH  128
+#define CUSTOM_BOOTSCREEN_INVERTED
+
+const unsigned char custom_start_bmp[] PROGMEM = {
+  B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,
+  B11111110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,
+  B11111100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
+  B11111100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
+  B11111100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000000,B00000001,B11110000,B00111111,
+  B11111110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000000,B00000010,B00001000,B00011111,
+  B11111100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000000,B00000101,B00000100,B00111111,
+  B11111110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000000,B00001010,B00000010,B00011111,
+  B11111100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000000,B00010101,B00000001,B00111111,
+  B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
+  B11111100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000000,B00010100,B00000001,B00111111,
+  B11111110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
+  B11111100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B00010101,B00000001,B00111111,
+  B11111110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101010,B00001010,B00000010,B00011111,
+  B11111100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010001,B00000101,B00000100,B00111111,
+  B11111110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100001,B00000010,B10001000,B00011111,
+  B11111100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010001,B00000001,B11110000,B00111111,
+  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101010,B00000000,B00000000,B00011111,
+  B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00000000,B00000000,B00111111,
+  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
+  B11111100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
+  B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
+  B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
+  B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+  B11100000,B00101110,B11111011,B01111101,B11111011,B11111011,B11001111,B11000001,B11011111,B10111011,B00111110,B11000000,B11100001,B11111110,B00111100,B00011111,
+  B11111101,B11101110,B01111011,B00111001,B11111001,B11110011,B11001111,B10011110,B11011111,B10111011,B00111110,B11011111,B11011110,B11111100,B11011101,B11100111,
+  B11111101,B11101110,B00111011,B10111011,B11111001,B11101011,B11010111,B10111111,B01011111,B10111011,B01011110,B11011111,B11011110,B11111101,B11101101,B11110111,
+  B11111101,B11101110,B10111011,B11010011,B11111010,B11101011,B10110111,B00111111,B11011111,B10111011,B01001110,B11011111,B11011111,B11111111,B11001101,B11110011,
+  B11111101,B11101110,B11011011,B11000111,B11111010,B11101011,B10111011,B01111111,B11000000,B00111011,B01101110,B11000000,B11100011,B11111111,B00011101,B11110011,
+  B11111101,B11101110,B11001011,B11101111,B11111010,B11011011,B10111011,B01111111,B11011111,B10111011,B01100110,B11011111,B11111000,B11111111,B11001101,B11110011,
+  B11111101,B11101110,B11101011,B11101111,B11111011,B01011011,B00000011,B00111111,B01011111,B10111011,B01110110,B11011111,B11111110,B01111111,B11101101,B11110011,
+  B11111101,B11101110,B11110011,B11101111,B11111011,B01011011,B01111001,B10111110,B11011111,B10111011,B01111010,B11011111,B11011110,B01111101,B11101101,B11110111,
+  B11111101,B11101110,B11110011,B11101111,B11111011,B10111010,B11111101,B10011110,B11011111,B10111011,B01111100,B11011111,B11011110,B11111101,B11001101,B11100111,
+  B11111101,B11101110,B11111011,B11101111,B11111011,B10111010,B11111101,B11000001,B11011111,B10111011,B01111110,B11000000,B11100000,B11111110,B00011100,B00011111
+};
@@ -0,0 +1,74 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Custom Status Screen bitmap
+ *
+ * Place this file in the root with your configuration files
+ * and enable CUSTOM_STATUS_SCREEN_IMAGE in Configuration.h.
+ *
+ * Use the Marlin Bitmap Converter to make your own:
+ * http://marlinfw.org/tools/u8glib/converter.html
+ */
+
+//
+// Status Screen Logo bitmap
+//
+#define STATUS_LOGO_Y            3
+#define STATUS_LOGO_WIDTH       24
+
+const unsigned char status_logo_bmp[] PROGMEM = {
+  B11111111,B11111111,B11111111,
+  B10000000,B00000000,B00000001,
+  B10001110,B00000000,B11100001,
+  B10011111,B00000001,B11110001,
+  B10010011,B10000001,B00111001,
+  B10011111,B10000001,B11111001,
+  B10011111,B10000001,B11111001,
+  B10011111,B10111001,B11111001,
+  B10001111,B00101000,B11110001,
+  B10000000,B00111000,B00000001,
+  B10000000,B00000000,B00000001,
+  B10011111,B11111111,B11111001,
+  B10010001,B01110100,B10011001,
+  B10011011,B00000110,B10101001,
+  B10011011,B01010100,B10101001,
+  B10011011,B01010110,B10101001,
+  B10011011,B01010100,B10011001,
+  B10011111,B11111111,B11111001,
+  B11111111,B11111111,B11111111
+};
+
+//
+// Use default bitmaps
+//
+#define STATUS_HOTEND_ANIM
+#define STATUS_BED_ANIM
+#if HOTENDS < 2
+  #define STATUS_LOGO_X          8
+  #define STATUS_HEATERS_X      40
+  #define STATUS_BED_X          72
+#else
+  #define STATUS_LOGO_X          0
+  #define STATUS_HEATERS_X      32
+  #define STATUS_BED_X          80
+#endif
@@ -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 ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
-    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
+    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
  #endif
 #endif

@@ -159,7 +159,7 @@ typedef Servo hal_servo_t;
 #define GET_PIN_MAP_INDEX(pin) pin
 #define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)

-#define HAL_SENSITIVE_PINS 0, 1
+#define HAL_SENSITIVE_PINS 0, 1,

 #ifdef __AVR_AT90USB1286__
  #define JTAG_DISABLE() do{ MCUCR = 0x80; MCUCR = 0x80; }while(0)
@@ -629,7 +629,7 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
  template class MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> >;
  MSerialLCD lcdSerial(MSerialLCD::HasEmergencyParser);

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

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

  typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialLCD;
@@ -345,14 +345,6 @@ void setup_endstop_interrupts() {
      pciSetup(Z_MIN_PROBE_PIN);
    #endif
  #endif
-  #if USE_CALIBRATION
-    #if (digitalPinToInterrupt(CALIBRATION_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(CALIBRATION_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(CALIBRATION_PIN), "CALIBRATION_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
-      pciSetup(CALIBRATION_PIN);
-    #endif
-  #endif

  // If we arrive here without raising an assertion, each pin has either an EXT-interrupt or a PCI.
 }
@@ -150,7 +150,7 @@ void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
      else {
        if (p == 32 || p == 128) continue;                    // Skip TIMER2 specific prescalers when not TIMER2
        const uint16_t rft = (F_CPU) / (p * f_desired);
-        DEBUG_ECHOLNPGM("(Not Timer 2) F_CPU=", STRINGIFY(F_CPU), " prescaler=", p, " f_desired=", f_desired);
+        DEBUG_ECHOLNPGM("(Not Timer 2) F_CPU=" STRINGIFY(F_CPU), " prescaler=", p, " f_desired=", f_desired);
        res_fast_temp = rft - 1;
        res_pc_temp = rft / 2;
      }
@@ -28,6 +28,9 @@
 *   Port          : E0 E1 E4 E5 G5 E3 H3 H4 H5 H6 B4 B5 B6 B7 J1 J0 H1 H0 D3 D2 D1 D0 A0 A1 A2 A3 A4 A5 A6 A7 C7 C6 C5 C4 C3 C2 C1 C0 D7 G2 G1 G0 L7 L6 L5 L4 L3 L2 L1 L0 B3 B2 B1 B0 F0 F1 F2 F3 F4 F5 F6 F7 K0 K1 K2 K3 K4 K5 K6 K7 | E2 E6 E7 xx xx H2 H7 G3 G4 xx xx xx xx xx D4 D5 D6 xx xx J2 J3 J4 J5 J6 J7 xx xx xx xx xx
 *   Logical Pin   : 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 78 79 80 xx xx 84 85 71 70 xx xx xx xx xx 81 82 83 xx xx 72 73 75 76 77 74 xx xx xx xx xx
 *   Analog Input  :                                                                                                                                                                    0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
+ *
+ * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
+ * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 #include "../fastio.h"
@@ -26,6 +26,9 @@
 *
 *   Logical Pin: 38 39 40 41 42 43 44 45 16 10 11 12 06 07 08 09 30 31 32 33 34 35 36 37 17 18 19 20 21 22 23 24 00 01 13 05 02 03 14 15 46 47 48 49 50 51 52 53 25 26 27 28 29 04
 *   Port:        A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7 G0 G1 G2 G3 G4 G5
+ *
+ * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
+ * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 #include "../fastio.h"
@@ -26,6 +26,9 @@
 *
 *   Logical Pin: 08 09 10 11 12 13 14 15 16 17 18 19 20 21 00 01 02 03 04 05 06 07
 *   Port:        B0 B1 B2 B3 B4 B5 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7
+ *
+ * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
+ * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 #include "../fastio.h"
@@ -26,6 +26,9 @@
 *
 *   Logical Pin: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *   Port:        B0 B1 B2 B3 B4 B5 B6 B7 D0 D1 D2 D3 D4 D5 D6 D7 C0 C1 C2 C3 C4 C5 C6 C7 A7 A6 A5 A4 A3 A2 A1 A0
+ *
+ * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
+ * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 /**                        ATMega644
@@ -27,6 +27,9 @@
 *   Logical Pin: 28 29 30 31 32 33 34 35 20 21 22 23 24 25 26 27 10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07 08 09(46*47)36 37 18 19 38 39 40 41 42 43 44 45
 *   Port:        A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7
 *            The logical pins 46 and 47 are not supported by Teensyduino, but are supported below as E2 and E3
+ *
+ * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
+ * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
 */

 #include "../fastio.h"
@@ -120,7 +120,7 @@ void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
  U8G_ATOMIC_END();
 }

-#if U8G_SPI_USE_MODE_3
+#if ENABLED(FYSETC_MINI_12864)
  #define SPISEND_SW_AVR u8g_spiSend_sw_AVR_mode_3
 #else
  #define SPISEND_SW_AVR u8g_spiSend_sw_AVR_mode_0
@@ -143,9 +143,9 @@ uint8_t u8g_com_HAL_AVR_sw_sp_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
      break;

    case U8G_COM_MSG_CHIP_SELECT:
-      #if U8G_SPI_USE_MODE_3                                  // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                                        // SCK idle state needs to be set to the proper idle state before
-                                                              //  the next chip select goes active
+      #if ENABLED(FYSETC_MINI_12864)           // LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                         //   SCK idle state needs to be set to the proper idle state before
+                                               //   the next chip select goes active
          u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, 1);  // Set SCK to mode 3 idle state before CS goes active
          u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
        }
@@ -64,7 +64,6 @@ void setup_endstop_interrupts() {
  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
@@ -61,7 +61,7 @@
 #else
  #define G2_PWM_Z 0
 #endif
-#if HAS_MOTOR_CURRENT_PWM_E
+#if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
  #define G2_PWM_E 1
 #else
  #define G2_PWM_E 0
@@ -68,15 +68,16 @@
 * Usually the hardware SPI pins are only available to the LCD. This makes the DUE hard SPI used at the same time
 * as the TMC2130 soft SPI the most common setup.
 */
+#define _IS_HW_SPI(P) (defined(TMC_SPI_##P) && (TMC_SPI_##P == SD_MOSI_PIN || TMC_SPI_##P == SD_MISO_PIN || TMC_SPI_##P == SD_SCK_PIN))
+
 #if HAS_MEDIA && HAS_DRIVER(TMC2130)
-  #define _IS_HW_SPI(P) (defined(TMC_SPI_##P) && (TMC_SPI_##P == SD_MOSI_PIN || TMC_SPI_##P == SD_MISO_PIN || TMC_SPI_##P == SD_SCK_PIN))
-  #if DISABLED(SOFTWARE_SPI) && ENABLED(TMC_USE_SW_SPI) && (_IS_HW_SPI(MOSI) || _IS_HW_SPI(MISO) || _IS_HW_SPI(SCK))
-    #error "DUE hardware SPI is required but is incompatible with TMC2130 software SPI. Either disable TMC_USE_SW_SPI or use separate pins for the two SPIs."
-  #endif
-  #if ENABLED(SOFTWARE_SPI) && DISABLED(TMC_USE_SW_SPI)
+  #if ENABLED(TMC_USE_SW_SPI)
+    #if DISABLED(SOFTWARE_SPI) && (_IS_HW_SPI(MOSI) || _IS_HW_SPI(MISO) || _IS_HW_SPI(SCK))
+      #error "DUE hardware SPI is required but is incompatible with TMC2130 software SPI. Either disable TMC_USE_SW_SPI or use separate pins for the two SPIs."
+    #endif
+  #elif ENABLED(SOFTWARE_SPI)
    #error "DUE software SPI is required but is incompatible with TMC2130 hardware SPI. Enable TMC_USE_SW_SPI to fix."
  #endif
-  #undef _IS_HW_SPI
 #endif

 #if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_FREQUENCY
@@ -24,7 +24,7 @@
 /**
 * Define SPI Pins: SCK, MISO, MOSI, SS
 *
- * Available chip select pins for HW SPI are 4 10 52 77 87
+ * Available chip select pins for HW SPI are 4 10 52 77
 */
 #if SDSS == 4 || SDSS == 10 || SDSS == 52 || SDSS == 77 || SDSS == 87
  #if SDSS == 4
@@ -66,7 +66,7 @@

 #include <U8glib-HAL.h>

-#if U8G_SPI_USE_MODE_3
+#if ENABLED(FYSETC_MINI_12864)
  #define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_3
 #else
  #define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_0
@@ -96,15 +96,15 @@ uint8_t u8g_com_HAL_DUE_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
      break;

    case U8G_COM_MSG_CHIP_SELECT:
-      #if U8G_SPI_USE_MODE_3                        // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                              // SCK idle state needs to be set to the proper idle state before
-                                                    //  the next chip select goes active
-          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 1);   // Set SCK to mode 3 idle state before CS goes active
+      #if ENABLED(FYSETC_MINI_12864)           // LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                        //   SCK idle state needs to be set to the proper idle state before
+                                               //   the next chip select goes active
+          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 1);  //set SCK to mode 3 idle state before CS goes active
          u8g_SetPILevel_DUE(u8g, U8G_PI_CS, LOW);
        }
        else {
          u8g_SetPILevel_DUE(u8g, U8G_PI_CS, HIGH);
-          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0);   // Set SCK to mode 0 idle state after CS goes inactive
+          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0); //set SCK to mode 0 idle state after CS goes inactive
        }
      #else
        u8g_SetPILevel_DUE(u8g, U8G_PI_CS, !arg_val);
@@ -11,7 +11,7 @@ if pioutil.is_pio_build():

    if current_OS == 'Windows':

-        env = pioutil.env
+        Import("env")

        # Use bossac.exe on Windows
        env.Replace(
@@ -18,32 +18,32 @@ extern "C" {
 void sd_mmc_spi_mem_init() {
 }

-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 !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;
+  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 (!media_ready()) return CTRL_NO_PRESENT;
+  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;
 }

+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());
+}
+
 #if ACCESS_USB == true
 /**
 * \name MEM <-> USB Interface
@@ -61,7 +61,8 @@ 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 (!media_ready()) return CTRL_NO_PRESENT;
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+    return CTRL_NO_PRESENT;

  #ifdef DEBUG_MMC
  {
@@ -100,7 +101,8 @@ 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 (!media_ready()) return CTRL_NO_PRESENT;
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+    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.
 //!/
-void sd_mmc_spi_mem_init();
+extern void           sd_mmc_spi_mem_init(void);

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

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

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

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

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

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

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

 #endif // #if ACCESS_USB == true

@@ -59,7 +59,6 @@ void setup_endstop_interrupts() {
  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
@@ -142,31 +142,12 @@
 // ADC
 //
 #define HAL_ADC_VREF_MV 3300
-#define HAL_ADC_RESOLUTION 12
+#define HAL_ADC_RESOLUTION 10

 #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,9 +232,7 @@ int MarlinHAL::freeMemory() {
  return &top - _sbrk(0);
 }

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

 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,12 +64,7 @@
 // redirect printf to host serial
 #define REDIRECT_PRINTF_TO_SERIAL 1

-// 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
+// FIXME override F_CPU to PCLK1, as marlin freaks out otherwise
+#define F_CPU (SYSTEM_CLOCK_FREQUENCIES.pclk1)

 #endif // _HC32_APP_CONFIG_H_
@@ -101,14 +101,12 @@ void setup_endstop_interrupts() {

  SETUP(Z_MIN_PROBE);

-  SETUP(CALIBRATION);
-
  #undef SETUP
 }

 // Ensure 1 - 10 IRQs are registered
 // Disable some endstops if you encounter this error
-#define ENDSTOPS_INTERRUPTS_COUNT COUNT_ENABLED(USE_X_MAX, USE_X_MIN, USE_X2_MAX, USE_X2_MIN, USE_Y_MAX, USE_Y_MIN, USE_Y2_MAX, USE_Y2_MIN, USE_Z_MAX, USE_Z_MIN, USE_Z2_MAX, USE_Z2_MIN, USE_Z3_MAX, USE_Z3_MIN, USE_Z4_MAX, USE_Z4_MIN, USE_Z_MIN_PROBE, USE_CALIBRATION)
+#define ENDSTOPS_INTERRUPTS_COUNT COUNT_ENABLED(USE_X_MAX, USE_X_MIN, USE_X2_MAX, USE_X2_MIN, USE_Y_MAX, USE_Y_MIN, USE_Y2_MAX, USE_Y2_MIN, USE_Z_MAX, USE_Z_MIN, USE_Z2_MAX, USE_Z2_MIN, USE_Z3_MAX, USE_Z3_MIN, USE_Z4_MAX, USE_Z4_MIN, USE_Z_MIN_PROBE)
 #if ENDSTOPS_INTERRUPTS_COUNT > 10
  #error "Too many endstop interrupts! HC32F460 only supports 10 endstop interrupts."
 #elif ENDSTOPS_INTERRUPTS_COUNT == 0
@@ -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,44 +96,29 @@ void core_hook_sysclock_init() {
    #endif
  #endif

-  // 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
+  // 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)
-  constexpr stc_clk_sysclk_cfg_t sysClkConf = {
+  stc_clk_sysclk_cfg_t sysClkConf = {
      .enHclkDiv = ClkSysclkDiv1,  // HCLK  = 200 MHz (CPU)
      .enExclkDiv = ClkSysclkDiv2, // EXCLK = 100 MHz (SDIO)
-      .enPclk0Div = ClkSysclkDiv2, // PCLK0 = 100 MHz (Timer6 (not used))
+      .enPclk0Div = ClkSysclkDiv1, // PCLK0 = 200 MHz (Timer6 (not used))
      .enPclk1Div = ClkSysclkDiv4, // PCLK1 = 50 MHz (USART, SPI, I2S, Timer0 (step+temp), TimerA (Servo))
-      .enPclk2Div = ClkSysclkDiv8, // PCLK2 = 25 MHz (ADC)
-      .enPclk3Div = ClkSysclkDiv8, // PCLK3 = 25 MHz (I2C, WDT)
+      .enPclk2Div = ClkSysclkDiv4, // PCLK2 = 50 MHz (ADC)
+      .enPclk3Div = ClkSysclkDiv4, // PCLK3 = 50 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
-  power_mode_update_pre(sysclock);
+  #define POWER_MODE_SYSTEM_CLOCK 200000000 // 200 MHz
+  power_mode_update_pre(POWER_MODE_SYSTEM_CLOCK);

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

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

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

-/**
- * 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
+// 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)

 // Temperature timer
-#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
+#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

 // Stepper timer
-#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
+#define STEP_TIMER_NUM (&step_timer)
+#define STEP_TIMER_PRIORITY DDL_IRQ_PRIORITY_01
+#define STEPPER_TIMER_PRESCALE 16ul

-#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
+// 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)

 // 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
@@ -82,7 +82,7 @@ static inline uint8_t swSpiTransfer_mode_3(uint8_t b, const uint8_t spi_speed, c
 }

 static void u8g_sw_spi_shift_out(uint8_t val) {
-  #if U8G_SPI_USE_MODE_3
+  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
    swSpiTransfer_mode_3(val, SPI_speed);
  #else
    swSpiTransfer_mode_0(val, SPI_speed);
@@ -116,15 +116,15 @@ uint8_t u8g_com_HAL_HC32_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, voi
      break;

    case U8G_COM_MSG_CHIP_SELECT:
-      #if U8G_SPI_USE_MODE_3        // This LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {              // SCK idle state needs to be set to the proper idle state before
-                                    //  the next chip select goes active
-          WRITE(DOGLCD_SCK, HIGH);  // Set SCK to mode 3 idle state before CS goes active
+      #if ANY(FYSETC_MINI_12864, MKS_MINI_12864) // This LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                           // SCK idle state needs to be set to the proper idle state before
+                                                 // the next chip select goes active
+          WRITE(DOGLCD_SCK, HIGH);               // Set SCK to mode 3 idle state before CS goes active
          WRITE(DOGLCD_CS, LOW);
        }
        else {
          WRITE(DOGLCD_CS, HIGH);
-          WRITE(DOGLCD_SCK, LOW);   // Set SCK to mode 0 idle state after CS goes inactive
+          WRITE(DOGLCD_SCK, LOW);  // Set SCK to mode 0 idle state after CS goes inactive
        }
      #else
        WRITE(DOGLCD_CS, !arg_val);
@@ -28,6 +28,12 @@
                        // spiBeginTransaction.
 #endif

+// Onboard SD
+//#define SD_SCK_PIN     P0_07
+//#define SD_MISO_PIN    P0_08
+//#define SD_MOSI_PIN    P0_09
+//#define SD_SS_PIN      P0_06
+
 // External SD
 #ifndef SD_SCK_PIN
  #define SD_SCK_PIN        50
@@ -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 ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+  #if HAS_DGUS_LCD || ENABLED(DWINOS_4)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.available()
  #endif
 #endif
@@ -159,7 +159,7 @@ constexpr pin_t GET_PIN_MAP_PIN(const int16_t index) {
 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
 // P0.6 thru P0.9 are for the onboard SD card
-#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09
+#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09,

 // ------------------------
 // Defines
@@ -146,12 +146,6 @@ void setup_endstop_interrupts() {
    #endif
    _ATTACH(Z_MIN_PROBE_PIN);
  #endif
-  #if USE_CALIBRATION
-    #if !LPC1768_PIN_INTERRUPT_M(CALIBRATION_PIN)
-      #error "CALIBRATION_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
-    #endif
-    _ATTACH(CALIBRATION_PIN);
-  #endif
  #if USE_I_MAX
    #if !LPC1768_PIN_INTERRUPT_M(I_MAX_PIN)
      #error "I_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
@@ -26,10 +26,8 @@

 void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
  if (!LPC176x::pin_is_valid(pin)) return;
-  if (LPC176x::pwm_attach_pin(pin)) {
-    const uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, LPC176x::pwm_get_period(pin));
-    LPC176x::pwm_write(pin, duty);
-  }
+  if (LPC176x::pwm_attach_pin(pin))
+    LPC176x::pwm_write_ratio(pin, invert ? 1.0f - (float)v / v_size : (float)v / v_size);  // map 1-254 onto PWM range
 }

 void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
@@ -66,7 +66,7 @@
 #define _WRITE(IO,V)          WRITE_PIN(IO,V)

 /// toggle a pin
-#define _TOGGLE(IO)           LPC176x::gpio_toggle(IO)
+#define _TOGGLE(IO)           _WRITE(IO, !READ(IO))

 /// set pin as input
 #define _SET_INPUT(IO)        SET_DIR_INPUT(IO)
@@ -28,13 +28,12 @@
                        // spiBeginTransaction.
 #endif

-// Onboard SD
-//#define SD_SCK_PIN     P0_07
-//#define SD_MISO_PIN    P0_08
-//#define SD_MOSI_PIN    P0_09
-//#define SD_SS_PIN      P0_06
-
-// External SD
+/** onboard SD card */
+//#define SD_SCK_PIN        P0_07
+//#define SD_MISO_PIN       P0_08
+//#define SD_MOSI_PIN       P0_09
+//#define SD_SS_PIN         P0_06
+/** external */
 #ifndef SD_SCK_PIN
  #define SD_SCK_PIN        P0_15
 #endif
@@ -132,7 +132,7 @@ uint8_t swSpiTransfer_mode_3(uint8_t b, const uint8_t spi_speed, const pin_t sck
 static uint8_t SPI_speed = 0;

 static void u8g_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val) {
-  #if U8G_SPI_USE_MODE_3
+  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
    swSpiTransfer_mode_3(val, SPI_speed, clockPin, -1, dataPin);
  #else
    swSpiTransfer_mode_0(val, SPI_speed, clockPin, -1, dataPin);
@@ -160,15 +160,15 @@ uint8_t u8g_com_HAL_LPC1768_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
      break;

    case U8G_COM_MSG_CHIP_SELECT:
-      #if U8G_SPI_USE_MODE_3                    // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                          // SCK idle state needs to be set to the proper idle state before
-                                                //  the next chip select goes active
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);   // Set SCK to mode 3 idle state before CS goes active
+      #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)  // LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                            //   SCK idle state needs to be set to the proper idle state before
+                                                  //   the next chip select goes active
+          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);     // Set SCK to mode 3 idle state before CS goes active
          u8g_SetPILevel(u8g, U8G_PI_CS, LOW);
        }
        else {
          u8g_SetPILevel(u8g, U8G_PI_CS, HIGH);
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);   // Set SCK to mode 0 idle state after CS goes inactive
+          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);  // Set SCK to mode 0 idle state after CS goes inactive
        }
      #else
        u8g_SetPILevel(u8g, U8G_PI_CS, !arg_val);
@@ -13,9 +13,9 @@ if pioutil.is_pio_build():
    target_drive = "REARM"

    import platform
-    current_OS = platform.system()

-    env = pioutil.env
+    current_OS = platform.system()
+    Import("env")

    def print_error(e):
        print('\nUnable to find destination disk (%s)\n' \
@@ -131,7 +131,7 @@ static uint8_t swSpiInit(const uint8_t spi_speed, const uint8_t clk_pin, const u
 }

 static void u8g_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val) {
-  #if U8G_SPI_USE_MODE_3
+  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
    swSpiTransfer_mode_3(val, SPI_speed, clockPin, -1, dataPin);
  #else
    swSpiTransfer_mode_0(val, SPI_speed, clockPin, -1, dataPin);
@@ -159,15 +159,15 @@ uint8_t u8g_com_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_pt
      break;

    case U8G_COM_MSG_CHIP_SELECT:
-      #if U8G_SPI_USE_MODE_3                    // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                          // SCK idle state needs to be set to the proper idle state before
-                                                //  the next chip select goes active
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);   // Set SCK to mode 3 idle state before CS goes active
+      #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)  // LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                            //   SCK idle state needs to be set to the proper idle state before
+                                                  //   the next chip select goes active
+          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);     // Set SCK to mode 3 idle state before CS goes active
          u8g_SetPILevel(u8g, U8G_PI_CS, LOW);
        }
        else {
          u8g_SetPILevel(u8g, U8G_PI_CS, HIGH);
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);   // Set SCK to mode 0 idle state after CS goes inactive
+          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);  // Set SCK to mode 0 idle state after CS goes inactive
        }
      #else
        u8g_SetPILevel(u8g, U8G_PI_CS, !arg_val);
@@ -83,7 +83,6 @@
 #define MATCH_Z4_MAX_EILINE(P) TERN0(USE_Z4_MAX, DEFER4(MATCH_EILINE)(P, Z4_MAX_PIN))
 #define MATCH_Z4_MIN_EILINE(P) TERN0(USE_Z4_MIN, DEFER4(MATCH_EILINE)(P, Z4_MIN_PIN))
 #define MATCH_Z_MIN_PROBE_EILINE(P) TERN0(USE_Z_MIN_PROBE, DEFER4(MATCH_EILINE)(P, Z_MIN_PROBE_PIN))
-#define MATCH_CALIBRATION_EILINE(P) TERN0(USE_CALIBRATION, DEFER4(MATCH_EILINE)(P, CALIBRATION_PIN))

 #define AVAILABLE_EILINE(P) ( PIN_TO_EILINE(P) != -1    \
  && !MATCH_X_MAX_EILINE(P) && !MATCH_X_MIN_EILINE(P)   \
@@ -100,8 +99,7 @@
  && !MATCH_Z2_MAX_EILINE(P) && !MATCH_Z2_MIN_EILINE(P) \
  && !MATCH_Z3_MAX_EILINE(P) && !MATCH_Z3_MIN_EILINE(P) \
  && !MATCH_Z4_MAX_EILINE(P) && !MATCH_Z4_MIN_EILINE(P) \
-  && !MATCH_Z_MIN_PROBE_EILINE(P)                       \
-  && !MATCH_CALIBRATION_EILINE(P) )
+  && !MATCH_Z_MIN_PROBE_EILINE(P) )

 // One ISR for all EXT-Interrupts
 void endstop_ISR() { endstops.update(); }
@@ -210,12 +208,6 @@ void setup_endstop_interrupts() {
    #endif
    _ATTACH(Z_MIN_PROBE_PIN);
  #endif
-  #if USE_CALIBRATION
-    #if !AVAILABLE_EILINE(CALIBRATION_PIN)
-      #error "CALIBRATION_PIN has no EXTINT line available. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
-    #endif
-    _ATTACH(CALIBRATION_PIN);
-  #endif
  #if USE_I_MAX
    #if !AVAILABLE_EILINE(I_MAX_PIN)
      #error "I_MAX_PIN has no EXTINT line available. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
@@ -82,7 +82,6 @@
 #define MATCH_Z4_MAX_EILINE(P) TERN0(USE_Z4_MAX, DEFER4(MATCH_EILINE)(P, Z4_MAX_PIN))
 #define MATCH_Z4_MIN_EILINE(P) TERN0(USE_Z4_MIN, DEFER4(MATCH_EILINE)(P, Z4_MIN_PIN))
 #define MATCH_Z_MIN_PROBE_EILINE(P) TERN0(USE_Z_MIN_PROBE, DEFER4(MATCH_EILINE)(P, Z_MIN_PROBE_PIN))
-#define MATCH_CALIBRATION_EILINE(P) TERN0(USE_CALIBRATION, DEFER4(MATCH_EILINE)(P, CALIBRATION_PIN))

 #define AVAILABLE_EILINE(P) ( PIN_TO_EILINE(P) != -1    \
  && !MATCH_X_MAX_EILINE(P) && !MATCH_X_MIN_EILINE(P)   \
@@ -99,8 +98,7 @@
  && !MATCH_Z2_MAX_EILINE(P) && !MATCH_Z2_MIN_EILINE(P) \
  && !MATCH_Z3_MAX_EILINE(P) && !MATCH_Z3_MIN_EILINE(P) \
  && !MATCH_Z4_MAX_EILINE(P) && !MATCH_Z4_MIN_EILINE(P) \
-  && !MATCH_Z_MIN_PROBE_EILINE(P)                       \
-  && !MATCH_CALIBRATION_EILINE(P) )
+  && !MATCH_Z_MIN_PROBE_EILINE(P) )

 // One ISR for all EXT-Interrupts
 void endstop_ISR() { endstops.update(); }
@@ -185,12 +183,6 @@ void setup_endstop_interrupts() {
    #endif
    _ATTACH(Z_MIN_PROBE_PIN);
  #endif
-  #if USE_CALIBRATION
-    #if !AVAILABLE_EILINE(CALIBRATION_PIN)
-      #error "CALIBRATION_PIN has no EXTINT line available. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
-    #endif
-    _ATTACH(CALIBRATION_PIN);
-  #endif
  #if USE_I_MAX
    #if !AVAILABLE_EILINE(I_MAX_PIN)
      #error "I_MAX_PIN has no EXTINT line available. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
@@ -112,19 +112,11 @@
  #else
    #error "LCD_SERIAL_PORT must be from 1 to 9, or -1 for Native USB."
  #endif
-  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)  || ENABLED(EXTENSIBLE_UI)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif

-#ifdef RS485_SERIAL_PORT
-  #if WITHIN(RS485_SERIAL_PORT, 1, 9)
-    #define RS485_SERIAL MSERIAL(RS485_SERIAL_PORT)
-  #else
-    #error "RS485_SERIAL_PORT must be from 1 to 9."
-  #endif
-#endif
-
 /**
 * TODO: review this to return 1 for pins that are not analog input
 */
@@ -37,7 +37,7 @@ static SPISettings spiConfig;
 // Public functions
 // ------------------------

-#if ANY(SOFTWARE_SPI, FORCE_SOFT_SPI)
+#if ENABLED(SOFTWARE_SPI)

  // ------------------------
  // Software SPI
@@ -43,6 +43,7 @@

 #else // Arduino non-DMA

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

  struct MarlinSerial : public HardwareSerial {
@@ -54,6 +55,7 @@

    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;
@@ -1,136 +0,0 @@
-/**
- * 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 / Ryan Power
- *
- * 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/>.
- *
- */
-
-#ifdef HAL_STM32
-
-#include "../../../inc/MarlinConfig.h"
-
-#if ALL(HAS_MARLINUI_U8GLIB, FORCE_SOFT_SPI)
-
-#include <U8glib-HAL.h>
-#include "../../shared/HAL_SPI.h"
-
-#define nop asm volatile ("\tnop\n")
-
-static inline uint8_t swSpiTransfer_mode_0(uint8_t b) {
-  for (uint8_t i = 0; i < 8; ++i) {
-    const uint8_t state = (b & 0x80) ? HIGH : LOW;
-    WRITE(DOGLCD_SCK, HIGH);
-    WRITE(DOGLCD_MOSI, state);
-    b <<= 1;
-    WRITE(DOGLCD_SCK, LOW);
-  }
-  return b;
-}
-
-static inline uint8_t swSpiTransfer_mode_3(uint8_t b) {
-  for (uint8_t i = 0; i < 8; ++i) {
-    const uint8_t state = (b & 0x80) ? HIGH : LOW;
-    WRITE(DOGLCD_SCK, LOW);
-    WRITE(DOGLCD_MOSI, state);
-    b <<= 1;
-    WRITE(DOGLCD_SCK, HIGH);
-  }
-  return b;
-}
-
-static void u8g_sw_spi_shift_out(uint8_t val) {
-  #if U8G_SPI_USE_MODE_3
-    swSpiTransfer_mode_3(val);
-  #else
-    swSpiTransfer_mode_0(val);
-  #endif
-}
-
-static void swSpiInit() {
-  #if PIN_EXISTS(LCD_RESET)
-    SET_OUTPUT(LCD_RESET_PIN);
-  #endif
-  SET_OUTPUT(DOGLCD_A0);
-  OUT_WRITE(DOGLCD_SCK, LOW);
-  OUT_WRITE(DOGLCD_MOSI, LOW);
-  OUT_WRITE(DOGLCD_CS, HIGH);
-}
-
-uint8_t u8g_com_HAL_STM32_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-  switch (msg) {
-    case U8G_COM_MSG_INIT:
-      swSpiInit();
-      break;
-
-    case U8G_COM_MSG_STOP:
-      break;
-
-    case U8G_COM_MSG_RESET:
-      #if PIN_EXISTS(LCD_RESET)
-        WRITE(LCD_RESET_PIN, arg_val);
-      #endif
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      #if U8G_SPI_USE_MODE_3        // This LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {              // SCK idle state needs to be set to the proper idle state before
-                                    //  the next chip select goes active
-          WRITE(DOGLCD_SCK, HIGH);  // Set SCK to mode 3 idle state before CS goes active
-          WRITE(DOGLCD_CS, LOW);
-          nop; // hold SCK high for a few ns
-          nop;
-         }
-        else {
-          WRITE(DOGLCD_CS, HIGH);
-          WRITE(DOGLCD_SCK, LOW);   // Set SCK to mode 0 idle state after CS goes inactive
-        }
-      #else
-        WRITE(DOGLCD_CS, !arg_val);
-      #endif
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      u8g_sw_spi_shift_out(arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ: {
-      uint8_t *ptr = (uint8_t *)arg_ptr;
-      while (arg_val > 0) {
-        u8g_sw_spi_shift_out(*ptr++);
-        arg_val--;
-      }
-    } break;
-
-    case U8G_COM_MSG_WRITE_SEQ_P: {
-      uint8_t *ptr = (uint8_t *)arg_ptr;
-      while (arg_val > 0) {
-        u8g_sw_spi_shift_out(u8g_pgm_read(ptr));
-        ptr++;
-        arg_val--;
-      }
-    } break;
-
-    case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      WRITE(DOGLCD_A0, arg_val);
-      break;
-  }
-  return 1;
-}
-
-#endif // HAS_MARLINUI_U8GLIB && FORCE_SOFT_SPI
-#endif // HAL_STM32
@@ -45,7 +45,6 @@ void setup_endstop_interrupts() {
  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
@@ -30,3 +30,6 @@
  #undef F_CPU
  #define F_CPU BOARD_F_CPU
 #endif
+
+// The Sensitive Pins array is not optimizable
+#define RUNTIME_ONLY_ANALOG_TO_DIGITAL
@@ -25,8 +25,8 @@
 * STM32 LCD-specific defines
 */

-uint8_t u8g_com_HAL_STM32_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);   // u8g_com_stm32duino_swspi.cpp
-#define U8G_COM_HAL_SW_SPI_FN u8g_com_HAL_STM32_sw_spi_fn
-
+uint8_t u8g_com_std_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);         // See U8glib-HAL
 uint8_t u8g_com_stm32duino_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);  // See U8glib-HAL
+
+#define U8G_COM_HAL_SW_SPI_FN u8g_com_std_sw_spi_fn
 #define U8G_COM_HAL_HW_SPI_FN u8g_com_stm32duino_hw_spi_fn
@@ -138,22 +138,11 @@
    #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 ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(DWINOS_4)
    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif

-#ifdef RS485_SERIAL_PORT
-  #if RS485_SERIAL_PORT == -1
-    #define RS485_SERIAL UsbSerial
-  #elif WITHIN(RS485_SERIAL_PORT, 1, NUM_UARTS)
-    #define RS485_SERIAL MSERIAL(RS485_SERIAL_PORT)
-  #else
-    #define RS485_SERIAL MSERIAL(1) // dummy port
-    static_assert(false, "RS485_SERIAL_PORT must be from 1 to " STRINGIFY(NUM_UARTS) ".")
-  #endif
-#endif
-
 /**
 * TODO: review this to return 1 for pins that are not analog input
 */
@@ -0,0 +1,56 @@
+from __future__ import print_function
+import sys
+
+#dynamic build flags for generic compile options
+if __name__ == "__main__":
+  args = " ".join([ "-std=gnu++14",
+                    "-Os",
+                    "-mcpu=cortex-m3",
+                    "-mthumb",
+
+                    "-fsigned-char",
+                    "-fno-move-loop-invariants",
+                    "-fno-strict-aliasing",
+                    "-fsingle-precision-constant",
+
+                    "--specs=nano.specs",
+                    "--specs=nosys.specs",
+
+                    "-IMarlin/src/HAL/STM32F1",
+
+                    "-MMD",
+                    "-MP",
+                    "-DTARGET_STM32F1"
+                  ])
+
+  for i in range(1, len(sys.argv)):
+    args += " " + sys.argv[i]
+
+  print(args)
+
+# extra script for linker options
+else:
+  import pioutil
+  if pioutil.is_pio_build():
+    from SCons.Script import DefaultEnvironment
+    env = DefaultEnvironment()
+    env.Append(
+      ARFLAGS=["rcs"],
+
+      ASFLAGS=["-x", "assembler-with-cpp"],
+
+      CXXFLAGS=[
+        "-fabi-version=0",
+        "-fno-use-cxa-atexit",
+        "-fno-threadsafe-statics"
+      ],
+      LINKFLAGS=[
+        "-Os",
+        "-mcpu=cortex-m3",
+        "-ffreestanding",
+        "-mthumb",
+        "--specs=nano.specs",
+        "--specs=nosys.specs",
+        "-u_printf_float",
+      ],
+    )
@@ -89,7 +89,7 @@ static inline uint8_t swSpiTransfer_mode_3(uint8_t b, const uint8_t spi_speed, c
 }

 static void u8g_sw_spi_shift_out(uint8_t val) {
-  #if U8G_SPI_USE_MODE_3
+  #if ENABLED(FYSETC_MINI_12864)
    swSpiTransfer_mode_3(val, SPI_speed);
  #else
    swSpiTransfer_mode_0(val, SPI_speed);
@@ -123,15 +123,15 @@ uint8_t u8g_com_HAL_STM32F1_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
      break;

    case U8G_COM_MSG_CHIP_SELECT:
-      #if U8G_SPI_USE_MODE_3        // This LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {              // SCK idle state needs to be set to the proper idle state before
-                                    //  the next chip select goes active
-          WRITE(DOGLCD_SCK, HIGH);  // Set SCK to mode 3 idle state before CS goes active
+      #if ENABLED(FYSETC_MINI_12864) // This LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {               // SCK idle state needs to be set to the proper idle state before
+                                     // the next chip select goes active
+          WRITE(DOGLCD_SCK, HIGH);   // Set SCK to mode 3 idle state before CS goes active
          WRITE(DOGLCD_CS, LOW);
        }
        else {
          WRITE(DOGLCD_CS, HIGH);
-          WRITE(DOGLCD_SCK, LOW);   // Set SCK to mode 0 idle state after CS goes inactive
+          WRITE(DOGLCD_SCK, LOW);  // Set SCK to mode 0 idle state after CS goes inactive
        }
      #else
        WRITE(DOGLCD_CS, !arg_val);
@@ -70,7 +70,6 @@ void setup_endstop_interrupts() {
  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
@@ -25,7 +25,7 @@
 * STM32F1 (Maple) LCD-specific defines
 */

-uint8_t u8g_com_HAL_STM32F1_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr); // u8g_com_stm32duino_swspi.cpp
+uint8_t u8g_com_HAL_STM32F1_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
 uint8_t u8g_com_stm32duino_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);  // See U8glib-HAL

 #define U8G_COM_HAL_SW_SPI_FN     u8g_com_HAL_STM32F1_sw_spi_fn
@@ -64,7 +64,6 @@ void setup_endstop_interrupts() {
  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
@@ -63,7 +63,6 @@ void setup_endstop_interrupts() {
  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
@@ -63,7 +63,6 @@ void setup_endstop_interrupts() {
  TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
  TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
  TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
  TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
  TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
  TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));
@@ -36,13 +36,13 @@
 typedef uint32_t hal_timer_t;
 #define HAL_TIMER_TYPE_MAX 0xFFFFFFFE

-#define GPT_TIMER_RATE (F_CPU / 4) // 150MHz (Can't use F_BUS_ACTUAL because it's extern volatile)
+#define GPT_TIMER_RATE F_BUS_ACTUAL   // 150MHz

 #define GPT1_TIMER_PRESCALE 2
 #define GPT2_TIMER_PRESCALE 10

-#define GPT1_TIMER_RATE (GPT_TIMER_RATE / GPT1_TIMER_PRESCALE) // 150MHz /  2 = 75MHz
-#define GPT2_TIMER_RATE (GPT_TIMER_RATE / GPT2_TIMER_PRESCALE) // 150MHz / 10 = 15MHz
+#define GPT1_TIMER_RATE (GPT_TIMER_RATE / GPT1_TIMER_PRESCALE) // 75MHz
+#define GPT2_TIMER_RATE (GPT_TIMER_RATE / GPT2_TIMER_PRESCALE) // 15MHz

 #ifndef MF_TIMER_STEP
  #define MF_TIMER_STEP         0  // Timer Index for Stepper
@@ -57,8 +57,7 @@ typedef uint32_t hal_timer_t;
 #define TEMP_TIMER_RATE        1000000
 #define TEMP_TIMER_FREQUENCY   1000

-#define HAL_TIMER_RATE         GPT1_TIMER_RATE
-#define STEPPER_TIMER_RATE     HAL_TIMER_RATE
+#define STEPPER_TIMER_RATE     GPT1_TIMER_RATE
 #define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000)
 #define STEPPER_TIMER_PRESCALE ((GPT_TIMER_RATE / 1000000) / STEPPER_TIMER_TICKS_PER_US)

@@ -261,16 +261,12 @@
  #include "tests/marlin_tests.h"
 #endif

-#if HAS_RS485_SERIAL
-  #include "feature/rs485.h"
-#endif
-
 PGMSTR(M112_KILL_STR, "M112 Shutdown");

-MarlinState marlin_state = MarlinState::MF_INITIALIZING;
+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 = false;
+bool wait_for_heatup = true;

 // For M0/M1, this flag may be cleared (by M108) to exit the wait-for-user loop
 #if HAS_RESUME_CONTINUE
@@ -312,12 +308,23 @@ bool wait_for_heatup = false;
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wnarrowing"

+#ifndef RUNTIME_ONLY_ANALOG_TO_DIGITAL
+  template <pin_t ...D>
+  constexpr pin_t OnlyPins<_SP_END, D...>::table[sizeof...(D)];
+#endif
+
 bool pin_is_protected(const pin_t pin) {
-  #define pgm_read_pin(P) (sizeof(pin_t) == 2 ? (pin_t)pgm_read_word(P) : (pin_t)pgm_read_byte(P))
-  for (uint8_t i = 0; i < COUNT(sensitive_dio); ++i)
-    if (pin == pgm_read_pin(&sensitive_dio[i])) return true;
-  for (uint8_t i = 0; i < COUNT(sensitive_aio); ++i)
-    if (pin == analogInputToDigitalPin(pgm_read_pin(&sensitive_dio[i]))) return true;
+  #ifdef RUNTIME_ONLY_ANALOG_TO_DIGITAL
+    static const pin_t sensitive_pins[] PROGMEM = { SENSITIVE_PINS };
+    const size_t pincount = COUNT(sensitive_pins);
+  #else
+    static constexpr size_t pincount = OnlyPins<SENSITIVE_PINS>::size;
+    static const pin_t (&sensitive_pins)[pincount] PROGMEM = OnlyPins<SENSITIVE_PINS>::table;
+  #endif
+  for (uint8_t i = 0; i < pincount; ++i) {
+    const pin_t * const pptr = &sensitive_pins[i];
+    if (pin == (sizeof(pin_t) == 2 ? (pin_t)pgm_read_word(pptr) : (pin_t)pgm_read_byte(pptr))) return true;
+  }
  return false;
 }

@@ -381,8 +388,8 @@ void startOrResumeJob() {
  }

  inline void finishSDPrinting() {
-    if (queue.enqueue_one(F("M1001"))) {      // Keep trying until it gets queued
-      marlin_state = MarlinState::MF_RUNNING; // Signal to stop trying
+    if (queue.enqueue_one(F("M1001"))) {  // Keep trying until it gets queued
+      marlin_state = MF_RUNNING;          // Signal to stop trying
      TERN_(PASSWORD_AFTER_SD_PRINT_END, password.lock_machine());
      TERN_(DGUS_LCD_UI_MKS, screen.sdPrintingFinished());
    }
@@ -777,7 +784,7 @@ void idle(const bool no_stepper_sleep/*=false*/) {
  TERN_(MAX7219_DEBUG, max7219.idle_tasks());

  // Return if setup() isn't completed
-  if (marlin_state == MarlinState::MF_INITIALIZING) goto IDLE_DONE;
+  if (marlin_state == MF_INITIALIZING) goto IDLE_DONE;

  // TODO: Still causing errors
  TERN_(TOOL_SENSOR, (void)check_tool_sensor_stats(active_extruder, true));
@@ -963,7 +970,7 @@ void stop() {
    SERIAL_ERROR_MSG(STR_ERR_STOPPED);
    LCD_MESSAGE(MSG_STOPPED);
    safe_delay(350);       // allow enough time for messages to get out before stopping
-    marlin_state = MarlinState::MF_STOPPED;
+    marlin_state = MF_STOPPED;
  }
 }

@@ -1277,7 +1284,7 @@ void setup() {

  // Identify myself as Marlin x.x.x
  SERIAL_ECHOLNPGM("Marlin " SHORT_BUILD_VERSION);
-  #ifdef STRING_DISTRIBUTION_DATE
+  #if defined(STRING_DISTRIBUTION_DATE) && defined(STRING_CONFIG_H_AUTHOR)
    SERIAL_ECHO_MSG(
      " Last Updated: " STRING_DISTRIBUTION_DATE
      " | Author: " STRING_CONFIG_H_AUTHOR
@@ -1323,23 +1330,18 @@ void setup() {
    #endif
  #endif

-  #if HAS_MEDIA && ANY(SDCARD_EEPROM_EMULATION, POWER_LOSS_RECOVERY)
+  #if ALL(HAS_MEDIA, SDCARD_EEPROM_EMULATION)
    SETUP_RUN(card.mount());          // Mount media with settings before first_load
  #endif

-  // Prepare some LCDs to display early
-  #if HAS_EARLY_LCD_SETTINGS
-    SETUP_RUN(settings.load_lcd_state());
-  #endif
+  SETUP_RUN(settings.first_load());   // Load data from EEPROM if available (or use defaults)
+                                      // This also updates variables in the planner, elsewhere

  #if ALL(HAS_WIRED_LCD, SHOW_BOOTSCREEN)
    SETUP_RUN(ui.show_bootscreen());
    const millis_t bootscreen_ms = millis();
  #endif

-  SETUP_RUN(settings.first_load());   // Load data from EEPROM if available (or use defaults)
-                                      // This also updates variables in the planner, elsewhere
-
  #if ENABLED(PROBE_TARE)
    SETUP_RUN(probe.tare_init());
  #endif
@@ -1646,15 +1648,11 @@ void setup() {
    SETUP_RUN(bdl.init(I2C_BD_SDA_PIN, I2C_BD_SCL_PIN, I2C_BD_DELAY));
  #endif

-  #if HAS_RS485_SERIAL
-    SETUP_RUN(rs485_init());
-  #endif
-
  #if ENABLED(FT_MOTION)
    SETUP_RUN(ftMotion.init());
  #endif

-  marlin_state = MarlinState::MF_RUNNING;
+  marlin_state = MF_RUNNING;

  #ifdef STARTUP_TUNE
    // Play a short startup tune before continuing.
@@ -1686,7 +1684,7 @@ void loop() {

    #if HAS_MEDIA
      if (card.flag.abort_sd_printing) abortSDPrinting();
-      if (marlin_state == MarlinState::MF_SD_COMPLETE) finishSDPrinting();
+      if (marlin_state == MF_SD_COMPLETE) finishSDPrinting();
    #endif

    queue.advance();
@@ -42,7 +42,7 @@ void kill(FSTR_P const lcd_error=nullptr, FSTR_P const lcd_component=nullptr, co
 void minkill(const bool steppers_off=false);

 // Global State of the firmware
-enum class MarlinState : uint8_t {
+enum MarlinState : uint8_t {
  MF_INITIALIZING = 0,
  MF_STOPPED,
  MF_KILLED,
@@ -53,8 +53,8 @@ enum class MarlinState : uint8_t {
 };

 extern MarlinState marlin_state;
-inline bool IsRunning() { return marlin_state >= MarlinState::MF_RUNNING; }
-inline bool IsStopped() { return marlin_state == MarlinState::MF_STOPPED; }
+inline bool IsRunning() { return marlin_state >= MF_RUNNING; }
+inline bool IsStopped() { return marlin_state == MF_STOPPED; }

 bool printingIsActive();
 bool printJobOngoing();
@@ -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) 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_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_TRIGORILLA_PRO          5056  // Trigorilla Pro (STM32F103ZE)
 #define BOARD_FLY_MINI                5057  // FLYmaker FLY MINI (STM32F103RC)
 #define BOARD_FLSUN_HISPEED           5058  // FLSUN HiSpeedV1 (STM32F103VE)
@@ -468,11 +468,6 @@
 #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
 //
@@ -103,8 +103,7 @@

 #define HAS_TRINAMIC HAS_TRINAMIC_CONFIG

-#if (    HAS_DRIVER(TMC2100) \
-      || HAS_DRIVER(TMC2130_STANDALONE) || HAS_DRIVER(TMC2160_STANDALONE) \
+#if (    HAS_DRIVER(TMC2130_STANDALONE) || HAS_DRIVER(TMC2160_STANDALONE) \
      || HAS_DRIVER(TMC2208_STANDALONE) || HAS_DRIVER(TMC2209_STANDALONE) \
      || HAS_DRIVER(TMC2660_STANDALONE) || HAS_DRIVER(TMC5130_STANDALONE) \
      || HAS_DRIVER(TMC5160_STANDALONE) )
@@ -135,7 +135,6 @@
 #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: "
@@ -355,8 +354,6 @@
 #define STR_PROBE_EN                        "probe_en"
 #define STR_FILAMENT                        "filament"

-#define STR_CALIBRATION                     "calibration"
-
 // General axis names
 #define STR_X "X"
 #define STR_Y "Y"
@@ -55,6 +55,9 @@
  #define CYCLES_PER_MICROSECOND (F_CPU / 1000000UL) // 16 or 20 on AVR
 #endif

+// Nanoseconds per cycle
+#define NANOSECONDS_PER_CYCLE (1000000000.0 / F_CPU)
+
 // Macros to make a string from a macro
 #define STRINGIFY_(M) #M
 #define STRINGIFY(M) STRINGIFY_(M)
@@ -86,8 +89,7 @@
 #define HYPOT2(x,y) (sq(x)+sq(y))
 #define NORMSQ(x,y,z) (sq(x)+sq(y)+sq(z))

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

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

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

 // Force define expansion
-#define EVAL(V...)     EVAL16(V)
+#define EVAL           EVAL16
 #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 pfmt, Args... more) { SNPRINTF_P(str, SIZE, pfmt, more...); debug(F("setf_P")); return *this; }
+  MString& setf_P(PGM_P const fmt, Args... more) { SNPRINTF_P(str, SIZE, fmt, 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 ffmt, Args... more) { return setf_P(FTOP(ffmt), more...); }
+  MString& setf(FSTR_P const fmt, Args... more)  { return setf_P(FTOP(fmt), 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 pfmt, Args... more) {
+  MString& appendf_P(PGM_P const fmt, Args... more) {
    int sz = length();
-    if (sz < SIZE) SNPRINTF_P(str + sz, SIZE - sz, pfmt, more...);
+    if (sz < SIZE) SNPRINTF_P(str + sz, SIZE - sz, fmt, 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 pfmt, Args... more) { super::setf_P(pfmt, more...); return *this; }
+  SString& setf_P(PGM_P const fmt, Args... more) { super::setf_P(fmt, 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 ffmt, Args... more)  { super::setf(ffmt, more...); return *this; }
+  SString& setf(FSTR_P const fmt, Args... more)  { super::setf(fmt, more...); return *this; }

  template <typename T>
  SString& set(const T &v) { super::set(v); return *this; }
@@ -46,7 +46,6 @@ 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)
@@ -59,21 +58,17 @@ 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
@@ -84,7 +79,6 @@ 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 ,
@@ -98,7 +92,6 @@ 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)
@@ -166,7 +159,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 bits_t(N) flagbits_t;
+  typedef uvalue_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,
@@ -226,7 +219,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 axes on Core kinematics
+//  - X_HEAD, Y_HEAD, and Z_HEAD should be used for Steppers on Core kinematics
 //
 enum AxisEnum : uint8_t {

@@ -610,9 +603,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 TERN0(HAS_X_AXIS, _MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w))); }
+  FI constexpr T small()        const { return TERN(HAS_X_AXIS, _MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)), 0); }
  // Largest element
-  FI constexpr T large()        const { return TERN0(HAS_X_AXIS, _MAX(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w))); }
+  FI constexpr T large()        const { return TERN(HAS_X_AXIS, _MAX(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)), 0); }

  // Explicit copy and copies with conversion
  FI constexpr XYZval<T>           copy() const { XYZval<T> o = *this; return o; }
@@ -1091,7 +1084,6 @@ 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); }
@@ -171,14 +171,13 @@ int32_t Backlash::get_applied_steps(const AxisEnum axis) {

  const int32_t residual_error_axis = residual_error[axis];

-  // At startup, when no steps are applied, it is assumed the last move was backwards.
-  // So the applied steps will always be zero (when moving backwards) or a positive
-  // number (when moving forwards).
+  // At startup it is assumed the last move was forward.
+  // So the applied steps will always be negative.

-  if (!forward) return -residual_error_axis;
+  if (forward) return -residual_error_axis;

  const float f_corr = float(correction) / all_on;
-  const int32_t full_error_axis = f_corr * distance_mm[axis] * planner.settings.axis_steps_per_mm[axis];
+  const int32_t full_error_axis = -f_corr * distance_mm[axis] * planner.settings.axis_steps_per_mm[axis];
  return full_error_axis - residual_error_axis;
 }

@@ -46,16 +46,10 @@ BDS_Leveling bdl;
 #define DEBUG_OUT ENABLED(DEBUG_OUT_BD)
 #include "../../../core/debug_out.h"

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

 #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_F(MSG_PROBING_POINT), point_num, int(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_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_F(MSG_LCD_TILTING_MESH), i + 1));
+        TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/3"), GET_TEXT(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_F(MSG_LCD_TILTING_MESH), point_num, total_points));
+          TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(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

@@ -141,7 +141,7 @@ void MarlinEthernet::check() {

    case CONNECTING:
      telnetClient.println("Marlin " SHORT_BUILD_VERSION);
-      #ifdef STRING_DISTRIBUTION_DATE
+      #if defined(STRING_DISTRIBUTION_DATE) && defined(STRING_CONFIG_H_AUTHOR)
        telnetClient.println(
          " Last Updated: " STRING_DISTRIBUTION_DATE
          " | Author: " STRING_CONFIG_H_AUTHOR
@@ -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
-      MUL_TERN(RETRACT_SYNC_MIXING, settings.retract_feedrate_mm_s, MIXING_STEPPERS)
+      settings.retract_feedrate_mm_s * TERN1(RETRACT_SYNC_MIXING, (MIXING_STEPPERS))
    );

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

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

@@ -239,7 +239,7 @@ void LEDLights::set_color(const LEDColor &incol
  void LEDLights::toggle() { if (lights_on) set_off(); else update(); }
 #endif

-#if HAS_LED_POWEROFF_TIMEOUT
+#if LED_POWEROFF_TIMEOUT > 0

  millis_t LEDLights::led_off_time; // = 0

@@ -164,11 +164,11 @@ public:
  #if ENABLED(LED_CONTROL_MENU)
    static void toggle();  // swap "off" with color
  #endif
-  #if ANY(LED_CONTROL_MENU, CASE_LIGHT_USE_RGB_LED, HAS_LED_POWEROFF_TIMEOUT)
+  #if ANY(LED_CONTROL_MENU, CASE_LIGHT_USE_RGB_LED) || LED_POWEROFF_TIMEOUT > 0
    static void update() { set_color(color); }
  #endif

-  #if HAS_LED_POWEROFF_TIMEOUT
+  #if LED_POWEROFF_TIMEOUT > 0
    private:
      static millis_t led_off_time;
    public:
@@ -130,7 +130,7 @@ public:
  }

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

  static uint32_t pixel_color(const uint16_t n) {
    #if ENABLED(NEOPIXEL2_INSERIES)
@@ -689,7 +689,7 @@ void resume_print(const_float_t slow_load_length/*=0*/, const_float_t fast_load_
  #endif

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

  #ifdef ACTION_ON_RESUMED
@@ -122,6 +122,7 @@ void Power::power_off() {
  TERN_(HAS_SUICIDE, suicide());

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

  SERIAL_ECHOLNPGM(STR_POWEROFF);

@@ -201,7 +202,7 @@ void Power::power_off() {
  /**
   * Check all conditions that would signal power needing to be on.
   *
-   * @return bool  if power is needed
+   * @returns bool  if power is needed
   */
  bool Power::is_power_needed() {

@@ -205,9 +205,6 @@ void PrintJobRecovery::save(const bool force/*=false*/, const float zraise/*=POW
    // info.sdpos and info.current_position are pre-filled from the Stepper ISR

    info.feedrate = uint16_t(MMS_TO_MMM(feedrate_mm_s));
-    info.feedrate_percentage = feedrate_percentage;
-    COPY(info.flow_percentage, planner.flow_percentage);
-
    info.zraise = zraise;
    info.flag.raised = raised;                      // Was Z raised before power-off?

@@ -219,7 +216,7 @@ void PrintJobRecovery::save(const bool force/*=false*/, const float zraise/*=POW
    #if DISABLED(NO_VOLUMETRICS)
      info.flag.volumetric_enabled = parser.volumetric_enabled;
      #if HAS_MULTI_EXTRUDER
-        COPY(info.filament_size, planner.filament_size);
+        EXTRUDER_LOOP() info.filament_size[e] = planner.filament_size[e];
      #else
        if (parser.volumetric_enabled) info.filament_size[0] = planner.filament_size[active_extruder];
      #endif
@@ -272,10 +269,7 @@ void PrintJobRecovery::save(const bool force/*=false*/, const float zraise/*=POW

        #if POWER_LOSS_RETRACT_LEN
          // Retract filament now
-          const uint16_t old_flow = planner.flow_percentage[active_extruder];
-          planner.set_flow(active_extruder, 100);
-          gcode.process_subcommands_now(F("G1F3000E-" STRINGIFY(POWER_LOSS_RETRACT_LEN)));
-          planner.set_flow(active_extruder, old_flow);
+          gcode.process_subcommands_now(F("G1 F3000 E-" STRINGIFY(POWER_LOSS_RETRACT_LEN)));
        #endif

        #if POWER_LOSS_ZRAISE
@@ -561,12 +555,8 @@ void PrintJobRecovery::resume() {
  // Move back down to the saved Z for printing
  PROCESS_SUBCOMMANDS_NOW(TS(F("G1F600Z"), p_float_t(z_print, 3)));

-  // Restore the feedrate and percentage
+  // Restore the feedrate
  PROCESS_SUBCOMMANDS_NOW(TS(F("G1F"), info.feedrate));
-  feedrate_percentage = info.feedrate_percentage;
-
-  // Flowrate percentage
-  EXTRUDER_LOOP() planner.set_flow(e, info.flow_percentage[e]);

  // Restore E position with G92.9
  PROCESS_SUBCOMMANDS_NOW(TS(F("G92.9E"), p_float_t(resume_pos.e, 3)));
@@ -599,8 +589,7 @@ void PrintJobRecovery::resume() {
        }
        DEBUG_EOL();

-        DEBUG_ECHOLN(F("feedrate: "), info.feedrate, F(" x "), info.feedrate_percentage, '%');
-        EXTRUDER_LOOP() DEBUG_ECHOLN('E', e + 1, F(" flow %: "), info.flow_percentage[e]);
+        DEBUG_ECHOLNPGM("feedrate: ", info.feedrate);

        DEBUG_ECHOLNPGM("zraise: ", info.zraise, " ", info.flag.raised ? "(before)" : "");

@@ -59,8 +59,6 @@ typedef struct {
  // Machine state
  xyze_pos_t current_position;
  uint16_t feedrate;
-  int16_t feedrate_percentage;
-  uint16_t flow_percentage[EXTRUDERS];

  float zraise;

@@ -1,39 +0,0 @@
-/**
- * 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 HAS_RS485_SERIAL
-
-#include "rs485.h"
-
-HardwareSerialBusIO rs485BusIO(&RS485_SERIAL);
-RS485Bus<RS485_BUS_BUFFER_SIZE> rs485Bus(rs485BusIO, RS485_RX_ENABLE_PIN, RS485_TX_ENABLE_PIN);
-
-PhotonProtocol rs485Protocol;
-
-Packetizer rs485Packetizer(rs485Bus, rs485Protocol);
-
-uint8_t rs485Buffer[RS485_SEND_BUFFER_SIZE];
-
-void rs485_init() { RS485_SERIAL.begin(57600); }
-
-#endif // HAS_RS485_SERIAL
@@ -1,40 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2024 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "../inc/MarlinConfigPre.h"
-
-#include <rs485/rs485bus.hpp>
-#include <rs485/bus_adapters/hardware_serial.h>
-
-#include <rs485/protocols/photon.h>
-#include <rs485/packetizer.h>
-
-#define RS485_SEND_BUFFER_SIZE 32
-
-extern HardwareSerialBusIO rs485BusIO;
-extern RS485Bus<RS485_BUS_BUFFER_SIZE> rs485Bus;
-extern PhotonProtocol rs485Protocol;
-extern Packetizer rs485Packetizer;
-extern uint8_t rs485Buffer[RS485_SEND_BUFFER_SIZE];
-
-void rs485_init();
@@ -40,6 +40,10 @@
 #endif

 //#define FILAMENT_RUNOUT_SENSOR_DEBUG
+#ifndef FILAMENT_RUNOUT_THRESHOLD
+  #define FILAMENT_RUNOUT_THRESHOLD 5
+#endif
+

 typedef Flags<
          #if NUM_MOTION_SENSORS > NUM_RUNOUT_SENSORS
@@ -52,6 +56,20 @@ typedef Flags<
 void event_filament_runout(const uint8_t extruder);
 inline bool should_monitor_runout() { return did_pause_print || printingIsActive(); }

+template<class RESPONSE_T, class SENSOR_T>
+class TFilamentMonitor;
+class FilamentSensorCore;
+class RunoutResponseDelayed;
+
+/********************************* TEMPLATE SPECIALIZATION *********************************/
+
+typedef TFilamentMonitor<
+          RunoutResponseDelayed,
+          FilamentSensorCore
+        > FilamentMonitor;
+
+extern FilamentMonitor runout;
+
 /*******************************************************************************************/

 enum RunoutMode : uint8_t {
@@ -65,7 +83,7 @@ enum RunoutMode : uint8_t {
  RM_MOTION_SENSOR
 };

-class FilamentSensor {
+class FilamentMonitorBase {
  public:
    static bool enabled[NUM_RUNOUT_SENSORS], filament_ran_out;
    static RunoutMode mode[NUM_RUNOUT_SENSORS];
@@ -77,35 +95,32 @@ class FilamentSensor {
    #else
      static constexpr bool host_handling = false;
    #endif
+};

+template<class RESPONSE_T, class SENSOR_T>
+class TFilamentMonitor : public FilamentMonitorBase {
+  private:
+    typedef RESPONSE_T response_t;
+    typedef SENSOR_T   sensor_t;
+    static  response_t response;
+    static  sensor_t   sensor;
+
+  public:
    static void setup() {
-      #define _INIT_RUNOUT_PIN(P,S,U,D) do{ if (ENABLED(U)) SET_INPUT_PULLUP(P); else if (ENABLED(D)) SET_INPUT_PULLDOWN(P); else SET_INPUT(P); }while(0);
-      #define  INIT_RUNOUT_PIN(N) _INIT_RUNOUT_PIN(FIL_RUNOUT##N##_PIN, FIL_RUNOUT##N##_STATE, FIL_RUNOUT##N##_PULLUP, FIL_RUNOUT##N##_PULLDOWN);
-      REPEAT_1(NUM_RUNOUT_SENSORS, INIT_RUNOUT_PIN)
-      #undef INIT_RUNOUT_PIN
-
-      #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-        #define INIT_MOTION_PIN(N) _INIT_RUNOUT_PIN(FIL_MOTION##N##_PIN, FIL_MOTION##N##_STATE, FIL_MOTION##N##_PULLUP, FIL_MOTION##N##_PULLDOWN);
-        REPEAT_1(NUM_MOTION_SENSORS, INIT_MOTION_PIN)
-        #undef  INIT_MOTION_PIN
-      #endif
-      #undef _INIT_RUNOUT_PIN
+      sensor.setup();
      reset();
    }

    static void reset() {
      filament_ran_out = false;
-      for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) filament_present(i);
-        #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-          for (uint8_t i = 0; i < NUM_MOTION_SENSORS; ++i) filament_motion_present(i);
-        #endif
+      response.reset();
    }

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

    // Handle a block completion. RunoutResponseDelayed uses this to
    // add up the length of filament moved while the filament is out.
@@ -151,7 +166,11 @@ class FilamentSensor {
        }
      }
    }
+};

+/*************************** FILAMENT PRESENCE SENSORS ***************************/
+
+class FilamentSensorBase {
  protected:
    /**
     * Called by FilamentSensorSwitch::run when filament is detected.
@@ -162,6 +181,37 @@ class FilamentSensor {
    }

  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);
+      #endif
+      #undef _INIT_RUNOUT_PIN
+      #undef  INIT_RUNOUT_PIN
+    }
+

    // Return a bitmask of runout pin states
    static uint8_t poll_runout_pins() {
@@ -177,6 +227,7 @@ class FilamentSensor {
      #undef _INVERT_BIT
    }

+    #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
      // Return a bitmask of motion pin states
      static uint8_t poll_motion_pins() {
        #define _OR_MOTION(N) | (READ(FIL_MOTION##N##_PIN) ? _BV((N) - 1) : 0)
@@ -190,6 +241,7 @@ class FilamentSensor {
        return poll_motion_pins() ^ uint8_t(0 REPEAT_1(NUM_MOTION_SENSORS, _OR_MOTION));
        #undef _OR_MOTION
      }
+    #endif
 };

 class FilamentSensorCore : public FilamentSensorBase {
@@ -214,17 +266,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 < TERN(FILAMENT_SWITCH_AND_MOTION, NUM_MOTION_SENSORS, NUM_RUNOUT_SENSORS); ++e)
-              if (TEST(change, e)) SERIAL_CHAR(' ', '0' + e);
-            SERIAL_EOL();
-          }
-        #endif
+      #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
+        if (change) {
+          SERIAL_ECHOPGM("Motion detected:");
+          for(uint8_t e = 0; e < NUM_RUNOUT_SENSORS; ++e)
+            if (TEST(change, e)) SERIAL_CHAR(' ', '0' + e);
+          SERIAL_EOL();
+        }
+      #endif

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

    public:
      static void block_completed(const block_t * const b) {
@@ -238,10 +290,10 @@ class FilamentSensorCore : public FilamentSensorBase {
      }

    static void run() {
-      if (mode[active_extruder] == RM_MOTION_SENSOR) {
+      if (runout.mode[active_extruder] == RM_MOTION_SENSOR) {
        poll_motion_sensor();
      }
-      else if (mode[active_extruder] != RM_NONE) {
+      else if (runout.mode[active_extruder] != RM_NONE) {
        for(uint8_t s = 0; s < NUM_RUNOUT_SENSORS; ++s) {
          const bool out = poll_runout_state(s);
          if (!out) filament_present(s);
@@ -257,7 +309,6 @@ class FilamentSensorCore : public FilamentSensorBase {
    }
 };

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

 typedef struct {
@@ -269,94 +320,51 @@ typedef struct {
    #endif
  } countdown_t;

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

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

-      static void run() {
-        #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
-          static millis_t t = 0;
-          const millis_t ms = millis();
-          if (ELAPSED(ms, t)) {
-            t = millis() + 1000UL;
-            for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i)
-              SERIAL_ECHO(i ? F(", ") : F("Runout remaining mm: "), mm_countdown.runout[i]);
+      static void reset() {
+        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) filament_present(i);
+        #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
+          for (uint8_t i = 0; i < NUM_MOTION_SENSORS; ++i) filament_motion_present(i);
+        #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]);
            #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
              for (uint8_t i = 0; i < NUM_MOTION_SENSORS; ++i)
                SERIAL_ECHO(i ? F(", ") : F("Motion remaining mm: "), mm_countdown.motion[i]);
            #endif
-            SERIAL_EOL();
-          }
-        #endif
-      }
-
-      static runout_flags_t has_run_out() {
-        runout_flags_t runout_flags{0};
-        for (uint8_t i = 0; i < NUM_RUNOUT_SENSORS; ++i) if (mm_countdown.runout[i] < 0) runout_flags.set(i);
-        #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-          for (uint8_t i = 0; i < NUM_MOTION_SENSORS; ++i) if (mm_countdown.motion[i] < 0) runout_flags.set(i);
-        #endif
-        return runout_flags;
-      }
-
-      static void filament_present(const uint8_t extruder) {
-        if (mm_countdown.runout[extruder] < runout_distance_mm[extruder] || 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[extruder];
-          mm_countdown.runout_reset.clear(extruder);
-        }
-        else {
-          // If runout is larger than runout distance, we cannot reset right now, as Bowden and retract
-          // distance larger than runout_distance_mm leads to negative runout right after unretract.
-          // But we cannot ignore filament_present event. After unretract, runout will become smaller
-          // than runout_distance_mm and should be reset after that. So activate delayed reset.
-          mm_countdown.runout_reset.set(extruder);
-        }
-      }
-
-      #if ENABLED(FILAMENT_SWITCH_AND_MOTION)
-        static void filament_motion_present(const uint8_t extruder) {
-          // Same logic as filament_present
-          if (mm_countdown.motion[extruder] < runout_distance_mm || did_pause_print) {
-            mm_countdown.motion[extruder] = runout_distance_mm;
-            mm_countdown.motion_reset.clear(extruder);
-          }
-          else
-            mm_countdown.motion_reset.set(extruder);
+          SERIAL_EOL();
        }
      #endif
+    }

-      static void block_completed(const block_t * const b) {
-        const int32_t esteps = b->steps.e;
-        if (!esteps) return;
+    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;
+    }

-        // No calculation unless paused or printing
-        if (!should_monitor_runout()) return;
+      static void block_completed(const block_t * const) { }

-        // 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
+      static void filament_present(const uint8_t extruder) {
+        runout_count[extruder] = runout_distance_mm[extruder];
      }
  };

@@ -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_F(MSG_DRIVER_BACKWARD));
+  ui.status_printf(2, F(S_FMT S_FMT), FTOP(fstr), GET_TEXT(MSG_DRIVER_BACKWARD));
 }

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

 /**
 * 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_F(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(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_F(MSG_PROBING_POINT), int(i + 1)));
+        TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/3"), GET_TEXT(MSG_PROBING_POINT), int(i + 1)));

        // Retain the last probe position
        abl.probePos = xy_pos_t(points[i]);
@@ -985,6 +985,9 @@ G29_TYPE GcodeSuite::G29() {
    process_subcommands_now(F(EVENT_GCODE_AFTER_G29));
  #endif

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

  report_current_position();
@@ -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_F(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(MSG_PROBING_POINT), _MIN(mbl_probe_index, GRID_MAX_POINTS), int(GRID_MAX_POINTS)));
  }

  report_current_position();
@@ -634,7 +634,7 @@ void GcodeSuite::G33() {
          }
        SERIAL_EOL();

-        MString<21> msg(F("Calibration sd:"));
+        MString<20> msg(F("Calibration sd:"));
        if (zero_std_dev_min < 1)
          msg.appendf(F("0.%03i"), (int)LROUND(zero_std_dev_min * 1000.0f));
        else
@@ -181,6 +181,20 @@ inline void park_above_object(measurements_t &m, const float uncertainty) {

 #endif

+#if !PIN_EXISTS(CALIBRATION)
+  #include "../../module/probe.h"
+#endif
+
+inline bool read_calibration_pin() {
+  return (
+    #if PIN_EXISTS(CALIBRATION)
+      READ(CALIBRATION_PIN) != CALIBRATION_PIN_INVERTING
+    #else
+      PROBE_TRIGGERED()
+    #endif
+  );
+}
+
 /**
 * Move along axis in the specified dir until the probe value becomes stop_state,
 * then return the axis value.
@@ -191,18 +205,18 @@ inline void park_above_object(measurements_t &m, const float uncertainty) {
 *   fast         in - Fast vs. precise measurement
 */
 float measuring_movement(const AxisEnum axis, const int dir, const bool stop_state, const bool fast) {
+  const float step     = fast ? 0.25 : CALIBRATION_MEASUREMENT_RESOLUTION;
  const feedRate_t mms = fast ? MMM_TO_MMS(CALIBRATION_FEEDRATE_FAST) : MMM_TO_MMS(CALIBRATION_FEEDRATE_SLOW);
  const float limit    = fast ? 50 : 5;

  destination = current_position;
-  destination[axis] += dir * limit;
-  endstops.enable_calibration_probe(true, stop_state);
-  do_blocking_move_to((xyz_pos_t)destination, mms);
-  endstops.enable_calibration_probe(false);
-  endstops.hit_on_purpose();
-  set_current_from_steppers_for_axis(axis);
-  sync_plan_position();
-  return current_position[axis];
+  for (float travel = 0; travel < limit; travel += step) {
+    destination[axis] += dir * step;
+    do_blocking_move_to((xyz_pos_t)destination, mms);
+    planner.synchronize();
+    if (read_calibration_pin() == stop_state) break;
+  }
+  return destination[axis];
 }

 /**
@@ -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_F(MSG_M48_POINT), int(n + 1), int(n_samples));
+        ui.status_printf(0, F(S_FMT ": %d/%d"), GET_TEXT(MSG_M48_POINT), int(n + 1), int(n_samples));
      #endif

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

-/**
- * 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());
@@ -112,9 +112,9 @@ void GcodeSuite::M81() {
    return;
  }

-  #if ENABLED(PSU_CONTROL)
-    powerManager.power_off_soon();
-  #elif HAS_SUICIDE
+  #if HAS_SUICIDE
    suicide();
+  #elif ENABLED(PSU_CONTROL)
+    powerManager.power_off_soon();
  #endif
 }
@@ -36,7 +36,7 @@
 * existing command buffer.
 */
 void GcodeSuite::M999() {
-  marlin_state = MarlinState::MF_RUNNING;
+  marlin_state = MF_RUNNING;
  ui.reset_alert_level();

  if (parser.boolval('S')) return;
@@ -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 || HAS_MOTOR_CURRENT_PWM_E || PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
+    #if HAS_X_Y_XY_I_J_K_U_V_W || ANY_PIN(MOTOR_CURRENT_PWM_E, 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 HAS_MOTOR_CURRENT_PWM_E
+        #if PIN_EXISTS(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 HAS_MOTOR_CURRENT_PWM_E
+      #if PIN_EXISTS(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 HAS_MOTOR_CURRENT_PWM_E
+        #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
          , SP_E_STR,       stepper.motor_current_setting[2]  // E
        #endif
      );
--- a/Show More
+++ b/Show More