Merge remote-tracking branch 'upstream/bugfix-2.0.x' into 2.0.x

2019-12-24 00:05:04 -06:00 · 2019-12-24 00:05:04 -06:00 · 0673f335e1
commit 0673f335e1
parent ac7ee4b94a 1c9ccce520
449 changed files with 33177 additions and 6801 deletions
--- a/.github/workflows/bump-date.yml
+++ b/.github/workflows/bump-date.yml
@ -0,0 +1,25 @@
+#
+# bump-date.yml
+# Bump the distribution date once per day
+#
+
+name: Bump Distribution Date
+
+on:
+  schedule:
+    - cron:  '0 0 * * *'
+
+jobs:
+  bump_date:
+
+    runs-on: ubuntu-latest
+
+    steps:
+
+    - name: Check out bugfix-2.0.x
+      uses: actions/checkout@v2
+      with:
+        ref: bugfix-2.0.x
+
+    - name: Bump Distribution Date
+      run: source ./buildroot/bin/bump_date
--- a/.github/workflows/test-builds.yml
+++ b/.github/workflows/test-builds.yml
@ -0,0 +1,100 @@
+#
+# test-builds.yml
+# Do test builds to catch compile errors
+#
+
+name: CI
+
+on:
+  pull_request:
+    branches:
+    - bugfix-2.0.x
+    - dev-2.1.x
+    paths-ignore:
+    - config/**
+    - data/**
+    - docs/**
+    - '**/*.md'
+
+jobs:
+  test_builds:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        test-platform:
+        # Base Environments
+
+        - DUE
+        - esp32
+        - linux_native
+        - megaatmega2560
+        - teensy31
+        - teensy35
+
+        # Extended AVR Environments
+
+        - FYSETC_F6_13
+        - megaatmega1280
+        - rambo
+        - sanguino_atmega1284p
+        - sanguino_atmega644p
+
+        # Extended STM32 Environments
+
+        - STM32F103RC_bigtree
+        - STM32F103RC_bigtree_USB
+        - STM32F103RE_bigtree
+        - STM32F103RE_bigtree_USB
+        - STM32F103RC_fysetc
+        - jgaurora_a5s_a1
+        - STM32F103VE_longer
+        - STM32F407VE_black
+        - BIGTREE_SKR_PRO
+        - mks_robin
+        - ARMED
+
+        # Put lengthy tests last
+
+        - LPC1768
+        - LPC1769
+
+        # STM32 with non-STM framework. both broken for now. they should use HAL_STM32 which is working.
+
+        #- STM32F4
+        #- STM32F7
+
+        # Non-working environment tests
+
+        #- BIGTREE_BTT002
+        #- at90usb1286_cdc
+        #- at90usb1286_dfu
+        #- STM32F103CB_malyan
+        #- mks_robin_lite
+        #- mks_robin_mini
+        #- mks_robin_nano
+        #- SAMD51_grandcentral_m4
+
+    steps:
+
+    - name: Select Python 3.7
+      uses: actions/setup-python@v1
+      with:
+        python-version: '3.7' # Version range or exact version of a Python version to use, using semvers version range syntax.
+        architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
+
+    - name: Install PlatformIO
+      run: |
+        pip install -U https://github.com/platformio/platformio-core/archive/master.zip
+        platformio update
+
+    - name: Check out the PR
+      uses: actions/checkout@v2
+
+    - name: Run ${{ matrix.test-platform }} Tests
+      run: |
+        chmod +x buildroot/bin/*
+        chmod +x buildroot/share/tests/*
+        export PATH=./buildroot/bin/:./buildroot/share/tests/:${PATH}
+        run_tests . ${{ matrix.test-platform }}
--- a/.travis.yml
+++ b/.travis.yml
@ -1,84 +0,0 @@
-dist: bionic
-sudo: false
-
-language: python
-python:
-  - "3.7"
-
-notifications:
-  email: false
-
-env:
-  # Base Environments
-  - TEST_PLATFORM="DUE"
-  - TEST_PLATFORM="esp32"
-  - TEST_PLATFORM="linux_native"
-  - TEST_PLATFORM="megaatmega2560"
-  - TEST_PLATFORM="teensy31"
-  - TEST_PLATFORM="teensy35"
-
-  # Extended AVR Environments
-  - TEST_PLATFORM="FYSETC_F6_13"
-  - TEST_PLATFORM="megaatmega1280"
-  - TEST_PLATFORM="rambo"
-  - TEST_PLATFORM="sanguino_atmega1284p"
-  - TEST_PLATFORM="sanguino_atmega644p"
-
-  # Extended STM32 Environments
-  - TEST_PLATFORM="STM32F103RC_bigtree"
-  - TEST_PLATFORM="STM32F103RC_bigtree_USB"
-  - TEST_PLATFORM="STM32F103RE_bigtree"
-  - TEST_PLATFORM="STM32F103RE_bigtree_USB"
-  - TEST_PLATFORM="STM32F103RC_fysetc"
-  - TEST_PLATFORM="jgaurora_a5s_a1"
-  - TEST_PLATFORM="STM32F103VE_longer"
-  - TEST_PLATFORM="STM32F407VE_black"
-  - TEST_PLATFORM="BIGTREE_SKR_PRO"
-  - TEST_PLATFORM="mks_robin"
-  - TEST_PLATFORM="ARMED"
-
-  # STM32 with non-STM framework. both broken for now. they should use HAL_STM32 which is working.
-  #- TEST_PLATFORM="STM32F4"
-  #- TEST_PLATFORM="STM32F7"
-
-  # Put lengthy tests last
-  - TEST_PLATFORM="LPC1768"
-  - TEST_PLATFORM="LPC1769"
-
-  # Non-working environment tests
-  #- TEST_PLATFORM="BIGTREE_BTT002" this board isn't released yet. we need pinout to be sure about what we do
-  #- TEST_PLATFORM="at90usb1286_cdc"
-  #- TEST_PLATFORM="at90usb1286_dfu"
-  #- TEST_PLATFORM="STM32F103CB_malyan"
-  #- TEST_PLATFORM="mks_robin_lite"
-  #- TEST_PLATFORM="mks_robin_mini"
-  #- TEST_PLATFORM="mks_robin_nano"
-  #- TEST_PLATFORM="SAMD51_grandcentral_m4"
-
-before_install:
-  #
-  # Fetch the tag information for the current branch
-  - git fetch origin --tags
-  #
-  # Publish the buildroot script folder
-  - chmod +x ${TRAVIS_BUILD_DIR}/buildroot/bin/*
-  - chmod +x ${TRAVIS_BUILD_DIR}/buildroot/share/tests/*
-  - export PATH=${TRAVIS_BUILD_DIR}/buildroot/bin/:${TRAVIS_BUILD_DIR}/buildroot/share/tests/:${PATH}
-
-install:
-  #- pip install -U platformio
-  - pip install -U https://github.com/platformio/platformio-core/archive/master.zip
-
-before_script:
-  # Update PlatformIO packages
-  - platformio update
-  #
-  # Change current working directory to the build dir
-  - cd ${TRAVIS_BUILD_DIR}
-  #
-  # Generate custom version include
-  - generate_version ${TRAVIS_BUILD_DIR}/Marlin/
-  - cat ${TRAVIS_BUILD_DIR}/Marlin/Version.h
-  #
-script:
-  - run_tests ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM}
--- a/Marlin/Configuration.h
+++ b/Marlin/Configuration.h
@ -855,6 +855,12 @@
 */
 //#define FIX_MOUNTED_PROBE

+/**
+ * Use the nozzle as the probe, as with a conductive
+ * nozzle system or a piezo-electric smart effector.
+ */
+//#define NOZZLE_AS_PROBE
+
 /**
 * Z Servo Probe, such as an endstop switch on a rotating arm.
 */
@ -1769,7 +1775,7 @@

 //
 // Makeboard 3D Printer Parts 3D Printer Mini Display 1602 Mini Controller
-// https://www.aliexpress.com/item/Micromake-Makeboard-3D-Printer-Parts-3D-Printer-Mini-Display-1602-Mini-Controller-Compatible-with-Ramps-1/32765887917.html
+// https://www.aliexpress.com/item/32765887917.html
 //
 //#define MAKEBOARD_MINI_2_LINE_DISPLAY_1602

@ -1943,7 +1949,7 @@

 //
 // Factory display for Creality CR-10
-// https://www.aliexpress.com/item/Universal-LCD-12864-3D-Printer-Display-Screen-With-Encoder-For-CR-10-CR-7-Model/32833148327.html
+// https://www.aliexpress.com/item/32833148327.html
 //
 // This is RAMPS-compatible using a single 10-pin connector.
 // (For CR-10 owners who want to replace the Melzi Creality board but retain the display)
@ -1961,7 +1967,7 @@

 //
 // AZSMZ 12864 LCD with SD
-// https://www.aliexpress.com/store/product/3D-printer-smart-controller-SMART-RAMPS-OR-RAMPS-1-4-LCD-12864-LCD-control-panel-green/2179173_32213636460.html
+// https://www.aliexpress.com/item/32837222770.html
 //
 //#define AZSMZ_12864

--- a/Marlin/Configuration_adv.h
+++ b/Marlin/Configuration_adv.h
@ -656,7 +656,7 @@
 //#define Z_STEPPER_AUTO_ALIGN
 #if ENABLED(Z_STEPPER_AUTO_ALIGN)
  // Define probe X and Y positions for Z1, Z2 [, Z3]
-  #define Z_STEPPER_ALIGN_XY { {  10, 290 }, { 150,  10 }, { 290, 290 } }
+  #define Z_STEPPER_ALIGN_XY { {  10, 190 }, { 100,  10 }, { 190, 190 } }

  // Provide Z stepper positions for more rapid convergence in bed alignment.
  // Currently requires triple stepper drivers.
@ -1548,12 +1548,12 @@
 /**
 * Maximum stepping rate (in Hz) the stepper driver allows
 *  If undefined, defaults to 1MHz / (2 * MINIMUM_STEPPER_PULSE)
- *  500000 : Maximum for A4988 stepper driver
- *  400000 : Maximum for TMC2xxx stepper drivers
- *  250000 : Maximum for DRV8825 stepper driver
- *  200000 : Maximum for LV8729 stepper driver
- *  150000 : Maximum for TB6600 stepper driver
- *   15000 : Maximum for TB6560 stepper driver
+ *  5000000 : Maximum for TMC2xxx stepper drivers
+ *  1000000 : Maximum for LV8729 stepper driver
+ *  500000  : Maximum for A4988 stepper driver
+ *  250000  : Maximum for DRV8825 stepper driver
+ *  150000  : Maximum for TB6600 stepper driver
+ *   15000  : Maximum for TB6560 stepper driver
 *
 * Override the default value based on the driver type set in Configuration.h.
 */
@ -1751,8 +1751,8 @@
  //#define ADVANCED_PAUSE_FANS_PAUSE             // Turn off print-cooling fans while the machine is paused.

                                                  // Filament Unload does a Retract, Delay, and Purge first:
-  #define FILAMENT_UNLOAD_RETRACT_LENGTH      13  // (mm) Unload initial retract length.
-  #define FILAMENT_UNLOAD_DELAY             5000  // (ms) Delay for the filament to cool after retract.
+  #define FILAMENT_UNLOAD_PURGE_RETRACT       13  // (mm) Unload initial retract length.
+  #define FILAMENT_UNLOAD_PURGE_DELAY       5000  // (ms) Delay for the filament to cool after retract.
  #define FILAMENT_UNLOAD_PURGE_LENGTH         8  // (mm) An unretract is done, then this length is purged.

  #define PAUSE_PARK_NOZZLE_TIMEOUT           45  // (seconds) Time limit before the nozzle is turned off for safety.
@ -2128,8 +2128,6 @@
   *
   * IMPROVE_HOMING_RELIABILITY tunes acceleration and jerk when
   * homing and adds a guard period for endstop triggering.
-   *
-   * TMC2209 requires STEALTHCHOP enabled for SENSORLESS_HOMING
   */
  //#define SENSORLESS_HOMING // StallGuard capable drivers only

@ -2148,7 +2146,6 @@
    #define Y_STALL_SENSITIVITY  8
    //#define Z_STALL_SENSITIVITY  8
    //#define SPI_ENDSTOPS              // TMC2130 only
-    //#define HOME_USING_SPREADCYCLE
    //#define IMPROVE_HOMING_RELIABILITY
  #endif

--- a/Marlin/Makefile
+++ b/Marlin/Makefile
@ -188,7 +188,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1109)
 else ifeq ($(HARDWARE_MOTHERBOARD),1110)
 # zrib V2.0 control board (Chinese knock off RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1111)
-# Bigtreetech or BIQU KFB2.0
+# BigTreeTech or BIQU KFB2.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1112)
 # Felix 2.0+ Electronics Board (RAMPS like)
 else ifeq ($(HARDWARE_MOTHERBOARD),1113)
--- a/Marlin/src/HAL/HAL_AVR/inc/SanityCheck.h
+++ b/Marlin/src/HAL/HAL_AVR/inc/SanityCheck.h
@ -39,7 +39,7 @@
 * Checks for FAST PWM
 */
 #if ENABLED(FAST_PWM_FAN) && (ENABLED(USE_OCR2A_AS_TOP) && defined(TCCR2))
-    #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
+  #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
 #endif

 /**
--- a/Marlin/src/HAL/HAL_AVR/pinsDebug.h
+++ b/Marlin/src/HAL/HAL_AVR/pinsDebug.h
@ -26,7 +26,10 @@

 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS

+#define AVR_ATmega2560_FAMILY_PLUS_70 MB(BQ_ZUM_MEGA_3D, MIGHTYBOARD_REVE, MINIRAMBO, SCOOVO_X9H)
+
 #if AVR_AT90USB1286_FAMILY
+
  // Working with Teensyduino extension so need to re-define some things
  #include "pinsDebug_Teensyduino.h"
  // Can't use the "digitalPinToPort" function from the Teensyduino type IDEs
@ -35,7 +38,9 @@
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
  #define digitalPinToPort_DEBUG(p) digitalPinToPort_Teensy(p)
  #define GET_PINMODE(pin) (*portModeRegister(pin) & digitalPinToBitMask_DEBUG(pin))
+
 #elif AVR_ATmega2560_FAMILY_PLUS_70   // So we can access/display all the pins on boards using more than 70
+
  #include "pinsDebug_plus_70.h"
  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer_plus_70(p)
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask_plus_70(p)
@ -43,11 +48,13 @@
  bool GET_PINMODE(int8_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }

 #else
+
  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer(p)
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
  #define digitalPinToPort_DEBUG(p) digitalPinToPort(p)
  bool GET_PINMODE(int8_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
  #define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].pin)
+
 #endif

 #define VALID_PIN(pin) (pin >= 0 && pin < NUM_DIGITAL_PINS ? 1 : 0)
--- a/Marlin/src/HAL/HAL_ESP32/HAL.cpp
+++ b/Marlin/src/HAL/HAL_ESP32/HAL.cpp
@ -30,7 +30,7 @@

 #include "../../inc/MarlinConfigPre.h"

-#if EITHER(EEPROM_SETTINGS, WEBSUPPORT)
+#if ENABLED(WEBSUPPORT)
  #include "spiffs.h"
 #endif

@ -83,7 +83,7 @@ void HAL_init() {
 }

 void HAL_init_board() {
-  #if EITHER(EEPROM_SETTINGS, WEBSUPPORT)
+  #if ENABLED(WEBSUPPORT)
    spiffs_init();
  #endif

--- a/Marlin/src/HAL/HAL_ESP32/WebSocketSerial.h
+++ b/Marlin/src/HAL/HAL_ESP32/WebSocketSerial.h
@ -25,14 +25,16 @@

 #include <Stream.h>

-#ifndef RX_BUFFER_SIZE
-  #define RX_BUFFER_SIZE 128
-#endif
 #ifndef TX_BUFFER_SIZE
  #define TX_BUFFER_SIZE 32
 #endif
-#if TX_BUFFER_SIZE <= 0
-  #error "TX_BUFFER_SIZE is required for the WebSocket."
+#if ENABLED(WIFISUPPORT)
+  #ifndef RX_BUFFER_SIZE
+    #define RX_BUFFER_SIZE 128
+  #endif
+  #if TX_BUFFER_SIZE <= 0
+    #error "TX_BUFFER_SIZE is required for the WebSocket."
+  #endif
 #endif

 typedef uint16_t ring_buffer_pos_t;
--- a/Marlin/src/HAL/HAL_ESP32/persistent_store_impl.cpp
+++ b/Marlin/src/HAL/HAL_ESP32/persistent_store_impl.cpp
@ -0,0 +1,63 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2019 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/>.
+ *
+ */
+
+#ifdef ARDUINO_ARCH_ESP32
+
+#include "../../inc/MarlinConfig.h"
+
+#if ENABLED(EEPROM_SETTINGS) && DISABLED(FLASH_EEPROM_EMULATION)
+
+#include "../shared/persistent_store_api.h"
+#include "EEPROM.h"
+
+#define EEPROM_SIZE 4096
+
+bool PersistentStore::access_start() {
+  return EEPROM.begin(EEPROM_SIZE);
+}
+
+bool PersistentStore::access_finish() {
+  EEPROM.end();
+  return true;
+}
+
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+  for (size_t i = 0; i < size; i++) {
+    EEPROM.write(pos++, value[i]);
+    crc16(crc, &value[i], 1);
+  }
+  return false;
+}
+
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+  for (size_t i = 0; i < size; i++) {
+    uint8_t c = EEPROM.read(pos++);
+    if (writing) value[i] = c;
+    crc16(crc, &c, 1);
+  }
+  return false;
+}
+
+size_t PersistentStore::capacity() { return EEPROM_SIZE; }
+
+#endif // EEPROM_SETTINGS
+#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/HAL_ESP32/persistent_store_spiffs.cpp
+++ b/Marlin/src/HAL/HAL_ESP32/persistent_store_spiffs.cpp
@ -1,106 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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/>.
- *
- */
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(EEPROM_SETTINGS) && DISABLED(FLASH_EEPROM_EMULATION)
-
-#include "../shared/persistent_store_api.h"
-
-#include <SPIFFS.h>
-#include <FS.h>
-#include "spiffs.h"
-
-#define HAL_ESP32_EEPROM_SIZE 4096
-#define HAL_ESP32_EEPROM_FILE_PATH "/eeprom.dat"
-
-File eeprom_file;
-
-bool PersistentStore::access_start() {
-  if (spiffs_initialized) {
-    eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "r+");
-
-    size_t file_size = eeprom_file.size();
-    if (file_size < HAL_ESP32_EEPROM_SIZE) {
-      SERIAL_ECHO_MSG("SPIFFS EEPROM settings file " HAL_ESP32_EEPROM_FILE_PATH " is too small or did not exist, expanding.");
-      SERIAL_ECHO_START(); SERIAL_ECHOLNPAIR(" file size: ", file_size, ", required size: ", HAL_ESP32_EEPROM_SIZE);
-
-      // mode r+ does not allow to expand the file (at least on ESP32 SPIFFS9, so we close, reopen "a", append, close, reopen "r+"
-      eeprom_file.close();
-
-      eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "a");
-      for (size_t i = eeprom_file.size(); i < HAL_ESP32_EEPROM_SIZE; i++)
-        eeprom_file.write(0xFF);
-      eeprom_file.close();
-
-      eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "r+");
-      file_size = eeprom_file.size();
-      if (file_size < HAL_ESP32_EEPROM_SIZE) {
-        SERIAL_ERROR_MSG("Failed to expand " HAL_ESP32_EEPROM_FILE_PATH " to required size. SPIFFS partition full?");
-        SERIAL_ERROR_START(); SERIAL_ECHOLNPAIR(" file size: ", file_size, ", required size: ", HAL_ESP32_EEPROM_SIZE);
-        SERIAL_ERROR_START(); SERIAL_ECHOLNPAIR(" SPIFFS used bytes: ", SPIFFS.usedBytes(), ", total bytes: ", SPIFFS.totalBytes());
-      }
-    }
-    return true;
-  }
-  return false;
-}
-
-bool PersistentStore::access_finish() {
-  eeprom_file.close();
-  return true;
-}
-
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  if (!eeprom_file.seek(pos)) return true; // return true for any error
-  if (eeprom_file.write(value, size) != size) return true;
-
-  crc16(crc, value, size);
-  pos += size;
-
-  return false;
-}
-
-bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  if (!eeprom_file.seek(pos)) return true; // return true for any error
-
-  if (writing) {
-    if (eeprom_file.read(value, size) != size) return true;
-    crc16(crc, value, size);
-  }
-  else {
-    uint8_t tmp[size];
-    if (eeprom_file.read(tmp, size) != size) return true;
-    crc16(crc, tmp, size);
-  }
-
-  pos += size;
-
-  return false;
-}
-
-size_t PersistentStore::capacity() { return HAL_ESP32_EEPROM_SIZE; }
-
-#endif // EEPROM_SETTINGS
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/HAL_ESP32/spiffs.cpp
+++ b/Marlin/src/HAL/HAL_ESP32/spiffs.cpp
@ -24,7 +24,7 @@

 #include "../../inc/MarlinConfigPre.h"

-#if EITHER(WEBSUPPORT, EEPROM_SETTINGS)
+#if ENABLED(WEBSUPPORT)

 #include "../../core/serial.h"

--- a/Marlin/src/HAL/HAL_ESP32/watchdog.h
+++ b/Marlin/src/HAL/HAL_ESP32/watchdog.h
@ -21,8 +21,18 @@
 */
 #pragma once

+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+    esp_err_t esp_task_wdt_reset();
+
+#ifdef __cplusplus
+  }
+#endif
+
 // Initialize watchdog with a 4 second interrupt time
 void watchdog_init();

 // Reset watchdog.
-inline void HAL_watchdog_refresh() {}
+inline void HAL_watchdog_refresh() { esp_task_wdt_reset(); }
--- a/Marlin/src/HAL/HAL_LPC1768/inc/SanityCheck.h
+++ b/Marlin/src/HAL/HAL_LPC1768/inc/SanityCheck.h
@ -68,3 +68,7 @@
 #if IS_RE_ARM_BOARD && ENABLED(REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER) && HAS_DRIVER(TMC2130) && DISABLED(TMC_USE_SW_SPI)
  #error "Re-ARM with REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER and TMC2130 require TMC_USE_SW_SPI"
 #endif
+
+#if ENABLED(BAUD_RATE_GCODE)
+  #error "BAUD_RATE_GCODE is not yet supported on LPC176x."
+#endif
--- a/Marlin/src/HAL/HAL_SAMD51/inc/SanityCheck.h
+++ b/Marlin/src/HAL/HAL_SAMD51/inc/SanityCheck.h
@ -36,7 +36,7 @@
 #endif

 #if ENABLED(SDIO_SUPPORT)
-  #error "SDIO_SUPPORT is not supported."
+  #error "SDIO_SUPPORT is not supported on SAMD51."
 #endif

 #if ENABLED(FAST_PWM_FAN)
--- a/Marlin/src/HAL/HAL_STM32/HAL_SPI.cpp
+++ b/Marlin/src/HAL/HAL_STM32/HAL_SPI.cpp
@ -83,6 +83,13 @@ void spiInit(uint8_t spiRate) {
  }
  spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0);

+  #if ENABLED(CUSTOM_SPI_PINS)
+    SPI.setMISO(MISO_PIN);
+    SPI.setMOSI(MOSI_PIN);
+    SPI.setSCLK(SCK_PIN);
+    SPI.setSSEL(SS_PIN);
+  #endif
+
  SPI.begin();
 }

--- a/Marlin/src/HAL/HAL_STM32/Servo.cpp
+++ b/Marlin/src/HAL/HAL_STM32/Servo.cpp
@ -28,25 +28,30 @@

 #include "Servo.h"

-uint8_t servoPin[MAX_SERVOS] = { 0 };
+static uint_fast8_t servoCount = 0;
+constexpr millis_t servoDelay[] = SERVO_DELAY;
+static_assert(COUNT(servoDelay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");
+
+libServo::libServo()
+: delay(servoDelay[servoCount++])
+{}

 int8_t libServo::attach(const int pin) {
-  if (servoIndex >= MAX_SERVOS) return -1;
-  if (pin > 0) servoPin[servoIndex] = pin;
-  return super::attach(servoPin[servoIndex]);
+  if (servoCount >= MAX_SERVOS) return -1;
+  if (pin > 0) servo_pin = pin;
+  return super::attach(servo_pin);
 }

 int8_t libServo::attach(const int pin, const int min, const int max) {
-  if (pin > 0) servoPin[servoIndex] = pin;
-  return super::attach(servoPin[servoIndex], min, max);
+  if (servoCount >= MAX_SERVOS) return -1;
+  if (pin > 0) servo_pin = pin;
+  return super::attach(servo_pin, min, max);
 }

 void libServo::move(const int value) {
-  constexpr uint16_t servo_delay[] = SERVO_DELAY;
-  static_assert(COUNT(servo_delay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");
  if (attach(0) >= 0) {
    write(value);
-    safe_delay(servo_delay[servoIndex]);
+    safe_delay(delay);
    #if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE)
      detach();
    #endif
--- a/Marlin/src/HAL/HAL_STM32/Servo.h
+++ b/Marlin/src/HAL/HAL_STM32/Servo.h
@ -27,11 +27,13 @@
 // Inherit and expand on the official library
 class libServo : public Servo {
  public:
+    libServo();
    int8_t attach(const int pin);
    int8_t attach(const int pin, const int min, const int max);
    void move(const int value);
  private:
    typedef Servo super;
-    uint16_t min_ticks, max_ticks;
-    uint8_t servoIndex;               // index into the channel data for this servo
+
+    int servo_pin = 0;
+    millis_t delay = 0;
 };
--- a/Marlin/src/HAL/HAL_STM32/SoftwareSerial.cpp
+++ b/Marlin/src/HAL/HAL_STM32/SoftwareSerial.cpp
@ -34,7 +34,7 @@
 //
 // Includes
 //
-#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)
+#if defined(PLATFORMIO) && defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)

 #include "SoftwareSerial.h"
 #include "timers.h"
--- a/Marlin/src/HAL/HAL_STM32/persistent_store_flash.cpp
+++ b/Marlin/src/HAL/HAL_STM32/persistent_store_flash.cpp
@ -0,0 +1,265 @@
+/**
+ * Marlin 3D Printer Firmware
+ *
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
+ * Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
+ *
+ * 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/>.
+ *
+ */
+
+#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)
+
+#include "../../inc/MarlinConfig.h"
+
+#if BOTH(EEPROM_SETTINGS, FLASH_EEPROM_EMULATION)
+
+#include "../shared/persistent_store_api.h"
+
+
+// Only STM32F4 can support wear leveling at this time
+#ifndef STM32F4xx
+  #undef FLASH_EEPROM_LEVELING
+#endif
+
+/**
+ * The STM32 HAL supports chips that deal with "pages" and some with "sectors" and some that
+ * even have multiple "banks" of flash.
+ *
+ * This code is a bit of a mashup of
+ *   framework-arduinoststm32/cores/arduino/stm32/stm32_eeprom.c
+ *   hal/hal_lpc1768/persistent_store_flash.cpp
+ *
+ * This has only be written against those that use a single "sector" design.
+ *
+ * Those that deal with "pages" could be made to work. Looking at the STM32F07 for example, there are
+ * 128 "pages", each 2kB in size. If we continued with our EEPROM being 4Kb, we'd always need to operate
+ * on 2 of these pages. Each write, we'd use 2 different pages from a pool of pages until we are done.
+ */
+
+#if ENABLED(FLASH_EEPROM_LEVELING)
+
+  #include "stm32_def.h"
+
+  #define DEBUG_OUT ENABLED(EEPROM_CHITCHAT)
+  #include "src/core/debug_out.h"
+
+  #ifndef EEPROM_SIZE
+    #define EEPROM_SIZE           0x1000  // 4kB
+  #endif
+
+  #ifndef FLASH_SECTOR
+    #define FLASH_SECTOR          (FLASH_SECTOR_TOTAL - 1)
+  #endif
+  #ifndef FLASH_UNIT_SIZE
+    #define FLASH_UNIT_SIZE       0x20000 // 128kB
+  #endif
+
+  #define FLASH_ADDRESS_START     (FLASH_END - ((FLASH_SECTOR_TOTAL - FLASH_SECTOR) * FLASH_UNIT_SIZE) + 1)
+  #define FLASH_ADDRESS_END       (FLASH_ADDRESS_START + FLASH_UNIT_SIZE  - 1)
+
+  #define EEPROM_SLOTS            (FLASH_UNIT_SIZE/EEPROM_SIZE)
+  #define SLOT_ADDRESS(slot)      (FLASH_ADDRESS_START + (slot * EEPROM_SIZE))
+
+  #define UNLOCK_FLASH()          if (!flash_unlocked) { \
+                                    HAL_FLASH_Unlock(); \
+                                    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | \
+                                                           FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR); \
+                                    flash_unlocked = true; \
+                                  }
+  #define LOCK_FLASH()            if (flash_unlocked) { HAL_FLASH_Lock(); flash_unlocked = false; }
+
+  #define EMPTY_UINT32            ((uint32_t)-1)
+  #define EMPTY_UINT8             ((uint8_t)-1)
+
+  static uint8_t ram_eeprom[EEPROM_SIZE] __attribute__((aligned(4))) = {0};
+  static int current_slot = -1;
+
+  static_assert(0 == EEPROM_SIZE % 4, "EEPROM_SIZE must be a multiple of 4"); // Ensure copying as uint32_t is safe
+  static_assert(0 == FLASH_UNIT_SIZE % EEPROM_SIZE, "EEPROM_SIZE must divide evenly into your FLASH_UNIT_SIZE");
+  static_assert(FLASH_UNIT_SIZE >= EEPROM_SIZE, "FLASH_UNIT_SIZE must be greater than or equal to your EEPROM_SIZE");
+  static_assert(IS_FLASH_SECTOR(FLASH_SECTOR), "FLASH_SECTOR is invalid");
+  static_assert(IS_POWER_OF_2(FLASH_UNIT_SIZE), "FLASH_UNIT_SIZE should be a power of 2, please check your chip's spec sheet");
+
+#endif
+
+static bool eeprom_data_written = false;
+
+bool PersistentStore::access_start() {
+
+  #if ENABLED(FLASH_EEPROM_LEVELING)
+
+    if (current_slot == -1 || eeprom_data_written) {
+      // This must be the first time since power on that we have accessed the storage, or someone
+      // loaded and called write_data and never called access_finish.
+      // Lets go looking for the slot that holds our configuration.
+      if (eeprom_data_written) DEBUG_ECHOLN("Dangling EEPROM write_data");
+      uint32_t address = FLASH_ADDRESS_START;
+      while (address <= FLASH_ADDRESS_END) {
+        uint32_t address_value = (*(__IO uint32_t*)address);
+        if (address_value != EMPTY_UINT32) {
+          current_slot = (address - FLASH_ADDRESS_START) / EEPROM_SIZE;
+          break;
+        }
+        address += sizeof(uint32_t);
+      }
+      if (current_slot == -1) {
+        // We didn't find anything, so we'll just intialize to empty
+        for (int i = 0; i < EEPROM_SIZE; i++) ram_eeprom[i] = EMPTY_UINT8;
+        current_slot = EEPROM_SLOTS;
+      }
+      else {
+        // load current settings
+        uint8_t *eeprom_data = (uint8_t *)SLOT_ADDRESS(current_slot);
+        for (int i = 0; i < EEPROM_SIZE; i++) ram_eeprom[i] = eeprom_data[i];
+        DEBUG_ECHOLNPAIR("EEPROM loaded from slot ", current_slot, ".");
+      }
+      eeprom_data_written = false;
+    }
+
+  #else
+    eeprom_buffer_fill();
+  #endif
+
+  return true;
+}
+
+bool PersistentStore::access_finish() {
+
+  if (eeprom_data_written) {
+
+    #if ENABLED(FLASH_EEPROM_LEVELING)
+
+      HAL_StatusTypeDef status = HAL_ERROR;
+      bool flash_unlocked = false;
+
+      if (--current_slot < 0) {
+        // all slots have been used, erase everything and start again
+
+        FLASH_EraseInitTypeDef EraseInitStruct;
+        uint32_t SectorError = 0;
+
+        EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
+        EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_3;
+        EraseInitStruct.Sector = FLASH_SECTOR;
+        EraseInitStruct.NbSectors = 1;
+
+        current_slot = EEPROM_SLOTS - 1;
+        UNLOCK_FLASH();
+
+        status = HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError);
+        if (status != HAL_OK) {
+          DEBUG_ECHOLNPAIR("HAL_FLASHEx_Erase=", status);
+          DEBUG_ECHOLNPAIR("GetError=", HAL_FLASH_GetError());
+          DEBUG_ECHOLNPAIR("SectorError=", SectorError);
+          LOCK_FLASH();
+          return false;
+        }
+      }
+
+      UNLOCK_FLASH();
+
+      uint32_t offset = 0;
+      uint32_t address = SLOT_ADDRESS(current_slot);
+      uint32_t address_end = address + EEPROM_SIZE;
+      uint32_t data = 0;
+
+      bool success = true;
+
+      while (address < address_end) {
+        memcpy(&data, ram_eeprom + offset, sizeof(uint32_t));
+        status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, data);
+        if (status == HAL_OK) {
+          address += sizeof(uint32_t);
+          offset += sizeof(uint32_t);
+        }
+        else {
+          DEBUG_ECHOLNPAIR("HAL_FLASH_Program=", status);
+          DEBUG_ECHOLNPAIR("GetError=", HAL_FLASH_GetError());
+          DEBUG_ECHOLNPAIR("address=", address);
+          success = false;
+          break;
+        }
+      }
+
+      LOCK_FLASH();
+
+      if (success) {
+        eeprom_data_written = false;
+        DEBUG_ECHOLNPAIR("EEPROM saved to slot ", current_slot, ".");
+      }
+
+      return success;
+
+    #else
+      eeprom_buffer_flush();
+      eeprom_data_written = false;
+    #endif
+  }
+
+  return true;
+}
+
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+  while (size--) {
+    uint8_t v = *value;
+    #if ENABLED(FLASH_EEPROM_LEVELING)
+      if (v != ram_eeprom[pos]) {
+        ram_eeprom[pos] = v;
+        eeprom_data_written = true;
+      }
+    #else
+      if (v != eeprom_buffered_read_byte(pos)) {
+        eeprom_buffered_write_byte(pos, v);
+        eeprom_data_written = true;
+      }
+    #endif
+    crc16(crc, &v, 1);
+    pos++;
+    value++;
+  }
+  return false;
+}
+
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+  do {
+    const uint8_t c = (
+      #if ENABLED(FLASH_EEPROM_LEVELING)
+        ram_eeprom[pos]
+      #else
+        eeprom_buffered_read_byte(pos)
+      #endif
+    );
+    if (writing) *value = c;
+    crc16(crc, &c, 1);
+    pos++;
+    value++;
+  } while (--size);
+  return false;
+}
+
+size_t PersistentStore::capacity() {
+  return (
+    #if ENABLED(FLASH_EEPROM_LEVELING)
+      EEPROM_SIZE
+    #else
+      E2END + 1
+    #endif
+  );
+}
+
+#endif // EEPROM_SETTINGS && FLASH_EEPROM_EMULATION
+#endif // ARDUINO_ARCH_STM32 && !STM32GENERIC
--- a/Marlin/src/HAL/HAL_STM32/persistent_store_impl.cpp
+++ b/Marlin/src/HAL/HAL_STM32/persistent_store_impl.cpp
@ -24,29 +24,15 @@

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

-#if ENABLED(EEPROM_SETTINGS) && ANY(FLASH_EEPROM_EMULATION, SRAM_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)
+#if ENABLED(EEPROM_SETTINGS) && ANY(SRAM_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)

 #include "../shared/persistent_store_api.h"

-#if ENABLED(FLASH_EEPROM_EMULATION)
-  #include <EEPROM.h>
-  static bool eeprom_data_written = false;
-#endif
-
 bool PersistentStore::access_start() {
-  #if ENABLED(FLASH_EEPROM_EMULATION)
-    eeprom_buffer_fill();
-  #endif
  return true;
 }

 bool PersistentStore::access_finish() {
-  #if ENABLED(FLASH_EEPROM_EMULATION)
-    if (eeprom_data_written) {
-      eeprom_buffer_flush();
-      eeprom_data_written = false;
-    }
-  #endif
  return true;
 }

@ -66,8 +52,6 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
          return true;
        }
      }
-    #elif ENABLED(FLASH_EEPROM_EMULATION)
-      eeprom_buffered_write_byte(pos, v);
    #else
      *(__IO uint8_t *)(BKPSRAM_BASE + (uint8_t * const)pos) = v;
    #endif
@ -76,9 +60,6 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
    pos++;
    value++;
  };
-  #if ENABLED(FLASH_EEPROM_EMULATION)
-    eeprom_data_written = true;
-  #endif

  return false;
 }
@ -89,8 +70,6 @@ bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t
    const uint8_t c = (
      #if EITHER(SPI_EEPROM, I2C_EEPROM)
        eeprom_read_byte((uint8_t*)pos)
-      #elif ENABLED(FLASH_EEPROM_EMULATION)
-        eeprom_buffered_read_byte(pos)
      #else
        (*(__IO uint8_t *)(BKPSRAM_BASE + ((uint8_t*)pos)))
      #endif
@ -114,5 +93,5 @@ size_t PersistentStore::capacity() {
  );
 }

-#endif // EEPROM_SETTINGS && (FLASH_EEPROM_EMULATION || SRAM_EEPROM_EMULATION || SPI_EEPROM || I2C_EEPROM)
+#endif // EEPROM_SETTINGS && (SRAM_EEPROM_EMULATION || SPI_EEPROM || I2C_EEPROM)
 #endif // ARDUINO_ARCH_STM32 && !STM32GENERIC
--- a/Marlin/src/HAL/HAL_STM32F1/persistent_store_flash.cpp
+++ b/Marlin/src/HAL/HAL_STM32F1/persistent_store_flash.cpp
@ -40,53 +40,73 @@
 #include <EEPROM.h>

 // Store settings in the last two pages
-// Flash pages must be erased before writing, so keep track.
-bool firstWrite = false;
+#define EEPROM_SIZE (EEPROM_PAGE_SIZE * 2)
+#define ACCESS_FINISHED(TF) do{ FLASH_Lock(); eeprom_dirty = false; return TF; }while(0)
+
+static uint8_t ram_eeprom[EEPROM_SIZE] __attribute__((aligned(4))) = {0};
+static bool eeprom_dirty = false;

 bool PersistentStore::access_start() {
-  firstWrite = true;
+  const uint32_t* source = reinterpret_cast<const uint32_t*>(EEPROM_PAGE0_BASE);
+  uint32_t* destination = reinterpret_cast<uint32_t*>(ram_eeprom);
+
+  static_assert(0 == EEPROM_SIZE % 4, "EEPROM_SIZE is corrupted. (Must be a multiple of 4.)"); // Ensure copying as uint32_t is safe
+  constexpr size_t eeprom_size_u32 = EEPROM_SIZE / 4;
+
+  for (size_t i = 0; i < eeprom_size_u32; ++i, ++destination, ++source)
+    *destination = *source;
+
+  eeprom_dirty = false;
  return true;
 }

 bool PersistentStore::access_finish() {
-  FLASH_Lock();
-  firstWrite = false;
+
+  if (eeprom_dirty) {
+    FLASH_Status status;
+
+    // Instead of erasing all (both) pages, maybe in the loop we check what page we are in, and if the
+    // data has changed in that page. We then erase the first time we "detect" a change. In theory, if
+    // nothing changed in a page, we wouldn't need to erase/write it.
+    // Or, instead of checking at this point, turn eeprom_dirty into an array of bool the size of number
+    // of pages. Inside write_data, we set the flag to true at that time if something in that
+    // page changes...either way, something to look at later.
+    FLASH_Unlock();
+
+    status = FLASH_ErasePage(EEPROM_PAGE0_BASE);
+    if (status != FLASH_COMPLETE) ACCESS_FINISHED(true);
+    status = FLASH_ErasePage(EEPROM_PAGE1_BASE);
+    if (status != FLASH_COMPLETE) ACCESS_FINISHED(true);
+
+    const uint16_t *source = reinterpret_cast<const uint16_t*>(ram_eeprom);
+    for (size_t i = 0; i < EEPROM_SIZE; i += 2, ++source) {
+      if (FLASH_ProgramHalfWord(EEPROM_PAGE0_BASE + i, *source) != FLASH_COMPLETE)
+        ACCESS_FINISHED(false);
+    }
+
+    ACCESS_FINISHED(true);
+  }
+
  return true;
 }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  FLASH_Status status;
-
-  if (firstWrite) {
-    FLASH_Unlock();
-    status = FLASH_ErasePage(EEPROM_PAGE0_BASE);
-    if (status != FLASH_COMPLETE) return true;
-    status = FLASH_ErasePage(EEPROM_PAGE1_BASE);
-    if (status != FLASH_COMPLETE) return true;
-    firstWrite = false;
-  }
-
-  for (size_t i = 0; i < size; i++) {
-    if (FLASH_ProgramHalfWord(EEPROM_PAGE0_BASE + (pos + i) * 2, value[i]) != FLASH_COMPLETE)
-      return true;
-  }
-
+  for (size_t i = 0; i < size; ++i) ram_eeprom[pos + i] = value[i];
+  eeprom_dirty = true;
  crc16(crc, value, size);
  pos += size;
-  return false;
+  return false;  // return true for any error
 }

 bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  for (size_t i = 0; i < size; i++) {
-    uint8_t v = *(uint16_t *)(EEPROM_PAGE0_BASE + (pos + i) * 2);
-    if (writing) value[i] = v;
-    crc16(crc, &v, 1);
-  }
+  const uint8_t * const buff = writing ? &value[0] : &ram_eeprom[pos];
+  if (writing) for (size_t i = 0; i < size; i++) value[i] = ram_eeprom[pos + i];
+  crc16(crc, buff, size);
  pos += size;
-  return false;
+  return false;  // return true for any error
 }

-size_t PersistentStore::capacity() { return size_t(E2END + 1); }
+size_t PersistentStore::capacity() { return EEPROM_SIZE; }

 #endif // EEPROM_SETTINGS && EEPROM FLASH
 #endif // __STM32F1__
--- a/Marlin/src/Marlin.cpp
+++ b/Marlin/src/Marlin.cpp
@ -553,7 +553,7 @@ void manage_inactivity(const bool ignore_stepper_queue/*=false*/) {
        bool oldstatus;
        switch (active_extruder) {
          default:
-          #define _CASE_EN(N) case N: oldstatus = E##N_ENABLE_READ(); enable_E##N(); break;
+          #define _CASE_EN(N) case N: oldstatus = E##N##_ENABLE_READ(); enable_E##N(); break;
          REPEAT(E_STEPPERS, _CASE_EN);
        }
      #endif
--- a/Marlin/src/core/boards.h
+++ b/Marlin/src/core/boards.h
@ -64,7 +64,7 @@
 #define BOARD_MKS_BASE_HEROIC         1108  // MKS BASE 1.0 with Heroic HR4982 stepper drivers
 #define BOARD_MKS_GEN_13              1109  // MKS GEN v1.3 or 1.4
 #define BOARD_MKS_GEN_L               1110  // MKS GEN L
-#define BOARD_KFB_2                   1111  // Bigtreetech or BIQU KFB2.0
+#define BOARD_KFB_2                   1111  // BigTreeTech or BIQU KFB2.0
 #define BOARD_ZRIB_V20                1112  // zrib V2.0 control board (Chinese knock off RAMPS replica)
 #define BOARD_FELIX2                  1113  // Felix 2.0+ Electronics Board (RAMPS like)
 #define BOARD_RIGIDBOARD              1114  // Invent-A-Part RigidBoard
@ -208,14 +208,15 @@
 #define BOARD_COHESION3D_MINI         2011  // Cohesion3D Mini
 #define BOARD_SMOOTHIEBOARD           2012  // Smoothieboard
 #define BOARD_AZTEEG_X5_MINI_WIFI     2013  // Azteeg X5 Mini Wifi (Power outputs: Hotend0, Bed, Fan)
-#define BOARD_BIGTREE_SKR_V1_1        2014  // BIGTREE SKR_V1.1 (Power outputs: Hotend0,Hotend1, Fan, Bed)
-#define BOARD_BIQU_B300_V1_0          2015  // BIQU B300_V1.0 (Power outputs: Hotend0, Fan, Bed, SPI Driver)
-#define BOARD_BIGTREE_SKR_V1_3        2016  // BIGTREE SKR_V1.3 (Power outputs: Hotend0, Hotend1, Fan, Bed)
-#define BOARD_AZTEEG_X5_MINI          2017  // Azteeg X5 Mini (Power outputs: Hotend0, Bed, Fan)
-#define BOARD_MKS_SGEN                2018  // MKS-SGen (Power outputs: Hotend0, Hotend1, Bed, Fan)
-#define BOARD_MKS_SGEN_L              2019  // MKS-SGen-L (Power outputs: Hotend0, Hotend1, Bed, Fan)
-#define BOARD_TH3D_EZBOARD            2020  // TH3D EZBoard v1.0
-#define BOARD_GMARSH_X6_REV1          2021  // GMARSH X6 board, revision 1 prototype
+#define BOARD_BIQU_B300_V1_0          2014  // BIQU B300_V1.0 (Power outputs: Hotend0, Fan, Bed, SPI Driver)
+#define BOARD_AZTEEG_X5_MINI          2015  // Azteeg X5 Mini (Power outputs: Hotend0, Bed, Fan)
+#define BOARD_MKS_SGEN                2016  // MKS-SGen (Power outputs: Hotend0, Hotend1, Bed, Fan)
+#define BOARD_MKS_SGEN_L              2017  // MKS-SGen-L (Power outputs: Hotend0, Hotend1, Bed, Fan)
+#define BOARD_TH3D_EZBOARD            2018  // TH3D EZBoard v1.0
+#define BOARD_GMARSH_X6_REV1          2019  // GMARSH X6 board, revision 1 prototype
+#define BOARD_BIGTREE_SKR_V1_1        2020  // BigTreeTech SKR v1.1 (Power outputs: Hotend0, Hotend1, Fan, Bed)
+#define BOARD_BIGTREE_SKR_V1_3        2021  // BigTreeTech SKR v1.3 (Power outputs: Hotend0, Hotend1, Fan, Bed)
+#define BOARD_BIGTREE_SKR_V1_4        2022  // BigTreeTech SKR v1.4 (Power outputs: Hotend0, Hotend1, Fan, Bed)

 //
 // SAM3X8E ARM Cortex M3
@ -269,18 +270,21 @@
 #define BOARD_MKS_ROBIN_MINI          4007  // MKS Robin Mini (STM32F103VET6)
 #define BOARD_MKS_ROBIN_NANO          4008  // MKS Robin Nano (STM32F103VET6)
 #define BOARD_MKS_ROBIN_LITE          4009  // MKS Robin Lite/Lite2 (STM32F103RCT6)
-#define BOARD_BIGTREE_SKR_MINI_V1_1   4010  // BigTreeTech SKR Mini v1.1 (STM32F103RC)
-#define BOARD_BTT_SKR_MINI_E3_V1_0    4011  // BigTreeTech SKR Mini E3 (STM32F103RC)
-#define BOARD_BTT_SKR_MINI_E3_V1_2    4012  // BigTreeTech SKR Mini E3 V1.2 (STM32F103RC)
-#define BOARD_BIGTREE_SKR_E3_DIP      4013  // BigTreeTech SKR E3 DIP V1.0 (STM32F103RC / STM32F103RE)
-#define BOARD_JGAURORA_A5S_A1         4014  // JGAurora A5S A1 (STM32F103ZET6)
-#define BOARD_FYSETC_AIO_II           4015  // FYSETC AIO_II
-#define BOARD_FYSETC_CHEETAH          4016  // FYSETC Cheetah
-#define BOARD_FYSETC_CHEETAH_V12      4017  // FYSETC Cheetah V1.2
-#define BOARD_LONGER3D_LK             4018  // Alfawise U20/U20+/U30 (Longer3D LK1/2) / STM32F103VET6
-#define BOARD_GTM32_MINI              4019  // STM32F103VET6 controller
-#define BOARD_GTM32_MINI_A30          4020  // STM32F103VET6 controller
-#define BOARD_GTM32_REV_B             4021  // STM32F103VET6 controller
+#define BOARD_MKS_ROBIN_LITE3         4010  // MKS Robin Lite3 (STM32F103RCT6)
+#define BOARD_MKS_ROBIN_PRO           4011  // MKS Robin Pro (STM32F103ZET6)
+#define BOARD_BIGTREE_SKR_MINI_V1_1   4012  // BigTreeTech SKR Mini v1.1 (STM32F103RC)
+#define BOARD_BTT_SKR_MINI_E3_V1_0    4013  // BigTreeTech SKR Mini E3 (STM32F103RC)
+#define BOARD_BTT_SKR_MINI_E3_V1_2    4014  // BigTreeTech SKR Mini E3 V1.2 (STM32F103RC)
+#define BOARD_BIGTREE_SKR_E3_DIP      4015  // BigTreeTech SKR E3 DIP V1.0 (STM32F103RC / STM32F103RE)
+#define BOARD_JGAURORA_A5S_A1         4016  // JGAurora A5S A1 (STM32F103ZET6)
+#define BOARD_FYSETC_AIO_II           4017  // FYSETC AIO_II
+#define BOARD_FYSETC_CHEETAH          4018  // FYSETC Cheetah
+#define BOARD_FYSETC_CHEETAH_V12      4019  // FYSETC Cheetah V1.2
+#define BOARD_LONGER3D_LK             4020  // Alfawise U20/U20+/U30 (Longer3D LK1/2) / STM32F103VET6
+#define BOARD_GTM32_MINI              4021  // STM32F103VET6 controller
+#define BOARD_GTM32_MINI_A30          4022  // STM32F103VET6 controller
+#define BOARD_GTM32_REV_B             4023  // STM32F103VET6 controller
+

 //
 // ARM Cortex-M4F
@ -306,6 +310,8 @@
 #define BOARD_LERDGE_X                4210  // Lerdge X (STM32F407VE)
 #define BOARD_VAKE403D                4211  // VAkE 403D (STM32F446VET6)
 #define BOARD_FYSETC_S6               4212  // FYSETC S6 board
+#define BOARD_FLYF407ZG               4213  // FLYF407ZG board (STM32F407ZG)
+#define BOARD_MKS_ROBIN2              4214  // MKS_ROBIN2 (STM32F407ZE)

 //
 // ARM Cortex M7
@ -318,6 +324,8 @@
 // Espressif ESP32 WiFi
 //
 #define BOARD_ESPRESSIF_ESP32         6000
+#define BOARD_MRR_ESPA                6001
+#define BOARD_MRR_ESPE                6002

 //
 // Simulations
--- a/Marlin/src/core/language.h
+++ b/Marlin/src/core/language.h
@ -252,10 +252,10 @@
 #define MSG_FILAMENT_CHANGE_INSERT_M108     "Insert filament and send M108"
 #define MSG_FILAMENT_CHANGE_WAIT_M108       "Send M108 to resume"

-#define MSG_STOP_BLTOUCH                    "STOP called because of BLTouch error - restart with M999"
-#define MSG_STOP_UNHOMED                    "STOP called because of unhomed error - restart with M999"
-#define MSG_KILL_INACTIVE_TIME              "KILL caused by too much inactive time - current command: "
-#define MSG_KILL_BUTTON                     "KILL caused by KILL button/pin"
+#define MSG_STOP_BLTOUCH                    "!! STOP called because of BLTouch error - restart with M999"
+#define MSG_STOP_UNHOMED                    "!! STOP called because of unhomed error - restart with M999"
+#define MSG_KILL_INACTIVE_TIME              "!! KILL caused by too much inactive time - current command: "
+#define MSG_KILL_BUTTON                     "!! KILL caused by KILL button/pin"

 // temperature.cpp strings
 #define MSG_PID_AUTOTUNE_PREFIX             "PID Autotune"
--- a/Marlin/src/core/serial.h
+++ b/Marlin/src/core/serial.h
@ -75,7 +75,7 @@ extern uint8_t marlin_debug_flags;
 #define SERIAL_PRINTF(V...)     SERIAL_OUT(printf, V)
 #define SERIAL_FLUSH()          SERIAL_OUT(flush)

-#ifdef __STM32F1__
+#ifdef ARDUINO_ARCH_STM32
  #define SERIAL_FLUSHTX()      SERIAL_OUT(flush)
 #elif TX_BUFFER_SIZE > 0
  #define SERIAL_FLUSHTX()      SERIAL_OUT(flushTX)
--- a/Marlin/src/core/utility.cpp
+++ b/Marlin/src/core/utility.cpp
@ -59,6 +59,8 @@ void safe_delay(millis_t ms) {
    SERIAL_ECHOLNPGM("Probe: "
      #if ENABLED(PROBE_MANUALLY)
        "PROBE_MANUALLY"
+      #elif ENABLED(NOZZLE_AS_PROBE)
+        "NOZZLE_AS_PROBE"
      #elif ENABLED(FIX_MOUNTED_PROBE)
        "FIX_MOUNTED_PROBE"
      #elif ENABLED(BLTOUCH)
--- a/Marlin/src/feature/binary_protocol.h
+++ b/Marlin/src/feature/binary_protocol.h
@ -77,7 +77,7 @@ private:
  static bool file_open(char* filename) {
    if (!dummy_transfer) {
      card.mount();
-      card.openFile(filename, false);
+      card.openFileWrite(filename);
      if (!card.isFileOpen()) return false;
    }
    transfer_active = true;
--- a/Marlin/src/feature/pause.cpp
+++ b/Marlin/src/feature/pause.cpp
@ -345,13 +345,13 @@ bool unload_filament(const float &unload_length, const bool show_lcd/*=false*/,
  #endif

  // Retract filament
-  do_pause_e_move(-(FILAMENT_UNLOAD_RETRACT_LENGTH) * mix_multiplier, (PAUSE_PARK_RETRACT_FEEDRATE) * mix_multiplier);
+  do_pause_e_move(-(FILAMENT_UNLOAD_PURGE_RETRACT) * mix_multiplier, (PAUSE_PARK_RETRACT_FEEDRATE) * mix_multiplier);

  // Wait for filament to cool
-  safe_delay(FILAMENT_UNLOAD_DELAY);
+  safe_delay(FILAMENT_UNLOAD_PURGE_DELAY);

  // Quickly purge
-  do_pause_e_move((FILAMENT_UNLOAD_RETRACT_LENGTH + FILAMENT_UNLOAD_PURGE_LENGTH) * mix_multiplier,
+  do_pause_e_move((FILAMENT_UNLOAD_PURGE_RETRACT + FILAMENT_UNLOAD_PURGE_LENGTH) * mix_multiplier,
                  planner.settings.max_feedrate_mm_s[E_AXIS] * mix_multiplier);

  // Unload filament
@ -694,6 +694,10 @@ void resume_print(const float &slow_load_length/*=0*/, const float &fast_load_le
    thermalManager.set_fans_paused(false);
  #endif

+  #if HAS_FILAMENT_SENSOR
+    runout.reset();
+  #endif
+
  // Resume the print job timer if it was running
  if (print_job_timer.isPaused()) print_job_timer.start();

--- a/Marlin/src/feature/tmc_util.cpp
+++ b/Marlin/src/feature/tmc_util.cpp
@ -1022,7 +1022,7 @@
 #if USE_SENSORLESS

  bool tmc_enable_stallguard(TMC2130Stepper &st) {
-    bool stealthchop_was_enabled = st.en_pwm_mode();
+    const bool stealthchop_was_enabled = st.en_pwm_mode();

    st.TCOOLTHRS(0xFFFFF);
    st.en_pwm_mode(false);
@ -1038,9 +1038,10 @@

  bool tmc_enable_stallguard(TMC2209Stepper &st) {
    st.TCOOLTHRS(0xFFFFF);
-    return true;
+    return !st.en_spreadCycle();
  }
-  void tmc_disable_stallguard(TMC2209Stepper &st, const bool restore_stealth _UNUSED) {
+  void tmc_disable_stallguard(TMC2209Stepper &st, const bool restore_stealth) {
+    st.en_spreadCycle(!restore_stealth);
    st.TCOOLTHRS(0);
  }

--- a/Marlin/src/gcode/bedlevel/abl/G29.cpp
+++ b/Marlin/src/gcode/bedlevel/abl/G29.cpp
@ -403,13 +403,14 @@ G29_TYPE GcodeSuite::G29() {
      }
      else {
        probe_position_lf.set(
-          parser.seenval('L') ? (int)RAW_X_POSITION(parser.value_linear_units()) : _MAX(X_CENTER - (X_BED_SIZE) / 2,      x_min),
-          parser.seenval('F') ? (int)RAW_Y_POSITION(parser.value_linear_units()) : _MAX(Y_CENTER - (Y_BED_SIZE) / 2,      y_min)
+          parser.seenval('L') ? (int)RAW_X_POSITION(parser.value_linear_units()) : (_MAX(x_min, X_CENTER - (X_BED_SIZE) / 2)      + MIN_PROBE_EDGE_LEFT),
+          parser.seenval('F') ? (int)RAW_Y_POSITION(parser.value_linear_units()) : (_MAX(y_min, Y_CENTER - (Y_BED_SIZE) / 2)      + MIN_PROBE_EDGE_FRONT)
        );
        probe_position_rb.set(
-          parser.seenval('R') ? (int)RAW_X_POSITION(parser.value_linear_units()) : _MIN(probe_position_lf.x + X_BED_SIZE, x_max),
-          parser.seenval('B') ? (int)RAW_Y_POSITION(parser.value_linear_units()) : _MIN(probe_position_lf.y + Y_BED_SIZE, y_max)
+          parser.seenval('R') ? (int)RAW_X_POSITION(parser.value_linear_units()) : (_MIN(x_max, probe_position_lf.x + X_BED_SIZE) - MIN_PROBE_EDGE_RIGHT),
+          parser.seenval('B') ? (int)RAW_Y_POSITION(parser.value_linear_units()) : (_MIN(y_max, probe_position_lf.y + Y_BED_SIZE) - MIN_PROBE_EDGE_BACK)
        );
+        SERIAL_ECHOLN("Set Trail 1");
      }

      if (
--- a/Marlin/src/gcode/calibrate/G28.cpp
+++ b/Marlin/src/gcode/calibrate/G28.cpp
@ -262,7 +262,7 @@ void GcodeSuite::G28(const bool always_home_all) {

  #if HAS_HOMING_CURRENT
    auto debug_current = [](const char * const s, const int16_t a, const int16_t b){
-      DEBUG_ECHO(s); DEBUG_ECHOLNPGM(" current: ", a, " -> ", b);
+      DEBUG_ECHO(s); DEBUG_ECHOLNPAIR(" current: ", a, " -> ", b);
    };
    #if HAS_CURRENT_HOME(X)
      const int16_t tmc_save_current_X = stepperX.getMilliamps();
@ -286,11 +286,6 @@ void GcodeSuite::G28(const bool always_home_all) {
    #endif
  #endif

-  #if BOTH(STEALTHCHOP_XY, HOME_USING_SPREADCYCLE)
-    if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Set XY to spreadCycle...");
-    process_subcommands_now_P(PSTR("M569S0XY"));
-  #endif
-
  #if ENABLED(IMPROVE_HOMING_RELIABILITY)
    slow_homing_t slow_homing = begin_slow_homing();
  #endif
@ -515,11 +510,6 @@ void GcodeSuite::G28(const bool always_home_all) {
    #endif
  #endif

-  #if BOTH(STEALTHCHOP_XY, HOME_USING_SPREADCYCLE)
-    if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Set XY to StealthChop...");
-    process_subcommands_now_P(PSTR("M569S1XY"));
-  #endif
-
  ui.refresh();

  report_current_position();
--- a/Marlin/src/gcode/calibrate/G34_M422.cpp
+++ b/Marlin/src/gcode/calibrate/G34_M422.cpp
@ -45,29 +45,62 @@
 #define DEBUG_OUT ENABLED(DEBUG_LEVELING_FEATURE)
 #include "../../core/debug_out.h"

-// Sanity-check the count of Z_STEPPER_ALIGN_XY points
-constexpr xy_pos_t sanity_arr_z_align[] = Z_STEPPER_ALIGN_XY;
+//
+// Sanity check G34 / M422 settings
+//
+constexpr xy_pos_t test_z_stepper_align_xy[] = Z_STEPPER_ALIGN_XY;
+
 #if ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS)
-  static_assert(COUNT(sanity_arr_z_align) >= Z_STEPPER_COUNT,
+
+  static_assert(COUNT(test_z_stepper_align_xy) >= Z_STEPPER_COUNT,
    "Z_STEPPER_ALIGN_XY requires at least three {X,Y} entries (Z, Z2, Z3, ...)."
  );
+
+  constexpr float test_z_stepper_align_stepper_xy[][XY] = Z_STEPPER_ALIGN_STEPPER_XY;
+  static_assert(
+    COUNT(test_z_stepper_align_stepper_xy) == Z_STEPPER_COUNT,
+    "Z_STEPPER_ALIGN_STEPPER_XY requires three {X,Y} entries (one per Z stepper)."
+  );
+
 #else
-  static_assert(COUNT(sanity_arr_z_align) == Z_STEPPER_COUNT,
+
+  static_assert(COUNT(test_z_stepper_align_xy) == Z_STEPPER_COUNT,
    #if ENABLED(Z_TRIPLE_STEPPER_DRIVERS)
      "Z_STEPPER_ALIGN_XY requires three {X,Y} entries (Z, Z2, and Z3)."
    #else
      "Z_STEPPER_ALIGN_XY requires two {X,Y} entries (Z and Z2)."
    #endif
  );
+
 #endif

-static xy_pos_t z_auto_align_pos[Z_STEPPER_COUNT] = Z_STEPPER_ALIGN_XY;
+constexpr xyz_pos_t dpo = NOZZLE_TO_PROBE_OFFSET;
+
+#define LTEST(N) (test_z_stepper_align_xy[N].x >= _MAX(X_MIN_BED + MIN_PROBE_EDGE_LEFT,  X_MIN_POS + dpo.x) - 0.00001f)
+#define RTEST(N) (test_z_stepper_align_xy[N].x <= _MIN(X_MAX_BED - MIN_PROBE_EDGE_RIGHT, X_MAX_POS + dpo.x) + 0.00001f)
+#define FTEST(N) (test_z_stepper_align_xy[N].y >= _MAX(Y_MIN_BED + MIN_PROBE_EDGE_FRONT, Y_MIN_POS + dpo.y) - 0.00001f)
+#define BTEST(N) (test_z_stepper_align_xy[N].y <= _MIN(Y_MAX_BED - MIN_PROBE_EDGE_BACK,  Y_MAX_POS + dpo.y) + 0.00001f)
+
+static_assert(LTEST(0) && RTEST(0), "The 1st Z_STEPPER_ALIGN_XY X is unreachable with the default probe X offset.");
+static_assert(FTEST(0) && BTEST(0), "The 1st Z_STEPPER_ALIGN_XY Y is unreachable with the default probe Y offset.");
+static_assert(LTEST(1) && RTEST(1), "The 2nd Z_STEPPER_ALIGN_XY X is unreachable with the default probe X offset.");
+static_assert(FTEST(1) && BTEST(1), "The 2nd Z_STEPPER_ALIGN_XY Y is unreachable with the default probe Y offset.");
+
+#if ENABLED(Z_TRIPLE_STEPPER_DRIVERS)
+  static_assert(LTEST(2) && RTEST(2), "The 3rd Z_STEPPER_ALIGN_XY X is unreachable with the default probe X offset.");
+  static_assert(FTEST(2) && BTEST(2), "The 3rd Z_STEPPER_ALIGN_XY Y is unreachable with the default probe Y offset.");
+#endif
+
+//
+// G34 / M422 shared data
+//
+static xy_pos_t z_stepper_align_pos[] = Z_STEPPER_ALIGN_XY;

 #if ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS)
-  static xy_pos_t z_stepper_pos[] = Z_STEPPER_ALIGN_STEPPER_XY;
+  static xy_pos_t z_stepper_align_stepper_pos[] = Z_STEPPER_ALIGN_STEPPER_XY;
 #endif

-#define G34_PROBE_COUNT COUNT(z_auto_align_pos)
+#define G34_PROBE_COUNT COUNT(z_stepper_align_pos)

 inline void set_all_z_lock(const bool lock) {
  stepper.set_z_lock(lock);
@ -155,11 +188,11 @@ void GcodeSuite::G34() {
    // iteration this will be re-calculated based on the actual bed position
    float z_probe = Z_BASIC_CLEARANCE + (G34_MAX_GRADE) * 0.01f * (
      #if ENABLED(Z_TRIPLE_STEPPER_DRIVERS)
-         SQRT(_MAX(HYPOT2(z_auto_align_pos[0].x - z_auto_align_pos[0].y, z_auto_align_pos[1].x - z_auto_align_pos[1].y),
-                   HYPOT2(z_auto_align_pos[1].x - z_auto_align_pos[1].y, z_auto_align_pos[2].x - z_auto_align_pos[2].y),
-                   HYPOT2(z_auto_align_pos[2].x - z_auto_align_pos[2].y, z_auto_align_pos[0].x - z_auto_align_pos[0].y)))
+         SQRT(_MAX(HYPOT2(z_stepper_align_pos[0].x - z_stepper_align_pos[0].y, z_stepper_align_pos[1].x - z_stepper_align_pos[1].y),
+                   HYPOT2(z_stepper_align_pos[1].x - z_stepper_align_pos[1].y, z_stepper_align_pos[2].x - z_stepper_align_pos[2].y),
+                   HYPOT2(z_stepper_align_pos[2].x - z_stepper_align_pos[2].y, z_stepper_align_pos[0].x - z_stepper_align_pos[0].y)))
      #else
-         HYPOT(z_auto_align_pos[0].x - z_auto_align_pos[0].y, z_auto_align_pos[1].x - z_auto_align_pos[1].y)
+         HYPOT(z_stepper_align_pos[0].x - z_stepper_align_pos[0].y, z_stepper_align_pos[1].x - z_stepper_align_pos[1].y)
      #endif
    );

@ -194,7 +227,7 @@ void GcodeSuite::G34() {
        if (iteration == 0 || i > 0) do_blocking_move_to_z(z_probe);

        // Probe a Z height for each stepper.
-        const float z_probed_height = probe_at_point(z_auto_align_pos[iprobe], raise_after, 0, true);
+        const float z_probed_height = probe_at_point(z_stepper_align_pos[iprobe], raise_after, 0, true);
        if (isnan(z_probed_height)) {
          SERIAL_ECHOLNPGM("Probing failed.");
          err_break = true;
@ -235,13 +268,13 @@ void GcodeSuite::G34() {
        incremental_LSF_reset(&lfd);
        for (uint8_t i = 0; i < G34_PROBE_COUNT; ++i) {
          SERIAL_ECHOLNPAIR("PROBEPT_", int(i + 1), ": ", z_measured[i]);
-          incremental_LSF(&lfd, z_auto_align_pos[i], z_measured[i]);
+          incremental_LSF(&lfd, z_stepper_align_pos[i], z_measured[i]);
        }
        finish_incremental_LSF(&lfd);

        z_measured_min = 100000.0f;
        for (uint8_t i = 0; i < Z_STEPPER_COUNT; ++i) {
-          z_measured[i] = -(lfd.A * z_stepper_pos[i].x + lfd.B * z_stepper_pos[i].y);
+          z_measured[i] = -(lfd.A * z_stepper_align_stepper_pos[i].x + lfd.B * z_stepper_align_stepper_pos[i].y);
          z_measured_min = _MIN(z_measured_min, z_measured[i]);
        }

@ -362,10 +395,10 @@ void GcodeSuite::G34() {
 void GcodeSuite::M422() {
  if (!parser.seen_any()) {
    for (uint8_t i = 0; i < G34_PROBE_COUNT; ++i)
-      SERIAL_ECHOLNPAIR_P(PSTR("M422 S"), i + 1, SP_X_STR, z_auto_align_pos[i].x, SP_Y_STR, z_auto_align_pos[i].y);
+      SERIAL_ECHOLNPAIR_P(PSTR("M422 S"), i + 1, SP_X_STR, z_stepper_align_pos[i].x, SP_Y_STR, z_stepper_align_pos[i].y);
    #if ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS)
      for (uint8_t i = 0; i < Z_STEPPER_COUNT; ++i)
-        SERIAL_ECHOLNPAIR_P(PSTR("M422 W"), i + 1, SP_X_STR, z_stepper_pos[i].x, SP_Y_STR, z_stepper_pos[i].y);
+        SERIAL_ECHOLNPAIR_P(PSTR("M422 W"), i + 1, SP_X_STR, z_stepper_align_stepper_pos[i].x, SP_Y_STR, z_stepper_align_stepper_pos[i].y);
    #endif
    return;
  }
@ -381,9 +414,9 @@ void GcodeSuite::M422() {

  xy_pos_t *pos_dest = (
    #if ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS)
-      !is_probe_point ? z_stepper_pos :
+      !is_probe_point ? z_stepper_align_stepper_pos :
    #endif
-    z_auto_align_pos
+    z_stepper_align_pos
  );

  if (!is_probe_point
--- a/Marlin/src/gcode/calibrate/M100.cpp
+++ b/Marlin/src/gcode/calibrate/M100.cpp
@ -51,7 +51,7 @@
 * Also, there are two support functions that can be called from a developer's C code.
 *
 *    uint16_t check_for_free_memory_corruption(PGM_P const free_memory_start);
- *    void M100_dump_routine(PGM_P const title, char *start, char *end);
+ *    void M100_dump_routine(PGM_P const title, const char * const start, const char * const end);
 *
 * Initial version by Roxy-3D
 */
@ -151,8 +151,8 @@ inline int32_t count_test_bytes(const char * const start_free_memory) {
    // Start and end the dump on a nice 16 byte boundary
    // (even though the values are not 16-byte aligned).
    //
-    start_free_memory = (char*)((ptr_int_t)((uint32_t)start_free_memory & 0xFFFFFFF0)); // Align to 16-byte boundary
-    end_free_memory  = (char*)((ptr_int_t)((uint32_t)end_free_memory  | 0x0000000F)); // Align end_free_memory to the 15th byte (at or above end_free_memory)
+    start_free_memory = (char*)(ptr_int_t(uint32_t(start_free_memory) & ~0xFUL)); // Align to 16-byte boundary
+    end_free_memory   = (char*)(ptr_int_t(uint32_t(end_free_memory)   |  0xFUL)); // Align end_free_memory to the 15th byte (at or above end_free_memory)

    // Dump command main loop
    while (start_free_memory < end_free_memory) {
@ -177,15 +177,16 @@ inline int32_t count_test_bytes(const char * const start_free_memory) {
    }
  }

-  void M100_dump_routine(PGM_P const title, char *start, char *end) {
+  void M100_dump_routine(PGM_P const title, const char * const start, const char * const end) {
    serialprintPGM(title);
    SERIAL_EOL();
    //
    // Round the start and end locations to produce full lines of output
    //
-    start = (char*)((ptr_int_t)((uint32_t)start & 0xFFFFFFF0)); // Align to 16-byte boundary
-    end   = (char*)((ptr_int_t)((uint32_t)end   | 0x0000000F)); // Align end_free_memory to the 15th byte (at or above end_free_memory)
-    dump_free_memory(start, end);
+    dump_free_memory(
+      (char*)(ptr_int_t(uint32_t(start) & ~0xFUL)), // Align to 16-byte boundary
+      (char*)(ptr_int_t(uint32_t(end)   |  0xFUL))  // Align end_free_memory to the 15th byte (at or above end_free_memory)
+    );
  }

 #endif // M100_FREE_MEMORY_DUMPER
@ -211,7 +212,7 @@ inline int check_for_free_memory_corruption(PGM_P const title) {
    //   idle();
    serial_delay(20);
    #if ENABLED(M100_FREE_MEMORY_DUMPER)
-      M100_dump_routine(PSTR("   Memory corruption detected with end_free_memory<Heap\n"), (char*)0x1B80, (char*)0x21FF);
+      M100_dump_routine(PSTR("   Memory corruption detected with end_free_memory<Heap\n"), (const char*)0x1B80, (const char*)0x21FF);
    #endif
  }

--- a/Marlin/src/gcode/feature/camera/M240.cpp
+++ b/Marlin/src/gcode/feature/camera/M240.cpp
@ -31,7 +31,7 @@
  millis_t chdk_timeout; // = 0
 #endif

-#ifdef PHOTO_POSITION && PHOTO_DELAY_MS > 0
+#if defined(PHOTO_POSITION) && PHOTO_DELAY_MS > 0
  #include "../../../Marlin.h" // for idle()
 #endif

--- a/Marlin/src/gcode/feature/trinamic/M569.cpp
+++ b/Marlin/src/gcode/feature/trinamic/M569.cpp
@ -44,7 +44,9 @@ void tmc_set_stealthChop(TMC &st, const bool enable) {
 static void set_stealth_status(const bool enable, const int8_t target_extruder) {
  #define TMC_SET_STEALTH(Q) tmc_set_stealthChop(stepper##Q, enable)

-  #if AXIS_HAS_STEALTHCHOP(X) || AXIS_HAS_STEALTHCHOP(X2) || AXIS_HAS_STEALTHCHOP(Y) || AXIS_HAS_STEALTHCHOP(Y2) || AXIS_HAS_STEALTHCHOP(Z) || AXIS_HAS_STEALTHCHOP(Z2) || AXIS_HAS_STEALTHCHOP(Z3)
+  #if    AXIS_HAS_STEALTHCHOP(X) || AXIS_HAS_STEALTHCHOP(X2) \
+      || AXIS_HAS_STEALTHCHOP(Y) || AXIS_HAS_STEALTHCHOP(Y2) \
+      || AXIS_HAS_STEALTHCHOP(Z) || AXIS_HAS_STEALTHCHOP(Z2) || AXIS_HAS_STEALTHCHOP(Z3)
    const uint8_t index = parser.byteval('I');
  #endif

--- a/Marlin/src/gcode/gcode.cpp
+++ b/Marlin/src/gcode/gcode.cpp
@ -209,7 +209,7 @@ void GcodeSuite::dwell(millis_t time) {
 // Placeholders for non-migrated codes
 //
 #if ENABLED(M100_FREE_MEMORY_WATCHER)
-  extern void M100_dump_routine(PGM_P const title, char *start, char *end);
+  extern void M100_dump_routine(PGM_P const title, const char * const start, const char * const end);
 #endif

 /**
@ -865,7 +865,7 @@ void GcodeSuite::process_next_command() {
    SERIAL_ECHOLN(current_command);
    #if ENABLED(M100_FREE_MEMORY_DUMPER)
      SERIAL_ECHOPAIR("slot:", queue.index_r);
-      M100_dump_routine(PSTR("   Command Queue:"), queue.command_buffer, queue.command_buffer + sizeof(queue.command_buffer));
+      M100_dump_routine(PSTR("   Command Queue:"), &queue.command_buffer[0][0], &queue.command_buffer[BUFSIZE - 1][MAX_CMD_SIZE - 1]);
    #endif
  }

--- a/Marlin/src/gcode/sdcard/M23.cpp
+++ b/Marlin/src/gcode/sdcard/M23.cpp
@ -36,7 +36,7 @@
 void GcodeSuite::M23() {
  // Simplify3D includes the size, so zero out all spaces (#7227)
  for (char *fn = parser.string_arg; *fn; ++fn) if (*fn == ' ') *fn = '\0';
-  card.openFile(parser.string_arg, true);
+  card.openFileRead(parser.string_arg);

  #if ENABLED(LCD_SET_PROGRESS_MANUALLY)
    ui.set_progress(0);
--- a/Marlin/src/gcode/sdcard/M28_M29.cpp
+++ b/Marlin/src/gcode/sdcard/M28_M29.cpp
@ -54,11 +54,11 @@ void GcodeSuite::M28() {
      #endif
    }
    else
-      card.openFile(p, false);
+      card.openFileWrite(p);

  #else

-    card.openFile(parser.string_arg, false);
+    card.openFileWrite(parser.string_arg);

  #endif
 }
--- a/Marlin/src/gcode/sdcard/M32.cpp
+++ b/Marlin/src/gcode/sdcard/M32.cpp
@ -26,8 +26,7 @@

 #include "../gcode.h"
 #include "../../sd/cardreader.h"
-#include "../../module/printcounter.h"
-#include "../../module/planner.h"
+#include "../../module/planner.h" // for synchronize()

 #include "../../Marlin.h" // for startOrResumeJob

@ -45,9 +44,9 @@ void GcodeSuite::M32() {
  if (IS_SD_PRINTING()) planner.synchronize();

  if (card.isMounted()) {
-    const bool call_procedure = parser.boolval('P');
+    const uint8_t call_procedure = parser.boolval('P');

-    card.openFile(parser.string_arg, true, call_procedure);
+    card.openFileRead(parser.string_arg, call_procedure);

    if (parser.seenval('S')) card.setIndex(parser.value_long());

--- a/Marlin/src/inc/Conditionals_LCD.h
+++ b/Marlin/src/inc/Conditionals_LCD.h
@ -290,7 +290,7 @@

 #ifndef STD_ENCODER_PULSES_PER_STEP
  #if ENABLED(TOUCH_BUTTONS)
-    #define STD_ENCODER_PULSES_PER_STEP 1
+    #define STD_ENCODER_PULSES_PER_STEP 2
  #else
    #define STD_ENCODER_PULSES_PER_STEP 5
  #endif
@ -496,7 +496,7 @@
 /**
 * Set flags for enabled probes
 */
-#define HAS_BED_PROBE (HAS_Z_SERVO_PROBE || ANY(FIX_MOUNTED_PROBE, TOUCH_MI_PROBE, Z_PROBE_ALLEN_KEY, Z_PROBE_SLED, SOLENOID_PROBE, SENSORLESS_PROBING, RACK_AND_PINION_PROBE))
+#define HAS_BED_PROBE (HAS_Z_SERVO_PROBE || ANY(FIX_MOUNTED_PROBE, NOZZLE_AS_PROBE, TOUCH_MI_PROBE, Z_PROBE_ALLEN_KEY, Z_PROBE_SLED, SOLENOID_PROBE, SENSORLESS_PROBING, RACK_AND_PINION_PROBE))
 #define PROBE_SELECTED (HAS_BED_PROBE || EITHER(PROBE_MANUALLY, MESH_BED_LEVELING))

 #if HAS_BED_PROBE
--- a/Marlin/src/inc/Conditionals_post.h
+++ b/Marlin/src/inc/Conditionals_post.h
@ -26,12 +26,9 @@
 * Defines that depend on configuration but are not editable.
 */

-#define AVR_ATmega2560_FAMILY_PLUS_70 ( \
-     MB(BQ_ZUM_MEGA_3D)                 \
-  || MB(MIGHTYBOARD_REVE)               \
-  || MB(MINIRAMBO)                      \
-  || MB(SCOOVO_X9H)                     \
-)
+#ifdef GITHUB_ACTIONS
+  // Extras for CI testing
+#endif

 #ifdef TEENSYDUINO
  #undef max
@ -259,6 +256,9 @@
 #elif ENABLED(AZSMZ_12864)
  #define _LCD_CONTRAST_MIN  120
  #define _LCD_CONTRAST_INIT 190
+#elif ENABLED(MKS_LCD12864B)
+  #define _LCD_CONTRAST_MIN  120
+  #define _LCD_CONTRAST_INIT 205
 #elif ENABLED(MKS_MINI_12864)
  #define _LCD_CONTRAST_MIN  120
  #define _LCD_CONTRAST_INIT 195
@ -592,11 +592,7 @@
  #elif HAS_DRIVER(A4988) || HAS_DRIVER(A5984)
    #define MINIMUM_STEPPER_PULSE 1
  #elif TRINAMICS
-    #if ENABLED(LIN_ADVANCE) && (HAS_TMC_STANDALONE_E_DRIVER || (HAS_TMC_E_DRIVER && DISABLED(SQUARE_WAVE_STEPPING)))
-      #define MINIMUM_STEPPER_PULSE 1
-    #else
-      #define MINIMUM_STEPPER_PULSE 0
-    #endif
+    #define MINIMUM_STEPPER_PULSE 0
  #elif HAS_DRIVER(LV8729)
    #define MINIMUM_STEPPER_PULSE 0
  #else
@ -609,14 +605,14 @@
    #define MAXIMUM_STEPPER_RATE 15000
  #elif HAS_DRIVER(TB6600)
    #define MAXIMUM_STEPPER_RATE 150000
-  #elif HAS_DRIVER(LV8729)
-    #define MAXIMUM_STEPPER_RATE 200000
  #elif HAS_DRIVER(DRV8825)
    #define MAXIMUM_STEPPER_RATE 250000
-  #elif TRINAMICS
-    #define MAXIMUM_STEPPER_RATE 400000
  #elif HAS_DRIVER(A4988)
    #define MAXIMUM_STEPPER_RATE 500000
+  #elif HAS_DRIVER(LV8729)
+    #define MAXIMUM_STEPPER_RATE 1000000
+  #elif TRINAMICS
+    #define MAXIMUM_STEPPER_RATE 5000000
  #else
    #define MAXIMUM_STEPPER_RATE 250000
  #endif
@ -1487,6 +1483,10 @@
  #undef MIN_PROBE_EDGE_RIGHT
  #undef MIN_PROBE_EDGE_FRONT
  #undef MIN_PROBE_EDGE_BACK
+  #define MIN_PROBE_EDGE_LEFT 0
+  #define MIN_PROBE_EDGE_RIGHT 0
+  #define MIN_PROBE_EDGE_FRONT 0
+  #define MIN_PROBE_EDGE_BACK 0
 #else
  #ifndef MIN_PROBE_EDGE_LEFT
    #define MIN_PROBE_EDGE_LEFT MIN_PROBE_EDGE
--- a/Marlin/src/inc/SanityCheck.h
+++ b/Marlin/src/inc/SanityCheck.h
@ -418,6 +418,12 @@
  #error "LULZBOT_TOUCH_UI is now TOUCH_UI_FTDI_EVE. Please update your configuration."
 #elif defined(PS_DEFAULT_OFF)
  #error "PS_DEFAULT_OFF is now PSU_DEFAULT_OFF. Please update your configuration."
+#elif defined(FILAMENT_UNLOAD_RETRACT_LENGTH)
+  #error "FILAMENT_UNLOAD_RETRACT_LENGTH is now FILAMENT_UNLOAD_PURGE_RETRACT. Please update Configuration_adv.h."
+#elif defined(FILAMENT_UNLOAD_DELAY)
+  #error "FILAMENT_UNLOAD_DELAY is now FILAMENT_UNLOAD_PURGE_DELAY. Please update Configuration_adv.h."
+#elif defined(HOME_USING_SPREADCYCLE)
+  #error "HOME_USING_SPREADCYCLE is now obsolete. Please remove it from Configuration_adv.h."
 #endif

 #define BOARD_MKS_13        -1000
@ -1076,6 +1082,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
 #if 1 < 0 \
  + ENABLED(PROBE_MANUALLY) \
  + ENABLED(FIX_MOUNTED_PROBE) \
+  + ENABLED(NOZZLE_AS_PROBE) \
  + (HAS_Z_SERVO_PROBE && DISABLED(BLTOUCH)) \
  + ENABLED(BLTOUCH) \
  + ENABLED(TOUCH_MI_PROBE) \
@ -1084,7 +1091,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
  + ENABLED(Z_PROBE_SLED) \
  + ENABLED(RACK_AND_PINION_PROBE) \
  + ENABLED(SENSORLESS_PROBING)
-  #error "Please enable only one probe option: PROBE_MANUALLY, SENSORLESS_PROBING, BLTOUCH, FIX_MOUNTED_PROBE, TOUCH_MI_PROBE, SOLENOID_PROBE, Z_PROBE_ALLEN_KEY, Z_PROBE_SLED, or Z Servo."
+  #error "Please enable only one probe option: PROBE_MANUALLY, SENSORLESS_PROBING, BLTOUCH, FIX_MOUNTED_PROBE, NOZZLE_AS_PROBE, TOUCH_MI_PROBE, SOLENOID_PROBE, Z_PROBE_ALLEN_KEY, Z_PROBE_SLED, or Z Servo."
 #endif

 #if HAS_BED_PROBE
@ -1129,7 +1136,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
  #if ENABLED(BLTOUCH)
    #if BLTOUCH_DELAY < 200
      #error "BLTOUCH_DELAY less than 200 is unsafe and is not supported."
-    #elif DISABLED(BLTOUCH_SET_5V_MODE) && NONE(ENDSTOPPULLUPS, ENDSTOPPULLUP_ZMIN, ENDSTOPPULLUP_ZMIN_PROBE)
+    #elif DISABLED(BLTOUCH_SET_5V_MODE) && NONE(ONBOARD_ENDSTOPPULLUPS, ENDSTOPPULLUPS, ENDSTOPPULLUP_ZMIN, ENDSTOPPULLUP_ZMIN_PROBE)
      #error "BLTOUCH without BLTOUCH_SET_5V_MODE requires ENDSTOPPULLUPS, ENDSTOPPULLUP_ZMIN or ENDSTOPPULLUP_ZMIN_PROBE."
    #endif
  #endif
@ -1215,11 +1222,11 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
   * Require some kind of probe for bed leveling and probe testing
   */
  #if HAS_ABL_NOT_UBL && !PROBE_SELECTED
-    #error "Auto Bed Leveling requires one of these: PROBE_MANUALLY, FIX_MOUNTED_PROBE, BLTOUCH, SOLENOID_PROBE, Z_PROBE_ALLEN_KEY, Z_PROBE_SLED, or a Z Servo."
+    #error "Auto Bed Leveling requires one of these: PROBE_MANUALLY, FIX_MOUNTED_PROBE, NOZZLE_AS_PROBE, BLTOUCH, SOLENOID_PROBE, Z_PROBE_ALLEN_KEY, Z_PROBE_SLED, or a Z Servo."
  #endif

  #if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
-    #error "Z_MIN_PROBE_REPEATABILITY_TEST requires a probe: FIX_MOUNTED_PROBE, BLTOUCH, SOLENOID_PROBE, Z_PROBE_ALLEN_KEY, Z_PROBE_SLED, or Z Servo."
+    #error "Z_MIN_PROBE_REPEATABILITY_TEST requires a probe: FIX_MOUNTED_PROBE, NOZZLE_AS_PROBE, BLTOUCH, SOLENOID_PROBE, Z_PROBE_ALLEN_KEY, Z_PROBE_SLED, or Z Servo."
  #endif

 #endif
@ -1953,7 +1960,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
 /**
 * Check existing CS pins against enabled TMC SPI drivers.
 */
-#define INVALID_TMC_SPI(ST) (AXIS_HAS_SPI && !PIN_EXISTS(ST##_CS))
+#define INVALID_TMC_SPI(ST) (AXIS_HAS_SPI(ST) && !PIN_EXISTS(ST##_CS))
 #if INVALID_TMC_SPI(X)
  #error "An SPI driven TMC driver on X requires X_CS_PIN."
 #elif INVALID_TMC_SPI(X2)
@ -2077,6 +2084,10 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
  #error "TMC2208 Software Serial is supported only on AVR, LPC1768, STM32F1 and STM32F4 platforms."
 #endif

+#if ENABLED(DELTA) && (ENABLED(STEALTHCHOP_XY) != ENABLED(STEALTHCHOP_Z))
+  #error "STEALTHCHOP_XY and STEALTHCHOP_Z must be the same on DELTA."
+#endif
+
 #if ENABLED(SENSORLESS_HOMING)
  // Require STEALTHCHOP for SENSORLESS_HOMING on DELTA as the transition from spreadCycle to stealthChop
  // is necessary in order to reset the stallGuard indication between the initial movement of all three
@ -2091,17 +2102,17 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS

  #if ENABLED(DELTA) && !BOTH(STEALTHCHOP_XY, STEALTHCHOP_Z)
    #error "SENSORLESS_HOMING on DELTA currently requires STEALTHCHOP_XY and STEALTHCHOP_Z."
-  #elif X_SENSORLESS && X_HOME_DIR < 0 && DISABLED(ENDSTOPPULLUPS, ENDSTOPPULLUP_XMIN)
+  #elif X_SENSORLESS && X_HOME_DIR < 0 && NONE(ONBOARD_ENDSTOPPULLUPS, ENDSTOPPULLUPS, ENDSTOPPULLUP_XMIN)
    #error "SENSORLESS_HOMING requires ENDSTOPPULLUP_XMIN (or ENDSTOPPULLUPS) when homing to X_MIN."
-  #elif X_SENSORLESS && X_HOME_DIR > 0 && DISABLED(ENDSTOPPULLUPS, ENDSTOPPULLUP_XMAX)
+  #elif X_SENSORLESS && X_HOME_DIR > 0 && NONE(ONBOARD_ENDSTOPPULLUPS, ENDSTOPPULLUPS, ENDSTOPPULLUP_XMAX)
    #error "SENSORLESS_HOMING requires ENDSTOPPULLUP_XMAX (or ENDSTOPPULLUPS) when homing to X_MAX."
-  #elif Y_SENSORLESS && Y_HOME_DIR < 0 && DISABLED(ENDSTOPPULLUPS, ENDSTOPPULLUP_YMIN)
+  #elif Y_SENSORLESS && Y_HOME_DIR < 0 && NONE(ONBOARD_ENDSTOPPULLUPS, ENDSTOPPULLUPS, ENDSTOPPULLUP_YMIN)
    #error "SENSORLESS_HOMING requires ENDSTOPPULLUP_YMIN (or ENDSTOPPULLUPS) when homing to Y_MIN."
-  #elif Y_SENSORLESS && Y_HOME_DIR > 0 && DISABLED(ENDSTOPPULLUPS, ENDSTOPPULLUP_YMAX)
+  #elif Y_SENSORLESS && Y_HOME_DIR > 0 && NONE(ONBOARD_ENDSTOPPULLUPS, ENDSTOPPULLUPS, ENDSTOPPULLUP_YMAX)
    #error "SENSORLESS_HOMING requires ENDSTOPPULLUP_YMAX (or ENDSTOPPULLUPS) when homing to Y_MAX."
-  #elif Z_SENSORLESS && Z_HOME_DIR < 0 && DISABLED(ENDSTOPPULLUPS, ENDSTOPPULLUP_ZMIN)
+  #elif Z_SENSORLESS && Z_HOME_DIR < 0 && NONE(ONBOARD_ENDSTOPPULLUPS, ENDSTOPPULLUPS, ENDSTOPPULLUP_ZMIN)
    #error "SENSORLESS_HOMING requires ENDSTOPPULLUP_ZMIN (or ENDSTOPPULLUPS) when homing to Z_MIN."
-  #elif Z_SENSORLESS && Z_HOME_DIR > 0 && DISABLED(ENDSTOPPULLUPS, ENDSTOPPULLUP_ZMAX)
+  #elif Z_SENSORLESS && Z_HOME_DIR > 0 && NONE(ONBOARD_ENDSTOPPULLUPS, ENDSTOPPULLUPS, ENDSTOPPULLUP_ZMAX)
    #error "SENSORLESS_HOMING requires ENDSTOPPULLUP_ZMAX (or ENDSTOPPULLUPS) when homing to Z_MAX."
  #elif X_SENSORLESS && X_HOME_DIR < 0 && X_MIN_ENDSTOP_INVERTING != X_ENDSTOP_INVERTING
    #if X_ENDSTOP_INVERTING
@ -2232,10 +2243,6 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
 #endif
 #undef IN_CHAIN

-#if ENABLED(DELTA) && (ENABLED(STEALTHCHOP_XY) != ENABLED(STEALTHCHOP_Z))
-  #error "STEALTHCHOP_XY and STEALTHCHOP_Z must be the same on DELTA."
-#endif
-
 /**
 * Digipot requirement
 */
@ -2349,24 +2356,13 @@ static_assert(   _ARR_TEST(3,0) && _ARR_TEST(3,1) && _ARR_TEST(3,2)
 #endif

 #if ENABLED(Z_STEPPER_AUTO_ALIGN)
-
  #if !Z_MULTI_STEPPER_DRIVERS
    #error "Z_STEPPER_AUTO_ALIGN requires Z_DUAL_STEPPER_DRIVERS or Z_TRIPLE_STEPPER_DRIVERS."
  #elif !HAS_BED_PROBE
    #error "Z_STEPPER_AUTO_ALIGN requires a Z-bed probe."
+  #elif ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS) && DISABLED(Z_TRIPLE_STEPPER_DRIVERS)
+    #error "Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS requires Z_TRIPLE_STEPPER_DRIVERS."
  #endif
-
-  #if ENABLED(Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS)
-    #if DISABLED(Z_TRIPLE_STEPPER_DRIVERS)
-      #error "Z_STEPPER_ALIGN_KNOWN_STEPPER_POSITIONS requires Z_TRIPLE_STEPPER_DRIVERS."
-    #endif
-    constexpr float sanity_arr_screw_xy[][2] = Z_STEPPER_ALIGN_STEPPER_XY;
-    static_assert(
-      COUNT(sanity_arr_screw_xy) == Z_STEPPER_COUNT,
-      "Z_STEPPER_ALIGN_STEPPER_XY requires three {X,Y} entries (one per Z stepper)."
-    );
-  #endif
-
 #endif

 #if ENABLED(PRINTCOUNTER) && DISABLED(EEPROM_SETTINGS)
@ -2558,11 +2554,3 @@ static_assert(   _ARR_TEST(3,0) && _ARR_TEST(3,1) && _ARR_TEST(3,2)
    #error "SHOW_REMAINING_TIME currently requires a Graphical LCD."
  #endif
 #endif
-
-#if ENABLED(LIN_ADVANCE) && MINIMUM_STEPPER_PULSE < 1
-  #if HAS_TMC_STANDALONE_E_DRIVER
-    #error "LIN_ADVANCE with TMC standalone driver on extruder requires MIMIMUM_STEPPER_PULSE >= 1"
-  #elif HAS_TMC_E_DRIVER && DISABLED(SQUARE_WAVE_STEPPING)
-    #error "LIN_ADVANCE with TMC driver on extruder requires SQUARE_WAVE_STEPPING or MINIMUM_STEPPER_PULSE >= 1"
-  #endif
-#endif
--- a/Marlin/src/lcd/dogm/dogm_Statusscreen.h
+++ b/Marlin/src/lcd/dogm/dogm_Statusscreen.h
@ -1726,3 +1726,17 @@
    #endif
  #endif
 #endif
+
+#define DO_DRAW_LOGO (STATUS_LOGO_WIDTH && ENABLED(CUSTOM_STATUS_SCREEN_IMAGE))
+#define DO_DRAW_HOTENDS (HOTENDS > 0)
+#define DO_DRAW_CUTTER (HAS_CUTTER)
+#define DO_DRAW_BED (HAS_HEATED_BED && STATUS_BED_WIDTH && HOTENDS <= 4)
+#define DO_DRAW_CHAMBER (HAS_TEMP_CHAMBER && STATUS_CHAMBER_WIDTH && HOTENDS <= 4)
+#define DO_DRAW_FAN (HAS_FAN0 && STATUS_FAN_WIDTH && HOTENDS <= 4 && defined(STATUS_FAN_FRAMES))
+
+#define ANIM_HOTEND (HOTENDS && ENABLED(STATUS_HOTEND_ANIM))
+#define ANIM_BED (DO_DRAW_BED && ENABLED(STATUS_BED_ANIM))
+#define ANIM_CHAMBER (DO_DRAW_CHAMBER && ENABLED(STATUS_CHAMBER_ANIM))
+#define ANIM_CUTTER (DO_DRAW_CUTTER && ENABLED(STATUS_CUTTER_ANIM))
+
+#define ANIM_HBCC (ANIM_HOTEND || ANIM_BED || ANIM_CHAMBER || ANIM_CUTTER)
--- a/Marlin/src/lcd/dogm/status_screen_DOGM.cpp
+++ b/Marlin/src/lcd/dogm/status_screen_DOGM.cpp
@ -67,20 +67,6 @@
 #define EXTRAS_BASELINE (40 + INFO_FONT_ASCENT)
 #define STATUS_BASELINE (LCD_PIXEL_HEIGHT - INFO_FONT_DESCENT)

-#define DO_DRAW_LOGO (STATUS_LOGO_WIDTH && ENABLED(CUSTOM_STATUS_SCREEN_IMAGE))
-#define DO_DRAW_HOTENDS (HOTENDS > 0)
-#define DO_DRAW_CUTTER (HAS_CUTTER)
-#define DO_DRAW_BED (HAS_HEATED_BED && STATUS_BED_WIDTH && HOTENDS <= 4)
-#define DO_DRAW_CHAMBER (HAS_TEMP_CHAMBER && STATUS_CHAMBER_WIDTH && HOTENDS <= 4)
-#define DO_DRAW_FAN (HAS_FAN0 && STATUS_FAN_WIDTH && HOTENDS <= 4 && defined(STATUS_FAN_FRAMES))
-
-#define ANIM_HOTEND (HOTENDS && ENABLED(STATUS_HOTEND_ANIM))
-#define ANIM_BED (DO_DRAW_BED && ENABLED(STATUS_BED_ANIM))
-#define ANIM_CHAMBER (DO_DRAW_CHAMBER && ENABLED(STATUS_CHAMBER_ANIM))
-#define ANIM_CUTTER (DO_DRAW_CUTTER && ENABLED(STATUS_CUTTER_ANIM))
-
-#define ANIM_HBCC (ANIM_HOTEND || ANIM_BED || ANIM_CHAMBER || ANIM_CUTTER)
-
 #if ANIM_HBCC
  enum HeatBits : uint8_t {
    HEATBIT_HOTEND,
@ -90,6 +76,7 @@
  };
  IF<(HEATBIT_CUTTER > 7), uint16_t, uint8_t>::type heat_bits;
 #endif
+
 #if ANIM_HOTEND
  #define HOTEND_ALT(N) TEST(heat_bits, HEATBIT_HOTEND + N)
 #else
--- a/Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp
+++ b/Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp
@ -201,7 +201,7 @@ u8g_dev_t u8g_dev_st7920_128x64_HAL_4x_sw_spi = { u8g_dev_st7920_128x64_HAL_4x_f
 U8G_PB_DEV(u8g_dev_st7920_128x64_HAL_hw_spi, LCD_PIXEL_WIDTH, LCD_PIXEL_HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_128x64_HAL_fn, U8G_COM_ST7920_HAL_HW_SPI);
 u8g_dev_t u8g_dev_st7920_128x64_HAL_4x_hw_spi = { u8g_dev_st7920_128x64_HAL_4x_fn, &u8g_dev_st7920_128x64_HAL_4x_pb, U8G_COM_ST7920_HAL_HW_SPI };

-#if NONE(__AVR__, ARDUINO_ARCH_STM32) || defined(U8G_HAL_LINKS)
+#if NONE(__AVR__, ARDUINO_ARCH_STM32, ARDUINO_ARCH_ESP32) || defined(U8G_HAL_LINKS)
  // Also use this device for HAL version of rrd class. This results in the same device being used
  // for the ST7920 for HAL systems no matter what is selected in ultralcd_impl_DOGM.h.
  u8g_dev_t u8g_dev_st7920_128x64_rrd_sw_spi = { u8g_dev_st7920_128x64_HAL_4x_fn, &u8g_dev_st7920_128x64_HAL_4x_pb, U8G_COM_ST7920_HAL_SW_SPI };
--- a/Marlin/src/lcd/dogm/ultralcd_DOGM.cpp
+++ b/Marlin/src/lcd/dogm/ultralcd_DOGM.cpp
@ -244,48 +244,51 @@ bool MarlinUI::detected() { return true; }

 // Initialize or re-initialize the LCD
 void MarlinUI::init_lcd() {
+  #if DISABLED(MKS_LCD12864B)

-  #if PIN_EXISTS(LCD_BACKLIGHT)
-    OUT_WRITE(LCD_BACKLIGHT_PIN, (
-      #if ENABLED(DELAYED_BACKLIGHT_INIT)
-        LOW  // Illuminate after reset
-      #else
-        HIGH // Illuminate right away
-      #endif
-    ));
-  #endif
-
-  #if EITHER(MKS_12864OLED, MKS_12864OLED_SSD1306)
-    SET_OUTPUT(LCD_PINS_DC);
-    #ifndef LCD_RESET_PIN
-      #define LCD_RESET_PIN LCD_PINS_RS
+    #if PIN_EXISTS(LCD_BACKLIGHT)
+      OUT_WRITE(LCD_BACKLIGHT_PIN, (
+        #if ENABLED(DELAYED_BACKLIGHT_INIT)
+          LOW  // Illuminate after reset
+        #else
+          HIGH // Illuminate right away
+        #endif
+      ));
    #endif
-  #endif

-  #if PIN_EXISTS(LCD_RESET)
-    // Perform a clean hardware reset with needed delays
-    OUT_WRITE(LCD_RESET_PIN, LOW);
-    _delay_ms(5);
-    WRITE(LCD_RESET_PIN, HIGH);
-    _delay_ms(5);
-    u8g.begin();
-  #endif
+    #if EITHER(MKS_12864OLED, MKS_12864OLED_SSD1306)
+      SET_OUTPUT(LCD_PINS_DC);
+      #ifndef LCD_RESET_PIN
+        #define LCD_RESET_PIN LCD_PINS_RS
+      #endif
+    #endif

-  #if PIN_EXISTS(LCD_BACKLIGHT) && ENABLED(DELAYED_BACKLIGHT_INIT)
-    WRITE(LCD_BACKLIGHT_PIN, HIGH);
-  #endif
+    #if PIN_EXISTS(LCD_RESET)
+      // Perform a clean hardware reset with needed delays
+      OUT_WRITE(LCD_RESET_PIN, LOW);
+      _delay_ms(5);
+      WRITE(LCD_RESET_PIN, HIGH);
+      _delay_ms(5);
+      u8g.begin();
+    #endif

-  #if HAS_LCD_CONTRAST
-    refresh_contrast();
-  #endif
+    #if PIN_EXISTS(LCD_BACKLIGHT) && ENABLED(DELAYED_BACKLIGHT_INIT)
+      WRITE(LCD_BACKLIGHT_PIN, HIGH);
+    #endif

-  #if ENABLED(LCD_SCREEN_ROT_90)
-    u8g.setRot90();
-  #elif ENABLED(LCD_SCREEN_ROT_180)
-    u8g.setRot180();
-  #elif ENABLED(LCD_SCREEN_ROT_270)
-    u8g.setRot270();
-  #endif
+    #if HAS_LCD_CONTRAST
+      refresh_contrast();
+    #endif
+
+    #if ENABLED(LCD_SCREEN_ROT_90)
+      u8g.setRot90();
+    #elif ENABLED(LCD_SCREEN_ROT_180)
+      u8g.setRot180();
+    #elif ENABLED(LCD_SCREEN_ROT_270)
+      u8g.setRot270();
+    #endif
+
+  #endif // !MKS_LCD12864B

  uxg_SetUtf8Fonts(g_fontinfo, COUNT(g_fontinfo));
 }
--- a/Marlin/src/lcd/dogm/ultralcd_st7920_u8glib_rrd_AVR.cpp
+++ b/Marlin/src/lcd/dogm/ultralcd_st7920_u8glib_rrd_AVR.cpp
@ -25,7 +25,7 @@

 #include "../../inc/MarlinConfigPre.h"

-#if !defined(U8G_HAL_LINKS) && ANY(__AVR__, ARDUINO_ARCH_STM32)
+#if !defined(U8G_HAL_LINKS) && ANY(__AVR__, ARDUINO_ARCH_STM32, ARDUINO_ARCH_ESP32)

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

--- a/Marlin/src/lcd/extensible_ui/ui_api.cpp
+++ b/Marlin/src/lcd/extensible_ui/ui_api.cpp
@ -773,7 +773,7 @@ namespace ExtUI {
    #if HAS_BED_PROBE
      return probe_offset.z;
    #elif ENABLED(BABYSTEP_DISPLAY_TOTAL)
-      return babystep.axis_total[BS_TOTAL_AXIS(Z_AXIS) + 1];
+      return (planner.steps_to_mm[Z_AXIS] * babystep.axis_total[BS_TODO_AXIS(Z_AXIS)]);
    #else
      return 0.0;
    #endif
@ -784,7 +784,7 @@ namespace ExtUI {
      if (WITHIN(value, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX))
        probe_offset.z = value;
    #elif ENABLED(BABYSTEP_DISPLAY_TOTAL)
-      babystep.add_mm(Z_AXIS, (value - babystep.axis_total[BS_TOTAL_AXIS(Z_AXIS) + 1]));
+      babystep.add_mm(Z_AXIS, (value - getZOffset_mm()));
    #else
      UNUSED(value);
    #endif
--- a/Marlin/src/lcd/extui_malyan_lcd.cpp
+++ b/Marlin/src/lcd/extui_malyan_lcd.cpp
@ -396,8 +396,8 @@ void update_usb_status(const bool forceUpdate) {
  // This is mildly different than stock, which
  // appears to use the usb discovery status.
  // This is more logical.
-  if (last_usb_connected_status != SerialUSB || forceUpdate) {
-    last_usb_connected_status = SerialUSB;
+  if (last_usb_connected_status != MYSERIAL0 || forceUpdate) {
+    last_usb_connected_status = MYSERIAL0;
    write_to_lcd_P(last_usb_connected_status ? PSTR("{R:UC}\r\n") : PSTR("{R:UD}\r\n"));
  }
 }
--- a/Marlin/src/lcd/language/language_an.h
+++ b/Marlin/src/lcd/language/language_an.h
@ -119,7 +119,7 @@ namespace Language_an {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Temperatura");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Movimiento");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filamento");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E in mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E in mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Fil. Dia.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Fil. Dia. *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("Contraste");
--- a/Marlin/src/lcd/language/language_bg.h
+++ b/Marlin/src/lcd/language/language_bg.h
@ -104,7 +104,7 @@ namespace Language_bg {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Температура");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Движение");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Нишка");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E in mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E in mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Диам. нишка");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Диам. нишка *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("LCD контраст");
--- a/Marlin/src/lcd/language/language_ca.h
+++ b/Marlin/src/lcd/language/language_ca.h
@ -114,7 +114,7 @@ namespace Language_ca {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Temperatura");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Moviment");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filament");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E en mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E en mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Diam. Fil.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Diam. Fil. *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("Contrast de LCD");
@ -204,7 +204,10 @@ namespace Language_ca {
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Font alimentacio");

  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Força motor");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Driver %");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("DAC EEPROM Write");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_OPTION_RESUME   = _UxGT("Repren impressió");

--- a/Marlin/src/lcd/language/language_cz.h
+++ b/Marlin/src/lcd/language/language_cz.h
@ -46,8 +46,14 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_YES                             = _UxGT("ANO");
  PROGMEM Language_Str MSG_NO                              = _UxGT("NE");
  PROGMEM Language_Str MSG_BACK                            = _UxGT("Zpět");
-  PROGMEM Language_Str MSG_MEDIA_INSERTED                  = _UxGT("Karta vložena");
-  PROGMEM Language_Str MSG_MEDIA_REMOVED                   = _UxGT("Karta vyjmuta");
+  PROGMEM Language_Str MSG_MEDIA_ABORTING                  = _UxGT("Rušení...");
+  PROGMEM Language_Str MSG_MEDIA_INSERTED                  = _UxGT("Médium vloženo");
+  PROGMEM Language_Str MSG_MEDIA_REMOVED                   = _UxGT("Médium vyjmuto");
+  PROGMEM Language_Str MSG_MEDIA_RELEASED                  = _UxGT("Médium uvolněno");
+  PROGMEM Language_Str MSG_MEDIA_WAITING                   = _UxGT("Čekání na médium");
+  PROGMEM Language_Str MSG_MEDIA_READ_ERROR                = _UxGT("Chyba čtení média");
+  PROGMEM Language_Str MSG_MEDIA_USB_REMOVED               = _UxGT("USB odstraněno");
+  PROGMEM Language_Str MSG_MEDIA_USB_FAILED                = _UxGT("Chyba USB");
  PROGMEM Language_Str MSG_LCD_ENDSTOPS                    = _UxGT("Endstopy"); // max 8 znaku
  PROGMEM Language_Str MSG_LCD_SOFT_ENDSTOPS               = _UxGT("Soft Endstopy");
  PROGMEM Language_Str MSG_MAIN                            = _UxGT("Hlavní nabídka");
@ -94,6 +100,10 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_LASER_OFF                       = _UxGT("Vypnout laser");
  PROGMEM Language_Str MSG_LASER_ON                        = _UxGT("Zapnout laser");
  PROGMEM Language_Str MSG_LASER_POWER                     = _UxGT("Výkon laseru");
+  PROGMEM Language_Str MSG_SPINDLE_MENU                    = _UxGT("Vřeteno ovládání");
+  PROGMEM Language_Str MSG_SPINDLE_OFF                     = _UxGT("Vřeteno vyp");
+  PROGMEM Language_Str MSG_SPINDLE_ON                      = _UxGT("Vřeteno zap");
+  PROGMEM Language_Str MSG_SPINDLE_POWER                   = _UxGT("Vřeteno výkon");
  PROGMEM Language_Str MSG_SPINDLE_REVERSE                 = _UxGT("Vřeteno opačně");
  PROGMEM Language_Str MSG_SWITCH_PS_ON                    = _UxGT("Zapnout napájení");
  PROGMEM Language_Str MSG_SWITCH_PS_OFF                   = _UxGT("Vypnout napájení");
@ -104,13 +114,18 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_LEVEL_BED                       = _UxGT("Vyrovnat podložku");
  PROGMEM Language_Str MSG_LEVEL_CORNERS                   = _UxGT("Vyrovnat rohy");
  PROGMEM Language_Str MSG_NEXT_CORNER                     = _UxGT("Další roh");
+  PROGMEM Language_Str MSG_MESH_EDITOR                     = _UxGT("Editor sítě");
  PROGMEM Language_Str MSG_EDIT_MESH                       = _UxGT("Upravit síť bodů");
  PROGMEM Language_Str MSG_EDITING_STOPPED                 = _UxGT("Konec úprav sítě");
+  PROGMEM Language_Str MSG_PROBING_MESH                    = _UxGT("Měření bodu");
  PROGMEM Language_Str MSG_MESH_X                          = _UxGT("Index X");
  PROGMEM Language_Str MSG_MESH_Y                          = _UxGT("Index Y");
  PROGMEM Language_Str MSG_MESH_EDIT_Z                     = _UxGT("Hodnota Z");

  PROGMEM Language_Str MSG_USER_MENU                       = _UxGT("Vlastní příkazy");
+  PROGMEM Language_Str MSG_M48_TEST                        = _UxGT("M48 test sondy");
+  PROGMEM Language_Str MSG_M48_POINT                       = _UxGT("M48 bod");
+  PROGMEM Language_Str MSG_M48_DEVIATION                   = _UxGT("Odchylka");
  PROGMEM Language_Str MSG_IDEX_MENU                       = _UxGT("Režim IDEX");
  PROGMEM Language_Str MSG_OFFSETS_MENU                    = _UxGT("Ofsety nástrojů");
  PROGMEM Language_Str MSG_IDEX_MODE_AUTOPARK              = _UxGT("Auto-Park");
@ -124,6 +139,7 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_UBL_DOING_G29                   = _UxGT("Provádím G29");
  PROGMEM Language_Str MSG_UBL_TOOLS                       = _UxGT("UBL nástroje");
  PROGMEM Language_Str MSG_UBL_LEVEL_BED                   = _UxGT("Unified Bed Leveling");
+  PROGMEM Language_Str MSG_LCD_TILTING_MESH                = _UxGT("Vyrovnání bodu");
  PROGMEM Language_Str MSG_UBL_MANUAL_MESH                 = _UxGT("Manuální síť bodů");
  PROGMEM Language_Str MSG_UBL_BC_INSERT                   = _UxGT("Vložte kartu, změřte");
  PROGMEM Language_Str MSG_UBL_BC_INSERT2                  = _UxGT("Změřte");
@ -150,6 +166,13 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_UBL_VALIDATE_MESH_M1            = _UxGT("Kontrola sítě ") PREHEAT_1_LABEL;
  PROGMEM Language_Str MSG_UBL_VALIDATE_MESH_M2            = _UxGT("Kontrola sítě ") PREHEAT_2_LABEL;
  PROGMEM Language_Str MSG_UBL_VALIDATE_CUSTOM_MESH        = _UxGT("Kontrola vlast. sítě");
+  PROGMEM Language_Str MSG_G26_HEATING_BED                 = _UxGT("G26 zahřívání podl.");
+  PROGMEM Language_Str MSG_G26_HEATING_NOZZLE              = _UxGT("G26 zařívání trysky");
+  PROGMEM Language_Str MSG_G26_MANUAL_PRIME                = _UxGT("Ruční zavedení...");
+  PROGMEM Language_Str MSG_G26_FIXED_LENGTH                = _UxGT("Pevné zavední");
+  PROGMEM Language_Str MSG_G26_PRIME_DONE                  = _UxGT("Done Priming");
+  PROGMEM Language_Str MSG_G26_CANCELED                    = _UxGT("G26 Canceled");
+  PROGMEM Language_Str MSG_G26_LEAVING                     = _UxGT("Leaving G26");
  PROGMEM Language_Str MSG_UBL_CONTINUE_MESH               = _UxGT("Pokračovat v síťi");
  PROGMEM Language_Str MSG_UBL_MESH_LEVELING               = _UxGT("Síťové rovnání");
  PROGMEM Language_Str MSG_UBL_3POINT_MESH_LEVELING        = _UxGT("3-bodové rovnání");
@ -179,7 +202,8 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_UBL_NO_STORAGE                  = _UxGT("Nedostatek místa");
  PROGMEM Language_Str MSG_UBL_SAVE_ERROR                  = _UxGT("Ch.: Uložit UBL");
  PROGMEM Language_Str MSG_UBL_RESTORE_ERROR               = _UxGT("Ch.: Obnovit UBL");
-  PROGMEM Language_Str MSG_UBL_Z_OFFSET_STOPPED            = _UxGT("Konec Z-Offsetu");
+  PROGMEM Language_Str MSG_UBL_Z_OFFSET                    = _UxGT("Z-ofset: ");
+  PROGMEM Language_Str MSG_UBL_Z_OFFSET_STOPPED            = _UxGT("Konec Z-ofsetu");
  PROGMEM Language_Str MSG_UBL_STEP_BY_STEP_MENU           = _UxGT("UBL Postupně");
  PROGMEM Language_Str MSG_UBL_1_BUILD_COLD_MESH           = _UxGT("1. Studená síť bodů");
  PROGMEM Language_Str MSG_UBL_2_SMART_FILLIN              = _UxGT("2. Chytrá hustota");
@ -228,23 +252,51 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_CHAMBER                         = _UxGT("Komora");
  PROGMEM Language_Str MSG_FAN_SPEED                       = _UxGT("Rychlost vent.");
  PROGMEM Language_Str MSG_FAN_SPEED_N                     = _UxGT("Rychlost vent. =");
+  PROGMEM Language_Str MSG_STORED_FAN_N                    = _UxGT("Ulož. vent. =");
  PROGMEM Language_Str MSG_EXTRA_FAN_SPEED                 = _UxGT("Rychlost ex. vent.");
  PROGMEM Language_Str MSG_EXTRA_FAN_SPEED_N               = _UxGT("Rychlost ex. vent. =");
  PROGMEM Language_Str MSG_FLOW                            = _UxGT("Průtok");
  PROGMEM Language_Str MSG_FLOW_N                          = _UxGT("Průtok ~");
  PROGMEM Language_Str MSG_CONTROL                         = _UxGT("Ovládaní");
-  PROGMEM Language_Str MSG_MIN                             = " " LCD_STR_THERMOMETER _UxGT(" Min");
-  PROGMEM Language_Str MSG_MAX                             = " " LCD_STR_THERMOMETER _UxGT(" Max");
-  PROGMEM Language_Str MSG_FACTOR                          = " " LCD_STR_THERMOMETER _UxGT(" Fakt");
+  PROGMEM Language_Str MSG_MIN                             = " " LCD_STR_THERMOMETER _UxGT(" min");
+  PROGMEM Language_Str MSG_MAX                             = " " LCD_STR_THERMOMETER _UxGT(" max");
+  PROGMEM Language_Str MSG_FACTOR                          = " " LCD_STR_THERMOMETER _UxGT(" fakt");
  PROGMEM Language_Str MSG_AUTOTEMP                        = _UxGT("Autoteplota");
  PROGMEM Language_Str MSG_LCD_ON                          = _UxGT("Zap");
  PROGMEM Language_Str MSG_LCD_OFF                         = _UxGT("Vyp");
+  PROGMEM Language_Str MSG_PID_AUTOTUNE                    = _UxGT("PID automatika");
+  PROGMEM Language_Str MSG_PID_AUTOTUNE_E                  = _UxGT("PID automatika *");
+  PROGMEM Language_Str MSG_PID_P                           = _UxGT("PID-P");
+  PROGMEM Language_Str MSG_PID_P_E                         = _UxGT("PID-P *");
+  PROGMEM Language_Str MSG_PID_I                           = _UxGT("PID-I");
+  PROGMEM Language_Str MSG_PID_I_E                         = _UxGT("PID-I *");
+  PROGMEM Language_Str MSG_PID_D                           = _UxGT("PID-D");
+  PROGMEM Language_Str MSG_PID_D_E                         = _UxGT("PID-D *");
+  PROGMEM Language_Str MSG_PID_C                           = _UxGT("PID-C");
+  PROGMEM Language_Str MSG_PID_C_E                         = _UxGT("PID-C *");
  PROGMEM Language_Str MSG_SELECT                          = _UxGT("Vybrat");
  PROGMEM Language_Str MSG_SELECT_E                        = _UxGT("Vybrat *");
  PROGMEM Language_Str MSG_ACC                             = _UxGT("Zrychl");
+  PROGMEM Language_Str MSG_JERK                            = _UxGT("Jerk");
+  PROGMEM Language_Str MSG_VA_JERK                         = _UxGT("V") LCD_STR_A _UxGT("-jerk");
+  PROGMEM Language_Str MSG_VB_JERK                         = _UxGT("V") LCD_STR_B _UxGT("-jerk");
+  PROGMEM Language_Str MSG_VC_JERK                         = _UxGT("V") LCD_STR_C _UxGT("-jerk");
+  PROGMEM Language_Str MSG_VE_JERK                         = _UxGT("Ve-Jerk");
  PROGMEM Language_Str MSG_JUNCTION_DEVIATION              = _UxGT("Odchylka spoje");
  PROGMEM Language_Str MSG_VELOCITY                        = _UxGT("Rychlost");
+  PROGMEM Language_Str MSG_VMAX_A                          = _UxGT("Vmax ") LCD_STR_A;
+  PROGMEM Language_Str MSG_VMAX_B                          = _UxGT("Vmax ") LCD_STR_B;
+  PROGMEM Language_Str MSG_VMAX_C                          = _UxGT("Vmax ") LCD_STR_C;
+  PROGMEM Language_Str MSG_VMAX_E                          = _UxGT("Vmax ") LCD_STR_E;
+  PROGMEM Language_Str MSG_VMAX_EN                         = _UxGT("Vmax *");
+  PROGMEM Language_Str MSG_VMIN                            = _UxGT("Vmin");
+  PROGMEM Language_Str MSG_VTRAV_MIN                       = _UxGT("VTrav Min");
  PROGMEM Language_Str MSG_ACCELERATION                    = _UxGT("Akcelerace");
+  PROGMEM Language_Str MSG_AMAX_A                          = _UxGT("Amax ") LCD_STR_A;
+  PROGMEM Language_Str MSG_AMAX_B                          = _UxGT("Amax ") LCD_STR_B;
+  PROGMEM Language_Str MSG_AMAX_C                          = _UxGT("Amax ") LCD_STR_C;
+  PROGMEM Language_Str MSG_AMAX_E                          = _UxGT("Amax ") LCD_STR_E;
+  PROGMEM Language_Str MSG_AMAX_EN                         = _UxGT("Amax *");
  PROGMEM Language_Str MSG_A_RETRACT                       = _UxGT("A-retrakt");
  PROGMEM Language_Str MSG_A_TRAVEL                        = _UxGT("A-přejezd");
  PROGMEM Language_Str MSG_STEPS_PER_MM                    = _UxGT("Kroků/mm");
@ -256,7 +308,7 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Teplota");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Pohyb");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filament");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E na mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E na mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Fil. Prum.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Fil. Prum. *");
  PROGMEM Language_Str MSG_FILAMENT_UNLOAD                 = _UxGT("Vysunout mm");
@ -275,11 +327,21 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_PREPARE                         = _UxGT("Připrava tisku");
  PROGMEM Language_Str MSG_TUNE                            = _UxGT("Doladění tisku");
  PROGMEM Language_Str MSG_START_PRINT                     = _UxGT("Spustit tisk");
+  PROGMEM Language_Str MSG_BUTTON_NEXT                     = _UxGT("Další");
+  PROGMEM Language_Str MSG_BUTTON_INIT                     = _UxGT("Inicializace");
+  PROGMEM Language_Str MSG_BUTTON_STOP                     = _UxGT("Stop");
  PROGMEM Language_Str MSG_BUTTON_PRINT                    = _UxGT("Tisk");
+  PROGMEM Language_Str MSG_BUTTON_RESET                    = _UxGT("Reset");
  PROGMEM Language_Str MSG_BUTTON_CANCEL                   = _UxGT("Zrušit");
+  PROGMEM Language_Str MSG_BUTTON_DONE                     = _UxGT("Hotovo");
+  PROGMEM Language_Str MSG_BUTTON_BACK                     = _UxGT("Zpět");
+  PROGMEM Language_Str MSG_BUTTON_PROCEED                  = _UxGT("Pokračovat");
  PROGMEM Language_Str MSG_PAUSE_PRINT                     = _UxGT("Pozastavit tisk");
  PROGMEM Language_Str MSG_RESUME_PRINT                    = _UxGT("Obnovit tisk");
  PROGMEM Language_Str MSG_STOP_PRINT                      = _UxGT("Zastavit tisk");
+  PROGMEM Language_Str MSG_PRINTING_OBJECT                 = _UxGT("Tisk objektu");
+  PROGMEM Language_Str MSG_CANCEL_OBJECT                   = _UxGT("Zrušit objekt");
+  PROGMEM Language_Str MSG_CANCEL_OBJECT_N                 = _UxGT("Zrušit objekt =");
  PROGMEM Language_Str MSG_OUTAGE_RECOVERY                 = _UxGT("Obnova výpadku");
  PROGMEM Language_Str MSG_MEDIA_MENU                      = _UxGT("Tisknout z SD");
  PROGMEM Language_Str MSG_NO_MEDIA                        = _UxGT("Žádná SD karta");
@ -301,6 +363,7 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVER_SWAPF   = _UxGT("S UnRet V");
  PROGMEM Language_Str MSG_AUTORETRACT                     = _UxGT("AutoRetr.");
  PROGMEM Language_Str MSG_FILAMENT_SWAP_LENGTH            = _UxGT("Délka retrakce");
+  PROGMEM Language_Str MSG_FILAMENT_PURGE_LENGTH           = _UxGT("Délka zavedení");
  PROGMEM Language_Str MSG_TOOL_CHANGE                     = _UxGT("Výměna nástroje");
  PROGMEM Language_Str MSG_TOOL_CHANGE_ZLIFT               = _UxGT("Zdvih Z");
  PROGMEM Language_Str MSG_SINGLENOZZLE_PRIME_SPD          = _UxGT("Rychlost primár.");
@ -314,18 +377,29 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_FILAMENTUNLOAD_E                = _UxGT("Vysunout filament *");
  PROGMEM Language_Str MSG_FILAMENTUNLOAD_ALL              = _UxGT("Vysunout vše");

-  PROGMEM Language_Str MSG_INIT_MEDIA                      = _UxGT("Načíst SD kartu");
-  PROGMEM Language_Str MSG_CHANGE_MEDIA                    = _UxGT("Vyměnit SD kartu");
+  PROGMEM Language_Str MSG_INIT_MEDIA                      = _UxGT("Načíst médium");
+  PROGMEM Language_Str MSG_CHANGE_MEDIA                    = _UxGT("Vyměnit médium");
+  PROGMEM Language_Str MSG_RELEASE_MEDIA                   = _UxGT("Vysunout médium");
  PROGMEM Language_Str MSG_ZPROBE_OUT                      = _UxGT("Sonda Z mimo podl");
  PROGMEM Language_Str MSG_SKEW_FACTOR                     = _UxGT("Faktor zkosení");
  PROGMEM Language_Str MSG_BLTOUCH                         = _UxGT("BLTouch");
  PROGMEM Language_Str MSG_BLTOUCH_SELFTEST                = _UxGT("BLTouch self-test");
  PROGMEM Language_Str MSG_BLTOUCH_RESET                   = _UxGT("BLTouch reset");
+  PROGMEM Language_Str MSG_BLTOUCH_STOW                    = _UxGT("BLTouch zasunout");
  PROGMEM Language_Str MSG_BLTOUCH_DEPLOY                  = _UxGT("BLTouch vysunout");
  PROGMEM Language_Str MSG_BLTOUCH_SW_MODE                 = _UxGT("SW výsun BLTouch");
  PROGMEM Language_Str MSG_BLTOUCH_5V_MODE                 = _UxGT("BLTouch 5V režim");
  PROGMEM Language_Str MSG_BLTOUCH_OD_MODE                 = _UxGT("BLTouch OD režim");
-  PROGMEM Language_Str MSG_BLTOUCH_STOW                    = _UxGT("BLTouch zasunout");
+  PROGMEM Language_Str MSG_BLTOUCH_MODE_STORE              = _UxGT("Uložit režim");
+  PROGMEM Language_Str MSG_BLTOUCH_MODE_STORE_5V           = _UxGT("Nastavit 5V");
+  PROGMEM Language_Str MSG_BLTOUCH_MODE_STORE_OD           = _UxGT("Nastacit OD");
+  PROGMEM Language_Str MSG_BLTOUCH_MODE_ECHO               = _UxGT("Vypsat nastavení");
+  PROGMEM Language_Str MSG_BLTOUCH_MODE_CHANGE             = _UxGT("VAROVANÍ: Špatné nastavení může způsobit škody! Pokračovat?");
+  PROGMEM Language_Str MSG_TOUCHMI_PROBE                   = _UxGT("TouchMI");
+  PROGMEM Language_Str MSG_TOUCHMI_INIT                    = _UxGT("Inic. TouchMI");
+  PROGMEM Language_Str MSG_TOUCHMI_ZTEST                   = _UxGT("Test Z Ofsetu");
+  PROGMEM Language_Str MSG_TOUCHMI_SAVE                    = _UxGT("Uložiy");
+  PROGMEM Language_Str MSG_MANUAL_DEPLOY_TOUCHMI           = _UxGT("vysunout TouchMI");
  PROGMEM Language_Str MSG_MANUAL_DEPLOY                   = _UxGT("Vysunout Z-sondu");
  PROGMEM Language_Str MSG_MANUAL_STOW                     = _UxGT("Zasunout Z-sondu");
  PROGMEM Language_Str MSG_HOME_FIRST                      = _UxGT("Domů %s%s%s první");
@ -337,9 +411,11 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_ENDSTOP_ABORT                   = _UxGT("Endstop abort");
  PROGMEM Language_Str MSG_HEATING_FAILED_LCD              = _UxGT("Chyba zahřívání");
  PROGMEM Language_Str MSG_HEATING_FAILED_LCD_BED          = _UxGT("Chyba zahř.podl.");
+  PROGMEM Language_Str MSG_HEATING_FAILED_LCD_CHAMBER      = _UxGT("Chyba zahř.komory");
  PROGMEM Language_Str MSG_ERR_REDUNDANT_TEMP              = _UxGT("REDUND. TEPLOTA");
  PROGMEM Language_Str MSG_THERMAL_RUNAWAY                 = _UxGT("TEPLOTNÍ ÚNIK");
  PROGMEM Language_Str MSG_THERMAL_RUNAWAY_BED             = _UxGT("TEPL. ÚNIK PODL.");
+  PROGMEM Language_Str MSG_THERMAL_RUNAWAY_CHAMBER         = _UxGT("TEPL. ÚNIK KOMORA");
  PROGMEM Language_Str MSG_ERR_MAXTEMP                     = _UxGT("VYSOKÁ TEPLOTA");
  PROGMEM Language_Str MSG_ERR_MINTEMP                     = _UxGT("NÍZKA TEPLOTA");
  PROGMEM Language_Str MSG_ERR_MAXTEMP_BED                 = _UxGT("VYS. TEPL. PODL.");
@ -364,6 +440,8 @@ namespace Language_cz {
  #else
    PROGMEM Language_Str MSG_BED_COOLING                   = _UxGT("Chlazení podl.");
  #endif
+  PROGMEM Language_Str MSG_CHAMBER_HEATING                 = _UxGT("Zahřívání komory...");
+  PROGMEM Language_Str MSG_CHAMBER_COOLING                 = _UxGT("Chlazení komory...");
  PROGMEM Language_Str MSG_DELTA_CALIBRATE                 = _UxGT("Delta Kalibrace");
  PROGMEM Language_Str MSG_DELTA_CALIBRATE_X               = _UxGT("Kalibrovat X");
  PROGMEM Language_Str MSG_DELTA_CALIBRATE_Y               = _UxGT("Kalibrovat Y");
@ -389,8 +467,12 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_INFO_EXTRUDERS                  = _UxGT("Extrudéry");
  PROGMEM Language_Str MSG_INFO_BAUDRATE                   = _UxGT("Rychlost");
  PROGMEM Language_Str MSG_INFO_PROTOCOL                   = _UxGT("Protokol");
+  PROGMEM Language_Str MSG_INFO_RUNAWAY_OFF                = _UxGT("Sledování úniku: VYP");
+  PROGMEM Language_Str MSG_INFO_RUNAWAY_ON                 = _UxGT("Sledování úniku: ZAP");
+
  PROGMEM Language_Str MSG_CASE_LIGHT                      = _UxGT("Osvětlení");
  PROGMEM Language_Str MSG_CASE_LIGHT_BRIGHTNESS           = _UxGT("Jas světla");
+  PROGMEM Language_Str MSG_EXPECTED_PRINTER                = _UxGT("NESPRÁVNÁ TISKÁRNA");

  #if LCD_WIDTH >= 20
    PROGMEM Language_Str MSG_INFO_PRINT_COUNT              = _UxGT("Počet tisků");
@ -410,8 +492,12 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Teplota max");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Nap. zdroj");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Buzení motorů");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Motor %");
-  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Uložit do EEPROM");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Motor %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Motor %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Motor %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Motor %");
+  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("DAC uložit EEPROM");
+  PROGMEM Language_Str MSG_ERROR_TMC                       = _UxGT("TMC CHYBA SPOJENÍ");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER          = _UxGT("VÝMĚNA FILAMENTU");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_PAUSE    = _UxGT("TISK POZASTAVEN");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_LOAD     = _UxGT("ZAVEDENÍ FILAMENTU");
@ -421,6 +507,7 @@ namespace Language_cz {
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_OPTION_RESUME   = _UxGT("Obnovit tisk");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_NOZZLE          = _UxGT("  Tryska: ");
  PROGMEM Language_Str MSG_RUNOUT_SENSOR                   = _UxGT("Senzor filamentu");
+  PROGMEM Language_Str MSG_RUNOUT_DISTANCE_MM              = _UxGT("Délka mm senz.fil.");
  PROGMEM Language_Str MSG_LCD_HOMING_FAILED               = _UxGT("Parkování selhalo");
  PROGMEM Language_Str MSG_LCD_PROBING_FAILED              = _UxGT("Kalibrace selhala");
  PROGMEM Language_Str MSG_M600_TOO_COLD                   = _UxGT("M600: Moc studený");
@ -474,13 +561,13 @@ namespace Language_cz {
  #endif
  PROGMEM Language_Str MSG_START_Z                         = _UxGT("Počáteční Z:");
  PROGMEM Language_Str MSG_END_Z                           = _UxGT("  Koncové Z:");
+
+  PROGMEM Language_Str MSG_GAMES                           = _UxGT("Hry");
  PROGMEM Language_Str MSG_BRICKOUT                        = _UxGT("Brickout");
  PROGMEM Language_Str MSG_INVADERS                        = _UxGT("Invaders");
  PROGMEM Language_Str MSG_SNAKE                           = _UxGT("Sn4k3");
  PROGMEM Language_Str MSG_MAZE                            = _UxGT("Bludiště");

-  PROGMEM Language_Str MSG_EXPECTED_PRINTER                = _UxGT("Nesprávná tiskárna");
-
  #if LCD_HEIGHT >= 4
    // Up to 3 lines allowed
    PROGMEM Language_Str MSG_ADVANCED_PAUSE_WAITING        = _UxGT(MSG_2_LINE("Stikněte tlačítko", "pro obnovení tisku"));
--- a/Marlin/src/lcd/language/language_da.h
+++ b/Marlin/src/lcd/language/language_da.h
@ -99,7 +99,7 @@ namespace Language_da {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Temperatur");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Bevægelse");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filament");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E i mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E i mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Fil. Dia.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Fil. Dia. *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("LCD kontrast");
@ -176,7 +176,11 @@ namespace Language_da {
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Strømfors.");

  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Driv Styrke");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Driv %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Driv %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Driv %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Driv %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Driv %");
+
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("DAC EEPROM Skriv");

  PROGMEM Language_Str MSG_FILAMENT_CHANGE_OPTION_RESUME   = _UxGT("Forsæt print");
--- a/Marlin/src/lcd/language/language_de.h
+++ b/Marlin/src/lcd/language/language_de.h
@ -456,7 +456,10 @@ namespace Language_de {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Max Temp");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Netzteil");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Motorleistung");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Treiber %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Treiber %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Treiber %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Treiber %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Treiber %");
  PROGMEM Language_Str MSG_ERROR_TMC                       = _UxGT("TMC Verbindungsfehler");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Werte speichern");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER          = _UxGT("FILAMENT WECHSEL");
--- a/Marlin/src/lcd/language/language_el.h
+++ b/Marlin/src/lcd/language/language_el.h
@ -130,7 +130,7 @@ namespace Language_el {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Θερμοκρασία");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Κίνηση");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Νήμα");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("Ε σε μμ3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("Ε σε μμ³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Διάμετρος νήματος");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Διάμετρος νήματος *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("Κοντράστ LCD");
--- a/Marlin/src/lcd/language/language_el_gr.h
+++ b/Marlin/src/lcd/language/language_el_gr.h
@ -140,7 +140,7 @@ namespace Language_el_gr {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Θερμοκρασία");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Κίνηση");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Νήμα");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("Ε σε μμ3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("Ε σε μμ³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Διάμετρος νήματος");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Διάμετρος νήματος *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("Κοντράστ LCD");
--- a/Marlin/src/lcd/language/language_en.h
+++ b/Marlin/src/lcd/language/language_en.h
@ -39,12 +39,6 @@ namespace Language_en {
  constexpr uint8_t    CHARSIZE                            = 2;
  PROGMEM Language_Str LANGUAGE                            = _UxGT("English");

-  #ifdef NOT_EXTENDED_ISO10646_1_5X7
-    PROGMEM Language_Str MSG_CUBED                         = _UxGT("^3");
-  #else
-    PROGMEM Language_Str MSG_CUBED                         = _UxGT("³");
-  #endif
-
  PROGMEM Language_Str WELCOME_MSG                         = MACHINE_NAME _UxGT(" Ready.");
  PROGMEM Language_Str MSG_YES                             = _UxGT("YES");
  PROGMEM Language_Str MSG_NO                              = _UxGT("NO");
@ -480,7 +474,10 @@ namespace Language_en {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Max Temp");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("PSU");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Drive Strength");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Driver %");
  PROGMEM Language_Str MSG_ERROR_TMC                       = _UxGT("TMC CONNECTION ERROR");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("DAC EEPROM Write");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER          = _UxGT("FILAMENT CHANGE");
--- a/Marlin/src/lcd/language/language_es.h
+++ b/Marlin/src/lcd/language/language_es.h
@ -441,7 +441,10 @@ namespace Language_es {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Temp. Máxima");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Fuente alimentación");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Fuerza de empuje");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Driver %");
  PROGMEM Language_Str MSG_ERROR_TMC                       = _UxGT("ERROR CONEX. TMC");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Escribe DAC EEPROM");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER          = _UxGT("CAMBIAR FILAMENTO");
--- a/Marlin/src/lcd/language/language_eu.h
+++ b/Marlin/src/lcd/language/language_eu.h
@ -295,7 +295,10 @@ namespace Language_eu {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Tenp. Maximoa");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Elikadura-iturria");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Driver-aren potentzia");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Driver %");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Idatzi DAC EEPROM");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_PAUSE    = _UxGT("HARIZPIA ALDATU");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_LOAD     = _UxGT("HARIZPIA KARGATU");
--- a/Marlin/src/lcd/language/language_fr.h
+++ b/Marlin/src/lcd/language/language_fr.h
@ -85,7 +85,7 @@ namespace Language_fr {
  PROGMEM Language_Str MSG_PREHEAT_2_ALL                   = _UxGT("Préch. ") PREHEAT_2_LABEL _UxGT(" Tout");
  PROGMEM Language_Str MSG_PREHEAT_2_BEDONLY               = _UxGT("Préch. ") PREHEAT_2_LABEL _UxGT(" lit");
  PROGMEM Language_Str MSG_PREHEAT_2_SETTINGS              = _UxGT("Régler préch. ") PREHEAT_2_LABEL;
-  PROGMEM Language_Str MSG_PREHEAT_CUSTOM                  = _UxGT("Préchauffage perso");
+  PROGMEM Language_Str MSG_PREHEAT_CUSTOM                  = _UxGT("Préchauf. perso");
  PROGMEM Language_Str MSG_COOLDOWN                        = _UxGT("Refroidir");
  PROGMEM Language_Str MSG_LASER_MENU                      = _UxGT("Contrôle Laser");
  PROGMEM Language_Str MSG_LASER_POWER                     = _UxGT("Puissance");
@ -93,7 +93,7 @@ namespace Language_fr {
  PROGMEM Language_Str MSG_SWITCH_PS_ON                    = _UxGT("Allumer alim.");
  PROGMEM Language_Str MSG_SWITCH_PS_OFF                   = _UxGT("Eteindre alim.");
  PROGMEM Language_Str MSG_EXTRUDE                         = _UxGT("Extrusion");
-  PROGMEM Language_Str MSG_RETRACT                         = _UxGT("Rétractation");
+  PROGMEM Language_Str MSG_RETRACT                         = _UxGT("Rétraction");
  PROGMEM Language_Str MSG_MOVE_AXIS                       = _UxGT("Déplacer un axe");
  PROGMEM Language_Str MSG_BED_LEVELING                    = _UxGT("Régler Niv. lit");
  PROGMEM Language_Str MSG_LEVEL_BED                       = _UxGT("Niveau du lit");
@ -234,8 +234,9 @@ namespace Language_fr {
  PROGMEM Language_Str MSG_NOZZLE_N                        = _UxGT("Buse ~");
  PROGMEM Language_Str MSG_BED                             = _UxGT("Lit");
  PROGMEM Language_Str MSG_CHAMBER                         = _UxGT("Caisson");
-  PROGMEM Language_Str MSG_FAN_SPEED                       = _UxGT("Vit.  ventil.  ");
+  PROGMEM Language_Str MSG_FAN_SPEED                       = _UxGT("Vit.  ventil.  "); // 15 car. max
  PROGMEM Language_Str MSG_FAN_SPEED_N                     = _UxGT("Vit.  ventil. =");
+  PROGMEM Language_Str MSG_STORED_FAN_N                    = _UxGT("Vit.  enreg.  =");
  PROGMEM Language_Str MSG_EXTRA_FAN_SPEED                 = _UxGT("Extra ventil.  ");
  PROGMEM Language_Str MSG_EXTRA_FAN_SPEED_N               = _UxGT("Extra ventil. =");

@ -258,10 +259,10 @@ namespace Language_fr {
  PROGMEM Language_Str MSG_VE_JERK                         = _UxGT("Ve jerk");
  PROGMEM Language_Str MSG_VELOCITY                        = _UxGT("Vélocité");
  PROGMEM Language_Str MSG_JUNCTION_DEVIATION              = _UxGT("Déviat. jonct.");
-  PROGMEM Language_Str MSG_VTRAV_MIN                       = _UxGT("V dépl. min");
+  PROGMEM Language_Str MSG_VTRAV_MIN                       = _UxGT("Vmin course");
  PROGMEM Language_Str MSG_ACCELERATION                    = _UxGT("Accélération");
-  PROGMEM Language_Str MSG_A_RETRACT                       = _UxGT("A retrait");
-  PROGMEM Language_Str MSG_A_TRAVEL                        = _UxGT("A dépl.");
+  PROGMEM Language_Str MSG_A_RETRACT                       = _UxGT("Acc.rétraction");
+  PROGMEM Language_Str MSG_A_TRAVEL                        = _UxGT("Acc.course");
  PROGMEM Language_Str MSG_STEPS_PER_MM                    = _UxGT("Pas/mm");
  PROGMEM Language_Str MSG_A_STEPS                         = LCD_STR_A _UxGT(" pas/mm");
  PROGMEM Language_Str MSG_B_STEPS                         = LCD_STR_B _UxGT(" pas/mm");
@ -271,7 +272,7 @@ namespace Language_fr {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Température");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Mouvement");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filament");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E en mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E en mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Diamètre fil.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Diamètre fil. *");
  PROGMEM Language_Str MSG_FILAMENT_UNLOAD                 = _UxGT("Retrait mm");
@ -297,10 +298,15 @@ namespace Language_fr {
  PROGMEM Language_Str MSG_BUTTON_RESET                    = _UxGT("Reset");
  PROGMEM Language_Str MSG_BUTTON_CANCEL                   = _UxGT("Annuler");
  PROGMEM Language_Str MSG_BUTTON_DONE                     = _UxGT("Terminé");
+  PROGMEM Language_Str MSG_BUTTON_BACK                     = _UxGT("Retour");
+  PROGMEM Language_Str MSG_BUTTON_PROCEED                  = _UxGT("Procéder");
  PROGMEM Language_Str MSG_PAUSE_PRINT                     = _UxGT("Pause impression");
  PROGMEM Language_Str MSG_RESUME_PRINT                    = _UxGT("Reprendre impr.");
  PROGMEM Language_Str MSG_STOP_PRINT                      = _UxGT("Arrêter impr.");
-  PROGMEM Language_Str MSG_OUTAGE_RECOVERY                 = _UxGT("Récupér. coupure");
+  PROGMEM Language_Str MSG_PRINTING_OBJECT                 = _UxGT("Impression objet");
+  PROGMEM Language_Str MSG_CANCEL_OBJECT                   = _UxGT("Annuler objet");
+  PROGMEM Language_Str MSG_CANCEL_OBJECT_N                 = _UxGT("Annuler objet =");
+  PROGMEM Language_Str MSG_OUTAGE_RECOVERY                 = _UxGT("Récup. coup.");
  PROGMEM Language_Str MSG_MEDIA_MENU                      = _UxGT("Impression SD");
  PROGMEM Language_Str MSG_NO_MEDIA                        = _UxGT("Pas de média");
  PROGMEM Language_Str MSG_DWELL                           = _UxGT("Repos...");
@ -311,28 +317,29 @@ namespace Language_fr {
  PROGMEM Language_Str MSG_NO_MOVE                         = _UxGT("Moteurs bloqués");
  PROGMEM Language_Str MSG_KILLED                          = _UxGT("KILLED");
  PROGMEM Language_Str MSG_STOPPED                         = _UxGT("STOPPÉ");
-  PROGMEM Language_Str MSG_CONTROL_RETRACT                 = _UxGT("Retrait mm");
-  PROGMEM Language_Str MSG_CONTROL_RETRACT_SWAP            = _UxGT("Ech. Retr. mm");
-  PROGMEM Language_Str MSG_CONTROL_RETRACTF                = _UxGT("Retrait V");
+  PROGMEM Language_Str MSG_CONTROL_RETRACT                 = _UxGT("Rétraction mm");
+  PROGMEM Language_Str MSG_CONTROL_RETRACT_SWAP            = _UxGT("Ech. rétr. mm");
+  PROGMEM Language_Str MSG_CONTROL_RETRACTF                = _UxGT("Vit. rétract°");
  PROGMEM Language_Str MSG_CONTROL_RETRACT_ZHOP            = _UxGT("Saut Z mm");
-  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVER         = _UxGT("Rappel mm");
-  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVER_SWAP    = _UxGT("Ech. Rappel mm");
-  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVERF        = _UxGT("Rappel V");
-  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVER_SWAPF   = _UxGT("Ech. Rappel V");
-  PROGMEM Language_Str MSG_AUTORETRACT                     = _UxGT("Retrait auto");
+  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVER         = _UxGT("Rét.reprise mm");
+  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVER_SWAP    = _UxGT("Ech.reprise mm");
+  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVERF        = _UxGT("V.rét. reprise");
+  PROGMEM Language_Str MSG_CONTROL_RETRACT_RECOVER_SWAPF   = _UxGT("V.éch. reprise");
+  PROGMEM Language_Str MSG_AUTORETRACT                     = _UxGT("Rétraction auto");
  PROGMEM Language_Str MSG_TOOL_CHANGE                     = _UxGT("Changement outil");
  PROGMEM Language_Str MSG_TOOL_CHANGE_ZLIFT               = _UxGT("Augmenter Z");
  PROGMEM Language_Str MSG_SINGLENOZZLE_PRIME_SPD          = _UxGT("Vitesse primaire");
-  PROGMEM Language_Str MSG_SINGLENOZZLE_RETRACT_SPD        = _UxGT("Vitesse retrait");
+  PROGMEM Language_Str MSG_SINGLENOZZLE_RETRACT_SPD        = _UxGT("Vitesse rétract°");
  PROGMEM Language_Str MSG_NOZZLE_STANDBY                  = _UxGT("Attente buse");
-  PROGMEM Language_Str MSG_FILAMENT_SWAP_LENGTH            = _UxGT("Distance retrait");
+  PROGMEM Language_Str MSG_FILAMENT_SWAP_LENGTH            = _UxGT("Longueur retrait");
  PROGMEM Language_Str MSG_FILAMENT_PURGE_LENGTH           = _UxGT("Longueur de purge");
  PROGMEM Language_Str MSG_FILAMENTCHANGE                  = _UxGT("Changer filament");
  PROGMEM Language_Str MSG_FILAMENTCHANGE_E                = _UxGT("Changer filament *");
  PROGMEM Language_Str MSG_FILAMENTLOAD                    = _UxGT("Charger filament");
  PROGMEM Language_Str MSG_FILAMENTLOAD_E                  = _UxGT("Charger filament *");
+  PROGMEM Language_Str MSG_FILAMENTUNLOAD                  = _UxGT("Retrait filament");
  PROGMEM Language_Str MSG_FILAMENTUNLOAD_E                = _UxGT("Retrait filament *");
-  PROGMEM Language_Str MSG_FILAMENTUNLOAD_ALL              = _UxGT("Décharger tout");
+  PROGMEM Language_Str MSG_FILAMENTUNLOAD_ALL              = _UxGT("Retirer tout");
  PROGMEM Language_Str MSG_INIT_MEDIA                      = _UxGT("Charger le média");
  PROGMEM Language_Str MSG_CHANGE_MEDIA                    = _UxGT("Actualiser média");
  PROGMEM Language_Str MSG_RELEASE_MEDIA                   = _UxGT("Retirer le média");
@ -429,7 +436,10 @@ namespace Language_fr {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Temp Max");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Alimentation");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Puiss. moteur ");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Driver %");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("DAC EEPROM sauv.");
  PROGMEM Language_Str MSG_ERROR_TMC                       = _UxGT("ERREUR CONNEXION TMC");

--- a/Marlin/src/lcd/language/language_gl.h
+++ b/Marlin/src/lcd/language/language_gl.h
@ -111,7 +111,7 @@ namespace Language_gl {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Temperatura");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Movemento");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filamento");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E en mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E en mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Diam. fil.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Diam. fil. *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("Constraste LCD");
--- a/Marlin/src/lcd/language/language_hr.h
+++ b/Marlin/src/lcd/language/language_hr.h
@ -92,7 +92,7 @@ namespace Language_hr {
  PROGMEM Language_Str MSG_SELECT_E                        = _UxGT("Odaberi *");
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Temperature");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Gibanje");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E in mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E in mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Fil. Dia.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Fil. Dia. *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("Kontrast LCD-a");
--- a/Marlin/src/lcd/language/language_it.h
+++ b/Marlin/src/lcd/language/language_it.h
@ -239,10 +239,11 @@ namespace Language_it {
  PROGMEM Language_Str MSG_NOZZLE_N                        = _UxGT("Ugello ~");
  PROGMEM Language_Str MSG_BED                             = _UxGT("Piatto");
  PROGMEM Language_Str MSG_CHAMBER                         = _UxGT("Camera");
-  PROGMEM Language_Str MSG_FAN_SPEED                       = _UxGT("Vel. ventola"); // Max 15 characters
-  PROGMEM Language_Str MSG_FAN_SPEED_N                     = _UxGT("Vel. ventola ="); // Max 15 characters
-  PROGMEM Language_Str MSG_EXTRA_FAN_SPEED                 = _UxGT("Extra vel.vent."); // Max 15 characters
-  PROGMEM Language_Str MSG_EXTRA_FAN_SPEED_N               = _UxGT("Extra v.vent. ="); // Max 15 characters
+  PROGMEM Language_Str MSG_FAN_SPEED                       = _UxGT("Vel. ventola");     // Max 15 characters
+  PROGMEM Language_Str MSG_FAN_SPEED_N                     = _UxGT("Vel. ventola =");   // Max 15 characters
+  PROGMEM Language_Str MSG_STORED_FAN_N                    = _UxGT("Ventola mem. =");   // Max 15 characters
+  PROGMEM Language_Str MSG_EXTRA_FAN_SPEED                 = _UxGT("Extra vel.vent.");  // Max 15 characters
+  PROGMEM Language_Str MSG_EXTRA_FAN_SPEED_N               = _UxGT("Extra v.vent. =");  // Max 15 characters
  PROGMEM Language_Str MSG_FLOW                            = _UxGT("Flusso");
  PROGMEM Language_Str MSG_FLOW_N                          = _UxGT("Flusso ~");
  PROGMEM Language_Str MSG_CONTROL                         = _UxGT("Controllo");
@ -467,7 +468,10 @@ namespace Language_it {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Temp max");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Alimentatore");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Potenza Drive");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Driver %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Driver %");
  PROGMEM Language_Str MSG_ERROR_TMC                       = _UxGT("ERR.CONNESSIONE TMC");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Scrivi DAC EEPROM");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER          = _UxGT("CAMBIO FILAMENTO");
--- a/Marlin/src/lcd/language/language_jp_kana.h
+++ b/Marlin/src/lcd/language/language_jp_kana.h
@ -223,7 +223,10 @@ namespace Language_jp_kana {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("セッテイサイコウオン");              // "Max Temp"
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("デンゲンシュベツ");                // "Power Supply"
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("モータークドウリョク");              // "Drive Strength"
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("DACシュツリョク %");               // "Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X DACシュツリョク %");               // "X Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y DACシュツリョク %");               // "Y Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z DACシュツリョク %");               // "Z Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E DACシュツリョク %");               // "E Driver %"
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("EEPROMヘホゾン");               // "Store memory"
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_PAUSE    = _UxGT("イチジテイシ");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_OPTION_RESUME   = _UxGT("プリントサイカイ");                // "Resume print"
--- a/Marlin/src/lcd/language/language_nl.h
+++ b/Marlin/src/lcd/language/language_nl.h
@ -117,7 +117,7 @@ namespace Language_nl {
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filament");
  PROGMEM Language_Str MSG_ADVANCE_K                       = _UxGT("Advance K");        //accepted english dutch
  PROGMEM Language_Str MSG_ADVANCE_K_E                     = _UxGT("Advance K *"); //accepted english dutch
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E in mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E in mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Fil. Dia.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Fil. Dia. *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("LCD contrast");
@ -214,7 +214,10 @@ namespace Language_nl {
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("PSU");  //accepted English term in Dutch

  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Motorstroom");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Driver %");  //accepted English term in Dutch
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Driver %");  //accepted English term in Dutch
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Driver %");  //accepted English term in Dutch
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Driver %");  //accepted English term in Dutch
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Driver %");  //accepted English term in Dutch
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("DAC Opslaan");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_OPTION_RESUME   = _UxGT("Hervat print");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_NOZZLE          = _UxGT(" Nozzle: "); //accepeted English term
--- a/Marlin/src/lcd/language/language_pl.h
+++ b/Marlin/src/lcd/language/language_pl.h
@ -296,7 +296,7 @@ namespace Language_pl {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Temperatura");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Ruch");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filament");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E w mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E w mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Śr. fil.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Śr. fil. *");
  PROGMEM Language_Str MSG_FILAMENT_UNLOAD                 = _UxGT("Wyładuj mm");
@ -465,7 +465,10 @@ namespace Language_pl {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Max Temp");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Zasilacz");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Siła silnika");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Siła %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Siła %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Siła %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Siła %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Siła %");
  PROGMEM Language_Str MSG_ERROR_TMC                       = _UxGT("TMC BŁĄD POŁĄCZENIA");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Zapisz DAC EEPROM");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER          = _UxGT("ZMIEŃ FILAMENT");
--- a/Marlin/src/lcd/language/language_pt.h
+++ b/Marlin/src/lcd/language/language_pt.h
@ -107,7 +107,7 @@ namespace Language_pt {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Temperatura");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Movimento");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filamento");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E em mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E em mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Fil. Diam.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Fil. Diam. *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("Contraste");
--- a/Marlin/src/lcd/language/language_pt_br.h
+++ b/Marlin/src/lcd/language/language_pt_br.h
@ -242,7 +242,7 @@ namespace Language_pt_br {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Temperatura");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Movimento");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Filamento");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("Extrusão em mm3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("Extrusão em mm³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Diâmetro Fil.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Diâmetro Fil. *");
  PROGMEM Language_Str MSG_FILAMENT_UNLOAD                 = _UxGT("Descarr. mm");
--- a/Marlin/src/lcd/language/language_ru.h
+++ b/Marlin/src/lcd/language/language_ru.h
@ -258,7 +258,7 @@ namespace Language_ru {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Температура");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Движение");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Филамент");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E в мм3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E в мм³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Диаметр филамента");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Диаметр филамента *");
  PROGMEM Language_Str MSG_FILAMENT_UNLOAD                 = _UxGT("Загрузка мм");
@ -408,7 +408,10 @@ namespace Language_ru {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Макс. Т");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("БП");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Сила привода");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Привод %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Привод %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Привод %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Привод %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Привод %");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Запись DAC EEPROM");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_PAUSE    = _UxGT("ПЕЧАТЬ НА ПАУЗЕ");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_LOAD     = _UxGT("ЗАГРУЗКА ФИЛАМЕНТА");
--- a/Marlin/src/lcd/language/language_sk.h
+++ b/Marlin/src/lcd/language/language_sk.h
@ -474,7 +474,10 @@ namespace Language_sk {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Teplota max");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Nap. zdroj");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Budenie motorov");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Motor %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Motor %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Motor %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Motor %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Motor %");
  PROGMEM Language_Str MSG_ERROR_TMC                       = _UxGT("CHYBA KOMUNIKÁ. TMC");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Uložiť do EEPROM");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER          = _UxGT("VÝMENA FILAMENTU");
--- a/Marlin/src/lcd/language/language_tr.h
+++ b/Marlin/src/lcd/language/language_tr.h
@ -391,7 +391,10 @@ namespace Language_tr {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Max Sıc.");
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Güç Kaynağı");
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Sürücü Gücü");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("Sürücü %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X Sürücü %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y Sürücü %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z Sürücü %");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E Sürücü %");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("DAC EEPROM Yaz");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_PAUSE    = _UxGT("BASKI DURAKLATILDI");
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_LOAD     = _UxGT("FILAMAN YüKLE");
--- a/Marlin/src/lcd/language/language_uk.h
+++ b/Marlin/src/lcd/language/language_uk.h
@ -141,7 +141,7 @@ namespace Language_uk {
  PROGMEM Language_Str MSG_TEMPERATURE                     = _UxGT("Температура");
  PROGMEM Language_Str MSG_MOTION                          = _UxGT("Рух");
  PROGMEM Language_Str MSG_FILAMENT                        = _UxGT("Волокно");
-  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E в мм3");
+  PROGMEM Language_Str MSG_VOLUMETRIC_ENABLED              = _UxGT("E в мм³");
  PROGMEM Language_Str MSG_FILAMENT_DIAM                   = _UxGT("Діам. волок.");
  PROGMEM Language_Str MSG_FILAMENT_DIAM_E                 = _UxGT("Діам. волок. *");
  PROGMEM Language_Str MSG_CONTRAST                        = _UxGT("контраст LCD");
@ -223,7 +223,10 @@ namespace Language_uk {
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Джерело жив.");

  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Сила мотору");
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("% мотору");
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X % мотору");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y % мотору");
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z % мотору");
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E % мотору");
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Запис ЦАП на ПЗП");

  PROGMEM Language_Str MSG_FILAMENT_CHANGE_OPTION_RESUME   = _UxGT("Відновити друк");
--- a/Marlin/src/lcd/language/language_vi.h
+++ b/Marlin/src/lcd/language/language_vi.h
@ -398,7 +398,10 @@ namespace Language_vi {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("Nhiệt độ tối đa");                      // Max temp
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("Bộ nguồn");                             // PSU
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("Sức mạnh ổ đĩa");                       // Drive Strength
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("% trình điều khiển");                   // Driver %
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X % trình điều khiển");                 // X Driver %
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y % trình điều khiển");                 // Y Driver %
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z % trình điều khiển");                 // Z Driver %
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E % trình điều khiển");                 // E Driver %
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("Ghi DAC EEPROM");                       // DAC EEPROM Write
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_PAUSE    = _UxGT("In tạm dừng");                          // PRINT PAUSED
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_LOAD     = _UxGT("Nạp dây nhựa");
--- a/Marlin/src/lcd/language/language_zh_CN.h
+++ b/Marlin/src/lcd/language/language_zh_CN.h
@ -359,7 +359,10 @@ namespace Language_zh_CN {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("最高温度");     //"Max Temp"
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("电源供应");     //"Power Supply"
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("驱动力度");     // "Drive Strength"
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("驱动 %");     // "Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X 驱动 %");     // "X Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y 驱动 %");     // "Y Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z 驱动 %");     // "Z Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E 驱动 %");     // "E Driver %"
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("保存驱动设置");     // "DAC EEPROM Write"
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_PAUSE    = _UxGT("打印已暂停");     // "PRINT PAUSED"
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_LOAD     = _UxGT("装载丝料");     // "LOAD FILAMENT"
--- a/Marlin/src/lcd/language/language_zh_TW.h
+++ b/Marlin/src/lcd/language/language_zh_TW.h
@ -359,7 +359,10 @@ namespace Language_zh_TW {
  PROGMEM Language_Str MSG_INFO_MAX_TEMP                   = _UxGT("最高溫度");     //"Max Temp"
  PROGMEM Language_Str MSG_INFO_PSU                        = _UxGT("電源供應");     //"Power Supply"
  PROGMEM Language_Str MSG_DRIVE_STRENGTH                  = _UxGT("驅動力度");     // "Drive Strength"
-  PROGMEM Language_Str MSG_DAC_PERCENT                     = _UxGT("驅動 %");     // "Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_X                   = _UxGT("X 驅動 %");     // "X Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_Y                   = _UxGT("Y 驅動 %");     // "Y Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_Z                   = _UxGT("Z 驅動 %");     // "Z Driver %"
+  PROGMEM Language_Str MSG_DAC_PERCENT_E                   = _UxGT("E 驅動 %");     // "E Driver %"
  PROGMEM Language_Str MSG_DAC_EEPROM_WRITE                = _UxGT("保存驅動設置");     // "DAC EEPROM Write"
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_PAUSE    = _UxGT("列印已暫停");     // "PRINT PAUSED"
  PROGMEM Language_Str MSG_FILAMENT_CHANGE_HEADER_LOAD     = _UxGT("裝載絲料");     // "LOAD FILAMENT"
--- a/Marlin/src/lcd/menu/menu_advanced.cpp
+++ b/Marlin/src/lcd/menu/menu_advanced.cpp
@ -65,7 +65,7 @@ void menu_cancelobject();
    LOOP_XYZE(i) driverPercent[i] = dac_current_get_percent((AxisEnum)i);
    START_MENU();
    BACK_ITEM(MSG_ADVANCED_SETTINGS);
-    #define EDIT_DAC_PERCENT(A) EDIT_ITEM_P(uint8, PSTR(MSG_##A " " MSG_DAC_PERCENT), &driverPercent[_AXIS(A)], 0, 100, []{ dac_current_set_percents(driverPercent); })
+    #define EDIT_DAC_PERCENT(A) EDIT_ITEM(uint8, MSG_DAC_PERCENT_##A, &driverPercent[_AXIS(A)], 0, 100, []{ dac_current_set_percents(driverPercent); })
    EDIT_DAC_PERCENT(X);
    EDIT_DAC_PERCENT(Y);
    EDIT_DAC_PERCENT(Z);
--- a/Marlin/src/lcd/menu/menu_main.cpp
+++ b/Marlin/src/lcd/menu/menu_main.cpp
@ -106,7 +106,11 @@ void menu_main() {
    SUBMENU(MSG_TUNE, menu_tune);
  }
  else {
+
    #if !HAS_ENCODER_WHEEL && ENABLED(SDSUPPORT)
+
+      // *** IF THIS SECTION IS CHANGED, REPRODUCE BELOW ***
+
      //
      // Autostart
      //
@ -134,6 +138,7 @@ void menu_main() {
          ACTION_ITEM(MSG_MEDIA_RELEASED, nullptr);
        #endif
      }
+
    #endif // !HAS_ENCODER_WHEEL && SDSUPPORT

    #if MACHINE_CAN_PAUSE
@ -197,6 +202,9 @@ void menu_main() {
  #endif

  #if HAS_ENCODER_WHEEL && ENABLED(SDSUPPORT)
+
+    // *** IF THIS SECTION IS CHANGED, REPRODUCE ABOVE ***
+
    //
    // Autostart
    //
@ -224,6 +232,7 @@ void menu_main() {
        ACTION_ITEM(MSG_MEDIA_RELEASED, nullptr);
      #endif
    }
+
  #endif // HAS_ENCODER_WHEEL && SDSUPPORT

  #if HAS_SERVICE_INTERVALS
--- a/Marlin/src/lcd/ultralcd.cpp
+++ b/Marlin/src/lcd/ultralcd.cpp
@ -200,6 +200,7 @@ millis_t MarlinUI::next_button_update_ms; // = 0
  #endif

  #if ENABLED(TOUCH_BUTTONS)
+    uint8_t MarlinUI::touch_buttons;
    uint8_t MarlinUI::repeat_delay;
  #endif

@ -778,58 +779,46 @@ void MarlinUI::update() {

    #if ENABLED(TOUCH_BUTTONS)

-      #define TOUCH_MENU_MASK 0x80
-
-      static bool arrow_pressed; // = false
-
-      // Handle touch events which are slow to read
-      if (ELAPSED(ms, next_button_update_ms)) {
-        uint8_t touch_buttons = touch.read_buttons();
-        if (touch_buttons) {
-          RESET_STATUS_TIMEOUT();
-          if (touch_buttons & TOUCH_MENU_MASK) {        // Processing Menu Area touch?
-            if (!wait_for_unclick) {                    // If not waiting for a debounce release:
-              wait_for_unclick = true;                  //  - Set debounce flag to ignore continous clicks
-              wait_for_user = false;                    //  - Any click clears wait for user
-              // TODO for next PR.
-              //uint8_t tpos = touch_buttons & ~(TOUCH_MENU_MASK);  // Safe 7bit touched screen coordinate
-              next_button_update_ms = ms + 500;         // Defer next check for 1/2 second
-              #if HAS_LCD_MENU
-                refresh();
-              #endif
-            }
-            touch_buttons = 0;                          // Swallow the touch
-          }
-          buttons |= (touch_buttons & (EN_C | EN_D));   // Pass on Click and Back buttons
-          if (touch_buttons & (EN_A | EN_B)) {          // A and/or B button?
+      if (touch_buttons) {
+        RESET_STATUS_TIMEOUT();
+        if (buttons & (EN_A | EN_B)) {                    // Menu arrows, in priority
+          if (ELAPSED(ms, next_button_update_ms)) {
            encoderDiff = (ENCODER_STEPS_PER_MENU_ITEM) * (ENCODER_PULSES_PER_STEP) * encoderDirection;
-            if (touch_buttons & EN_A) encoderDiff *= -1;
-            next_button_update_ms = ms + repeat_delay;  // Assume the repeat delay
-            if (!wait_for_unclick && !arrow_pressed) {  // On click prepare for repeat
-              next_button_update_ms += 250;             // Longer delay on first press
-              arrow_pressed = true;                     // Mark arrow as pressed
+            if (buttons & EN_A) encoderDiff *= -1;
+            next_button_update_ms = ms + repeat_delay;    // Assume the repeat delay
+            if (!wait_for_unclick) {
+              next_button_update_ms += 250;               // Longer delay on first press
+              wait_for_unclick = true;                    // Avoid Back/Select click while repeating
              #if HAS_BUZZER
                buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
              #endif
            }
          }
        }
-        if (!(touch_buttons & (EN_A | EN_B))) arrow_pressed = false;
+        else if (!wait_for_unclick && (buttons & EN_C)) { // OK button, if not waiting for a debounce release:
+          wait_for_unclick = true;                        //  - Set debounce flag to ignore continous clicks
+          lcd_clicked = !wait_for_user && !no_reentry;    //  - Keep the click if not waiting for a user-click
+          wait_for_user = false;                          //  - Any click clears wait for user
+          quick_feedback();                               //  - Always make a click sound
+        }
      }
+      else // keep wait_for_unclick value

    #endif // TOUCH_BUTTONS

-    // Integrated LCD click handling via button_pressed
-    if (!external_control && button_pressed()) {
-      if (!wait_for_unclick) {                        // If not waiting for a debounce release:
-        wait_for_unclick = true;                      //  - Set debounce flag to ignore continous clicks
-        lcd_clicked = !wait_for_user && !no_reentry;  //  - Keep the click if not waiting for a user-click
-        wait_for_user = false;                        //  - Any click clears wait for user
-        quick_feedback();                             //  - Always make a click sound
+      {
+        // Integrated LCD click handling via button_pressed
+        if (!external_control && button_pressed()) {
+          if (!wait_for_unclick) {                        // If not waiting for a debounce release:
+            wait_for_unclick = true;                      //  - Set debounce flag to ignore continous clicks
+            lcd_clicked = !wait_for_user && !no_reentry;  //  - Keep the click if not waiting for a user-click
+            wait_for_user = false;                        //  - Any click clears wait for user
+            quick_feedback();                             //  - Always make a click sound
+          }
+        }
+        else
+          wait_for_unclick = false;
      }
-    }
-    else
-      wait_for_unclick = false;

    if (LCD_BACK_CLICKED()) {
      quick_feedback();
@ -894,8 +883,13 @@ void MarlinUI::update() {
    next_lcd_update_ms = ms + LCD_UPDATE_INTERVAL;

    #if ENABLED(TOUCH_BUTTONS)
-      if (on_status_screen())
-        next_lcd_update_ms += (LCD_UPDATE_INTERVAL) * 2;
+
+      if (on_status_screen()) next_lcd_update_ms += (LCD_UPDATE_INTERVAL) * 2;
+
+      #if HAS_ENCODER_ACTION
+        touch_buttons = touch.read_buttons();
+      #endif
+
    #endif

    #if ENABLED(LCD_HAS_STATUS_INDICATORS)
@ -1249,6 +1243,9 @@ void MarlinUI::update() {
          #if HAS_SLOW_BUTTONS
            | slow_buttons
          #endif
+          #if ENABLED(TOUCH_BUTTONS) && HAS_ENCODER_ACTION
+            | touch_buttons
+          #endif
        );

      #elif HAS_ADC_BUTTONS
--- a/Marlin/src/lcd/ultralcd.h
+++ b/Marlin/src/lcd/ultralcd.h
@ -27,10 +27,10 @@
  #include "../libs/buzzer.h"
 #endif

-#define HAS_DIGITAL_BUTTONS (!HAS_ADC_BUTTONS && ENABLED(NEWPANEL) || BUTTON_EXISTS(EN1, EN2) || ANY_BUTTON(ENC, BACK, UP, DWN, LFT, RT))
-#define HAS_SHIFT_ENCODER   (!HAS_ADC_BUTTONS && (ENABLED(REPRAPWORLD_KEYPAD) || (HAS_SPI_LCD && DISABLED(NEWPANEL))))
-#define HAS_ENCODER_WHEEL  ((!HAS_ADC_BUTTONS && ENABLED(NEWPANEL)) || BUTTON_EXISTS(EN1, EN2))
 #define HAS_ENCODER_ACTION (HAS_LCD_MENU || ENABLED(ULTIPANEL_FEEDMULTIPLY))
+#define HAS_ENCODER_WHEEL  ((!HAS_ADC_BUTTONS && ENABLED(NEWPANEL)) || BUTTON_EXISTS(EN1, EN2))
+#define HAS_DIGITAL_BUTTONS (HAS_ENCODER_WHEEL || ANY_BUTTON(ENC, BACK, UP, DWN, LFT, RT))
+#define HAS_SHIFT_ENCODER   (!HAS_ADC_BUTTONS && (ENABLED(REPRAPWORLD_KEYPAD) || (HAS_SPI_LCD && DISABLED(NEWPANEL))))

 // I2C buttons must be read in the main thread
 #define HAS_SLOW_BUTTONS EITHER(LCD_I2C_VIKI, LCD_I2C_PANELOLU2)
@ -425,6 +425,7 @@ public:
  #if HAS_LCD_MENU

    #if ENABLED(TOUCH_BUTTONS)
+      static uint8_t touch_buttons;
      static uint8_t repeat_delay;
    #endif

--- a/Marlin/src/module/configuration_store.cpp
+++ b/Marlin/src/module/configuration_store.cpp
@ -788,11 +788,16 @@ void MarlinSettings::postprocess() {
      _FIELD_TEST(hotendPID);
      HOTEND_LOOP() {
        PIDCF_t pidcf = {
-                       PID_PARAM(Kp, e),
-          unscalePID_i(PID_PARAM(Ki, e)),
-          unscalePID_d(PID_PARAM(Kd, e)),
-                       PID_PARAM(Kc, e),
-                       PID_PARAM(Kf, e)
+          #if DISABLED(PIDTEMP)
+            DUMMY_PID_VALUE, DUMMY_PID_VALUE, DUMMY_PID_VALUE,
+            DUMMY_PID_VALUE, DUMMY_PID_VALUE
+          #else
+                         PID_PARAM(Kp, e),
+            unscalePID_i(PID_PARAM(Ki, e)),
+            unscalePID_d(PID_PARAM(Kd, e)),
+                         PID_PARAM(Kc, e),
+                         PID_PARAM(Kf, e)
+          #endif
        };
        EEPROM_WRITE(pidcf);
      }
@ -2872,10 +2877,12 @@ void MarlinSettings::reset() {
          for (uint8_t py = 0; py < GRID_MAX_POINTS_Y; py++) {
            for (uint8_t px = 0; px < GRID_MAX_POINTS_X; px++) {
              CONFIG_ECHO_START();
-              SERIAL_ECHOPAIR_P(PSTR("  G29 S3 X"), (int)px + 1, SP_Y_STR, (int)py + 1);
+              SERIAL_ECHOPAIR_P(PSTR("  G29 S3 I"), (int)px, PSTR(" J"), (int)py);
              SERIAL_ECHOLNPAIR_F_P(SP_Z_STR, LINEAR_UNIT(mbl.z_values[px][py]), 5);
            }
          }
+          CONFIG_ECHO_START();
+          SERIAL_ECHOLNPAIR_F_P(PSTR("  G29 S4 Z"), LINEAR_UNIT(mbl.z_offset), 5);
        }

      #elif ENABLED(AUTO_BED_LEVELING_UBL)
--- a/Marlin/src/module/planner.cpp
+++ b/Marlin/src/module/planner.cpp
@ -2620,13 +2620,15 @@ bool Planner::buffer_line(const float &rx, const float &ry, const float &rz, con
    if (mm == 0.0)
      mm = (delta_mm_cart.x != 0.0 || delta_mm_cart.y != 0.0) ? delta_mm_cart.magnitude() : ABS(delta_mm_cart.z);

+    // Cartesian XYZ to kinematic ABC, stored in global 'delta'
    inverse_kinematics(machine);

    #if ENABLED(SCARA_FEEDRATE_SCALING)
      // For SCARA scale the feed rate from mm/s to degrees/s
      // i.e., Complete the angular vector in the given time.
      const float duration_recip = inv_duration ?: fr_mm_s / mm;
-      const feedRate_t feedrate = HYPOT(delta.a - position_float.a, delta.b - position_float.b) * duration_recip;
+      const xyz_pos_t diff = delta - position_float;
+      const feedRate_t feedrate = diff.magnitude() * duration_recip;
    #else
      const feedRate_t feedrate = fr_mm_s;
    #endif
@ -2762,8 +2764,8 @@ void Planner::set_max_acceleration(const uint8_t axis, float targetValue) {
      constexpr xyze_float_t max_accel_edit = MAX_ACCEL_EDIT_VALUES;
      const xyze_float_t &max_acc_edit_scaled = max_accel_edit;
    #else
-      constexpr xyze_float_t max_accel_edit = DEFAULT_MAX_ACCELERATION,
-                             max_acc_edit_scaled = max_accel_edit * 2;
+      constexpr xyze_float_t max_accel_edit = DEFAULT_MAX_ACCELERATION;
+      const xyze_float_t max_acc_edit_scaled = max_accel_edit * 2;
    #endif
    limit_and_warn(targetValue, axis, PSTR("Acceleration"), max_acc_edit_scaled);
  #endif
@ -2779,8 +2781,8 @@ void Planner::set_max_feedrate(const uint8_t axis, float targetValue) {
      constexpr xyze_float_t max_fr_edit = MAX_FEEDRATE_EDIT_VALUES;
      const xyze_float_t &max_fr_edit_scaled = max_fr_edit;
    #else
-      constexpr xyze_float_t max_fr_edit = DEFAULT_MAX_FEEDRATE,
-                             max_fr_edit_scaled = max_fr_edit * 2;
+      constexpr xyze_float_t max_fr_edit = DEFAULT_MAX_FEEDRATE;
+      const xyze_float_t max_fr_edit_scaled = max_fr_edit * 2;
    #endif
    limit_and_warn(targetValue, axis, PSTR("Feedrate"), max_fr_edit_scaled);
  #endif
--- a/Marlin/src/module/probe.cpp
+++ b/Marlin/src/module/probe.cpp
@ -113,7 +113,9 @@ xyz_pos_t probe_offset; // Initialized by settings.load()

  // Move to the magnet to unlock the probe
  void run_deploy_moves_script() {
-    #if TOUCH_MI_DEPLOY_XPOS > X_MAX_BED
+    #ifndef TOUCH_MI_DEPLOY_XPOS
+      #define TOUCH_MI_DEPLOY_XPOS X_MIN_POS
+    #elif TOUCH_MI_DEPLOY_XPOS > X_MAX_BED
      TemporaryGlobalEndstopsState unlock_x(false);
    #endif
    #if TOUCH_MI_DEPLOY_YPOS > Y_MAX_BED
@ -356,7 +358,7 @@ bool set_probe_deployed(const bool deploy) {
  // Make room for probe to deploy (or stow)
  // Fix-mounted probe should only raise for deploy
  // unless PAUSE_BEFORE_DEPLOY_STOW is enabled
-  #if ENABLED(FIX_MOUNTED_PROBE) && DISABLED(PAUSE_BEFORE_DEPLOY_STOW)
+  #if EITHER(FIX_MOUNTED_PROBE, NOZZLE_AS_PROBE) && DISABLED(PAUSE_BEFORE_DEPLOY_STOW)
    const bool deploy_stow_condition = deploy;
  #else
    constexpr bool deploy_stow_condition = true;
--- a/Marlin/src/module/probe.h
+++ b/Marlin/src/module/probe.h
@ -85,6 +85,8 @@
    return (
      #if IS_KINEMATIC
        (X_CENTER) - probe_radius()
+      #elif ENABLED(NOZZLE_AS_PROBE)
+        _MAX(MIN_PROBE_EDGE_LEFT, X_MIN_POS)
      #else
        _MAX((X_MIN_BED) + (MIN_PROBE_EDGE_LEFT), (X_MIN_POS) + probe_offset.x)
      #endif
@ -94,6 +96,8 @@
    return (
      #if IS_KINEMATIC
        (X_CENTER) + probe_radius()
+      #elif ENABLED(NOZZLE_AS_PROBE)
+        _MAX(MIN_PROBE_EDGE_RIGHT, X_MAX_POS)
      #else
        _MIN((X_MAX_BED) - (MIN_PROBE_EDGE_RIGHT), (X_MAX_POS) + probe_offset.x)
      #endif
@ -103,6 +107,8 @@
    return (
      #if IS_KINEMATIC
        (Y_CENTER) - probe_radius()
+      #elif ENABLED(NOZZLE_AS_PROBE)
+        _MIN(MIN_PROBE_EDGE_FRONT, Y_MIN_POS)
      #else
        _MAX((Y_MIN_BED) + (MIN_PROBE_EDGE_FRONT), (Y_MIN_POS) + probe_offset.y)
      #endif
@ -112,6 +118,8 @@
    return (
      #if IS_KINEMATIC
        (Y_CENTER) + probe_radius()
+      #elif ENABLED(NOZZLE_AS_PROBE)
+        _MAX(MIN_PROBE_EDGE_BACK, Y_MAX_POS)
      #else
        _MIN((Y_MAX_BED) - (MIN_PROBE_EDGE_BACK), (Y_MAX_POS) + probe_offset.y)
      #endif
--- a/Marlin/src/module/scara.cpp
+++ b/Marlin/src/module/scara.cpp
@ -95,7 +95,6 @@ void forward_kinematics_SCARA(const float &a, const float &b) {
 void inverse_kinematics(const xyz_pos_t &raw) {

  #if ENABLED(MORGAN_SCARA)
-
    /**
     * Morgan SCARA Inverse Kinematics. Results in 'delta'.
     *
--- a/Marlin/src/module/stepper.cpp
+++ b/Marlin/src/module/stepper.cpp
@ -339,6 +339,24 @@ xyze_int8_t Stepper::count_direction{0};
  #define E_APPLY_STEP(v,Q) E_STEP_WRITE(stepper_extruder, v)
 #endif

+#define CYCLES_TO_NS(CYC) (1000UL * (CYC) / ((F_CPU) / 1000000))
+constexpr uint32_t NS_PER_PULSE_TIMER_TICK = 1000000000UL / (STEPPER_TIMER_RATE);
+
+// Round up when converting from ns to timer ticks
+constexpr uint32_t NS_TO_PULSE_TIMER_TICKS(uint32_t NS) { return (NS + (NS_PER_PULSE_TIMER_TICK) / 2) / (NS_PER_PULSE_TIMER_TICK); }
+
+#define TIMER_SETUP_NS (CYCLES_TO_NS(TIMER_READ_ADD_AND_STORE_CYCLES))
+
+#define PULSE_HIGH_TICK_COUNT hal_timer_t(NS_TO_PULSE_TIMER_TICKS(_MIN_PULSE_HIGH_NS - _MIN(_MIN_PULSE_HIGH_NS, TIMER_SETUP_NS)))
+#define PULSE_LOW_TICK_COUNT hal_timer_t(NS_TO_PULSE_TIMER_TICKS(_MIN_PULSE_LOW_NS - _MIN(_MIN_PULSE_LOW_NS, TIMER_SETUP_NS)))
+
+#define START_TIMED_PULSE(DIR) (end_tick_count = HAL_timer_get_count(PULSE_TIMER_NUM) + PULSE_##DIR##_TICK_COUNT)
+#define AWAIT_TIMED_PULSE() while (HAL_timer_get_count(PULSE_TIMER_NUM) < end_tick_count) { }
+#define START_HIGH_PULSE()  START_TIMED_PULSE(HIGH)
+#define START_LOW_PULSE()   START_TIMED_PULSE(LOW)
+#define AWAIT_HIGH_PULSE()  AWAIT_TIMED_PULSE()
+#define AWAIT_LOW_PULSE()   AWAIT_TIMED_PULSE()
+
 void Stepper::wake_up() {
  // TCNT1 = 0;
  ENABLE_STEPPER_DRIVER_INTERRUPT();
@ -1416,34 +1434,73 @@ void Stepper::stepper_pulse_phase_isr() {
  // Just update the value we will get at the end of the loop
  step_events_completed += events_to_do;

-  // Get the timer count and estimate the end of the pulse
-  hal_timer_t pulse_end = HAL_timer_get_count(PULSE_TIMER_NUM) + hal_timer_t(MIN_PULSE_TICKS);
-
-  const hal_timer_t added_step_ticks = hal_timer_t(ADDED_STEP_TICKS);
-
  // Take multiple steps per interrupt (For high speed moves)
-  do {
+  bool firstStep = true;
+  xyze_bool_t step_needed{0};
+  hal_timer_t end_tick_count = 0;

+  do {
    #define _APPLY_STEP(AXIS) AXIS ##_APPLY_STEP
    #define _INVERT_STEP_PIN(AXIS) INVERT_## AXIS ##_STEP_PIN

+    // Determine if pulses are needed
+    #define PULSE_PREP(AXIS) do{ \
+      delta_error[_AXIS(AXIS)] += advance_dividend[_AXIS(AXIS)]; \
+      step_needed[_AXIS(AXIS)] = (delta_error[_AXIS(AXIS)] >= 0); \
+      if (step_needed[_AXIS(AXIS)]) { \
+        count_position[_AXIS(AXIS)] += count_direction[_AXIS(AXIS)]; \
+        delta_error[_AXIS(AXIS)] -= advance_divisor; \
+      } \
+    }while(0)
+
    // Start an active pulse, if Bresenham says so, and update position
    #define PULSE_START(AXIS) do{ \
-      delta_error[_AXIS(AXIS)] += advance_dividend[_AXIS(AXIS)]; \
-      if (delta_error[_AXIS(AXIS)] >= 0) { \
+      if (step_needed[_AXIS(AXIS)]) { \
        _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS), 0); \
-        count_position[_AXIS(AXIS)] += count_direction[_AXIS(AXIS)]; \
      } \
    }while(0)

    // Stop an active pulse, if any, and adjust error term
    #define PULSE_STOP(AXIS) do { \
-      if (delta_error[_AXIS(AXIS)] >= 0) { \
-        delta_error[_AXIS(AXIS)] -= advance_divisor; \
+      if (step_needed[_AXIS(AXIS)]) { \
        _APPLY_STEP(AXIS)(_INVERT_STEP_PIN(AXIS), 0); \
      } \
    }while(0)

+    // Determine if pulses are needed
+    #if HAS_X_STEP
+      PULSE_PREP(X);
+    #endif
+    #if HAS_Y_STEP
+      PULSE_PREP(Y);
+    #endif
+    #if HAS_Z_STEP
+      PULSE_PREP(Z);
+    #endif
+
+    #if EITHER(LIN_ADVANCE, MIXING_EXTRUDER)
+      delta_error.e += advance_dividend.e;
+      if (delta_error.e >= 0) {
+        count_position.e += count_direction.e;
+        #if ENABLED(LIN_ADVANCE)
+          delta_error.e -= advance_divisor;
+          // Don't step E here - But remember the number of steps to perform
+          motor_direction(E_AXIS) ? --LA_steps : ++LA_steps;
+        #else
+          step_needed[E_AXIS] = delta_error.e >= 0;
+        #endif
+      }
+    #elif HAS_E0_STEP
+      PULSE_PREP(E);
+    #endif
+
+    #if (MINIMUM_STEPPER_PULSE || MAXIMUM_STEPPER_RATE) && DISABLED(I2S_STEPPER_STREAM)
+      if (firstStep)
+        firstStep = false;
+      else
+        AWAIT_LOW_PULSE();
+    #endif
+
    // Pulse start
    #if HAS_X_STEP
      PULSE_START(X);
@ -1455,24 +1512,10 @@ void Stepper::stepper_pulse_phase_isr() {
      PULSE_START(Z);
    #endif

-    // Pulse Extruders
-    // Tick the E axis, correct error term and update position
-    #if EITHER(LIN_ADVANCE, MIXING_EXTRUDER)
-      delta_error.e += advance_dividend.e;
-      if (delta_error.e >= 0) {
-        count_position.e += count_direction.e;
-        #if ENABLED(LIN_ADVANCE)
-          delta_error.e -= advance_divisor;
-          // Don't step E here - But remember the number of steps to perform
-          motor_direction(E_AXIS) ? --LA_steps : ++LA_steps;
-        #else // !LIN_ADVANCE && MIXING_EXTRUDER
-          // Don't adjust delta_error.e here!
-          // Being positive is the criteria for ending the pulse.
-          E_STEP_WRITE(mixer.get_next_stepper(), !INVERT_E_STEP_PIN);
-        #endif
-      }
-    #else // !LIN_ADVANCE && !MIXING_EXTRUDER
-      #if HAS_E0_STEP
+    #if DISABLED(LIN_ADVANCE)
+      #if ENABLED(MIXING_EXTRUDER)
+        if (step_needed[E_AXIS]) E_STEP_WRITE(mixer.get_next_stepper(), !INVERT_E_STEP_PIN);
+      #elif HAS_E0_STEP
        PULSE_START(E);
      #endif
    #endif
@ -1482,14 +1525,11 @@ void Stepper::stepper_pulse_phase_isr() {
    #endif

    // TODO: need to deal with MINIMUM_STEPPER_PULSE over i2s
-    #if MINIMUM_STEPPER_PULSE && DISABLED(I2S_STEPPER_STREAM)
-      // Just wait for the requested pulse duration
-      while (HAL_timer_get_count(PULSE_TIMER_NUM) < pulse_end) { /* nada */ }
+    #if (MINIMUM_STEPPER_PULSE || MAXIMUM_STEPPER_RATE) && DISABLED(I2S_STEPPER_STREAM)
+      START_HIGH_PULSE();
+      AWAIT_HIGH_PULSE();
    #endif

-    // Add the delay needed to ensure the maximum driver rate is enforced
-    if (signed(added_step_ticks) > 0) pulse_end += hal_timer_t(added_step_ticks);
-
    // Pulse stop
    #if HAS_X_STEP
      PULSE_STOP(X);
@ -1503,31 +1543,26 @@ void Stepper::stepper_pulse_phase_isr() {

    #if DISABLED(LIN_ADVANCE)
      #if ENABLED(MIXING_EXTRUDER)
+
        if (delta_error.e >= 0) {
          delta_error.e -= advance_divisor;
          E_STEP_WRITE(mixer.get_stepper(), INVERT_E_STEP_PIN);
        }
+
      #else // !MIXING_EXTRUDER
+
        #if HAS_E0_STEP
          PULSE_STOP(E);
        #endif
-      #endif
+
+      #endif  // !MIXING_EXTRUDER
    #endif // !LIN_ADVANCE

-    // Decrement the count of pending pulses to do
-    --events_to_do;
+    #if (MINIMUM_STEPPER_PULSE || MAXIMUM_STEPPER_RATE) && DISABLED(I2S_STEPPER_STREAM)
+      if (events_to_do) START_LOW_PULSE();
+    #endif

-    // For minimum pulse time wait after stopping pulses also
-    if (events_to_do) {
-      // Just wait for the requested pulse duration
-      while (HAL_timer_get_count(PULSE_TIMER_NUM) < pulse_end) { /* nada */ }
-      #if MINIMUM_STEPPER_PULSE
-        // Add to the value, the time that the pulse must be active (to be used on the next loop)
-        pulse_end += hal_timer_t(MIN_PULSE_TICKS);
-      #endif
-    }
-
-  } while (events_to_do);
+  } while (--events_to_do);
 }

 // This is the last half of the stepper interrupt: This one processes and
@ -1909,13 +1944,19 @@ uint32_t Stepper::stepper_block_phase_isr() {
      DELAY_NS(MINIMUM_STEPPER_POST_DIR_DELAY);
    #endif

-    // Get the timer count and estimate the end of the pulse
-    hal_timer_t pulse_end = HAL_timer_get_count(PULSE_TIMER_NUM) + hal_timer_t(MIN_PULSE_TICKS);
-
-    const hal_timer_t added_step_ticks = hal_timer_t(ADDED_STEP_TICKS);
+    //const hal_timer_t added_step_ticks = hal_timer_t(ADDED_STEP_TICKS);

    // Step E stepper if we have steps
+    bool firstStep = true;
+    hal_timer_t end_tick_count = 0;
+
    while (LA_steps) {
+      #if (MINIMUM_STEPPER_PULSE || MAXIMUM_STEPPER_RATE) && DISABLED(I2S_STEPPER_STREAM)
+        if (firstStep)
+          firstStep = false;
+        else
+          AWAIT_LOW_PULSE();
+      #endif

      // Set the STEP pulse ON
      #if ENABLED(MIXING_EXTRUDER)
@ -1925,16 +1966,16 @@ uint32_t Stepper::stepper_block_phase_isr() {
      #endif

      // Enforce a minimum duration for STEP pulse ON
-      #if MINIMUM_STEPPER_PULSE
-        // Just wait for the requested pulse duration
-        while (HAL_timer_get_count(PULSE_TIMER_NUM) < pulse_end) { /* nada */ }
+      #if (MINIMUM_STEPPER_PULSE || MAXIMUM_STEPPER_RATE)
+        START_HIGH_PULSE();
      #endif

-      // Add the delay needed to ensure the maximum driver rate is enforced
-      if (signed(added_step_ticks) > 0) pulse_end += hal_timer_t(added_step_ticks);
-
      LA_steps < 0 ? ++LA_steps : --LA_steps;

+      #if (MINIMUM_STEPPER_PULSE || MAXIMUM_STEPPER_RATE)
+        AWAIT_HIGH_PULSE();
+      #endif
+
      // Set the STEP pulse OFF
      #if ENABLED(MIXING_EXTRUDER)
        E_STEP_WRITE(mixer.get_stepper(), INVERT_E_STEP_PIN);
@ -1944,13 +1985,9 @@ uint32_t Stepper::stepper_block_phase_isr() {

      // For minimum pulse time wait before looping
      // Just wait for the requested pulse duration
-      if (LA_steps) {
-        while (HAL_timer_get_count(PULSE_TIMER_NUM) < pulse_end) { /* nada */ }
-        #if MINIMUM_STEPPER_PULSE
-          // Add to the value, the time that the pulse must be active (to be used on the next loop)
-          pulse_end += hal_timer_t(MIN_PULSE_TICKS);
-        #endif
-      }
+      #if (MINIMUM_STEPPER_PULSE || MAXIMUM_STEPPER_RATE)
+        if (LA_steps) START_LOW_PULSE();
+      #endif
    } // LA_steps

    return interval;
@ -2239,7 +2276,7 @@ void Stepper::endstop_triggered(const AxisEnum axis) {
      (axis == CORE_AXIS_2
        ? CORESIGN(count_position[CORE_AXIS_1] - count_position[CORE_AXIS_2])
        : count_position[CORE_AXIS_1] + count_position[CORE_AXIS_2]
-      ) * 0.5f
+      ) * double(0.5)
    #else // !IS_CORE
      count_position[axis]
    #endif
--- a/Marlin/src/module/stepper.h
+++ b/Marlin/src/module/stepper.h
@ -56,7 +56,24 @@
 // Estimate the amount of time the Stepper ISR will take to execute
 //

+/**
+ * The method of calculating these cycle-constants is unclear.
+ * Most of them are no longer used directly for pulse timing, and exist
+ * only to estimate a maximum step rate based on the user's configuration.
+ * As 32-bit processors continue to diverge, maintaining cycle counts
+ * will become increasingly difficult and error-prone.
+ */
+
 #ifdef CPU_32_BIT
+  /**
+   * Duration of START_TIMED_PULSE
+   * 
+   * ...as measured on an LPC1768 with a scope and converted to cycles.
+   * Not applicable to other 32-bit processors, but as long as others
+   * take longer, pulses will be longer. For example the SKR Pro
+   * (stm32f407zgt6) requires ~60 cyles.
+   */
+  #define TIMER_READ_ADD_AND_STORE_CYCLES 34UL

  // The base ISR takes 792 cycles
  #define ISR_BASE_CYCLES  792UL
@ -85,6 +102,8 @@
  #define ISR_STEPPER_CYCLES 16UL

 #else
+  // Cycles to perform actions in START_TIMED_PULSE
+  #define TIMER_READ_ADD_AND_STORE_CYCLES 13UL

  // The base ISR takes 752 cycles
  #define ISR_BASE_CYCLES  752UL
@ -116,43 +135,32 @@

 // Add time for each stepper
 #if HAS_X_STEP
-  #define ISR_START_X_STEPPER_CYCLES ISR_START_STEPPER_CYCLES
  #define ISR_X_STEPPER_CYCLES       ISR_STEPPER_CYCLES
 #else
-  #define ISR_START_X_STEPPER_CYCLES 0UL
  #define ISR_X_STEPPER_CYCLES       0UL
 #endif
 #if HAS_Y_STEP
-  #define ISR_START_Y_STEPPER_CYCLES ISR_START_STEPPER_CYCLES
  #define ISR_Y_STEPPER_CYCLES       ISR_STEPPER_CYCLES
 #else
  #define ISR_START_Y_STEPPER_CYCLES 0UL
  #define ISR_Y_STEPPER_CYCLES       0UL
 #endif
 #if HAS_Z_STEP
-  #define ISR_START_Z_STEPPER_CYCLES ISR_START_STEPPER_CYCLES
  #define ISR_Z_STEPPER_CYCLES       ISR_STEPPER_CYCLES
 #else
-  #define ISR_START_Z_STEPPER_CYCLES 0UL
  #define ISR_Z_STEPPER_CYCLES       0UL
 #endif

 // E is always interpolated, even for mixing extruders
-#define ISR_START_E_STEPPER_CYCLES   ISR_START_STEPPER_CYCLES
 #define ISR_E_STEPPER_CYCLES         ISR_STEPPER_CYCLES

 // If linear advance is disabled, the loop also handles them
 #if DISABLED(LIN_ADVANCE) && ENABLED(MIXING_EXTRUDER)
-  #define ISR_START_MIXING_STEPPER_CYCLES ((MIXING_STEPPERS) * (ISR_START_STEPPER_CYCLES))
  #define ISR_MIXING_STEPPER_CYCLES ((MIXING_STEPPERS) * (ISR_STEPPER_CYCLES))
 #else
-  #define ISR_START_MIXING_STEPPER_CYCLES 0UL
  #define ISR_MIXING_STEPPER_CYCLES  0UL
 #endif

-// Calculate the minimum time to start all stepper pulses in the ISR loop
-#define MIN_ISR_START_LOOP_CYCLES (ISR_START_X_STEPPER_CYCLES + ISR_START_Y_STEPPER_CYCLES + ISR_START_Z_STEPPER_CYCLES + ISR_START_E_STEPPER_CYCLES + ISR_START_MIXING_STEPPER_CYCLES)
-
 // And the total minimum loop time, not including the base
 #define MIN_ISR_LOOP_CYCLES (ISR_X_STEPPER_CYCLES + ISR_Y_STEPPER_CYCLES + ISR_Z_STEPPER_CYCLES + ISR_E_STEPPER_CYCLES + ISR_MIXING_STEPPER_CYCLES)

@ -166,18 +174,23 @@
  #define MIN_STEPPER_PULSE_CYCLES _MIN_STEPPER_PULSE_CYCLES(1UL)
 #endif

-// Calculate the minimum ticks of the PULSE timer that must elapse with the step pulse enabled
-// adding the "start stepper pulse" code section execution cycles to account for that not all
-// pulses start at the beginning of the loop, so an extra time must be added to compensate so
-// the last generated pulse (usually the extruder stepper) has the right length
-#if HAS_DRIVER(LV8729) && MINIMUM_STEPPER_PULSE == 0
-  #define MIN_PULSE_TICKS ((((PULSE_TIMER_TICKS_PER_US) + 1) / 2) + ((MIN_ISR_START_LOOP_CYCLES) / uint32_t(PULSE_TIMER_PRESCALE)))
+// Calculate the minimum pulse times (high and low)
+#if MINIMUM_STEPPER_PULSE && MAXIMUM_STEPPER_RATE
+  constexpr uint32_t _MIN_STEP_PERIOD_NS = 1000000000UL / MAXIMUM_STEPPER_RATE;
+  constexpr uint32_t _MIN_PULSE_HIGH_NS = 1000UL * MINIMUM_STEPPER_PULSE;
+  constexpr uint32_t _MIN_PULSE_LOW_NS = _MAX((_MIN_STEP_PERIOD_NS - _MIN(_MIN_STEP_PERIOD_NS, _MIN_PULSE_HIGH_NS)), _MIN_PULSE_HIGH_NS);
+#elif MINIMUM_STEPPER_PULSE
+  // Assume 50% duty cycle
+  constexpr uint32_t _MIN_PULSE_HIGH_NS = 1000UL * MINIMUM_STEPPER_PULSE;
+  constexpr uint32_t _MIN_PULSE_LOW_NS = _MIN_PULSE_HIGH_NS;
+#elif MAXIMUM_STEPPER_RATE
+  // Assume 50% duty cycle
+  constexpr uint32_t _MIN_PULSE_HIGH_NS = 500000000UL / MAXIMUM_STEPPER_RATE;
+  constexpr uint32_t _MIN_PULSE_LOW_NS = _MIN_PULSE_HIGH_NS;
 #else
-  #define MIN_PULSE_TICKS (((PULSE_TIMER_TICKS_PER_US) * uint32_t(MINIMUM_STEPPER_PULSE)) + ((MIN_ISR_START_LOOP_CYCLES) / uint32_t(PULSE_TIMER_PRESCALE)))
+  #error "Expected at least one of MINIMUM_STEPPER_PULSE or MAXIMUM_STEPPER_RATE to be defined"
 #endif

-// Calculate the extra ticks of the PULSE timer between step pulses
-#define ADDED_STEP_TICKS (((MIN_STEPPER_PULSE_CYCLES) / (PULSE_TIMER_PRESCALE)) - (MIN_PULSE_TICKS))

 // But the user could be enforcing a minimum time, so the loop time is
 #define ISR_LOOP_CYCLES (ISR_LOOP_BASE_CYCLES + _MAX(MIN_STEPPER_PULSE_CYCLES, MIN_ISR_LOOP_CYCLES))
--- a/Marlin/src/pins/esp32/pins_MRR_ESPA.h
+++ b/Marlin/src/pins/esp32/pins_MRR_ESPA.h
@ -0,0 +1,101 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2019 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/>.
+ *
+ */
+#pragma once
+
+/**
+ * MRR ESPA pin assignments
+ * MRR ESPA is a 3D printer control board based on the ESP32 microcontroller.
+ * Supports 4 stepper drivers, heated bed, single hotend.
+ */
+
+#ifndef ARDUINO_ARCH_ESP32
+  #error "Oops! Select an ESP32 board in 'Tools > Board.'"
+#elif EXTRUDERS > 1 || E_STEPPERS > 1
+  #error "MRR ESPA only supports one E Stepper. Comment out this line to continue."
+#elif HOTENDS > 1
+  #error "MRR ESPA currently supports only one hotend. Comment out this line to continue."
+#endif
+
+#define BOARD_INFO_NAME       "MRR ESPA"
+#define BOARD_WEBSITE_URL     "github.com/maplerainresearch/MRR_ESPA"
+#define DEFAULT_MACHINE_NAME  BOARD_INFO_NAME
+
+//
+// Disable I2S stepper stream
+//
+#ifdef I2S_STEPPER_STREAM
+  #undef I2S_STEPPER_STREAM
+#endif
+#define I2S_WS              -1
+#define I2S_BCK             -1
+#define I2S_DATA            -1
+
+//
+// Limit Switches
+//
+#define X_STOP_PIN         34
+#define Y_STOP_PIN         35
+#define Z_STOP_PIN         15
+
+//
+// Steppers
+//
+#define X_STEP_PIN         27
+#define X_DIR_PIN          26
+#define X_ENABLE_PIN       25
+//#define X_CS_PIN           21
+
+#define Y_STEP_PIN         33
+#define Y_DIR_PIN          32
+#define Y_ENABLE_PIN       X_ENABLE_PIN
+//#define Y_CS_PIN           22
+
+#define Z_STEP_PIN         14
+#define Z_DIR_PIN          12
+#define Z_ENABLE_PIN       X_ENABLE_PIN
+//#define Z_CS_PIN            5 // SS_PIN
+
+#define E0_STEP_PIN        16
+#define E0_DIR_PIN         17
+#define E0_ENABLE_PIN      X_ENABLE_PIN
+//#define E0_CS_PIN          21
+
+//
+// Temperature Sensors
+//
+#define TEMP_0_PIN         36   // Analog Input
+#define TEMP_BED_PIN       39   // Analog Input
+
+//
+// Heaters / Fans
+//
+#define HEATER_0_PIN        2
+#define FAN_PIN            13
+#define HEATER_BED_PIN      4
+
+//
+// MicroSD card
+//
+#define MOSI_PIN           23
+#define MISO_PIN           19
+#define SCK_PIN            18
+#define SDSS                5
--- a/Marlin/src/pins/esp32/pins_MRR_ESPE.h
+++ b/Marlin/src/pins/esp32/pins_MRR_ESPE.h
@ -0,0 +1,154 @@
+/**
+ * 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/>.
+ *
+ */
+#pragma once
+
+/**
+ * MRR ESPE pin assignments
+ * MRR ESPE is a 3D printer control board based on the ESP32 microcontroller.
+ * Supports 5 stepper drivers (using I2S stepper stream), heated bed,
+ * single hotend, and LCD controller.
+ */
+
+#ifndef ARDUINO_ARCH_ESP32
+  #error "Oops! Select an ESP32 board in 'Tools > Board.'"
+#elif EXTRUDERS > 2 || E_STEPPERS > 2
+  #error "MRR ESPE only supports two E Steppers. Comment out this line to continue."
+#elif HOTENDS > 1
+  #error "MRR ESPE currently supports only one hotend. Comment out this line to continue."
+#endif
+
+#define BOARD_INFO_NAME      "MRR ESPE"
+#define BOARD_WEBSITE_URL    "github.com/maplerainresearch/MRR_ESPE"
+#define DEFAULT_MACHINE_NAME BOARD_INFO_NAME
+
+//
+// Limit Switches
+//
+#define X_STOP_PIN         35
+#define Y_STOP_PIN         32
+#define Z_STOP_PIN         33
+
+//
+// Enable I2S stepper stream
+//
+#undef I2S_STEPPER_STREAM
+#define I2S_STEPPER_STREAM
+
+#undef LIN_ADVANCE  // Currently, I2S stream does not work with linear advance
+
+#define I2S_WS             26
+#define I2S_BCK            25
+#define I2S_DATA           27
+
+//
+// Steppers
+//
+#define X_STEP_PIN        129
+#define X_DIR_PIN         130
+#define X_ENABLE_PIN      128
+//#define X_CS_PIN           21
+
+#define Y_STEP_PIN        132
+#define Y_DIR_PIN         133
+#define Y_ENABLE_PIN      131
+//#define Y_CS_PIN           22
+
+#define Z_STEP_PIN        135
+#define Z_DIR_PIN         136
+#define Z_ENABLE_PIN      134
+//#define Z_CS_PIN            5 // SS_PIN
+
+#define E0_STEP_PIN       138
+#define E0_DIR_PIN        139
+#define E0_ENABLE_PIN     137
+//#define E0_CS_PIN          21
+
+#define E1_STEP_PIN       141
+#define E1_DIR_PIN        142
+#define E1_ENABLE_PIN     140
+//#define E1_CS_PIN          22
+
+#define Z2_STEP_PIN       141
+#define Z2_DIR_PIN        142
+#define Z2_ENABLE_PIN     140
+//#define Z2_CS_PIN            5
+
+//
+// Temperature Sensors
+//
+#define TEMP_0_PIN         36   // Analog Input
+#define TEMP_1_PIN         34   // Analog Input
+#define TEMP_BED_PIN       39   // Analog Input
+
+//
+// Heaters / Fans
+//
+#define HEATER_0_PIN      145 // 2
+#define FAN_PIN           146 // 15
+#define HEATER_BED_PIN    144 // 4
+
+#define CONTROLLER_FAN_PIN 147
+//#define E0_AUTO_FAN_PIN 148 // need to update Configuration_adv.h @section extruder 
+//#define E1_AUTO_FAN_PIN 149 // need to update Configuration_adv.h @section extruder 
+#define FAN1_PIN 149
+
+//
+// MicroSD card
+//
+#define MOSI_PIN           23
+#define MISO_PIN           19
+#define SCK_PIN            18
+#define SDSS                5
+
+//////////////////////////
+// LCDs and Controllers //
+//////////////////////////
+
+#if HAS_GRAPHICAL_LCD
+
+  #define LCD_PINS_RS        13
+  #define LCD_PINS_ENABLE    17
+  #define LCD_PINS_D4        16
+
+  #if ENABLED(CR10_STOCKDISPLAY)
+
+    #define BEEPER_PIN      151
+
+  #elif ENABLED(REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER)
+
+    #define BEEPER_PIN      152
+
+    //#define LCD_PINS_D5     150
+    //#define LCD_PINS_D6     151
+    //#define LCD_PINS_D7     153
+
+  #else
+
+    #error "Only CR10_STOCKDISPLAY and REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER are currently supported. Comment out this line to continue."
+
+  #endif
+
+  #define BTN_EN1             0
+  #define BTN_EN2            12
+  #define BTN_ENC            14
+
+#endif // HAS_GRAPHICAL_LCD
--- a/Marlin/src/pins/lpc1768/pins_BTT_SKR.h
+++ b/Marlin/src/pins/lpc1768/pins_BTT_SKR.h
@ -31,18 +31,29 @@
 //
 // Steppers
 //
-
-#define E1_STEP_PIN        P0_01
-#define E1_DIR_PIN         P0_00
-#define E1_ENABLE_PIN      P0_10
+#ifndef E1_STEP_PIN
+  #define E1_STEP_PIN      P0_01
+#endif
+#ifndef E1_DIR_PIN
+  #define E1_DIR_PIN       P0_00
+#endif
+#ifndef E1_ENABLE_PIN
+  #define E1_ENABLE_PIN    P0_10
+#endif

 //
 // Temperature Sensors
 //  3.3V max when defined as an analog input
 //
-#define TEMP_BED_PIN       P0_23_A0   // A0 (T0) - (67) - TEMP_BED_PIN
-#define TEMP_0_PIN         P0_24_A1   // A1 (T1) - (68) - TEMP_0_PIN
-#define TEMP_1_PIN         P0_25_A2   // A2 (T2) - (69) - TEMP_1_PIN
+#ifndef TEMP_0_PIN
+  #define TEMP_0_PIN       P0_24_A1   // A1 (T1) - (68) - TEMP_0_PIN
+#endif
+#ifndef TEMP_1_PIN
+  #define TEMP_1_PIN       P0_25_A2   // A2 (T2) - (69) - TEMP_1_PIN
+#endif
+#ifndef TEMP_BED_PIN
+  #define TEMP_BED_PIN     P0_23_A0   // A0 (T0) - (67) - TEMP_BED_PIN
+#endif

 //
 // Heaters / Fans
--- a/Marlin/src/pins/lpc1768/pins_BTT_SKR_V1_3.h
+++ b/Marlin/src/pins/lpc1768/pins_BTT_SKR_V1_3.h
@ -53,6 +53,8 @@
  #define Z_MAX_PIN          P1_25   // Z_MIN
 #endif

+#define ONBOARD_ENDSTOPPULLUPS     // Board has built-in pullups
+
 //
 // Servos
 //
--- a/Marlin/src/pins/lpc1768/pins_BTT_SKR_V1_4.h
+++ b/Marlin/src/pins/lpc1768/pins_BTT_SKR_V1_4.h
@ -0,0 +1,280 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2019 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/>.
+ *
+ */
+#pragma once
+
+#define BOARD_INFO_NAME "BIGTREE SKR 1.4"
+
+//
+// SD Connection
+//
+#ifndef SDCARD_CONNECTION
+  #define SDCARD_CONNECTION LCD
+#endif
+
+//
+// Servos
+//
+#define SERVO0_PIN         P2_00
+
+//
+// Limit Switches
+//
+#define X_STOP_PIN         P1_29
+#define Y_STOP_PIN         P1_28
+#define Z_STOP_PIN         P1_27
+
+//
+// Z Probe (when not Z_MIN_PIN)
+//
+#ifndef Z_MIN_PROBE_PIN
+  #define Z_MIN_PROBE_PIN  P0_10
+#endif
+
+//
+// Filament Runout Sensor
+//
+#define FIL_RUNOUT_PIN     P1_26
+#define FIL_RUNOUT2_PIN    P1_25
+
+//
+// Power Supply Control
+//
+#ifndef PS_ON_PIN
+  #define PS_ON_PIN        P1_00
+#endif
+
+//
+// Power Loss Detection
+//
+#ifndef POWER_LOSS_PIN
+  #define POWER_LOSS_PIN   P1_00
+#endif
+
+//
+// Steppers
+//
+#define X_STEP_PIN         P2_02
+#define X_DIR_PIN          P2_06
+#define X_ENABLE_PIN       P2_01
+#ifndef X_CS_PIN
+  #define X_CS_PIN         P1_10
+#endif
+
+#define Y_STEP_PIN         P0_19
+#define Y_DIR_PIN          P0_20
+#define Y_ENABLE_PIN       P2_08
+#ifndef Y_CS_PIN
+  #define Y_CS_PIN         P1_09
+#endif
+
+#define Z_STEP_PIN         P0_22
+#define Z_DIR_PIN          P2_11
+#define Z_ENABLE_PIN       P0_21
+#ifndef Z_CS_PIN
+  #define Z_CS_PIN         P1_08
+#endif
+
+#define E0_STEP_PIN        P2_13
+#define E0_DIR_PIN         P0_11
+#define E0_ENABLE_PIN      P2_12
+#ifndef E0_CS_PIN
+  #define E0_CS_PIN        P1_04
+#endif
+
+#define E1_STEP_PIN        P1_15
+#define E1_DIR_PIN         P1_14
+#define E1_ENABLE_PIN      P1_16
+#ifndef E1_CS_PIN
+  #define E1_CS_PIN        P1_01
+#endif
+
+#define TEMP_1_PIN         P0_23_A0   // A2 (T2) - (69) - TEMP_1_PIN
+#define TEMP_BED_PIN       P0_25_A2   // A0 (T0) - (67) - TEMP_BED_PIN
+
+//
+// Include common SKR pins
+//
+#include "pins_BTT_SKR.h"
+
+//
+// Software SPI pins for TMC2130 stepper drivers
+//
+#if ENABLED(TMC_USE_SW_SPI)
+  #ifndef TMC_SW_MOSI
+    #define TMC_SW_MOSI    P1_17
+  #endif
+  #ifndef TMC_SW_MISO
+    #define TMC_SW_MISO    P0_05
+  #endif
+  #ifndef TMC_SW_SCK
+    #define TMC_SW_SCK     P0_04
+  #endif
+#endif
+
+#if HAS_TMC220x
+  /**
+   * TMC2208/TMC2209 stepper drivers
+   *
+   * Hardware serial communication ports.
+   * If undefined software serial is used according to the pins below
+   */
+  //#define X_HARDWARE_SERIAL  Serial
+  //#define X2_HARDWARE_SERIAL Serial1
+  //#define Y_HARDWARE_SERIAL  Serial1
+  //#define Y2_HARDWARE_SERIAL Serial1
+  //#define Z_HARDWARE_SERIAL  Serial1
+  //#define Z2_HARDWARE_SERIAL Serial1
+  //#define E0_HARDWARE_SERIAL Serial1
+  //#define E1_HARDWARE_SERIAL Serial1
+  //#define E2_HARDWARE_SERIAL Serial1
+  //#define E3_HARDWARE_SERIAL Serial1
+  //#define E4_HARDWARE_SERIAL Serial1
+
+  //
+  // Software serial
+  //
+  #define X_SERIAL_TX_PIN  P1_10
+  #define X_SERIAL_RX_PIN  P1_10
+
+  #define Y_SERIAL_TX_PIN  P1_09
+  #define Y_SERIAL_RX_PIN  P1_09
+
+  #define Z_SERIAL_TX_PIN  P1_08
+  #define Z_SERIAL_RX_PIN  P1_08
+
+  #define E0_SERIAL_TX_PIN P1_04
+  #define E0_SERIAL_RX_PIN P1_04
+
+  #define E1_SERIAL_TX_PIN P1_01
+  #define E1_SERIAL_RX_PIN P1_01
+
+  #define Z2_SERIAL_TX_PIN P1_01
+  #define Z2_SERIAL_RX_PIN P1_01
+
+  // Reduce baud rate to improve software serial reliability
+  #define TMC_BAUD_RATE 19200
+#endif
+
+//
+// SD Connection
+//
+#if SD_CONNECTION_IS(LCD)
+  #define SS_PIN           P0_16
+#endif
+
+/**
+ *              _____                                             _____
+ *          NC | · · | GND                                    5V | · · | GND
+ *       RESET | · · | 1.31(SD_DETECT)             (LCD_D7) 1.23 | · · | 1.22 (LCD_D6)
+ *  (MOSI)0.18 | · · | 3.25(BTN_EN2)               (LCD_D5) 1.21 | · · | 1.20 (LCD_D4)
+ * (SD_SS)0.16 | · · | 3.26(BTN_EN1)               (LCD_RS) 1.19 | · · | 1.18 (LCD_EN)
+ *   (SCK)0.15 | · · | 0.17(MISO)                 (BTN_ENC) 0.28 | · · | 1.30 (BEEPER)
+ *              -----                                             -----
+ *              EXP2                                              EXP1
+ */
+#if HAS_SPI_LCD
+  #define BTN_ENC          P0_28   // (58) open-drain
+
+  #if ENABLED(CR10_STOCKDISPLAY)
+    #define LCD_PINS_RS    P1_22
+
+    #define BTN_EN1        P1_18
+    #define BTN_EN2        P1_20
+
+    #define LCD_PINS_ENABLE P1_23
+    #define LCD_PINS_D4    P1_21
+
+  #else
+    #define LCD_PINS_RS    P1_19
+
+    #define BTN_EN1        P3_26   // (31) J3-2 & AUX-4
+    #define BTN_EN2        P3_25   // (33) J3-4 & AUX-4
+
+    #define LCD_PINS_ENABLE P1_18
+    #define LCD_PINS_D4    P1_20
+
+    #define LCD_SDSS       P0_16   // (16) J3-7 & AUX-4
+    #define SD_DETECT_PIN  P1_31   // (49) (NOT 5V tolerant)
+
+    #if ENABLED(FYSETC_MINI_12864)
+      #define DOGLCD_CS    P1_18
+      #define DOGLCD_A0    P1_19
+      #define DOGLCD_SCK   P0_15
+      #define DOGLCD_MOSI  P0_18
+
+      #define LCD_BACKLIGHT_PIN -1
+
+      #define FORCE_SOFT_SPI      // Use this if default of hardware SPI causes display problems
+                                  //   results in LCD soft SPI mode 3, SD soft SPI mode 0
+
+      #define LCD_RESET_PIN P1_20   // Must be high or open for LCD to operate normally.
+
+      #if EITHER(FYSETC_MINI_12864_1_2, FYSETC_MINI_12864_2_0)
+        #ifndef RGB_LED_R_PIN
+          #define RGB_LED_R_PIN P1_21
+        #endif
+        #ifndef RGB_LED_G_PIN
+          #define RGB_LED_G_PIN P1_22
+        #endif
+        #ifndef RGB_LED_B_PIN
+          #define RGB_LED_B_PIN P1_23
+        #endif
+      #elif ENABLED(FYSETC_MINI_12864_2_1)
+        #define NEOPIXEL_PIN    P1_21
+      #endif
+
+    #else // !FYSETC_MINI_12864
+
+      #if ENABLED(MKS_MINI_12864)
+        #define DOGLCD_CS   P1_21
+        #define DOGLCD_A0   P1_22
+        #define DOGLCD_SCK  P0_15
+        #define DOGLCD_MOSI P0_18
+        #define FORCE_SOFT_SPI
+      #endif
+
+      #if ENABLED(ULTIPANEL)
+        #define LCD_PINS_D5 P1_21
+        #define LCD_PINS_D6 P1_22
+        #define LCD_PINS_D7 P1_23
+      #endif
+
+    #endif // !FYSETC_MINI_12864
+
+  #endif
+
+#endif // HAS_SPI_LCD
+
+//
+// Neopixel LED
+//
+#ifndef NEOPIXEL_PIN
+  #define NEOPIXEL_PIN      P1_24
+#endif
+
+/**
+ * Special pins
+ *   P1_30  (37) (NOT 5V tolerant)
+ *   P1_31  (49) (NOT 5V tolerant)
+ *   P0_27  (57) (Open collector)
+ *   P0_28  (58) (Open collector)
+ */
--- a/Marlin/src/pins/lpc1768/pins_MKS_SGEN_L.h
+++ b/Marlin/src/pins/lpc1768/pins_MKS_SGEN_L.h
@ -166,7 +166,15 @@
 //
 #define HEATER_BED_PIN     P2_05
 #define HEATER_0_PIN       P2_07
-#define HEATER_1_PIN       P2_06
+#if HOTENDS == 1
+  #ifndef FAN1_PIN
+    #define FAN1_PIN       P2_06
+  #endif
+#else
+  #ifndef HEATER_1_PIN
+    #define HEATER_1_PIN   P2_06
+  #endif
+#endif
 #ifndef FAN_PIN
  #define FAN_PIN          P2_04
 #endif
@ -203,60 +211,77 @@
    #define LCD_PINS_D4    P0_17

  #else
-    #define LCD_PINS_RS    P0_16

    #define BTN_EN1        P3_25
    #define BTN_EN2        P3_26

-    #define LCD_PINS_ENABLE P0_18
-    #define LCD_PINS_D4    P0_15
-
    #define LCD_SDSS       P0_28
-    #define SD_DETECT_PIN  P0_27

-    #if ENABLED(FYSETC_MINI_12864)
-      #define DOGLCD_CS    P0_18
-      #define DOGLCD_A0    P0_16
-      #define DOGLCD_SCK   P0_07
-      #define DOGLCD_MOSI  P1_20
+    #if ENABLED(MKS_12864OLED_SSD1306)

-      #define LCD_BACKLIGHT_PIN -1
+      #define LCD_PINS_DC  P0_17
+      #define DOGLCD_CS    P0_16
+      #define DOGLCD_A0    LCD_PINS_DC
+      #define DOGLCD_SCK   P0_15
+      #define DOGLCD_MOSI  P0_18

-      #define FORCE_SOFT_SPI      // Use this if default of hardware SPI causes display problems
-                                  //   results in LCD soft SPI mode 3, SD soft SPI mode 0
+      #define LCD_PINS_RS  P1_00
+      #define LCD_PINS_D7  P1_22
+      #define KILL_PIN     -1 // NC

-      #define LCD_RESET_PIN P0_15   // Must be high or open for LCD to operate normally.
+    #else // !MKS_12864OLED_SSD1306

-      #if EITHER(FYSETC_MINI_12864_1_2, FYSETC_MINI_12864_2_0)
-        #ifndef RGB_LED_R_PIN
-          #define RGB_LED_R_PIN P0_17
+      #define LCD_PINS_RS  P0_16
+
+      #define LCD_PINS_ENABLE P0_18
+      #define LCD_PINS_D4  P0_15
+
+      #if ENABLED(FYSETC_MINI_12864)
+
+        #define DOGLCD_CS  P0_18
+        #define DOGLCD_A0  P0_16
+        #define DOGLCD_SCK P0_07
+        #define DOGLCD_MOSI P1_20
+
+        #define LCD_BACKLIGHT_PIN -1
+
+        #define FORCE_SOFT_SPI      // Use this if default of hardware SPI causes display problems
+                                    //   results in LCD soft SPI mode 3, SD soft SPI mode 0
+
+        #define LCD_RESET_PIN P0_15   // Must be high or open for LCD to operate normally.
+
+        #if EITHER(FYSETC_MINI_12864_1_2, FYSETC_MINI_12864_2_0)
+          #ifndef RGB_LED_R_PIN
+            #define RGB_LED_R_PIN P0_17
+          #endif
+          #ifndef RGB_LED_G_PIN
+            #define RGB_LED_G_PIN P1_00
+          #endif
+          #ifndef RGB_LED_B_PIN
+            #define RGB_LED_B_PIN P1_22
+          #endif
+        #elif ENABLED(FYSETC_MINI_12864_2_1)
+          #define NEOPIXEL_PIN    P0_17
        #endif
-        #ifndef RGB_LED_G_PIN
-          #define RGB_LED_G_PIN P1_00
+
+      #else // !FYSETC_MINI_12864
+
+        #if ENABLED(MKS_MINI_12864)
+          #define DOGLCD_CS  P0_17
+          #define DOGLCD_A0  P1_00
        #endif
-        #ifndef RGB_LED_B_PIN
-          #define RGB_LED_B_PIN P1_22
+
+        #if ENABLED(ULTIPANEL)
+          #define LCD_PINS_D5 P0_17
+          #define LCD_PINS_D6 P1_00
+          #define LCD_PINS_D7 P1_22
        #endif
-      #elif ENABLED(FYSETC_MINI_12864_2_1)
-        #define NEOPIXEL_PIN    P0_17
-      #endif

-    #else // !FYSETC_MINI_12864
+      #endif // !FYSETC_MINI_12864

-      #if ENABLED(MKS_MINI_12864)
-        #define DOGLCD_CS  P0_17
-        #define DOGLCD_A0  P1_00
-      #endif
+    #endif // !MKS_12864OLED_SSD1306

-      #if ENABLED(ULTIPANEL)
-        #define LCD_PINS_D5 P0_17
-        #define LCD_PINS_D6 P1_00
-        #define LCD_PINS_D7 P1_22
-      #endif
-
-    #endif // !FYSETC_MINI_12864
-
-  #endif
+  #endif // !CR10_STOCKDISPLAY

 #endif // HAS_SPI_LCD

@ -266,17 +291,16 @@

 #define ONBOARD_SD_CS_PIN  P0_06   // Chip select for "System" SD card

-#if SD_CONNECTION_IS(LCD)
-  #define SCK_PIN          P0_07
-  #define MISO_PIN         P0_08
-  #define MOSI_PIN         P0_09
-  #define SS_PIN           P0_28
-#elif SD_CONNECTION_IS(ONBOARD)
+#if SD_CONNECTION_IS(LCD) || SD_CONNECTION_IS(ONBOARD)
  #define SD_DETECT_PIN    P0_27
  #define SCK_PIN          P0_07
  #define MISO_PIN         P0_08
  #define MOSI_PIN         P0_09
-  #define SS_PIN           ONBOARD_SD_CS_PIN
+  #if SD_CONNECTION_IS(ONBOARD)
+    #define SS_PIN         ONBOARD_SD_CS_PIN
+  #else
+    #define SS_PIN         P0_28
+  #endif
 #elif SD_CONNECTION_IS(CUSTOM_CABLE)
  #error "No custom SD drive cable defined for this board."
 #endif
--- a/Marlin/src/pins/lpc1768/pins_RAMPS_RE_ARM.h
+++ b/Marlin/src/pins/lpc1768/pins_RAMPS_RE_ARM.h
@ -59,6 +59,7 @@
 #define Y_MAX_PIN          P1_27   // (15) 10k pullup to 3.3V, 1K series
 #define Z_MIN_PIN          P1_29   // (18) 10k pullup to 3.3V, 1K series
 #define Z_MAX_PIN          P1_28   // (19) 10k pullup to 3.3V, 1K series
+#define ONBOARD_ENDSTOPPULLUPS     // Board has built-in pullups

 //
 // Steppers
--- a/Marlin/src/pins/mega/pins_GT2560_V3.h
+++ b/Marlin/src/pins/mega/pins_GT2560_V3.h
@ -132,8 +132,8 @@
 #define HEATER_2_PIN        1
 #define HEATER_BED_PIN      4
 #define FAN_PIN             9
-//#define FAN1_PIN          8
-//#define FAN2_PIN          7
+#define FAN1_PIN            8
+#define FAN2_PIN            7

 //
 // Misc. Functions
--- a/Marlin/src/pins/pins.h
+++ b/Marlin/src/pins/pins.h
@ -354,14 +354,16 @@
  #include "lpc1768/pins_BIQU_BQ111_A4.h"       // LPC1768                                env:LPC1768
 #elif MB(SELENA_COMPACT)
  #include "lpc1768/pins_SELENA_COMPACT.h"      // LPC1768                                env:LPC1768
-#elif MB(BIGTREE_SKR_V1_1)
-  #include "lpc1768/pins_BTT_SKR_V1_1.h"        // LPC1768                                env:LPC1768
 #elif MB(BIQU_B300_V1_0)
  #include "lpc1768/pins_BIQU_B300_V1.0.h"      // LPC1768                                env:LPC1768
-#elif MB(BIGTREE_SKR_V1_3)
-  #include "lpc1768/pins_BTT_SKR_V1_3.h"        // LPC1768                                env:LPC1768
 #elif MB(GMARSH_X6_REV1)
  #include "lpc1768/pins_GMARSH_X6_REV1.h"      // LPC1768                                env:LPC1768
+#elif MB(BIGTREE_SKR_V1_1)
+  #include "lpc1768/pins_BTT_SKR_V1_1.h"        // LPC1768                                env:LPC1768
+#elif MB(BIGTREE_SKR_V1_3)
+  #include "lpc1768/pins_BTT_SKR_V1_3.h"        // LPC1768                                env:LPC1768
+#elif MB(BIGTREE_SKR_V1_4)
+  #include "lpc1768/pins_BTT_SKR_V1_4.h"        // LPC1768                                env:LPC1768

 //
 // LPC1769 ARM Cortex M3
@ -493,6 +495,10 @@
  #include "stm32/pins_FYSETC_CHEETAH_V12.h"    // STM32F1                                env:STM32F103RC_fysetc
 #elif MB(LONGER3D_LK)
  #include "stm32/pins_LONGER3D_LK.h"           // STM32F1                                env:STM32F103VE_longer
+#elif MB(MKS_ROBIN_LITE3)
+  #include "stm32/pins_MKS_ROBIN_LITE3.h"       // STM32F1                                env:mks_robin_lite3
+#elif MB(MKS_ROBIN_PRO)
+  #include "stm32/pins_MKS_ROBIN_PRO.h"         // STM32F1                                env:mks_robin_pro

 //
 // ARM Cortex-M4F
@ -531,6 +537,10 @@
  #include "stm32/pins_VAKE403D.h"              // STM32F4                                env:STM32F4
 #elif MB(FYSETC_S6)
  #include "stm32/pins_FYSETC_S6.h"             // STM32F4                                env:FYSETC_S6
+#elif MB(FLYF407ZG)
+  #include "stm32/pins_FLYF407ZG.h"             // STM32F4                                env:FLYF407ZG
+#elif MB(MKS_ROBIN2)
+  #include "pins_MKS_ROBIN2.h"                  // STM32F4                                env:MKS_ROBIN2

 //
 // ARM Cortex M7
@ -548,6 +558,10 @@
 #elif MB(ESPRESSIF_ESP32)

  #include "esp32/pins_ESP32.h"                 // ESP32                                  env:esp32
+#elif MB(MRR_ESPA)
+  #include "esp32/pins_MRR_ESPA.h"              // ESP32                                  env:esp32
+#elif MB(MRR_ESPE)
+  #include "esp32/pins_MRR_ESPE.h"              // ESP32                                  env:esp32

 //
 // Linux Native Debug board
--- a/Marlin/src/pins/ramps/pins_RAMPS.h
+++ b/Marlin/src/pins/ramps/pins_RAMPS.h
@ -593,7 +593,7 @@
        //#define LCD_SCREEN_ROT_270

        // not connected to a pin
-        #define LCD_BACKLIGHT_PIN 65   // backlight LED on A11/D65
+        #define LCD_BACKLIGHT_PIN -1  // 65 (MKS mini12864 can't adjust backlight by software!)

        #define BTN_EN1         31
        #define BTN_EN2         33
--- a/Marlin/src/pins/sam/pins_RADDS.h
+++ b/Marlin/src/pins/sam/pins_RADDS.h
@ -34,7 +34,9 @@
 //
 // Servos
 //
-#define SERVO0_PIN          5
+#if !HAS_CUTTER
+  #define SERVO0_PIN        5
+#endif
 #define SERVO1_PIN          6
 #define SERVO2_PIN         39
 #define SERVO3_PIN         40
@ -184,7 +186,9 @@
 #define HEATER_0_PIN       13
 #define HEATER_1_PIN       12
 #define HEATER_2_PIN       11
-#define HEATER_BED_PIN      7   // BED
+#if !HAS_CUTTER
+  #define HEATER_BED_PIN    7   // BED
+#endif

 #ifndef FAN_PIN
  #define FAN_PIN           9
@ -204,6 +208,16 @@
 #define I2C_EEPROM
 #define E2END 0x1FFF // 8KB

+//
+// M3/M4/M5 - Spindle/Laser Control
+//
+#if HAS_CUTTER
+  #if !NUM_SERVOS
+    #define SPINDLE_LASER_PWM_PIN  5   // SERVO0_PIN
+  #endif
+  #define SPINDLE_LASER_ENA_PIN    7   // HEATER_BED_PIN - Pullup/down!
+#endif
+
 //
 // LCD / Controller
 //
--- a/Show More
+++ b/Show More